xenia-rs/migration/project-root/ppc-manual/memory/stswi.md

stswi — Store String Word Immediate

Category: Memory · Form: X · Opcode: 0x7c0005aa

Assembler Mnemonics

Mnemonic	XML entry	Flags	Description
stswi	stswi	—	Store String Word Immediate

Syntax

(no disassembly template)

Encoding

stswi — form X

• Opcode word: 0x7c0005aa
• Primary opcode (bits 0–5): 31
• Extended opcode: 725
• Synchronising: no

Bits	Field	Meaning
0–5	OPCD	primary opcode
6–10	RT/FRT/VRT	destination
11–15	RA/FRA/VRA	source A
16–20	RB/FRB/VRB	source B
21–30	XO	extended opcode (10 bits)
31	Rc	record-form flag

Operands

Field	Role	Description

Register Effects

stswi

• Reads (always): none
• Reads (conditional): none
• Writes (always): none
• Writes (conditional): none

Status-Register Effects

No condition-register or status-register effects.

Operation (pseudocode)

; Pseudocode derives directly from the xenia-rs interpreter
; arm (see Implementation References). Operation semantics:
;   - Read source operands from the fields listed under Operands.
;   - Apply the arithmetic / logical / memory action described
;     in the Description field above.
;   - Write results to the destination register(s); update any
;     status bits enumerated under Status-Register Effects.
; Consult the IBM AIX reference link under IBM Reference for
; canonical PPC-style pseudocode where xenia's expression is
; terse.

C Translation Example

/* C translation: the xenia-rs interpreter arm below in           */
/* Implementation References is the authoritative semantic        */
/* snapshot. Translate it line-by-line:                            */
/*   - ctx.gpr[N]  -> r[N]       (or f[]/v[] for FPRs/VRs)        */
/*   - mem.read_u*/write_u* -> mem_read_u*_be / mem_write_u*_be   */
/*   - ctx.update_cr_signed(fld, v) -> update_cr_signed(fld, v)   */
/*   - ctx.xer_ca / xer_ov / xer_so -> xer.CA / xer.OV / xer.SO   */
/* The Register Effects and Status-Register Effects tables above  */
/* enumerate every side effect a faithful translation must emit.  */

Implementation References

stswi

• xenia-canary XML: tools/ppc-instructions.xml — search for mnem="stswi"
• xenia-canary emit: src/xenia/cpu/ppc/ppc_emit_memory.cc:737
• xenia-rs opcode: crates/xenia-cpu/src/opcode.rs:75
• xenia-rs decoder: crates/xenia-cpu/src/decoder.rs:835
• xenia-rs interpreter: crates/xenia-cpu/src/interpreter.rs:1540-1564

xenia-rs interpreter body (frozen snapshot)

        PpcOpcode::stswi => {
            let mut ea = if instr.ra() == 0 { 0u32 } else { ctx.gpr[instr.ra()] as u32 };
            let nb = if instr.nb() == 0 { 32 } else { instr.nb() };
            let mut rs = instr.rs();
            let mut bytes_left = nb;
            if let Some(t) = ctx.reservation_table.as_ref().filter(|t| t.is_enabled()) {
                if t.has_active_reservers() {
                    let first_line = ea & !RESERVATION_MASK;
                    let last_line = ea.wrapping_add(nb - 1) & !RESERVATION_MASK;
                    t.invalidate_for_write(first_line);
                    if last_line != first_line { t.invalidate_for_write(last_line); }
                }
            }
            while bytes_left > 0 {
                let val = ctx.gpr[rs] as u32;
                for byte_idx in 0..4 {
                    if bytes_left == 0 { break; }
                    mem.write_u8(ea, (val >> (24 - byte_idx * 8)) as u8);
                    ea = ea.wrapping_add(1);
                    bytes_left -= 1;
                }
                rs = (rs + 1) % 32;
            }
            ctx.pc += 4;
        }

Special Cases & Edge Conditions

• Byte-granular bulk store. Symmetric counterpart of lswi. Reads the low 32 bits of RS, RS+1, …, takes the top byte of each (then the next, etc.) and writes successive bytes at EA. The byte count NB is in the RB field of the encoding (1..31), with NB = 0 meaning "32 bytes".
• Register wraparound at r31 → r0. Xenia's snapshot increments rs = (rs + 1) % 32. After r31 the source becomes r0, then r1, etc. Rare in practice; AIX flags overlapping register / address ranges as invalid.
• Big-endian byte ordering inside each register. Writes the most-significant byte first: mem.write_u8(ea, (val >> 24) as u8), then bits 16–23, etc. Matches the byte order produced by lswi, so a lswi/stswi pair round-trips a buffer.
• Last partial register. When NB is not a multiple of 4, the final source register has its trailing low bytes ignored — only the leading bytes that fit in the byte budget are written.
• RA0 semantics. RA = 0 selects literal zero. stswi is not an update form; RA is not modified.
• Alignment. Architecture allows arbitrary alignment; cache-inhibited storage may raise alignment exceptions on hardware.
• Vanishingly rare in compiled code. Compilers don't emit stswi. Hand-written memcpy cores may.

Related Instructions

• lswi — symmetric load.
• stswx — register-supplied byte-count variant.
• stmw — word-granular bulk store.
• stw, stb — scalar stores compilers actually emit.

IBM Reference

• AIX 7.3 — stswi (Store String Word Immediate)
• PowerISA v2.07B Book II § "Load and Store String".