CSC231 Homework 8 Solution 2012

--D. Thiebaut 12:15, 13 November 2012 (EST)

---

Problem #1, Version 1

This version contains the complete code. Version 2 below separates the dumpRegs functions and main program into two files.

;;; ---------------------------------------------------------
;;; hw8aSol.asm
;;; D. Thiebaut
;;; 11/13/12
;;; This program supports several functions that allow the user
;;; to dump the contents of the main 6 registers (eax, ebx, ecx,
;;; edx, esi and edi) to the screen.  Great for debugging without
;;; a debugger.
;;;
;;; Typical output:
;;; 	+-----------------+
;;; 	| eax = 1234 5678 |
;;; 	| ebx = 55FF 55FF |
;;; 	| ecx = FEDC BA98 |
;;; 	| edx = 0000 0000 |
;;; 	| esi = 1111 2222 |
;;; 	| edi = 2222 3333 |
;;; 	+-----------------+
;;; 	+-----------------+
;;; 	| eax = 1234 5678 |
;;; 	| ebx = 55FF 55FF |
;;; 	| ecx = FEDC BA98 |
;;; 	| edx = 0000 0000 |
;;; 	| esi = 1111 2222 |
;;; 	| edi = 2222 3333 |
;;; 	+-----------------+
;;;
;;; To assemble, link and run:
;;;   nasm -f elf hw8aSol.asm
;;;   ld -melf_i386 hw8aSol.o -o hw8aSol
;;;   ./hw8aSol
;;; ---------------------------------------------------------

		section	.data
hex		db	"0123456789ABCDEF"
regs		db	"axbxcxdxsidi"
line		db	"+-----------------+", 10
string		db	"| exx = .... .... |", 10
lineLen 	equ	$-string
reg		equ	string+3
word1		equ	string+8

		section	.text
		global	_start

_start:

;;; Initialize the registers
		mov	eax, 0x12345678
		mov	ebx, 0x55FF55FF
		mov	ecx, 0xFEDCBA98
		mov	edx, 0x00000000
		mov	esi, 0x11112222
		mov	edi, 0x22223333

;;; dump them twice to verify that no registers gets modified...
	        call    dumpRegs
		call	dumpRegs


;;; exit back to OS
		mov	ebx, 0
		mov	eax, 1
		int	0x80

;;; ---------------------------------------------------------
;;; dumpRegs: dumps the contents of the 6 main registers (eax
;;; ebx, ecx, edx, esi and edi) in a box on the screen.
;;; the screen.  Does not modify any register
;;; ---------------------------------------------------------
dumpRegs:	pushad

;;; put all the registers to print in the stack.  The loop
;;; will pop each one, one at a time, once per loop.
	
		push	edi
		push	esi
		push	edx
		push	ecx
		push	ebx
		push	eax

;;; print top bar
		call	printBar
	
;;; prepare to loop 6 times (6 registers )
		mov	ecx, 6
		mov	esi, 0

.for		pop	ebx			;get value of register to convert from stack
		push	ecx			;save loop counter
		lea	eax, [regs + esi*2]	;get address of string representing register
	
		mov	ax, word [eax] 		;ax gets "ax" or "bx" or "cx" or ... "di"
		mov	word[reg], ax		;modify string with name of register
	
		mov	edx, word1 		;edx points to buffer where to store hex digits
						;ebx contains register to convert
		call 	storeDWord		;store hex equivalent of ebx in string
	
		mov	ecx, string 		;print the whole string
		mov	edx, lineLen
		call	printInt80
		inc	esi			;index into register names incremented
		pop	ecx			;get loop counter back
		loop	.for

;;; print bottom bar
		call 	printBar
	
		popad
		ret

;;; ---------------------------------------------------------
;;; storeDWord: gets
;;; 	ebx: register to convert
;;; 	edx: address where to put information
;;; ---------------------------------------------------------
		
