Difference between revisions of "CSC103 Assembly Language Exercises and Solutions"

From dftwiki3
Jump to: navigation, search
(→‎LOD 10)
(→‎LOD-I 10/STO-I 10)
 
(17 intermediate revisions by the same user not shown)
Line 1: Line 1:
 +
--[[User:Thiebaut|D. Thiebaut]] 12:08, 20 February 2011 (EST)
 +
----
 +
 
=LOD-C 1=
 
=LOD-C 1=
 
;Exercise 1
 
;Exercise 1
Line 30: Line 33:
 
; and then increments it
 
; and then increments it
 
;
 
;
−
start: lod-c 0 ; first initialize the counter to 0
+
start: lod-c 0         ; first initialize the counter to 0
−
sto counter
+
sto counter
  
 
; increment counter
 
; increment counter
−
lod counter ;get counter in acc
+
lod counter ; get counter in acc
−
add-c 1 ;add 1 to acc
+
add-c 1 ; add 1 to acc
−
sto counter ;store acc in counter
+
sto counter ; store acc in counter
  
 
hlt
 
hlt
  
−
@10 ; the data section starts here
+
@10
−
counter: data
+
counter: data
 
</pre></code>
 
</pre></code>
  
Line 47: Line 50:
 
: compute sum of 3 variables
 
: compute sum of 3 variables
 
<code><pre>
 
<code><pre>
 +
; Exercise 3
 +
; D. Thiebaut
 +
; Compute the sum of 3 variables
 +
; and stores it into a 4th variable called
 +
; sum.
 +
 +
start: lod var1 ; get var1 in acc
 +
add var2 ; add var2 to acc
 +
add var3 ; add var3 to acc
 +
sto sum ; store acc into sum
 +
hlt
 +
 +
@10
 +
var1: 12
 +
var2: 5
 +
var3: 3
 +
sum: 0
 +
 
</pre></code>
 
</pre></code>
  
 
=LOD-I 10/STO-I 10=
 
=LOD-I 10/STO-I 10=
  
−
'Exercise 4:  
+
;Exercise 4:  
 
:create an index and use it to sum up the same 3 variables
 
:create an index and use it to sum up the same 3 variables
 
<code><pre>
 
<code><pre>
 +
; Exercise 4
 +
; D. Thiebaut
 +
; Compute the sum of 3 variables using an index
 +
; and stores it into a 4th variable called
 +
; sum. 
 +
 +
start: lod-i index         ; get var1 indirectly in acc
 +
sto sum ; set sum to var1
 +
lod index         ; get index in acc
 +
add-c 1 ; increment acc
 +
sto index
 +
 +
lod-i index         ; get var2 indirectly in acc
 +
add sum         ; add sum to acc
 +
; acc now contains var1 + var2
 +
sto sum ; store acc in sum
 +
 +
lod index         ; increment index
 +
add-c 1
 +
sto index
 +
 +
lod-i index         ; get var3 indirectly in acc
 +
add sum ; add var3 to sum (which contains var1+var2)
 +
sto sum ; store acc back in sum
 +
; sum now contains var1+var2+var3
 +
 +
hlt
 +
 +
@15
 +
index: var1       ; index points to var1
 +
var1: 12
 +
var2: 5
 +
var3: 3
 +
sum: 0
 +
 
</pre></code>
 
</pre></code>
  
Line 60: Line 116:
 
: create an infinite loop (incrementing a variable, for example)
 
: create an infinite loop (incrementing a variable, for example)
 
<code><pre>
 
<code><pre>
 +
; Exercise 5
 +
; D. Thiebaut
 +
; an infinite loop
 +
start: lod index ; increment index
 +
add-c 1
 +
sto index
 +
 +
jmp start
 +
hlt
 +
 +
@15
 +
index: data
 +
 
</pre></code>
 
</pre></code>
  
  
 
;Exercise 6
 
;Exercise 6
−
: create an infinite loop that clears the memory starting at 10
+
: create an infinite loop that stores 55 in all the memory words the memory starting at 10
 
<code><pre>
 
<code><pre>
 +
; Exercise 6
 +
; D. Thiebaut
 +
; an infinite loop
 +
