CS255 Syllabus

How to access various types of variables in memory in SPARC

Moving (copying) data in SPARC

SPARC allows you to move data

Moving data from one memory location to another memory location:

If you want to move data from one memory location to another memory location, you need to:

Note:

Although M68000 has a move instruction that can move data from one memory location to another memory location:
```
    move.l x, y
  
```
the data is not transfered from one memory location to another memory location directly
The M68000 CPU will:

Important difference

A common confusion among students are these 2 constructs in SPARC:

construct 1: Construct 2: ============================== =========================== sethi %hi(123456789), %l5 sethi %hi(123456789), %l5 add %l5, %lo(123456789), %l5 ld [%l5 + %lo(123456789], %l5

%hi(123456789) and %lo(123456789):

%hi(123456789) = 123456789 / 1024 = 120563 %lo(123456789) = 123456789 % 1024 = 277 Note: 120563 * 1024 = 123456512

Construct 1:

sethi %hi(123456789), %l5 ; %l5 = [ ............ | ..... ] ; ^^^^^^^^^^^^^^ ^^^^^^^ ; 120563 0 ; ; Decimal value of %l5 = 120563 * 1024 ; = 123456512 add %l5, %lo(123456789), %l5 ; %l5 = 123456512 + 277 = 123456789

Effect: register %l5 = 123456789

Construct 2:

sethi %hi(123456789), %l5 ; %l5 = [ ............ | ..... ] ; ^^^^^^^^^^^^^^ ^^^^^^^ ; 120563 0 ; ; Decimal value of %l5 = 120563 * 1024 ; = 123456512 ld [%l5 + %lo(123456789)], %l5 ; %l5 + %lo(123456789) = 123456512 + 277 ; = 123456789 ; ; The ld instruction will USE the address 123456789 ; ; So the value in memory location 123456789 ; is moved into register i5 !!!

Effect: register %l5 = value stored in memory address 123456789

Overview (summary) on how to access variables using SPARC addressing modes

BOTH

contrast

Move a constant value 987654 to a register (i5):

Move the constant 987654 into a register (d5 in M68000 and i5 in SPARC) M68000 SPARC =============== ================= move.l #987654, d5 sethi %hi(987654), %l0 add %l0, %lo(987654), %i5

Move the address of variable x to a register:

Note:

The label associated with a variable is infact an address
An address is a 32 bit number !!!
I.e., an address is a constant value !

Assembler code:

int x; Move the address of variable from x into a register (d5 in M68000 and i5 in SPARC) M68000 SPARC =============== ================= move.l #x, d5 sethi %hi(x), %l0 add %l0 ,%lo(x), %i5 x: ds.l 1 .align 4 x: .skip 4

Move the value stored in the variable x (in memory) to a register (i5):

Solution 1: (slow but clear solution)

int x; Move the value stored in variable x into a register (d5 in M68000 and i5 in SPARC) M68000 SPARC =============== ================= move.l x, d5 sethi %hi(x), %l0 add %l0, %lo(x), %l0 ; %l0 = address of x ! ld [%l0 + 0], %i5
x: ds.l 1 .align 4 x: .skip 4

Solution 2: (faster but less clear solution)

int x; Move the value stored in variable x into a register (d5 in M68000 and i5 in SPARC) M68000 SPARC =============== ================= move.l x, d5 sethi %hi(x), %l0 ld [%l0 + %lo(x)], %i5 ; %l0 + %lo(x) = address of x !
x: ds.l 1 .align 4 x: .skip 4

Move the value in a register (i5) to the variable x (in memory):

Solution 1: (slow but clear solution)

int x; Move the value in %i5 to variable x (d5 in M68000 and i5 in SPARC) M68000 SPARC =============== ================= move.l d5, x sethi %hi(x), %l0 add %l0, %lo(x), %l0 ; %l0 = address of x ! st %i5, [%l0 + 0]
x: ds.l 1 .align 4 x: .skip 4

Solution 2: (faster but less clear solution)

int x; Move the value in %i5 to variable x (d5 in M68000 and i5 in SPARC) M68000 SPARC =============== ================= move.l d5, x sethi %hi(x), %l0 st %i5, [%l0 + %lo(x)] ; %l0 + %lo(x) = address of x !
x: ds.l 1 .align 4 x: .skip 4

Move value from array element A[7] to a register (i5):

int A[100]; Move the value from variable A[7] into a register Offset to A[7] = 7 * 4 = 28 (d5 in M68000 and i5 in SPARC) M68000 SPARC =============== ================= move.l #A, a0 sethi %hi(A), %l0 move.l 28(a0), d5 add %l0, %lo(A), %l0 ; %l0 = address of array A ld [%l0 + 28], %i5 ; %l0 + 28 = address of A[7]
Reserve space for array: A: ds.l 100 .align 4 A: .skip 400

Move value a register (i5) to an array variable A[7]:

int A[100]; Move the value from register to variable A[9] Offset to A[9] = 9 * 4 = 36 (d5 in M68000 and i5 in SPARC) M68000 SPARC =============== ================= move.l #A, a0 sethi %hi(A), %l0 move.l d5, 36(a0) add %l0, %lo(A), %l0 ; %l0 = address of array A st %i5, [%l0 + 36] ; %l0 + 36 = address of A[9]
Reserve space for array: A: ds.l 100 .align 4 A: .skip 400

Move value from an array variable A[i] to a register (i5):

int A[100]; int i; Move the value from variable A[i] into a register (d5 in M68000 and i5 in SPARC) M68000 SPARC =============== ================= move.l #A, a0 sethi %hi(A), %l0 add %l0 + %lo(A), %l0 // l0 = address of array A move.l i, d1 sethi %hi(i), %l1 ld [%l1 + %lo(i)], %l1 // l1 = value of variable i muls #4, d1 smul %l1, 4, %l1 // l1 = 4*i move.l 0(a0, d1.w), d5 ld [%l0 + %l1], %i5

Move value a register (i5) to an array variable A[i]

int A[100]; int i; Move value in a register to the memory variable A[i] (d5 in M68000 and i5 in SPARC) M68000 SPARC =============== ================= move.l #A, a0 sethi %hi(A), %l0 add %l0 + %lo(A), %l0 // l0 = address of array A move.l i, d1 sethi %hi(i), %l1 ld [%l1 + %lo(i)], %l1 // l1 = value of variable i muls #4, d1 smul %l1, 4, %l1 // l1 = 4*i move.l d5, 0(a0, d1.w) st %i5, [%l0 + %l1]

Get value from a linked list

class List { int value; List next; } List head;
Move the value from head.value into a register (d5 in M68000 and i5 in SPARC) M68000 SPARC =============== ================= movea.l head, a0 sethi %hi(head), %l0 ld [%l0 + %lo(head)], %l0 // l0 = head move.l 0(a0), d5 ld [%l0 + 0], %i5 // i5 = head.value
Move the value from head.next.next.value into a register (d5 in M68000 and i5 in SPARC) M68000 SPARC =============== ================= movea.l head, a0 sethi %hi(head), %l0 ld [%l0 + %lo(head)], %l0 // l0 = head move.l 4(a0), a0 ld [%l0 + 4], %l0 // l0 = head.next move.l 4(a0), a0 ld [%l0 + 4], %l0 // l0 = head.next.next move.l 0(a0), d5 ld [%l0 + 0], %i5 // i5 = head.next.next.value

Here are some SPARC program examples that I have written to illustrate of the addressing modes:
- Immediate addressing mode (constants):
  - sparc-IMM.s
  - The use of sethi was illustrated with this program: sparc0-SETHI.s
- Direct addressing mode:
  - Register to register: sparc-REG-DIRECT.s
  - Memory to register (load): sparc-MEM1-DIRECT.s
  - Register to memory (store): sparc-MEM2-DIRECT.s
- Indirect addressing mode (indirect always uses memory !):
  - Constant offset from a base: sparc-INDIRECT1.s
  - Variable offset from a base: sparc-INDIRECT2.s