pyboy-advance 0.0.1__tar.gz

pyboy_advance-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 William Ha
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyboy_advance-0.0.1/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: pyboy-advance
+Version: 0.0.1
+Summary: Game Boy Advance emulator written in Python
+Author: William Ha
+Keywords: gameboy,game boy,game boy advance,gameboy advance,emulator,pypy
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: System :: Emulators
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pysdl2
+Requires-Dist: pysdl2-dll
+Dynamic: license-file
+
+<p align="center">
+  <img src="assets/pyboy_advance.svg" alt="PyBoy Advance" width="240">
+</p>
+
+---
+
+PyBoy Advance is a Game Boy Advance emulator written in Python.
+
+There are already plenty of fantastic GBA emulators out in the wild,
+most written in languages far better suited than Python for emulator development.
+This project is not meant to compete with those emulators nor match their
+capabilities. In fact, PyBoy Advance is rather crap (and slow!) by comparison. I work on this project purely for fun, 
+with my end goal being to offer a highly readable implementation of a GBA emulator for educational purposes.
+
+## Getting started
+
+PyBoy Advance is written in pure Python and technically can be run with the standard CPython interpreter, but
+performance will be unacceptably slow. Instead, you will need to run PyBoy Advance with [PyPy](https://pypy.org/),
+a fast implementation of Python (see [Downloading and Installing PyPy](https://doc.pypy.org/en/stable/install.html)).
+
+Install PyBoy Advance with `pip`:
+
+```bash
+$ pypy -m pip install pyboy-advance
+```
+
+You will need to provide a Game Boy Advance BIOS. Normatt's open source BIOS is supported and
+available [here](https://github.com/Nebuleon/ReGBA/blob/master/bios/gba_bios.bin).
+
+Launch PyBoy Advance from the terminal:
+
+```bash
+$ pyboy_advance --bios /path/to/bios.bin game_rom.gba
+```
+
+Or import and use it in your Python scripts:
+
+```python
+from pyboy_advance import PyBoyAdvance
+
+emulator = PyBoyAdvance(rom="game_rom.gba", bios="/path/to/bios.bin")
+emulator.run()
+```
+
+## Screenshots
+
+<p align="center">
+  <img src="assets/screenshot_kirby.png" alt="Screenshot of PyBoy Advance running Kirby: Nightmare in Dream Land" width="400">
+</p>
+
+## Acknowledgements
+
+- [GBATEK](https://problemkaputt.de/gbatek.htm) by Martin Korth, the king of GBA hardware documentation
+- [ARM7TDMI Technical Reference Manual](https://developer.arm.com/documentation/ddi0210/c/)
+- [CowBite Virtual Hardware Specifications](https://www.cs.rit.edu/~tjh8300/CowBite/CowBiteSpec.htm) by Tom Happ
+- [Tonc](https://www.coranac.com/tonc/text/toc.htm) by Jasper Vijn
+- Excellent reference GBA emulators:
+    - [mGBA](https://mgba.io/) by Vicki Pfau (endrift)
+    - [NanoBoyAdvance](https://github.com/nba-emu/NanoBoyAdvance) by Fleroviux
+    - [Hades](https://github.com/hades-emu/Hades) by Arignir
+    - [RustBoyAdvance-NG](https://github.com/michelhe/rustboyadvance-ng/) by Michel Heily
+- [GBA Tests](https://github.com/jsmolka/gba-tests) by Julian Smolka
+- [PyBoy](https://github.com/Baekalfen/PyBoy) by Mads Ynddal (Baekalfen), a sister project (Game Boy emulator written in
+  Python)

pyboy_advance-0.0.1/README.md

@@ -0,0 +1,64 @@
+<p align="center">
+  <img src="assets/pyboy_advance.svg" alt="PyBoy Advance" width="240">
+</p>
+
+---
+
+PyBoy Advance is a Game Boy Advance emulator written in Python.
+
+There are already plenty of fantastic GBA emulators out in the wild,
+most written in languages far better suited than Python for emulator development.
+This project is not meant to compete with those emulators nor match their
+capabilities. In fact, PyBoy Advance is rather crap (and slow!) by comparison. I work on this project purely for fun, 
+with my end goal being to offer a highly readable implementation of a GBA emulator for educational purposes.
+
+## Getting started
+
+PyBoy Advance is written in pure Python and technically can be run with the standard CPython interpreter, but
+performance will be unacceptably slow. Instead, you will need to run PyBoy Advance with [PyPy](https://pypy.org/),
+a fast implementation of Python (see [Downloading and Installing PyPy](https://doc.pypy.org/en/stable/install.html)).
+
+Install PyBoy Advance with `pip`:
+
+```bash
+$ pypy -m pip install pyboy-advance
+```
+
+You will need to provide a Game Boy Advance BIOS. Normatt's open source BIOS is supported and
+available [here](https://github.com/Nebuleon/ReGBA/blob/master/bios/gba_bios.bin).
+
+Launch PyBoy Advance from the terminal:
+
+```bash
+$ pyboy_advance --bios /path/to/bios.bin game_rom.gba
+```
+
+Or import and use it in your Python scripts:
+
+```python
+from pyboy_advance import PyBoyAdvance
+
+emulator = PyBoyAdvance(rom="game_rom.gba", bios="/path/to/bios.bin")
+emulator.run()
+```
+
+## Screenshots
+
+<p align="center">
+  <img src="assets/screenshot_kirby.png" alt="Screenshot of PyBoy Advance running Kirby: Nightmare in Dream Land" width="400">
+</p>
+
+## Acknowledgements
+
+- [GBATEK](https://problemkaputt.de/gbatek.htm) by Martin Korth, the king of GBA hardware documentation
+- [ARM7TDMI Technical Reference Manual](https://developer.arm.com/documentation/ddi0210/c/)
+- [CowBite Virtual Hardware Specifications](https://www.cs.rit.edu/~tjh8300/CowBite/CowBiteSpec.htm) by Tom Happ
+- [Tonc](https://www.coranac.com/tonc/text/toc.htm) by Jasper Vijn
+- Excellent reference GBA emulators:
+    - [mGBA](https://mgba.io/) by Vicki Pfau (endrift)
+    - [NanoBoyAdvance](https://github.com/nba-emu/NanoBoyAdvance) by Fleroviux
+    - [Hades](https://github.com/hades-emu/Hades) by Arignir
+    - [RustBoyAdvance-NG](https://github.com/michelhe/rustboyadvance-ng/) by Michel Heily
+- [GBA Tests](https://github.com/jsmolka/gba-tests) by Julian Smolka
+- [PyBoy](https://github.com/Baekalfen/PyBoy) by Mads Ynddal (Baekalfen), a sister project (Game Boy emulator written in
+  Python)

pyboy_advance-0.0.1/pyboy_advance/__main__.py

@@ -0,0 +1,19 @@
+import argparse
+import sys
+
+from pyboy_advance.gba import PyBoyAdvance
+
+
+def main():
+    parser = argparse.ArgumentParser("pyboy_advance")
+    parser.add_argument("rom", type=str)
+    parser.add_argument("--bios", type=str)
+    parser.add_argument("--skip-bios", action="store_true")
+    args = parser.parse_args()
+
+    pyboy_advance = PyBoyAdvance(args.rom, args.bios, skip_bios=args.skip_bios)
+    pyboy_advance.run()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pyboy_advance-0.0.1/pyboy_advance/app/window.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+from ctypes import c_void_p
+from enum import Enum, auto
+
+import sdl2.ext
+
+from pyboy_advance.ppu.constants import DISPLAY_WIDTH, DISPLAY_HEIGHT, COLOUR_SIZE
+
+
+class Window:
+    DEFAULT_WINDOW_SCALE = 2
+
+    def __init__(self):
+        self._events = []
+
+    def __enter__(self):
+        if sdl2.SDL_InitSubSystem(sdl2.SDL_INIT_VIDEO | sdl2.SDL_INIT_GAMECONTROLLER) < 0:
+            raise ValueError(f"SDL_InitSubSystem failed: {sdl2.SDL_GetError().decode()}")
+
+        self.sdl_window = sdl2.SDL_CreateWindow(
+            b"PyBoy Advance",
+            sdl2.SDL_WINDOWPOS_CENTERED,
+            sdl2.SDL_WINDOWPOS_CENTERED,
+            DISPLAY_WIDTH * Window.DEFAULT_WINDOW_SCALE,
+            DISPLAY_HEIGHT * Window.DEFAULT_WINDOW_SCALE,
+            sdl2.SDL_WINDOW_RESIZABLE,
+        )
+
+        self.sdl_renderer = sdl2.SDL_CreateRenderer(
+            self.sdl_window, -1, sdl2.SDL_RENDERER_ACCELERATED
+        )
+
+        sdl2.SDL_RenderSetLogicalSize(self.sdl_renderer, DISPLAY_WIDTH, DISPLAY_HEIGHT)
+
+        self.sdl_texture_buffer = sdl2.SDL_CreateTexture(
+            self.sdl_renderer,
+            sdl2.SDL_PIXELFORMAT_BGR555,
+            sdl2.SDL_TEXTUREACCESS_STREAMING,
+            DISPLAY_WIDTH,
+            DISPLAY_HEIGHT,
+        )
+
+        sdl2.SDL_ShowWindow(self.sdl_window)
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        sdl2.SDL_DestroyWindow(self.sdl_window)
+        sdl2.SDL_QuitSubSystem(sdl2.SDL_INIT_VIDEO | sdl2.SDL_INIT_GAMECONTROLLER)
+
+    @property
+    def fullscreen(self) -> bool:
+        flags = sdl2.SDL_GetWindowFlags(self.sdl_window)
+        return flags & sdl2.SDL_WINDOW_FULLSCREEN_DESKTOP
+
+    @fullscreen.setter
+    def fullscreen(self, value: bool):
+        sdl2.SDL_SetWindowFullscreen(
+            self.sdl_window,
+            sdl2.SDL_WINDOW_FULLSCREEN_DESKTOP if value else 0,
+        )
+
+    def get_events(self) -> list[WindowEvent]:
+        self._events.clear()
+        for event in sdl2.ext.get_events():
+            if event.type == sdl2.SDL_QUIT:
+                self._events.append(WindowEvent.QUIT)
+            elif event.type == sdl2.SDL_KEYDOWN:
+                self._events.append(KeyMapping.KEY_DOWN.get(event.key.keysym.sym, WindowEvent.NONE))
+            elif event.type == sdl2.SDL_KEYUP:
+                self._events.append(KeyMapping.KEY_UP.get(event.key.keysym.sym, WindowEvent.NONE))
+        return self._events
+
+    def render(self, frame_buffer_ptr: c_void_p):
+        sdl2.SDL_UpdateTexture(
+            self.sdl_texture_buffer,
+            None,
+            frame_buffer_ptr,
+            DISPLAY_WIDTH * COLOUR_SIZE,
+        )
+        sdl2.SDL_RenderClear(self.sdl_renderer)
+        sdl2.SDL_RenderCopy(self.sdl_renderer, self.sdl_texture_buffer, None, None)
+        sdl2.SDL_RenderPresent(self.sdl_renderer)
+
+
+class WindowEvent(Enum):
+    # fmt: off
+    NONE = auto()
+
+    QUIT                    = auto()
+    FULLSCREEN              = auto()
+
+    PRESS_BUTTON_A          = auto()
+    PRESS_BUTTON_B          = auto()
+    PRESS_BUTTON_SELECT     = auto()
+    PRESS_BUTTON_START      = auto()
+    PRESS_DPAD_RIGHT        = auto()
+    PRESS_DPAD_LEFT         = auto()
+    PRESS_DPAD_UP           = auto()
+    PRESS_DPAD_DOWN         = auto()
+    PRESS_SHOULDER_RIGHT    = auto()
+    PRESS_SHOULDER_LEFT     = auto()
+
+    RELEASE_BUTTON_A        = auto()
+    RELEASE_BUTTON_B        = auto()
+    RELEASE_BUTTON_SELECT   = auto()
+    RELEASE_BUTTON_START    = auto()
+    RELEASE_DPAD_RIGHT      = auto()
+    RELEASE_DPAD_LEFT       = auto()
+    RELEASE_DPAD_UP         = auto()
+    RELEASE_DPAD_DOWN       = auto()
+    RELEASE_SHOULDER_RIGHT  = auto()
+    RELEASE_SHOULDER_LEFT   = auto()
+    # fmt: on
+
+
+class KeyMapping:
+    # fmt: off
+    KEY_DOWN = {
+        sdl2.SDLK_a         : WindowEvent.PRESS_BUTTON_A,
+        sdl2.SDLK_s         : WindowEvent.PRESS_BUTTON_B,
+        sdl2.SDLK_BACKSPACE : WindowEvent.PRESS_BUTTON_SELECT,
+        sdl2.SDLK_RETURN    : WindowEvent.PRESS_BUTTON_START,
+        sdl2.SDLK_RIGHT     : WindowEvent.PRESS_DPAD_RIGHT,
+        sdl2.SDLK_LEFT      : WindowEvent.PRESS_DPAD_LEFT,
+        sdl2.SDLK_UP        : WindowEvent.PRESS_DPAD_UP,
+        sdl2.SDLK_DOWN      : WindowEvent.PRESS_DPAD_DOWN,
+        sdl2.SDLK_w         : WindowEvent.PRESS_SHOULDER_RIGHT,
+        sdl2.SDLK_q         : WindowEvent.PRESS_SHOULDER_LEFT,
+    }
+
+    KEY_UP = {
+        sdl2.SDLK_a         : WindowEvent.RELEASE_BUTTON_A,
+        sdl2.SDLK_s         : WindowEvent.RELEASE_BUTTON_B,
+        sdl2.SDLK_BACKSPACE : WindowEvent.RELEASE_BUTTON_SELECT,
+        sdl2.SDLK_RETURN    : WindowEvent.RELEASE_BUTTON_START,
+        sdl2.SDLK_RIGHT     : WindowEvent.RELEASE_DPAD_RIGHT,
+        sdl2.SDLK_LEFT      : WindowEvent.RELEASE_DPAD_LEFT,
+        sdl2.SDLK_UP        : WindowEvent.RELEASE_DPAD_UP,
+        sdl2.SDLK_DOWN      : WindowEvent.RELEASE_DPAD_DOWN,
+        sdl2.SDLK_w         : WindowEvent.RELEASE_SHOULDER_RIGHT,
+        sdl2.SDLK_q         : WindowEvent.RELEASE_SHOULDER_LEFT,
+        sdl2.SDLK_ESCAPE    : WindowEvent.QUIT,
+        sdl2.SDLK_F11       : WindowEvent.FULLSCREEN,
+    }
+    # fmt: on

pyboy_advance-0.0.1/pyboy_advance/cpu/arm/alu.py

@@ -0,0 +1,260 @@
+from __future__ import annotations
+
+from enum import IntEnum
+from typing import TYPE_CHECKING
+
+from pyboy_advance.cpu.registers import Registers
+from pyboy_advance.utils import get_bits, get_bit, ror_32, sign_32, bint
+
+if TYPE_CHECKING:
+    from pyboy_advance.cpu.cpu import CPU
+
+
+class ALUOpcode(IntEnum):
+    AND = 0x0
+    EOR = 0x1
+    SUB = 0x2
+    RSB = 0x3
+    ADD = 0x4
+    ADC = 0x5
+    SBC = 0x6
+    RSC = 0x7
+    TST = 0x8
+    TEQ = 0x9
+    CMP = 0xA
+    CMN = 0xB
+    ORR = 0xC
+    MOV = 0xD
+    BIC = 0xE
+    MVN = 0xF
+
+
+def arm_alu(cpu: CPU, instr: int):
+    """Execute a Data Processing (ALU) instruction (AND, EOR, ADD, SUB, MOV, etc.)"""
+
+    rn = get_bits(instr, 16, 19)
+    rd = get_bits(instr, 12, 15)
+
+    shift_carry = cpu.regs.cpsr.carry_flag
+
+    set_cond_codes = get_bit(instr, 20)
+    immediate = get_bit(instr, 25)
+
+    early_advance_pc = False
+
+    if immediate:  # Immediate value as 2nd operand
+        op1 = cpu.regs[rn]
+        op2 = get_bits(instr, 0, 7)
+        ror_amount = get_bits(instr, 8, 11) * 2
+
+        if ror_amount > 0:
+            shift_carry = get_bit(op2, ror_amount - 1)
+            op2 = ror_32(op2, ror_amount)
+
+    else:  # Register value as 2nd operand
+        rm = get_bits(instr, 0, 3)
+        shift = get_bits(instr, 4, 11)
+
+        # When using PC as an operand, the returned value depends on the instruction.
+        # If shifting by register (shift[0] = 1) and using a register value as op2,
+        # then the operand should be PC + 12.
+        if get_bit(shift, 0):
+            # Advance PC by 4 so that cpu.regs.pc returns PC + 12
+            cpu.advance_pc_arm()
+            early_advance_pc = True
+            cpu.scheduler.idle()
+        else:
+            # Otherwise, the operand should be PC + 8
+            # (which is what cpu.regs.pc returns normally).
+            pass
+
+        op1 = cpu.regs[rn]
+        op2, shift_carry = cpu.decode_and_compute_shift(cpu.regs[rm], shift)
+
+    opcode = ALUOpcode(get_bits(instr, 21, 24))
+    if opcode == ALUOpcode.AND:
+        arm_alu_and(cpu, op1, op2, rd, set_cond_codes, shift_carry)
+    elif opcode == ALUOpcode.EOR:
+        arm_alu_eor(cpu, op1, op2, rd, set_cond_codes, shift_carry)
+    elif opcode == ALUOpcode.SUB:
+        arm_alu_sub(cpu, op1, op2, rd, set_cond_codes)
+    elif opcode == ALUOpcode.RSB:
+        arm_alu_rsb(cpu, op1, op2, rd, set_cond_codes)
+    elif opcode == ALUOpcode.ADD:
+        arm_alu_add(cpu, op1, op2, rd, set_cond_codes)
+    elif opcode == ALUOpcode.ADC:
+        arm_alu_adc(cpu, op1, op2, rd, set_cond_codes)
+    elif opcode == ALUOpcode.SBC:
+        arm_alu_sbc(cpu, op1, op2, rd, set_cond_codes)
+    elif opcode == ALUOpcode.RSC:
+        arm_alu_rsc(cpu, op1, op2, rd, set_cond_codes)
+    elif opcode == ALUOpcode.TST:
+        arm_alu_tst(cpu, op1, op2, shift_carry)
+    elif opcode == ALUOpcode.TEQ:
+        arm_alu_teq(cpu, op1, op2, shift_carry)
+    elif opcode == ALUOpcode.CMP:
+        arm_alu_cmp(cpu, op1, op2)
+    elif opcode == ALUOpcode.CMN:
+        arm_alu_cmn(cpu, op1, op2)
+    elif opcode == ALUOpcode.ORR:
+        arm_alu_orr(cpu, op1, op2, rd, set_cond_codes, shift_carry)
+    elif opcode == ALUOpcode.MOV:
+        arm_alu_mov(cpu, op2, rd, set_cond_codes, shift_carry)
+    elif opcode == ALUOpcode.BIC:
+        arm_alu_bic(cpu, op1, op2, rd, set_cond_codes, shift_carry)
+    elif opcode == ALUOpcode.MVN:
+        arm_alu_mvn(cpu, op2, rd, set_cond_codes, shift_carry)
+
+    # When S bit = 1 (set_cond_codes) and Rd = PC, the result of operation is stored in PC
+    # and SPSR of the current mode is moved to CPSR
+    if rd == Registers.PC:
+        if set_cond_codes:
+            new_cpsr_reg = cpu.regs.spsr.reg
+            new_cpsr_mode = cpu.regs.spsr.mode
+            cpu.switch_mode(new_cpsr_mode)
+            cpu.regs.cpsr.reg = new_cpsr_reg
+
+        # Read only operations do not flush the pipeline
+        if opcode not in [ALUOpcode.TST, ALUOpcode.TEQ, ALUOpcode.CMP, ALUOpcode.CMN]:
+            cpu.flush_pipeline()
+
+    elif not early_advance_pc:
+        cpu.advance_pc_arm()
+
+
+def arm_alu_and(cpu: CPU, op1: int, op2: int, rd: int, set_cond_codes: bint, shift_carry: bint):
+    cpu.regs[rd] = arm_alu_and_impl(cpu, op1, op2, rd, set_cond_codes, shift_carry)
+
+
+def arm_alu_and_impl(
+    cpu: CPU, op1: int, op2: int, rd: int, set_cond_codes: bint, shift_carry: bint
+) -> int:
+    result = op1 & op2
+    if set_cond_codes and rd != Registers.PC:
+        cpu.regs.cpsr.sign_flag = sign_32(result)
+        cpu.regs.cpsr.zero_flag = result == 0
+        cpu.regs.cpsr.carry_flag = shift_carry
+    return result
+
+
+def arm_alu_eor(cpu: CPU, op1: int, op2: int, rd: int, set_cond_codes: bint, shift_carry: bint):
+    cpu.regs[rd] = arm_alu_eor_impl(cpu, op1, op2, rd, set_cond_codes, shift_carry)
+
+
+def arm_alu_eor_impl(
+    cpu: CPU, op1: int, op2: int, rd: int, set_cond_codes: bint, shift_carry: bint
+) -> int:
+    result = op1 ^ op2
+    if set_cond_codes and rd != Registers.PC:
+        cpu.regs.cpsr.sign_flag = sign_32(result)
+        cpu.regs.cpsr.zero_flag = result == 0
+        cpu.regs.cpsr.carry_flag = shift_carry
+    return result
+
+
+def arm_alu_sub(cpu: CPU, op1: int, op2: int, rd: int, set_cond_codes: bint):
+    cpu.regs[rd] = arm_alu_sub_impl(cpu, op1, op2, rd, set_cond_codes)
+
+
+def arm_alu_sub_impl(cpu: CPU, op1: int, op2: int, rd: int, set_cond_codes: bint) -> int:
+    result = op1 - op2
+    truncated_result = result & 0xFFFFFFFF
+    if set_cond_codes and rd != Registers.PC:
+        cpu.regs.cpsr.sign_flag = sign_32(truncated_result)
+        cpu.regs.cpsr.zero_flag = truncated_result == 0
+        cpu.regs.cpsr.carry_flag = op1 >= op2  # Carry = no borrow
+        cpu.regs.cpsr.overflow_flag = sign_32((op1 ^ op2) & (op1 ^ truncated_result))
+    return truncated_result
+
+
+def arm_alu_rsb(cpu: CPU, op1: int, op2: int, rd: int, set_cond_codes: bint):
+    arm_alu_sub(cpu, op2, op1, rd, set_cond_codes)
+
+
+def arm_alu_add(cpu: CPU, op1: int, op2: int, rd: int, set_cond_codes: bint):
+    cpu.regs[rd] = arm_alu_add_impl(cpu, op1, op2, rd, set_cond_codes)
+
+
+def arm_alu_add_impl(cpu: CPU, op1: int, op2: int, rd: int, set_cond_codes: bint) -> int:
+    result = op1 + op2
+    truncated_result = result & 0xFFFFFFFF
+    if set_cond_codes and rd != Registers.PC:
+        cpu.regs.cpsr.sign_flag = sign_32(truncated_result)
+        cpu.regs.cpsr.zero_flag = truncated_result == 0
+        cpu.regs.cpsr.carry_flag = result > 0xFFFFFFFF
+        cpu.regs.cpsr.overflow_flag = sign_32(~(op1 ^ op2) & (op2 ^ truncated_result))
+    return truncated_result
+
+
+def arm_alu_adc(cpu: CPU, op1: int, op2: int, rd: int, set_cond_codes: bint):
+    carry = cpu.regs.cpsr.carry_flag
+    result = op1 + op2 + carry
+    cpu.regs[rd] = result & 0xFFFFFFFF
+    if set_cond_codes and rd != Registers.PC:
+        cpu.regs.cpsr.sign_flag = sign_32(cpu.regs[rd])
+        cpu.regs.cpsr.zero_flag = cpu.regs[rd] == 0
+        cpu.regs.cpsr.carry_flag = result > 0xFFFFFFFF
+        cpu.regs.cpsr.overflow_flag = sign_32(~(op1 ^ op2) & (op2 ^ cpu.regs[rd]))
+
+
+def arm_alu_sbc(cpu: CPU, op1: int, op2: int, rd: int, set_cond_codes: bint):
+    borrow = 1 - cpu.regs.cpsr.carry_flag  # Carry = no borrow, so subtract 0
+    result = op1 - op2 - borrow
+    cpu.regs[rd] = result & 0xFFFFFFFF
+    if set_cond_codes and rd != Registers.PC:
+        cpu.regs.cpsr.sign_flag = sign_32(cpu.regs[rd])
+        cpu.regs.cpsr.zero_flag = cpu.regs[rd] == 0
+        cpu.regs.cpsr.carry_flag = op1 >= (op2 + borrow)
+        cpu.regs.cpsr.overflow_flag = sign_32((op1 ^ op2) & (op1 ^ cpu.regs[rd]))
+
+
+def arm_alu_rsc(cpu: CPU, op1: int, op2: int, rd: int, set_cond_codes: bint):
+    arm_alu_sbc(cpu, op2, op1, rd, set_cond_codes)
+
+
+def arm_alu_tst(cpu: CPU, op1: int, op2: int, shift_carry: bint):
+    arm_alu_and_impl(cpu, op1, op2, 0, True, shift_carry)
+
+
+def arm_alu_teq(cpu: CPU, op1: int, op2: int, shift_carry: bint):
+    arm_alu_eor_impl(cpu, op1, op2, 0, True, shift_carry)
+
+
+def arm_alu_cmp(cpu: CPU, op1: int, op2: int):
+    arm_alu_sub_impl(cpu, op1, op2, 0, True)
+
+
+def arm_alu_cmn(cpu: CPU, op1: int, op2: int):
+    arm_alu_add_impl(cpu, op1, op2, 0, True)
+
+
+def arm_alu_orr(cpu: CPU, op1: int, op2: int, rd: int, set_cond_codes: bint, shift_carry: bint):
+    cpu.regs[rd] = op1 | op2
+    if set_cond_codes and rd != Registers.PC:
+        cpu.regs.cpsr.sign_flag = sign_32(cpu.regs[rd])
+        cpu.regs.cpsr.zero_flag = cpu.regs[rd] == 0
+        cpu.regs.cpsr.carry_flag = shift_carry
+
+
+def arm_alu_mov(cpu: CPU, op2: int, rd: int, set_cond_codes: bint, shift_carry: bint):
+    cpu.regs[rd] = op2
+    if set_cond_codes and rd != Registers.PC:
+        cpu.regs.cpsr.sign_flag = sign_32(cpu.regs[rd])
+        cpu.regs.cpsr.zero_flag = cpu.regs[rd] == 0
+        cpu.regs.cpsr.carry_flag = shift_carry
+
+
+def arm_alu_bic(cpu: CPU, op1: int, op2: int, rd: int, set_cond_codes: bint, shift_carry: bint):
+    cpu.regs[rd] = op1 & ~op2
+    if set_cond_codes and rd != Registers.PC:
+        cpu.regs.cpsr.sign_flag = sign_32(cpu.regs[rd])
+        cpu.regs.cpsr.zero_flag = cpu.regs[rd] == 0
+        cpu.regs.cpsr.carry_flag = shift_carry
+
+
+def arm_alu_mvn(cpu: CPU, op2: int, rd: int, set_cond_codes: bint, shift_carry: bint):
+    cpu.regs[rd] = ~op2 & 0xFFFFFFFF
+    if set_cond_codes and rd != Registers.PC:
+        cpu.regs.cpsr.sign_flag = sign_32(cpu.regs[rd])
+        cpu.regs.cpsr.zero_flag = cpu.regs[rd] == 0
+        cpu.regs.cpsr.carry_flag = shift_carry