start: lod-c 10 ; store 10 in index
 +
sto index
 +
 +
loop: lod-c 55 ; acc set to 55
 +
sto-i index         ; store 55 where index is pointing
 +
 +
lod index         ; increment index
 +
add-c 1
 +
sto index
 +
 +
jmp loop         ; loop forever
 +
hlt
 +
 +
@9
 +
index: data
 
</pre></code>
 
</pre></code>
  
  
 
;Exercise 7
 
;Exercise 7
−
: why does the program of Exercise 6 stop?
+
: why does the program of Exercise 6 stop or misbehave?
−
<code><pre>
+
 
−
</pre></code>
+
The memory contains 1024 words of memory.  So, each address can be expressed with 10 bits.  Address 0 decimal is written as 0000000000 in binary.  Address 1023 is written as 1111111111 in binary.  So only 10 bits are used by the memory to figure out what address the processor wants to access.  When the processor sends Address 1024, in binary it is written with 11 bits: 10000000000, but the memory will only look at the lower 10 bits, which are 0000000000, or memory word 0. 
 +
 
 +
So the program, once it has reached the memory word at 1023 and stored 55 there, continues on with the words at address 0, 1, 2... Essentially the program overwrites itself from memory.
  
 
=JMZ=
 
=JMZ=
−
Exercise 8
+
;Exercise 8
 
: write a loop that loops 10 times (use a counter)
 
: write a loop that loops 10 times (use a counter)
 
<code><pre>
 
<code><pre>
 +
; Exercise 8
 +
; D. Thiebaut
 +
; A program that loops 10 times
 +
;
 +
start: lod-c 10 ; store 10 in counter
 +
sto counter
 +
 +
loop: lod counter ; decrement counter
 +
sub-c 1
 +
sto counter ; store new value in counter
 +
 +
jmz done ; if value in acc is 0, jump to done
 +
jmp loop ; otherwise, go back to loop label
 +
done:  hlt ; we're done. Stop!
 +
 +
@10
 +
counter: data
 
</pre></code>
 
</pre></code>
  
−
Exercise 9
+
;Exercise 9
 
: write a loop that stores 55 in the memory locations between 15 and 30
 
: write a loop that stores 55 in the memory locations between 15 and 30
 
<code><pre>
 
<code><pre>
 +
; Exercise 8
 +
; D. Thiebaut
 +
; A program that loops 10 times
 +
;
 +
start:
 +
loop: lod-c 55 ; store 55 indirecty where
 +
sto-i index ; index is pointing
 +
lod index ; get index
 +
add-c 1 ; increment its value
 +
sto index ; store value back in index
 +
lod counter ; load counter
 +
sub-c 1 ; decrement it
 +
sto counter ; store new value in counter
 +
 +
jmz done ; if value in acc is 0, jump to done
 +
jmp loop ; otherwise, go back to loop label
 +
done:  hlt ; we're done. Stop!
 +
 +
@13
 +
counter:16 ; between 15 and 30, there are 16 words of memory
 +
index: 15
 +
var1: data
 
</pre></code>
 
</pre></code>
 +
 +
<br />
 +
<br />
 +
<br />
 +
<br />
 +
<br />
 +
<br />
 +
[[Category:CSC103]][[Category:Exercises]]

Latest revision as of 11:34, 21 February 2011

--D. Thiebaut 12:08, 20 February 2011 (EST)

LOD-C 1

Exercise 1
initialize the contents of several variables to 0
; Exercise 1
; D. Thiebaut
; Initialize the contents of several variables 
; to 55

start:
		lod-c	55		; put 0 in acc
		sto		var1	; store acc in var1
		sto		var2	; store acc in var2
		sto		var3	; store acc in var3
		hlt

@10					; the data section starts here
var1:	        data
var2:	        data
var3:	        data

LOD 10/STO 10

Exercise 2
increment a counter
; Exercise 2
; D. Thiebaut
; A program that sets a counter to 0
; and then increments it
;
start:	lod-c	0		        ; first initialize the counter to 0
		sto	counter

; increment counter
		lod	counter	; get counter in acc
		add-c	1		; add 1 to acc
		sto	counter	; store acc in counter

		hlt

