CS 2110 Quiz 3

.orig x3000 ;;do something HALT HELLO .fill x6000 .end .orig x6000 .stringz "Hi" .end *Load the letter i into register 1*

.orig x3000 LD R0, HELLO LDR R1, R0, 1 HALT HELLO .fill x6000 .end .orig x6000 .stringz "Hi" .end *Load the letter i into register 1*

TrapVect8

0000 to 00FF

what are the steps of stack buildup

1. Function A pushes any parameters that B takes in reverse order (A is global) 2. RV is a space in memory then allocated for the return value of B (not the return address) 3. store A's return address 4. Save A's Frame Pointer 5. Save a spot for a local variable in case R0-R4 is not enough 6. Save the rest of the registers

1. Function A pushes any parameters that B takes in reverse order (A is global) 2. RV is a space in memory then allocated for the return value of B (not the return address) 3. store A's return address 4. Save A's Frame Pointer 5. Save a spot for a local variable in case R0-R4 is not enough 6. Save R5 to R7 on the stack You just did all of this when calling a function. Now you are done. What happens next?

1. Save the return value 2. Restore values in R0 and R4 3. Restore R5 4. Retrieve the return address for A and put it into R7 so that we can jump back to function A 5. Increment the stack pointer so that the top of stack points to the return value of B 6. A takes this value, pops it off . A also pops of the parameters to B. Then we can continue to execute A. == Stack TearDown :D

1. Caller pushes arguments in reverse order 2. Caller uses JSR or JSRR to call a subroutine What happens next?

3. Callee stores RV, RA, old R5, at least one local variable. 4. Callee sets FP = SP 5. Callee allocates space for locals Set R6 to point to the return value Load R7 with the return address

Each trap instruction has a corresponding

8 bit trap vector we sign extend this this gives us an index into the trap vector table

What is the stack?

A dynamic section of memory that allows for local variables to exist for only the lifetime of a subroutine

You are tearing down a stack and have n arguments. How do you pop off these arguments from the stack.

ADD R6, R6, #(n+1)

How could I add 25 to the value in a register?

Add twice or .fill LD R1, TWO LD R2, THREE ADD R2, R2, R1 ADD R0, R2, #0 OUT TRAP x25 TWO .fill x32 THREE .fill x25

Remember that labels are an assembler shorthand for offsets. How do we translate labels into hexadecimal?

Address - PC*

Say I have a LD instruction at address x3000. What is the lowest memory address it can load from? The highest?

All data is stored x3000 to xFDFF Highest in one line 30FF

Who saves the RV (space)

Callee

Who saves the first local

Callee

Who saves the last local

Callee

Who saves the old F5

Callee

Who saves Argument 1 and 2

Caller

How to get return value after function finishes executing?

Caller pops the value off of the stack First value it pops off is return value Everything else is the arguments it passed in, in reverse order

How do you push a value onto the stack?

Decrement R6 STR R0, R6, 0

What is the instruction's opcode? What do DR/SR1/SR2/BaseR represent? What do imm5, offset6, PCoffset9, PCoffset11, and trapvect8 mean?

Dr/Sr1/Sr2/BaseR are all registers; others are all good

What are some helpful traps?

Halt Out Puts GetC

.orig x3000 AND R0, R0, 0 ST R0, ANSWER HALT .end ANSWER .blkw 1 Is this valid code?

I don't think this will assemble b/c ANSWER comes after END If we assume it is valid, then it puts the value in R0 (which is 0) and stores it at the address represented by ANSWER

JSR

Jump to Subroutine Saves the PC* value into R7 Sets PC to target = PC* + Offset11 (Have to save the PC before changing the PC)

JSRR

Jump to Subroutine, Register Uses a register for the subroutine's address instead of a label or offset R7 = PC* PC = BaseR

Addressing modes: LD, LDI, LDR

LD: pc-relative LDI: indirect LDR: base+offset

How do you pop a value off of the stack?

LDR R0, R6, 0 Increment R6

Labels are accepted by

PC-Relative Instructions (ST and LD)

What information is considered important or relevant to a subroutine?

Parameters (arguments) Return value Return address Old frame pointer At least one local variable Save old register values as well

IN

Print prompt to console, read and echo character from keyboard x23

Order of important info stored in a stack frame

