Homework: Exercise L6 (Assembly)

Theory: How to Approach These

Hand-assembling (6.4): pass 1 builds the symbol table (label → address); pass 2 writes opcode digit + 3-digit address.
Deciphering machine code (6.2): 4-bit opcode + 12-bit address; use the ISA table (1 Load, 2 Store, 3 Add, 4 Subt, 7 Halt, 8 Skipcond, 9 Jump, A Clear).
Translating an if (6.4): compute a value whose sign answers the condition, then Skipcond over a Jump that bypasses the THEN part.
Testing: trace the AC and the variables instruction by instruction.

Jump to: Q1 · Q2 · Q3

Worked Examples

Exercise Q1

Given the assembly code below:

Hex Address	Label	Instruction
100		Load A
101		Add One
102		Jump S1
103	S2,	Add One
104		Store A
105		Halt
106	S1,	Add A
107		Jump S2
108	A,	HEX 0023
109	One,	HEX 0001

a) List the hexadecimal code for the program (hand assemble it). b) What are the contents of the symbol table for this program? c) Write the program, compile and show the result in Marie.

Part	Detail
Asks	(a) 4-digit hex word per line, (b) label → address table, (c) run it and give the final values.
Needs	Load 1, Store 2, Add 3, Halt 7, Jump 9; word = opcode digit + 3-digit address; `HEX` copied as is.
Look at	The labels S2, S1, A, One and their addresses; Jump changes the run order.
If it changes	Different labels or ORG change addresses and every word using them; opcode digits stay.

Show solution ↓

Solution

How to solve

Pass 1: every label gets the address of its line, giving the symbol table.
Pass 2: for each instruction write opcode digit + the label’s address (Halt = 7000).
Run: trace the AC, following jumps, until Halt.

Address	Instruction	Opcode	Operand address	Hex

Symbol	Address

Addr run	Instruction	AC after	Memory change

Sample answer

b) Symbol table

Symbol	Address
S2	103
S1	106
A	108
One	109

a) Hex code

Address	Instruction	Opcode	Operand	Hex
100	Load A	1	108	1108
101	Add One	3	109	3109
102	Jump S1	9	106	9106
103	S2, Add One	3	109	3109
104	Store A	2	108	2108
105	Halt	7	000	7000
106	S1, Add A	3	108	3108
107	Jump S2	9	103	9103
108	A, HEX 0023			0023
109	One, HEX 0001			0001

c) Program for the simulator

        ORG 100
        Load A
        Add One
        Jump S1
S2,     Add One
        Store A
        Halt
S1,     Add A
        Jump S2
A,      HEX 0023
One,    HEX 0001

Addr	Instruction	AC after	Memory change
100	Load A	0023
101	Add One	0024
102	Jump S1	0024
106	Add A	0047
107	Jump S2	0047
103	Add One	0048
104	Store A	0048	A (108) = 0048
105	Halt	0048

Result: AC = 0048, A = 0048 = 72. The program computes $A \leftarrow 2A + 2$ ( $2 \times 35 + 2 = 72$ ).

Watch out: Add A at 106 adds the value stored in A (still 0023, because Store A has not run yet), not the AC.

Exercise Q2

Given the instruction set for MARIE in this chapter, decipher the following MARIE machine language instructions. (Write the assembly language equivalent.)

a) 0010000000000111 b) 1001000000001011 c) 0011000000001001

Part	Detail
Asks	Turn 16-bit binary words into MARIE assembly.
Needs	First 4 bits = opcode, last 12 bits = address; opcode table (2 Store, 3 Add, 9 Jump).
Look at	Split into four 4-bit groups; each group is one hex digit.
If it changes	Only the bits change; the method is identical.

Show solution ↓

Solution

How to solve

Split the word into groups of 4 bits and convert each to hex.
First hex digit is the opcode; look up its name.
Remaining three digits are the address.

Binary	Groups of 4	Hex	Opcode name	Assembly	Meaning

Sample answer

	Opcode bits	Address bits	Hex	Opcode	Assembly
a)	0010	0000 0000 0111	2007	2 = Store	`Store 007`
b)	1001	0000 0000 1011	900B	9 = Jump	`Jump 00B`
c)	0011	0000 0000 1001	3009	3 = Add	`Add 009`

Meanings: a) M[007] ← AC; b) PC ← 00B; c) AC ← AC + M[009].

Watch out: the address is 12 bits (three hex digits), so keep the leading zeros.

Exercise Q3

Given the following code segment:

If X>1 then
    Y=X+X;
    X=0;
endif;
Y=Y+1;

Write the code in MARIE’s assembly language. Compile and test the program given X = 2 and Y = 10.

Part	Detail
Asks	Write, assemble and run a MARIE program for the if-statement with X = 2, Y = 10.
Needs	`Skipcond` (000: AC < 0, 400: AC = 0, 800: AC > 0); pattern: compute, Skipcond, Jump past THEN.
Look at	$X > 1$ is $X - 1 > 0$ , so `Skipcond 800`; you need a constant `One`.
If it changes	$X < Y$ : compute $X - Y$ , `Skipcond 000`. $X = Y$ : `Skipcond 400`. The `Jump EndIf` pattern stays.

Show solution ↓

Solution

How to solve

Load X, Subt One gives $X - 1$ in the AC.
Skipcond 800 skips the next line when AC > 0 (condition true).
The next line is Jump EndIf, so it runs only when the condition is false.
THEN part: $Y = X + X$ , then Clear and Store X.
EndIf: $Y = Y + 1$ , Halt, then the data after Halt.

If,     Load A
        Subt B           / AC = A - B
        Skipcond ___     / 800 for >, 000 for <, 400 for =
        Jump EndIf       / condition false: skip THEN
Then,   ...THEN part...
EndIf,  ...code after the if...
        Halt
A,      Dec ___
B,      Dec ___

Sample answer

        ORG 100
If,     Load X
        Subt One
        Skipcond 800    / X-1 > 0 ?
        Jump EndIf
Then,   Load X
        Add X
        Store Y         / Y = X + X
        Clear
        Store X         / X = 0
EndIf,  Load Y
        Add One
        Store Y         / Y = Y + 1
        Halt
X,      Dec 2
Y,      Dec 10
One,    Dec 1

Symbol table: If 100, Then 104, EndIf 109, X 10D, Y 10E, One 10F.

Address	Hex	Address	Hex
100	110D	108	210D
101	410F	109	110E
102	8800	10A	310F
103	9109	10B	210E
104	110D	10C	7000
105	310D	10D	0002
106	210E	10E	000A
107	A000	10F	0001

Test (X = 2, Y = 10):

Addr	Instruction	AC after	X	Y
100	Load X	0002	2	10
101	Subt One	0001	2	10
102	Skipcond 800	0001 (skip 103)	2	10
104	Load X	0002	2	10
105	Add X	0004	2	10
106	Store Y	0004	2	4
107	Clear	0000	2	4
108	Store X	0000	0	4
109	Load Y	0004	0	4
10A	Add One	0005	0	4
10B	Store Y	0005	0	5
10C	Halt		0	5

Result: Y = 5, X = 0. With X = 1 the AC is 0, nothing is skipped, Jump EndIf runs and only $Y = 11$ results.

Watch out: Skipcond skips when the condition is true, so the next line must be the jump for the false case. Put data after Halt or the CPU runs it as code.