@10						
counter:	data
Exercise 3
compute sum of 3 variables
; Exercise 3
; D. Thiebaut
; Compute the sum of 3 variables
; and stores it into a 4th variable called
; sum.

start:	lod		var1	; get var1 in acc
	add		var2	; add var2 to acc
	add		var3	; add var3 to acc
	sto		sum	; store acc into sum
	hlt

@10
var1:	12
var2:	5
var3:	3
sum:	0

LOD-I 10/STO-I 10

Exercise 4
create an index and use it to sum up the same 3 variables
; Exercise 4
; D. Thiebaut
; Compute the sum of 3 variables using an index
; and stores it into a 4th variable called
; sum.  

start:	lod-i 	index	        ; get var1 indirectly in acc
	sto	sum		; set sum to var1
	lod	index	        ; get index in acc
	add-c	1		; increment acc
	sto	index

	lod-i	index	        ; get var2 indirectly in acc
	add	sum	        ; add sum to acc
				; acc now contains var1 + var2
	sto	sum		; store acc in sum

	lod	index	        ; increment index
	add-c	1
	sto	index		

	lod-i	index	        ; get var3 indirectly in acc
	add	sum		; add var3 to sum (which contains var1+var2)
	sto	sum		; store acc back in sum
				; sum now contains var1+var2+var3

	hlt

@15
index: var1		       ; index points to var1
var1:	 12
var2:	 5
var3:	 3
sum:	 0

JMP instruction and labels

Exercise 5
create an infinite loop (incrementing a variable, for example)
; Exercise 5
; D. Thiebaut
; an infinite loop
start:	lod		index	; increment index
		add-c	1
		sto		index		

		jmp		start
		hlt

@15
index:	data


Exercise 6
create an infinite loop that stores 55 in all the memory words the memory starting at 10
; Exercise 6
; D. Thiebaut
; an infinite loop
start:	lod-c	10		; store 10 in index
	sto	index

loop:	lod-c	55		; acc set to 55
	sto-i	index	        ; store 55 where index is pointing

	lod	index	        ; increment index
	add-c	1
	sto	index		

	jmp	loop	        ; loop forever
	hlt

@9
index:	data


Exercise 7
why does the program of Exercise 6 stop or misbehave?

The memory contains 1024 words of memory. So, each address can be expressed with 10 bits. Address 0 decimal is written as 0000000000 in binary. Address 1023 is written as 1111111111 in binary. So only 10 bits are used by the memory to figure out what address the processor wants to access. When the processor sends Address 1024, in binary it is written with 11 bits: 10000000000, but the memory will only look at the lower 10 bits, which are 0000000000, or memory word 0.

So the program, once it has reached the memory word at 1023 and stored 55 there, continues on with the words at address 0, 1, 2... Essentially the program overwrites itself from memory.

JMZ

Exercise 8
write a loop that loops 10 times (use a counter)
; Exercise 8
; D. Thiebaut
; A program that loops 10 times
;
start:	lod-c	10		; store 10 in counter
	sto	counter

loop:	lod	counter	; decrement counter
	sub-c	1
	sto	counter	; store new value in counter

	jmz	done		; if value in acc is 0, jump to done
	jmp	loop		; otherwise, go back to loop label
done:   hlt			; we're done. Stop!

@10
counter:	data
Exercise 9
write a loop that stores 55 in the memory locations between 15 and 30
; Exercise 8
; D. Thiebaut
; A program that loops 10 times
;
start:	
loop:	lod-c	55		; store 55 indirecty where
	sto-i	index		; index is pointing
	lod	index		; get index
	add-c	1		; increment its value
	sto	index		; store value back in index
	lod	counter	; load counter
	sub-c	1		; decrement it
	sto	counter	; store new value in counter

	jmz	done		; if value in acc is 0, jump to done
	jmp	loop		; otherwise, go back to loop label
done:  hlt			; we're done. Stop!

@13
counter:16		; between 15 and 30, there are 16 words of memory
index:	15
var1:	data







Retrieved from "http://dominiquethiebaut.com/dftwiki3/index.php?title=CSC103_Assembly_Language_Exercises_and_Solutions&oldid=10560"