Intro to C

Question 1

Machine code

Answer 1

binary files (such as .obj, .exe, a.out)

Question 2

Assembly code

Answer 2

text files (e.g. .asm)

Question 3

C code

Answer 3

text files (.c, .h)

Question 4

Compiler

Answer 4

converts a high-level language (like C) to low-level language (assembly), for example .c to .asm

Question 5

Assembler

Answer 5

converts assembly language to machine language object files (.asm to .obj)

Question 6

Linker

Answer 6

combines multiple object files (.obj) into a single executable object file; e.g. user_program.obj + os.obj → my_program.obj

Question 7

Symbol table

Answer 7

created by a compiler to keep track of where data should be stored, the type of data stored, and scope of the data being stored by the program it compiled
Instead of recording exact addresses for variables, offset is used relative to the starting location (e.g. R5). WHY?
This was function could use any starting place in data memory and build its stack. Fct can be loaded at different places at different times.

Question 8

Local variables

Answer 8

the “scope” of these variables exists only within the { }.

Variables must be declared at the top of block!

Question 9

Stack

Answer 9

in the context of the C language, the region in data memory where data required to support functions in the C language will be stored (functions such as
arguments, local variables, and return values). It is organized like a physical stack: imagine piling one book on top of the next one in a stack of books. This is
why it grows “backwards” in memory.

Question 10

Frame

Answer 10

a logical grouping of the data on the stack that belongs to a single function. Examples of data in the stack frame are arguments, local variables, and return values. As one function calls another, each function will have its own frame.

Question 11

Frame pointer

Answer 11

a register that holds a starting address for the frame or , in the case of the LC4, a register holding the location of where the calling function’s frame pointer was stored in the active function’s stack frame. Sometimes called
the “base pointer.”

Question 12

Return address

Answer 12

address in program memory to return after function completes

Question 13

Prologue

Answer 13

assembly code created by the compiler to construct the frame for any given function. It is the first code executed when a function is called. It is also responsible for “pushing” the stack frame for the active function onto the stack.

Question 14

Epilogue

Answer 14

assembly code created by the compiler to “pop” the stack from the active function off of the stack. It copies the return value into the proper location
on the stack so that the calling function has access to the returning data (if any) from the active function. It is executed every time a function exits

Question 15

Prologue Code

Answer 15

Prologue: same for every function; remember this!
;; prologue
STR R7, R6, #-2 ; save caller’s return address
STR R5, R6, #-3 ; save caller’s frame pointer
ADD R6, R6, #-3 ; updates stack pointer
ADD R5, R6, #0 ; creates/updates frame pointer
○ Arguments are pushed onto stack from right to left.
○ This lets the first argument from the left be the one closest to the callee.
○ That is called “C convention” (while left-to-right is called “PASCAL”).
○ It is needed for functions with variable argument counts e.g. printf.
○ It can also lead to the order of evaluation being right-to-left.
■ Example: pow (a, ++a) may become pow (3, 3)

Question 16

Epilogue Code

Answer 16

Before enter epilogue store return value in R7
;;epilogue
ADD R6, R5, #0 ; pop local variables
ADD R6, R6, #3 ; decrease stack
STR R7, R6, #-1 ;update return value
LDR R5, R6, #-3 ; restore base ptr
LDR R7, R6 #-2 ; restore R7 for RET

Question 17

Big ideas of C

Answer 17

A high-level/low-level language: binds the gap between a machine level language and high-level languages.

• Imperative
• Procedural
• File-oriented
• Portability

Question 18

Imperative

Answer 18

The imperative is similar to how you do something (step by step) - assignment statements that explicitly change memory values, while declarative is more similar to what you do, describe function

An imperative approach (HOW): “I see that table located under the Gone Fishin’ sign is empty. My husband and I are going to walk over there and sit down.”

A declarative approach (WHAT): “Table for two, please.”

Question 19

Procedural

Answer 19

Emphasis on the program’s flow rather than the data operated on by functions

Question 20

File-oriented

Answer 20

Files: a simple abstraction for permanent storage and I/O

Question 21

Portability

Answer 21

