lbzux
Load Byte and Zero with Update Indexed - 7C 00 00 EE
lbzux
Instruction Syntax
Mnemonic | Format | Flags |
lbzux | rD,rA,rB | - |
Instruction Encoding
0
1
1
1
1
1
D
D
D
D
D
A
A
A
A
A
B
B
B
B
B
0
0
0
1
1
1
0
1
1
1
/
Field | Bits | Description |
Primary Opcode | 0-5 | 011111 (0x1F) |
rD | 6-10 | Destination register |
rA | 11-15 | Source register A |
rB | 16-20 | Source register B |
XO | 21-30 | 119 (Extended opcode) |
Rc | 31 | Reserved (0) |
Operation
EA ← (rA) + (rB) rD ← 0x00 || MEM(EA, 1) rA ← EA
A byte is loaded from memory and placed in the low-order 8 bits of register rD. The upper 24 bits of rD are set to zero. The effective address is computed by adding the contents of registers rA and rB. After the load, the effective address is stored back into register rA.
Note: This instruction cannot be used with rA=0. The update form requires a valid base register. This indexed update form is particularly useful for traversing data structures with dynamic offsets while maintaining pointer advancement.
Affected Registers
rA - Updated with the effective address after the load operation.
For more information on memory addressing see Section 2.1.6, "Effective Address Calculation," in the PowerPC Microprocessor Family: The Programming Environments manual.
Examples
Dynamic String Processing
# Process string with variable character advance (UTF-8 decoding) lis r3, utf8_string@ha addi r3, r3, utf8_string@l li r4, 1 # Default advance (1 byte for ASCII) utf8_decode_loop: mr r5, r4 # Use calculated advance lbzux r6, r3, r5 # Load byte and advance by computed offset # Decode UTF-8 character cmpwi r6, 0 # Check for null terminator beq string_done # Check UTF-8 encoding andi. r7, r6, 0x80 # Check if high bit set beq ascii_char # ASCII character (1 byte) andi. r7, r6, 0xE0 # Check for 110xxxxx pattern cmpwi r7, 0xC0 beq two_byte_char # 2-byte UTF-8 character andi. r7, r6, 0xF0 # Check for 1110xxxx pattern cmpwi r7, 0xE0 beq three_byte_char # 3-byte UTF-8 character andi. r7, r6, 0xF8 # Check for 11110xxx pattern cmpwi r7, 0xF0 beq four_byte_char # 4-byte UTF-8 character b invalid_utf8 # Invalid UTF-8 sequence ascii_char: # Process ASCII character bl process_ascii_char # Process character in r6 li r4, 1 # Next advance = 1 byte b utf8_decode_loop two_byte_char: # Load second byte li r8, 1 lbzux r9, r3, r8 # Load continuation byte # Decode 2-byte character: ((first & 0x1F) << 6) | (second & 0x3F) andi r10, r6, 0x1F # Extract 5 bits from first byte slwi r10, r10, 6 # Shift left 6 positions andi r11, r9, 0x3F # Extract 6 bits from second byte or r12, r10, r11 # Combine into Unicode code point bl process_unicode_char # Process character li r4, 1 # Advance 1 more byte (already advanced 1) b utf8_decode_loop three_byte_char: # Load second and third bytes li r8, 1 lbzux r9, r3, r8 # Load second byte li r8, 1 lbzux r13, r3, r8 # Load third byte # Decode 3-byte character andi r10, r6, 0x0F # Extract 4 bits from first byte slwi r10, r10, 12 # Shift left 12 positions andi r11, r9, 0x3F # Extract 6 bits from second byte slwi r11, r11, 6 # Shift left 6 positions andi r14, r13, 0x3F # Extract 6 bits from third byte or r15, r10, r11 # Combine first two parts or r12, r15, r14 # Final Unicode code point bl process_unicode_char li r4, 1 # Advance 1 more byte b utf8_decode_loop four_byte_char: # Handle 4-byte UTF-8 character (similar to above) # ... (implementation details) li r4, 3 # Advance 3 more bytes b utf8_decode_loop invalid_utf8: # Handle invalid UTF-8 sequence bl handle_invalid_utf8 li r4, 1 # Skip 1 byte and continue b utf8_decode_loop string_done:
Sparse Matrix Processing
# Process sparse matrix using compressed format lis r3, sparse_data@ha addi r3, r3, sparse_data@l # Compressed data array lis r4, offset_array@ha addi r4, r4, offset_array@l # Offset array for next element lwz r5, num_elements(r0) # Number of non-zero elements sparse_loop: lwz r6, 0(r4) # Load offset to next element lbzux r7, r3, r6 # Load sparse data value and advance by offset # Process non-zero element bl process_sparse_element # Process value in r7 # Update offset array pointer addi r4, r4, 4 # Move to next offset subi r5, r5, 1 # Decrement element counter cmpwi r5, 0 bne sparse_loop # Continue processing
Variable-Length Instruction Decoding
# Decode variable-length instructions (like x86) lis r3, instruction_stream@ha addi r3, r3, instruction_stream@l lwz r4, stream_end(r0) # End of instruction stream decode_loop: cmpw r3, r4 # Check if reached end bge decode_done li r5, 1 # Default instruction length lbzux r6, r3, r5 # Load opcode byte and advance # Decode instruction length based on opcode lis r7, opcode_lengths@ha addi r7, r7, opcode_lengths@l lbzx r8, r7, r6 # Load instruction length from table # If instruction has multiple bytes, load them cmpwi r8, 1 beq single_byte_instr # Single byte instruction # Multi-byte instruction subi r9, r8, 1 # Remaining bytes to load lis r10, temp_instr@ha addi r10, r10, temp_instr@l stb r6, 0(r10) # Store opcode byte li r11, 1 # Temp instruction offset multi_byte_loop: li r12, 1 # Advance 1 byte lbzux r13, r3, r12 # Load next instruction byte stbx r13, r10, r11 # Store in temp instruction buffer addi r11, r11, 1 # Next temp offset subi r9, r9, 1 # Decrement remaining bytes cmpwi r9, 0 bne multi_byte_loop # Continue loading bytes # Process multi-byte instruction bl process_multi_byte_instr # Pass instruction buffer b decode_loop single_byte_instr: # Process single-byte instruction bl process_single_byte_instr # Pass opcode in r6 b decode_loop decode_done:
Run-Length Decoding with Dynamic Advances
# Decode run-length encoded data with variable advances lis r3, encoded_data@ha addi r3, r3, encoded_data@l lis r4, decoded_buffer@ha addi r4, r4, decoded_buffer@l lwz r5, encoded_size(r0) # Size of encoded data decode_rle_loop: cmpwi r5, 0 # Check if more data to process ble decode_complete li r6, 1 # Advance 1 byte lbzux r7, r3, r6 # Load run length and advance subi r5, r5, 1 # Decrement remaining size li r6, 1 # Advance 1 byte lbzux r8, r3, r6 # Load data byte and advance subi r5, r5, 1 # Decrement remaining size # Check for special encoding cmpwi r7, 0 # Check for escape sequence beq escape_sequence # Normal run-length: repeat r8 for r7 times mr r9, r7 # Copy run length repeat_loop: stb r8, 0(r4) # Store data byte addi r4, r4, 1 # Advance output pointer subi r9, r9, 1 # Decrement repeat count cmpwi r9, 0 bne repeat_loop # Continue repeating b decode_rle_loop # Process next run escape_sequence: # Handle escape sequence - next byte indicates type li r6, 1 # Advance 1 byte lbzux r10, r3, r6 # Load escape type and advance subi r5, r5, 1 # Decrement remaining size cmpwi r10, ESC_LITERAL # Check for literal run beq literal_run cmpwi r10, ESC_REPEAT # Check for long repeat beq long_repeat b unknown_escape # Unknown escape literal_run: # Next byte is literal count li r6, 1 lbzux r11, r3, r6 # Load literal count and advance subi r5, r5, 1 # Copy literal bytes literal_copy_loop: li r6, 1 lbzux r12, r3, r6 # Load literal byte and advance stb r12, 0(r4) # Store to output addi r4, r4, 1 # Advance output pointer subi r5, r5, 1 # Decrement remaining size subi r11, r11, 1 # Decrement literal count cmpwi r11, 0 bne literal_copy_loop # Continue copying literals b decode_rle_loop long_repeat: # Next two bytes form 16-bit repeat count li r6, 1 lbzux r13, r3, r6 # Load high byte of count li r6, 1 lbzux r14, r3, r6 # Load low byte of count slwi r15, r13, 8 # Shift high byte or r16, r15, r14 # Combine into 16-bit count li r6, 1 lbzux r17, r3, r6 # Load data byte to repeat subi r5, r5, 3 # Decrement remaining size (3 bytes used) # Repeat data byte long_repeat_loop: stb r17, 0(r4) # Store data byte addi r4, r4, 1 # Advance output pointer subi r16, r16, 1 # Decrement repeat count cmpwi r16, 0 bne long_repeat_loop # Continue repeating b decode_rle_loop unknown_escape: # Handle unknown escape sequence bl handle_unknown_escape b decode_rle_loop decode_complete:
Protocol Parser with Variable Field Lengths
# Parse network protocol with variable-length fields lis r3, packet_data@ha addi r3, r3, packet_data@l lwz r4, packet_length(r0) # Total packet length parse_packet: cmpwi r4, 0 # Check if more data to parse ble parse_complete # Load field type li r5, 1 # Advance 1 byte lbzux r6, r3, r5 # Load field type and advance subi r4, r4, 1 # Decrement remaining length # Process field based on type cmpwi r6, FIELD_FIXED_8 # 8-bit fixed field beq parse_fixed_8 cmpwi r6, FIELD_VARIABLE # Variable-length field beq parse_variable cmpwi r6, FIELD_STRING # Null-terminated string beq parse_string cmpwi r6, FIELD_ARRAY # Array field beq parse_array b unknown_field parse_fixed_8: # Load 8-bit fixed field li r5, 1 lbzux r7, r3, r5 # Load field value and advance subi r4, r4, 1 # Decrement remaining length bl process_fixed_field # Process field value b parse_packet parse_variable: # Variable-length field: first byte is length li r5, 1 lbzux r8, r3, r5 # Load field length and advance subi r4, r4, 1 # Decrement remaining length # Load variable field data mr r9, r8 # Copy field length variable_loop: cmpwi r9, 0 # Check if done beq variable_done li r5, 1 lbzux r10, r3, r5 # Load field byte and advance bl process_variable_byte # Process byte subi r4, r4, 1 # Decrement remaining length subi r9, r9, 1 # Decrement field length b variable_loop variable_done: b parse_packet parse_string: # Null-terminated string field string_loop: li r5, 1 lbzux r11, r3, r5 # Load string byte and advance subi r4, r4, 1 # Decrement remaining length cmpwi r11, 0 # Check for null terminator beq string_done bl process_string_char # Process character b string_loop string_done: b parse_packet parse_array: # Array field: first byte is element count li r5, 1 lbzux r12, r3, r5 # Load element count and advance subi r4, r4, 1 # Decrement remaining length # Load array elements mr r13, r12 # Copy element count array_loop: cmpwi r13, 0 # Check if done beq array_done li r5, 1 lbzux r14, r3, r5 # Load array element and advance bl process_array_element # Process element subi r4, r4, 1 # Decrement remaining length subi r13, r13, 1 # Decrement element count b array_loop array_done: b parse_packet unknown_field: # Handle unknown field type bl handle_unknown_field # Try to skip to next field (implementation specific) li r5, 1 # Skip 1 byte add r3, r3, r5 # Manual advance since we can't use lbzux safely subi r4, r4, 1 b parse_packet parse_complete:
Adaptive Compression Dictionary
# Build adaptive dictionary with variable symbol lengths lis r3, input_stream@ha addi r3, r3, input_stream@l lis r4, dictionary@ha addi r4, r4, dictionary@l lwz r5, stream_length(r0) # Input stream length li r6, 0 # Dictionary size build_dictionary: cmpwi r5, 0 # Check if more input ble dict_complete # Load next symbol from input li r7, 1 # Default advance lbzux r8, r3, r7 # Load input byte and advance subi r5, r5, 1 # Decrement remaining input # Check if symbol exists in dictionary bl find_in_dictionary # Pass symbol in r8, returns index in r9 cmpwi r9, -1 # Check if found bne symbol_found # Symbol exists, update frequency # Add new symbol to dictionary cmpwi r6, MAX_DICT_SIZE # Check dictionary capacity bge dict_full # Dictionary full # Store new symbol stbx r8, r4, r6 # Store symbol in dictionary # Initialize frequency count (stored after symbol) li r10, 1 # Initial frequency lis r11, freq_array@ha addi r11, r11, freq_array@l slwi r12, r6, 2 # Convert index to word offset stwx r10, r11, r12 # Store frequency addi r6, r6, 1 # Increment dictionary size b build_dictionary symbol_found: # Update frequency for existing symbol lis r11, freq_array@ha addi r11, r11, freq_array@l slwi r12, r9, 2 # Convert index to word offset lwzx r13, r11, r12 # Load current frequency addi r14, r13, 1 # Increment frequency stwx r14, r11, r12 # Store updated frequency # Check if frequency threshold reached for multi-byte encoding cmpwi r14, MULTI_BYTE_THRESHOLD blt build_dictionary # Continue if below threshold # Create multi-byte symbol by looking ahead cmpwi r5, 0 # Check if more input available beq build_dictionary # No more input # Lookahead for pattern extension mr r15, r3 # Save current position mr r16, r5 # Save remaining length li r17, 2 # Look for 2-byte patterns initially pattern_extend_loop: cmpw r17, r16 # Check if enough input remaining bgt pattern_extend_done # Not enough input # Load potential multi-byte pattern li r18, 0 # Pattern index mr r19, r15 # Pattern start position lis r20, temp_pattern@ha addi r20, r20, temp_pattern@l # Temporary pattern buffer load_pattern_loop: cmpw r18, r17 # Check if loaded entire pattern bge check_pattern_exists li r21, 1 lbzux r22, r19, r21 # Load pattern byte stbx r22, r20, r18 # Store in pattern buffer addi r18, r18, 1 # Next pattern byte b load_pattern_loop check_pattern_exists: # Check if this pattern already exists in dictionary bl find_pattern_in_dict # Pass pattern buffer, length, returns index cmpwi r23, -1 # Check if pattern found bne pattern_exists # Pattern already exists # Add new multi-byte pattern to dictionary # ... (implementation for adding multi-byte patterns) pattern_exists: addi r17, r17, 1 # Try longer pattern cmpwi r17, MAX_PATTERN_LENGTH ble pattern_extend_loop # Continue extending if within limits pattern_extend_done: b build_dictionary dict_full: # Handle dictionary overflow bl handle_dict_overflow b build_dictionary dict_complete: # Sort dictionary by frequency for optimal encoding bl sort_dictionary_by_frequency