SNES JIT 65816 example

; The 65816 SNES code that is being JIT compiled:

; $00:8000: LDA #$5A
; $00:8002: LDX #$08
; loop:
; $00:8004: STA $0003,x
; $00:8007: DEX
; $00:8008: CPX #$01
; $00:800A: BNE loop
; $00:800C: STP

; Which basically just writes 7 bytes of 0x5A into memory at $0005-$000B

;--------------------------------

; The following functions are the result of the JIT compilation, which ran like this:
; Generate ADDR_008000_MX
; Run      ADDR_008000_MX | Initial LDA+LDX and 1st loop
;
; Generate ADDR_008004_MX
; Run      ADDR_008004_MX | 2nd loop
; Run      ADDR_008004_MX | 3rd loop
; Run      ADDR_008004_MX | 4th loop
; Run      ADDR_008004_MX | 5th loop
; Run      ADDR_008004_MX | 6th loop
; Run      ADDR_008004_MX | 7th loop
;
; Generate ADDR_00800C_MX
; Run      ADDR_00800C_MX | STP (stop)

;--------------------------------

; This function runs the first two instructions and the first loop until the branch.
; We can optimize things, because the first loop always runs with A=0x5A and X=0x08.
; Other things are optimized too, e.g. LDA, LDX and DEX all affect the N and Z flags of the P register,
; but those computations are all removed because their results are not needed before CPX overwrites them all.
define void @ADDR_008000_MX(ptr nocapture %0) local_unnamed_addr #0 {
entry:
  %mem = getelementptr i8, ptr %0, i64 32      ;\ Prepare pointers
  %ptrA = getelementptr i8, ptr %0, i64 4      ;|
  %ptrX = getelementptr i8, ptr %0, i64 6      ;|
  %ptrP = getelementptr i8, ptr %0, i64 12     ;|
  %ptrDB = getelementptr i8, ptr %0, i64 16    ;/
  %1 = load i8, ptr %ptrP, align 1             ; Load P
  %2 = load i8, ptr %ptrDB, align 1            ; Load DB
  %3 = zext i8 %2 to i64                       ;\ Prepare DB for indexing
  %4 = shl nuw nsw i64 %3, 16                  ;/
  %5 = or i64 %4, 11                           ; $0003,x and X equals 8 in this first loop, so hardcoded $0011 with DB bank
  %6 = getelementptr i8, ptr %mem, i64 %5      ; Prepare memory pointer
  store i8 90, ptr %6, align 1                 ; Execute STA of STA $0003,x | A is always 0x5A=90 here, that's why we can hardcode the value
  %7 = and i8 %1, 124                          ;\ In P (flag register): reset N,Z and set C
  %P8 = or i8 %7, 1                            ;/
  store i16 -32764, ptr %0, align 2            ; Write 0x8004 to PC and quit block because we reached a branch instruction
  store i8 90, ptr %ptrA, align 1              ; Write 0x5A to A
  store i8 7, ptr %ptrX, align 1               ; Write 0x07 to X
  store i8 %P8, ptr %ptrP, align 1             ; Write changed P
  ret void
}

; This function runs the loop.
; Since A and X can be anything here, we can't optimize things so much.
define void @ADDR_008004_MX(ptr nocapture %0) local_unnamed_addr #0 {
entry:
  %mem = getelementptr i8, ptr %0, i64 32       ;\ Prepare pointers
  %ptrA = getelementptr i8, ptr %0, i64 4       ;|
  %ptrX = getelementptr i8, ptr %0, i64 6       ;|
  %ptrP = getelementptr i8, ptr %0, i64 12      ;|
  %ptrDB = getelementptr i8, ptr %0, i64 16     ;/
  %1 = load i8, ptr %ptrA, align 1              ; Load A
  %2 = load i8, ptr %ptrX, align 1              ; Load X
  %3 = load i8, ptr %ptrP, align 1              ; Load P
  %4 = load i8, ptr %ptrDB, align 1             ; Load DB
  %5 = zext i8 %4 to i64                        ;\ Prepare DB for indexing
  %6 = shl nuw nsw i64 %5, 16                   ;/
  %7 = zext i8 %2 to i64                        ; Prepare X for indexing
  %8 = add nuw nsw i64 %7, 3                    ; Add 3 to X
  %9 = or i64 %8, %6                            ; Compute $0003,x
  %10 = getelementptr i8, ptr %mem, i64 %9      ; Prepare memory pointer
  store i8 %1, ptr %10, align 1                 ; Execute STA of STA $0003,x
  %11 = add i8 %2, -1                           ; Execute DEX
  %12 = and i8 %3, 124                          ; Reset flags N,Z and C
  %13 = add i8 %2, -2                           ;\ X-2 == 0, which is the combination of DEX and CPX #$01
  %14 = icmp eq i8 %13, 0                       ;/
  %15 = select i1 %14, i8 2, i8 0               ; If the loop is done, set Z
  %16 = and i8 %13, -128                        ;\ Build the flag register P
  %17 = or i8 %12, %16                          ;|
  %18 = icmp sge i8 %11, %13                    ;|
  %19 = zext i1 %18 to i8                       ;|
  %20 = or i8 %17, %19                          ;|
  %P4 = or i8 %20, %15                          ;/
  %21 = select i1 %14, i16 -32756, i16 -32764   ; Jump to $800C if loop ended, if loop continues jump back to $8004
  store i16 %21, ptr %0, align 2                ; Write PC
  store i8 %11, ptr %ptrX, align 1              ; Write X
  store i8 %P4, ptr %ptrP, align 1              ; Write P
  ret void
}

define void @ADDR_00800C_MX(ptr nocapture writeonly %0) local_unnamed_addr #0 {
entry:
  store i16 -32755, ptr %0, align 2             ; Write $800D to PC
  ret void
}