storeDWord:	rol	ebx, 16			;bring most sig word in least sig word
		call	storeWord
	
		inc	edx			;make edx skip space in string
	
		rol	ebx, 16			;get lower byte back in least sig pos
		call	storeWord
		
		ret

;;; ---------------------------------------------------------
;;; storeWord: gets
;;;     bx: word to convert
;;; 	edx: address where to put information. edx incremented by 4
;;; ---------------------------------------------------------
storeWord:	rol	bx, 8			;put most sig byte of bx in lower position
		call	storeByte		;and convert it.  Store it in where edx 
						;points to. 
		rol	bx, 8			;same with lower nybble
		call	storeByte
		ret
	
;;; ---------------------------------------------------------
;;; storeByte: gets
;;;     bl: byte to convert
;;; 	edx: address where to store information.  edx incremented by 2 automatically
;;; ---------------------------------------------------------
storeByte:	push	ebx
		push	eax
	
		rol	bl, 4			;get upper nybble in lower position (LSB)
		mov	al, bl			;play with al now
		and	eax, 0x0000000F		;clear all but the least significant nybble
		add	eax, hex		;get ascii in hex array equivalentn to nybble
		mov	al, [eax] 		;hex digit now in bl
		mov	byte [edx], al		;store ascii in string
		inc	edx

		rol	bl, 4			;get lower nybble back
		mov	al, bl			;play with al
		and	eax, 0x0000000F
		add	eax, hex
		mov	al, [eax]
		mov	byte [edx], al
		inc	edx
	
		pop	eax
		pop	ebx
		ret
		
;;; ---------------------------------------------------------
;;; printInt80: prints on the screen the string whose address
;;; is in ecx and length in edx.
;;; does not modify registers
;;; ---------------------------------------------------------
printInt80:	push	eax
		push	ebx
	
		mov	eax, 4
		mov	ebx, 1
		int	0x80
	
		pop	ebx
		pop	eax
		ret
	
;;; ---------------------------------------------------------
;;; printBar: prints the horizontal bar
;;; does not modify registers
;;; ---------------------------------------------------------
printBar:	push	ecx
		push	edx
	
		mov	ecx, line
		mov	edx, lineLen
		call	printInt80
	
		pop	edx
		pop	ecx
		ret

Problem #1, Version 2

Main Program

;;; ---------------------------------------------------------
;;; hw8aSol2.asm
;;; D. Thiebaut
;;; 11/13/12
;;; This program uses the library dumpRegs.asm to dump 
;;; the contents of the main 6 registers (eax, ebx, ecx,
;;; edx, esi and edi) to the screen.  Great for debugging without
;;; a debugger.
;;;
;;; Typical output:
;;; 	+-----------------+
;;; 	| eax = 1234 5678 |
;;; 	| ebx = 55FF 55FF |
;;; 	| ecx = FEDC BA98 |
;;; 	| edx = 0000 0000 |
;;; 	| esi = 1111 2222 |
;;; 	| edi = 2222 3333 |
;;; 	+-----------------+
;;; 	+-----------------+
;;; 	| eax = 1234 5678 |
;;; 	| ebx = 55FF 55FF |
;;; 	| ecx = FEDC BA98 |
;;; 	| edx = 0000 0000 |
;;; 	| esi = 1111 2222 |
;;; 	| edi = 2222 3333 |
;;; 	+-----------------+
;;;
;;; To assemble, link and run:
;;;   nasm -f elf hw8aSol.asm
;;;   ld -melf_i386 hw8aSol.o -o hw8aSol
;;;   ./hw8aSol
;;; ---------------------------------------------------------

%include "dumpRegs.asm"
	
		section	.text
		global	_start

_start:

;;; Initialize the registers
		mov	eax, 0x12345678
		mov	ebx, 0x55FF55FF
		mov	ecx, 0xFEDCBA98
		mov	edx, 0x00000000
		mov	esi, 0x11112222
		mov	edi, 0x22223333

