Run a virtual iPhone on an Apple Silicon Mac.
Swift
// ARM64Inst.swift — Raw (UInt32) instruction decoding for the fast pattern scanners.
//
// These operate directly on a 4-byte little-endian instruction word so the kernel
// patchers can scan megabytes of __TEXT_EXEC without paying Capstone's per-instruction
// cost. They are the SINGLE SOURCE OF TRUTH for the opcode masks that were previously
// re-spelled inline in each CFW patch file (KernelCustomFirmwarePatchTaskConversion, VmProtect,
// ProcPidinfo, HookCredLabel) and in KernelCustomFirmwarePatcherBase.findProcSecurityPolicy.
//
// Every mask/value is documented against the ARM64 ISA encoding and round-trip
// verified against Capstone in ARM64InstTests. When a Capstone `Instruction` is
// already in hand, prefer its typed operands (see ARM64Disassembler); these raw
// predicates exist for the hot scan loops only.
import Foundation
public enum ARM64Inst {
// MARK: - Register / immediate field accessors
/// Rd / Rt — destination (or transfer) register, bits [4:0].
public static func rd(_ i: UInt32) -> UInt32 {
i & 0x1F
}
/// Rn — first source / base register, bits [9:5].
public static func rn(_ i: UInt32) -> UInt32 {
(i >> 5) & 0x1F
}
/// Rm — second source register, bits [20:16].
public static func rm(_ i: UInt32) -> UInt32 {
(i >> 16) & 0x1F
}
/// MOVZ/MOVN/MOVK 16-bit immediate, bits [20:5].
public static func movImm16(_ i: UInt32) -> UInt32 {
(i >> 5) & 0xFFFF
}
/// Unsigned 12-bit immediate of an ADD/SUB (immediate), bits [21:10].
public static func addSubImm12(_ i: UInt32) -> UInt32 {
(i >> 10) & 0xFFF
}
// MARK: - Opcode predicates (mask/value verified against the ISA)
/// ADRP (any Rd): op=1, [28:24]=10000.
public static func isADRP(_ i: UInt32) -> Bool {
(i & 0x9F00_0000) == 0x9000_0000
}
/// LDR Xt, [Xn, #imm] — 64-bit unsigned-offset load, [31:22]=1111100101.
public static func isLDRImm64(_ i: UInt32) -> Bool {
(i & 0xFFC0_0000) == 0xF940_0000
}
/// CMP Xn, Xm ≡ SUBS XZR, Xn, Xm (64-bit, shift=0, imm6=0); Rn/Rm left free.
public static func isCMPReg64(_ i: UInt32) -> Bool {
(i & 0xFFE0_FC1F) == 0xEB00_001F
}
/// SUB Wd, Wn, #imm — 32-bit SUB (immediate), shift=0; [31:22]=0101000100.
public static func isSUBImm32(_ i: UInt32) -> Bool {
(i & 0xFFC0_0000) == 0x5100_0000
}
/// MOVZ Wd, #imm16 (32-bit, no shift): [31:21]=01010010100.
public static func isMOVZW(_ i: UInt32) -> Bool {
(i & 0xFFE0_0000) == 0x5280_0000
}
/// ORR Wd, WZR, #imm — 32-bit logical-immediate ORR, [31:22]=0011001000
/// (sf=0, opc=01, N=0). This is the *other* encoding an assembler may pick to
/// materialise a small constant, so a scanner looking for `mov wD, #imm` has
/// to let it through as well. Rn is left free: a caller that means WZR
/// specifically checks `rn(i) == 31` itself.
///
/// The immediate field is not decoded here. Logical immediates carry their own
/// element size, so the same value has several legal spellings — `orr w9, wzr,
/// #6` is 0x321F07E9 (element size 32) while `orr w9, wzr, #7` is 0x32000BE9 —
/// and reproducing that table would be the kind of hand-rolled decode the
/// kernel patcher guardrails exist to keep out. Callers confirm the value with
/// Capstone.
public static func isORRImmW(_ i: UInt32) -> Bool {
(i & 0xFFC0_0000) == 0x3200_0000
}
/// AND Wd, Wn, Wm — 32-bit shifted-register AND (imm6=0; shift type left free,
/// harmless at shift amount 0): [31:24]=00001010, N=0.
public static func isANDRegW(_ i: UInt32) -> Bool {
(i & 0xFF20_FC00) == 0x0A00_0000
}
/// LSR Wd, Wn, #7 ≡ UBFM Wd, Wn, #7, #31 (immr=7, imms=0x1F).
public static func isLSRImm7W(_ i: UInt32) -> Bool {
(i & 0xFFFF_FC00) == 0x5307_7C00
}
/// BL — branch with link, [31:26]=100101.
public static func isBL(_ i: UInt32) -> Bool {
i >> 26 == 0b100101
}
/// B or BL — unconditional branch (immediate), [30:26]=00101. Bit 31 is the
/// link bit and is left free, so both forms pass and nothing else does: those
/// two are the only encodings in the group.
public static func isBorBL(_ i: UInt32) -> Bool {
(i & 0x7C00_0000) == 0x1400_0000
}
/// B.EQ — conditional branch, [31:24]=0x54, bit4=0, cond=0000.
public static func isBEQ(_ i: UInt32) -> Bool {
(i & 0xFF00_001F) == 0x5400_0000
}
/// CBZ Wn (sf=0): top byte 0x34.
public static func isCBZW(_ i: UInt32) -> Bool {
(i & 0xFF00_0000) == 0x3400_0000
}
/// CBNZ Wn (sf=0): top byte 0x35.
public static func isCBNZW(_ i: UInt32) -> Bool {
(i & 0xFF00_0000) == 0x3500_0000
}
/// CBZ or CBNZ Wn.
public static func isCBZorCBNZW(_ i: UInt32) -> Bool {
isCBZW(i) || isCBNZW(i)
}
/// CBZ Xn (sf=1): top byte 0xB4.
public static func isCBZX(_ i: UInt32) -> Bool {
(i & 0xFF00_0000) == 0xB400_0000
}
}