R4 R3 R2 R1 R0 local <- R5 old R5 old R7 Return Value stored here 1st param passed into function (in reverse order)

You are given this stack 1. saved registeres 2. local variable x 3. old R5 4. old R7 5. Return Value 6. Parameter for function You just completed the function and need to save the return value. How do you get to this address?

R5 + 3

where is the subroutine's return value

R5 + 3

where is the subroutine's first argument

R5 + 4

Top of the stack is held in

R6

What to save at start of function? Why do we save it? How to build stack? How to load arguments off stack?

REST OF OLD REGISTERS LOCAL (NEW R5) R5 R7 RV PARAMETERS

RET

Return Equivalent to JMP R7 PC = R7

Addressing modes: ST, STI, STR

ST: pc-relative STI: indirect STR: base+offset

.orig

Tells the assembler to put this block of code at the desired address given

Who pops the return value and arguments off of the stack?

The caller!

.orig x3000 LD R0, HELLO LDR R1, R0, 1 HALT HELLO .fill x6000 .end .orig x6000 .stringz "Hi" .end What happens on line 2

The value located at the address of the label HELLO is loaded into SR0

.stringz

Will put a string of characters in memory followed by a null character (0)

Does HALT take up a memory address?

Yes

What does * after a type denote?

char *x, declares that x is a pointer to a char

char**y

declares that y is a pointer to a pointer to a char

When data gets pushed onto the stack, R6 is

decremented

.end

denotes the end of an address block, matches with .orig

the stack grows

down (into lower memory)

R7

holds the current return address

R5

holds the frame pointer

why do we need a frame pointer

if we undertsand the entire set of data a function pushes onto the stack as its stack frame, then we need to know where this data is stored and where relevant memory is

What do imm5, offset6, PCoffset9, PCoffset11, and trapvect8 mean? Understand the range of values for each of the immediate/offset sizes, and the implications of these limitations.

imm5: 15 to -16 ;; offset6: 31 to -32 ;; offset9: 255 to -256 ;; offset11: 1023 to -1024 ;; trapvect8:: does it matter?

When data is popped of the stack, R6 gets

increments

.orig x3000 LEA R0, BESTCS PUTS HALT BESTCS .stringz "CS2110" .end What is happening here?

line one will load the address represented by the BESTCS label into R0 line two will use use the starting address in R0 to print a string of chars until reaching the null characters

LD

loads data at a certain memory address into the designated register

LEA

loads the memory address into a designated register

Are labels stored anywhere

no

Does a pointer contain the type of data found at the address

no

does R5 change through a subroutine

no

does R5 change throughout a function's execution

no

Motivation for the stack

register saving and intelligent use of our 8 general purpose register is the main motivation for the stack

calling convention is a ____ abstraction

software

R6

stack pointer (top of the stack)

Halt

stops the LC3 from running x25

Traps are

subroutines built into the LC3 to help simplify instructions

GETC

takes in a character input and stores it in R0 x20

LDR

takes memory address from a register, adds it to an offset, retrieves the data at the offset + address memory address, and loads it into a register

.orig x3000 LD R0, HELLO LDR R1, R0, 1 HALT HELLO .fill x6000 .end .orig x6000 .stringz "Hi" .end What happens on line 3

takes the memory address x6000 located in R0 and adds 1 to give you x6001

Calling convention tells us

the standardized process for building up the stack when we want to execute a subroutine

The stack is a region in memory

to store temporary program data

Pointers

variables that contain a memory address

.blkw n

will allocate the next n locations of memory for a specified label

PUTS

will print a string of characters with the starting address saved in R0 until it reaches a 0 char x22

.fill value

will put that value in that memory location

OUT

will take whatever char is in R0 and print it x21

where is the trap vector table

x0000 to x00FF

Trap hex values

x20: GETC x21: OUT x22: PUTS x23: IN x25: HALT

.orig x3000 A .fill 2 ARRAY .fill x6000 .end

x3000: 2 x3001: x6000 The label never goes into memory! A simply points to this address

.orig x3000 string_label .stringz "Hey" block_label .blkw 2 fill_label .fill x1234 .end Draw this out in memory

x3000: H x3001: e x3002: y x3003: 0 x3004: blocked x3005: block x3006: x1234

function A calls function B. The instruction that tells the PC to jump to B's address is at x300B. Function B lives at x4000. What does R7 hold?

x300C (current return address)