;;; dump them twice to verify that no registers gets modified...
	        call    dumpRegs
		call	dumpRegs


;;; exit back to OS
		mov	ebx, 0
		mov	eax, 1
		int	0x80

Library

;;; ---------------------------------------------------------
;;; dumpRegs.asm
;;; D. Thiebaut
;;; 11/13/12
;;; This libary supports several functions that allow the user
;;; to dump the contents of the main 6 registers (eax, ebx, ecx,
;;; edx, esi and edi) to the screen.  Great for debugging without
;;; a debugger.
;;;
;;; Typical output:
;;; 	+-----------------+
;;; 	| eax = 1234 5678 |
;;; 	| ebx = 55FF 55FF |
;;; 	| ecx = FEDC BA98 |
;;; 	| edx = 0000 0000 |
;;; 	| esi = 1111 2222 |
;;; 	| edi = 2222 3333 |
;;; 	+-----------------+
;;; Include in program as follows:
;;; 
;;; 
;;; %include "dumpRegs.asm"
;;; ---------------------------------------------------------

		section	.data
hex		db	"0123456789ABCDEF"
regs		db	"axbxcxdxsidi"
line		db	"+-----------------+", 10
string		db	"| exx = .... .... |", 10
lineLen 	equ	$-string
reg		equ	string+3
word1		equ	string+8

		section	.text

;;; ---------------------------------------------------------
;;; dumpRegs: dumps the contents of the 6 main registers (eax
;;; ebx, ecx, edx, esi and edi) in a box on the screen.
;;; the screen.  Does not modify any register
;;; ---------------------------------------------------------
dumpRegs:	pushad

;;; put all the registers to print in the stack.  The loop
;;; will pop each one, one at a time, once per loop.
	
		push	edi
		push	esi
		push	edx
		push	ecx
		push	ebx
		push	eax

;;; print top bar
		call	printBar
	
;;; prepare to loop 6 times (6 registers )
		mov	ecx, 6
		mov	esi, 0

.for		pop	ebx			;get value of register to convert from stack
		push	ecx			;save loop counter
		lea	eax, [regs + esi*2]	;get address of string representing register
	
		mov	ax, word [eax] 		;ax gets "ax" or "bx" or "cx" or ... "di"
		mov	word[reg], ax		;modify string with name of register
	
		mov	edx, word1 		;edx points to buffer where to store hex digits
						;ebx contains register to convert
		call 	storeDWord		;store hex equivalent of ebx in string
	
		mov	ecx, string 		;print the whole string
		mov	edx, lineLen
		call	printInt80
		inc	esi			;index into register names incremented
		pop	ecx			;get loop counter back
		loop	.for

;;; print bottom bar
		call 	printBar
	
		popad
		ret

;;; ---------------------------------------------------------
;;; storeDWord: gets
;;; 	ebx: register to convert
;;; 	edx: address where to put information
;;; ---------------------------------------------------------
		
storeDWord:	rol	ebx, 16			;bring most sig word in least sig word
		call	storeWord
	
		inc	edx			;make edx skip space in string
	
		rol	ebx, 16			;get lower byte back in least sig pos
		call	storeWord
		
		ret

;;; ---------------------------------------------------------
;;; storeWord: gets
;;;     bx: word to convert
;;; 	edx: address where to put information. edx incremented by 4
;;; ---------------------------------------------------------
storeWord:	rol	bx, 8			;put most sig byte of bx in lower position
		call	storeByte		;and convert it.  Store it in where edx 
						;points to. 
		rol	bx, 8			;same with lower nybble
		call	storeByte
		ret
	