The same C code can be compiled for different ISAs

Question 22

How are arguments passed in C

Answer 22

● C is pass-by-value (not pass-by-reference)
○ Functions receive “copies” of local variables.
■ Recall that arguments to functions were copies of local vars.
○ Protects local variables from being modified accidentally.

Question 23

Why must varialbe be declared at the start of function

Answer 23

○ Size of static/automatic variables are known at compile time:
ADD R6, R6, #-1 ; allocate space for local vars
Also, compiler may compile line-by-line, hence right upfront!

Question 24

How are arrays stored on the stack

Answer 24

Like one giant variable. Address increases with array index
○ The order of arrays on the stack is consistent with the memory address
i.e. in increasing order.
○ Example:
arr[0] - x7FF5
arr[1] - x7FF6
arr[2] - x7FF7

Question 25

What is a hashtable in C

Answer 25

An associative array where the incoming data is mapped to the proper storage location within the array. 
An array (bucket holder) of linked lists with a hashing function to determine where data should fit.

Question 26

From c to obj

Answer 26

C -> compile -> .asm

.asm -> assemble -> .obj/machine code

Question 27

Assembly code is not machine specific

Answer 27

WRONG

Question 28

Main

Answer 28

• All C programs must start in main
• Recall C is procedural , I. e. everything is in a function
• Note that this gets converted to a label in assembly

Question 29

Local Variables

Answer 29

Exist only in code block they are defined in
Are NOT initialized to 0 in C
Variables MUST be declared at the top of block. Because when assembling first thing done after prologue is create variables on stack

Question 30

Where in memory do functions build their stack

Answer 30

Data memory, it will hold local variables, return values, return address, base pointer and arguments

Question 31

Memory split in LC4 of Data memory

Answer 31

1. Program Memory up to x1FFF
2. Global Variables up to x3FFF
3. Dynamic Storage - heap up to x6FFF
4. Local Variables (STACK) up to x7FFF

Question 32

Structure Frame

Answer 32

6. temporaries, arguments to callees
7. local variables
8. Callers frame Pointer
9. Return Address
10. Return Value
11. Arguments to function

1-4 addressed by R5 others by R6

Question 33

Adding 2 Local Variables to stack after prologue complete

Answer 33

ADD R6 R6 #-2
CONST R7 #2
STR R7 R5 #-1
CONST R7 #3
STR R7 R5 #-2

->arguments added incremental

Question 34

Where do R5 and R6 point to

Answer 34

R5 = "bottom"of the frame, entry, callers frame pointer
R6 = top of stack

Question 35

Adding Arguments to stack

Answer 35

One by one, right to left
e.g Pow(2,3)
LDR R7 R5 #-2
ADD R6, R6 #-1
STR R7, R6 #0
LDR R7 R5 #-1
ADD R6, R6 #-1
STR R7, R6 #0

Question 36

Why is C pass-by-value

Answer 36

Protects local variables from being modified accidentally

Question 37

How does calling main work in LC4

Answer 37

The LC4’s OS (Operating System) that we’ve written calls a function called USER_START, that puts the LC4 in user mode. USER_START then calls the function: main(), it must be called main() as it is hard coded in USER_START

.CODE
.ADDR x8200
.FALIGN
  ;; first job of OS is to return PennSim to x0000 & downgrade privledge
  CONST R7, #0   ; R7 = 0
  RTI            ; PC = R7 ; PSR[15]=0

Question 38

Explain Linking

Answer 38

It is useful if you write programs that have many separate files that depend on one another

It creates a pointer from one file to another.

“links” the files together as if they were one long .OBJ file.

Question 39

Function Definition vs Function Declaration

Answer 39

A function definition provides the actual body of the function

A function declaration tells the compiler about a function’s name, return type, and parameters.

Question 40

Where is #define PI stored

Answer 40

Nowhere, nno space allocated as it is a directive and not a available. When compiling, compiler will substitute PI in code with value

Question 41

The name of the array IS a memory address. The pointer IS a memory address. The array itself does NOT contain memory addresses

CORRECT?

Answer 41

NO, pointer IS not a memory address but rather contains a memory address