PowerPC Tutorial

Chapter 10: Basic Loads and Stores

This chapter will teach you about Loads and Stores. So far you've learned about modifying values in Registers using basic instructions. Now we will dive into how to interact with Memory.

Store = Value copied from Registers to Memory
Load = Value copied from Memory to Registers

If you need a refresher on Memory, go back to Chapter 4. Let's cover Store instructions first.

Store Word
stw rD, SIMM (rA)

For *any* load or store instructions in this Chapter, a Memory Address must first be calculated via the addition of the source register and the Immediate Value. The result of this equation is known as the Effective Address (EA for short).

Effective Address calculation guide (applies to all loads and stores in this Chapter):
rA + SIMM = Effective Address

Once the Effective Address has been determined, then the act of Storing will take place. In the stw (store-word) instruction, the entire value (32-bits) in rD is COPY-PASTED to the Memory Location determined by the Effective Address. It is important that you understand Store = *Copy-Paste* to Memory.

Example:

stw r9, 0x1B0 (r3)

Let's say that...
r9 = 0x100B3A8C
r3 = 0x407FFC80

The Effective Address is 0x407FFC80 + 0x01B0. Which is 0x407FFE30.

Once the instruction has executed, the value of 0x100B3A8C is stored to Memory Address 0x407FFE30. Whatever word value that was there beforehand, is now overwritten. Let's look at some pictures to get a better idea.

Here's a pic of right before the stw instruction has executed. Using a GDB Memory Command (you will learn about these shortly), we see the contents of memory at the address range of 0x407FFE20 thru 0x407FFE4F. The spot in memory where the write will occur is outlined in RED.

Now, let's execute the stw instruction. Here's what we see...

We see that the word value in r9 was copy-pasted to the Effective Address (0x80001600; outlined in Red).

GDB Memory Commands

Seeing memory within GDB is a bit of pain. GDB uses the following Memory Command template...

x/nfu addr

x = all GDB memory commands must start with a lower case x.
n = The count of how many units to display. Default value is 1.
f = Display format. Default is x (for hex). d is for signed decimal. u is for unsigned decimal. o is for octal. f is for float.
u = unit type. b for bytes. h for halfwords. w for words. g for doublewords. Default value is w (words).
addr = memory address

If nfu all are set to default values (which would also be the case if they were all omitted), then a the slash (/) is *NOT* needed in the memory command.

Example memory command showing 4 hex words at address 0x1234C
x/4xw 0x1234C

Instead of having to fill in an address, you can instead reference a register using the "$" symbol.

Example memory command showing 2 hex words located at r3:
x/2xw $r3

So if we wanted to see the word value at the effective address, the GDB memory command would be this...
x/xw $r3 + 0x1B0

In order to Store a halfword, we have to use the sth instruction.

Store Halfword:
sth rD, SIMM (rA}

This stores the LOWER 16-bits of rD to the Effective Address.

Example:

sth r5, 0xC (r10)

Let's pretend r5 = 0xABCD2001 and r10 = 0x407FFD10. First calculate the Effect Address. 0x407FFD10 + 0xC = 0x407FFD1C. This is the address where the halfword will be stored.

Here's a pic of right before the sth instruction executes.

The spot to where the store will occur is in RED. Now here's a pic of once the instruction executes.

Notice that only the lower 16-bits of r5 (0x2001) gets stored. The upper 16-bits (0ABCD) do NOT get copied.

To store just a Byte, we use the stb instruction.

Store Byte:
stb rD, SIMM (rA)

This stores the LOWER 8-bits of rD to the Effective Address.

Example:

stb r12, -0x28 (r11)

Let's pretend r12 = 0x0000007F and r11 = 0x407FFDC0. First calculate the Effect Address. 0x407FFDC0 - 0x28 = 0x407FFD98. The SIMM is negative, so we subtract to calcualte the EA instead of add. 0x407FFD98 the address where the byte will be stored.

Here's a pic of right before the stb instruction executes.

The spot to where the store will occur is in RED. Now here's a pic of once the instruction executes.

Only the lower 8-bits of r12 gets stored.

Before we cover specific Load instructions, let's discuss what they generally are. Load instructions still calculate the Effective Address via the same method as Store instructions do. Once the Effective Address is calculated, the load will occur

It's important that you understand that Load = Copy-Paste from Memory to Register. Whatever was in the Register beforehand is now overwritten.