;;; ---------------------------------------------------------
;;; storeByte: gets
;;;     bl: byte to convert
;;; 	edx: address where to store information.  edx incremented by 2 automatically
;;; ---------------------------------------------------------
storeByte:	push	ebx
		push	eax
	
		rol	bl, 4			;get upper nybble in lower position (LSB)
		mov	al, bl			;play with al now
		and	eax, 0x0000000F		;clear all but the least significant nybble
		add	eax, hex		;get ascii in hex array equivalentn to nybble
		mov	al, [eax] 		;hex digit now in bl
		mov	byte [edx], al		;store ascii in string
		inc	edx

		rol	bl, 4			;get lower nybble back
		mov	al, bl			;play with al
		and	eax, 0x0000000F
		add	eax, hex
		mov	al, [eax]
		mov	byte [edx], al
		inc	edx
	
		pop	eax
		pop	ebx
		ret
		
;;; ---------------------------------------------------------
;;; printInt80: prints on the screen the string whose address
;;; is in ecx and length in edx.
;;; does not modify registers
;;; ---------------------------------------------------------
printInt80:	push	eax
		push	ebx
	
		mov	eax, 4
		mov	ebx, 1
		int	0x80
	
		pop	ebx
		pop	eax
		ret
	
;;; ---------------------------------------------------------
;;; printBar: prints the horizontal bar
;;; does not modify registers
;;; ---------------------------------------------------------
printBar:	push	ecx
		push	edx
	
		mov	ecx, line
		mov	edx, lineLen
		call	printInt80
	
		pop	edx
		pop	ecx
		ret

Problem #2

;;; File: hw8b.asm
;;; Name: Emma Gould (edited by D. Thiebaut)
;;; Account: 231a-ap
;;; Due: 11/7/12
;;; Description: This program computes and displays the first 10 rows of Pascal's triangle.
;;; 01 00 00 00 00 00 00 00 00 00 
;;; 01 01 00 00 00 00 00 00 00 00 
;;; 01 02 01 00 00 00 00 00 00 00 
;;; 01 03 03 01 00 00 00 00 00 00 
;;; 01 04 06 04 01 00 00 00 00 00 
;;; 01 05 0A 0A 05 01 00 00 00 00 
;;; 01 06 0F 14 0F 06 01 00 00 00 
;;; 01 07 15 23 23 15 07 01 00 00 
;;; 01 08 1C 38 46 38 1C 08 01 00 
;;; 01 09 24 54 7E 7E 54 24 09 01 
;;;
;;; To assemble, link, and run: nasm -f elf -F stabs hw8b.asm ; ld -melf_i386  -o hw8b hw8b.o ; ./hw8b


;; -------------------------------
;; Data Section
;; -------------------------------
		section	.data
Pascal		db	0,0,0,0,0,0,0,0,0,0 	; Pascal array of 10 bytes

hexChars	db	"0123456789ABCDEF"	; list of hex characters
hexCharLen	equ	1			; length of a single character

notation	db	"0x"			; hex character notation
notationLen	equ	$-notation		; length of hex character notation

space		db	"   "			; to space the characters of the array
spaceLen	equ	$-space			; length of space

newLine		db	10			; hex characters for new line
newLineLen	equ	$-newLine		; length of newLine

;; -------------------------------
;; Code Section
;; -------------------------------
		section	.text
		global	_start

;; -------------------------------
;; main program
;; -------------------------------
_start:
		mov	ebx, Pascal		; pass address of array in ebx
		call	init			; store 0 in Pascal array
						; and 1 in first cell

		mov	ecx, 10
for:		mov	ebx, Pascal		; pass address of array in ebx
		call	printArray		; print Pascal array

		mov	ebx, Pascal		; pass address of array
		call	nextLine		; compute next line of triangle

		loop	for

;;; exit
		mov	eax, 1
		mov	ebx, 0
		int	0x80

;; -------------------------------
;; function init takes the address
;; in ebx and puts one in the first byte
;; at that address and zero in the other nine
;; bytes that follow
;; -------------------------------
init:
		mov     byte[ebx], 1 		; move 1 into the first cell
		mov	edi, 1			; edi <- index = 1
		mov	ecx, 9			; ecx <- n = 9
for1:		mov	byte[ebx+edi], 0	; Fib[n] <- 0
		inc	edi			; index <- index + 1
		loop	for1			; n <- n - 1
		ret

;; -------------------------------
;; function printArray takes the address
;; in ebx and prints it a byte at a time
;; in hexadecimal (by passing it to printByte)
;; between the string "0x" and three spaces
;; with a new line at the very beginning and end
;; -------------------------------
printArray:
		push	ecx			; save ecx from main program
		call	printNewLine

		mov	ecx, 10			; n = 10
for3:
 		push	ecx			; save n
 		push	ebx			; save address of Pascal array

		mov	ecx, notation		; ecx <- address of "0x"
		mov	edx, notationLen	; edx <- length of "0x"
		mov	eax, 4			; print "0x"
		mov	ebx, 1
		int	0x80

		pop	ebx 			; ebx <- address of Pascal array (from stack)
		pop	ecx			; ecx <- n (from stack)
		mov	edi, 10			; edi <- 10
		sub	edi, ecx		; edi <- 10 - n
		mov     eax, 0			; eax <- 0 (initialize)
		mov	al, byte[ebx+edi]	; al <- Pascal[10 - n]
		push	ecx			; save n
		push	ebx			; save address of Pascal array
		call	printByte		; print the byte in al in hexadecimal

		mov	ecx, space 		; ecx <- address of tab
		mov	edx, spaceLen		; edx <- length of tab
		mov	eax, 4			; print "	"
		mov	ebx, 1
		int	0x80

		pop	ebx			; ebx <- return address of Pascal array (from stack)
		pop	ecx			; ecx <- n (returned from stack)
		loop	for3			; n <- n - 1

		call	printNewLine

		pop	ecx			; ecx <- restore value from main program

		ret
;; -------------------------------
;; function printNewLine takes no
;; parameters and simply prints a new line
;; -------------------------------
printNewLine:
		push	ebx
		push	ecx
		mov	eax, 4
		mov	ebx, 1
		mov	ecx, newLine
		mov	edx, newLineLen
		int	0x80
		pop	ecx
		pop	ebx
		ret

;; -------------------------------
;; function printByte takes the value
;; stored in eax and print the two nybbles
;; (most significant first) in al
;; -------------------------------
printByte:
		rol	al, 4			; move most significant nybble to least
		push	eax			; save eax in stack
		and	eax, 0x0000000F		; get rid of upper nybble

		mov	ecx, hexChars	 	; ecx <- address of hexChars
		add	ecx, eax		; ecx <- address of hexChars + value of nybble
		mov	edx, hexCharLen		; edx <- length of a single character

		mov	eax, 4			; print the character
		mov	ebx, 1
		int	0x80

		pop	eax			; eax <- full hex value (from stack)
		rol	al, 4			; move lower nybble back to least significant
		and	eax, 0x0000000F		; get rid of upper nybble

		mov	ecx, hexChars	 	; ecx <- address of hexChars
		add	ecx, eax		; ecx <- address of hexChars + value of nybble
		mov	edx, hexCharLen		; edx <- length of a single character

		mov	eax, 4			; print the character
		mov	ebx, 1
		int	0x80

		ret

;; -------------------------------
;; function nextLine uses the address stored in ebx
;; to compute the next row of pascal's triangle
;; and stores it in the Pascal array
;; -------------------------------
nextLine:	push	ecx
		mov	ecx, 9			; ecx <- m = 9 (length of array - 1)
		mov	edi, 9			; edi <- n = 9 (length of array - 1)

for4:		mov	al, byte[ebx+edi] 	; al <- Pascal[n] (starting at the rightmost
						; number and working left)
		add	al, byte[ebx+edi-1]	; al <- Pascal[n-1]
		mov	byte[ebx+edi], al	; Fib[n] <- al
		dec	edi			; n = n - 1
		loop	for4			; m = m - 1

		pop	ecx
		ret