Load Word & Zero:
lwz rD, SIMM (rA)

This is essentially the opposite of a Store Word Instruction. The Effective Address must be calculated just like a Store Instruction would. The word value located at the Effective Address is COPY-PASTED into rD. Whatever value that was in rD beforehand, is now overwritten.

Example:

lwz r3, 0 (r4)

r4 = 0x40800190

The Effective Address (EA) is simply what's in r4 since the SIMM is Zero.

The word value located at 0x40800190 will be copy-pasted into r3.

Here's a pic of right before the lwz instruction executes...

The destination register (r3), and the word at the EA are both highlighted in blue. now here's a pic of once the lwz instruction has executed.

We can see the word is copy-pasted to r3. The previous value in r3 was overwritten.

Load Halfword & Zero:
lhz rD, SIMM (rA)

Whenever *any* lhz instruction is executed, the upper 16 bits of rD is always set to ZERO! Thus, in any lwz instruction, rD always results as 0x0000XXXX with XXXX being the halfword value that was loaded.

Example:

lhz r0, 0xFFFFFFF0 (r8)

r8 = 0x40800198
EA = 0x40800188 (0x40800198 - 0x10)

Here's a pic of right before the lhz instruction executes....

Here's a pic of once the lhz instruction has executed...

Load Byte & Zero:
lbz rD, SIMM (rA)

Whenever a lbz instruction is executed, the upper 24-bits of rD are set to ZERO! Thus, in any lbz instruction, rD always results as 0x000000XX with XX being the byte value that was loaded.

Example:

lbz r7, 0x111 (r3)

r3 = 0x40800080
EA = 0x40800191 (0x40800080 + 0x111)

Here's a pic of right before the lbz instruction executes....

Here's a pic of once the lbz instruction has executed...

One thing we haven't discussed yet is stores & loads that use the same numbered Destination & Source Register

Example 1:

stw r5, 0xF24 (r5)

Here we have a store word instruction where the Destination and Source register use the same GPR. It operates the same way as like any other basic store instruction. Calculate the Effective Address (r5 + 0xF24), then the instruction simply stores r5 to the Effective Address.

Example 2:

lbz r12, 0 (r12)

In this instruction the byte value located at the address in r12 is then loaded into r12. Thus, r12 is no longer its original value.

Okay so at this point in your Assembly Journey, you have learned basic integer instructions (i.e. add) and basic load+store instructions. Now let's go over a simple exercise in which you will use your newly learned skills.

We want to write a Source of code that will do the following...

Loads a word value from memory
Increment that value by 2
Store the updated word value back to where we've loaded it from

We will pretend that r5 + 0x4000 is the exact address of where our hypothetical word value resides in memory. We will use r3 as our register that will be part of the incrementing. Our first instruction will be a lwz instruction, which is this...

lwz r3, 0x4000 (r5)

After this instruction has executed, r3 now contains our word value. Let's increment it by 2. This will require a simple addi instruction that uses an Immediate Value of 2....

addi r3, r3, 2

In the addi instruction, we've used the same register for both the Destination Register & Source Register. Obviously, because we simply wanted to increment the loaded value by 2, this explains why we need our addi result rewrites itself back into r3. Okay great, our value has been incremented, now we just need to store it back to where we've loaded it from...

stw r3, 0x4000 (r5)

The stw instruction will store the word value back to memory. Here's the entire Source with comments...

lwz r3, 0x4000 (r5) #Load our value from Memory
addi r3, r3, 2 #Increment value by 2
stw r3, 0x4000 (r5) #Store value back to Memory

Here's a great visual diagram if you are still somewhat unsure of how stores and loads work...

IMAGE

FINAL IMPORTANT NOTE (READ THIS!):

For *any* load or store instruction, if r0 is used as the Source Register (rA), it will be treated as Literal ZERO.

Example:

lwz r12, 0x8 (r0)
#r0 = 0x80001500
#Load word from 0x80001508 (EA)

In the above example, the Comments/Notes are INCORRECT. The word will actually be loaded from Memory Address 0x00000008!. Because r0 is literal zero, the EA was calculated via 0x8 + 0 = 0x8. Forgetting the literal zero rule in Loads and Stores is the most common mistake that leads to exceptions. You will learn about exceptions in Chapter 17.

Next Chapter

Tutorial Index