CSC231 Homework 4 2014
--D. Thiebaut (talk) 07:11, 21 October 2014 (EDT)
The assignment is due on 10/28/10 at 11:55 p.m.
Contents
Problem #1: Addressing modes and one-dimensional arrays
Assume that your data section is initialized with the following variables:
msg db 3,"ALL",11,"PROGRAMMERS",3,"ARE",11,"PLAYWRIGHTS"
db 3,"AND",3,"ALL",9,"COMPUTERS",3,"ARE",5,"LOUSY"
db 6,"ACTORS"
N equ 10
Note that the msg contains byte numbers followed by words. The byte number preceeding a word corresponds to the number of letters in the word. So '3,"ALL"' for example means that the word that follows 3 is a 3-character word. '11,"PROGRAMMERS"' means that the string following the byte that contains 11 is an 11-character word.
N represents the total number of words in the string msg.
Your assignment is to write a program, called Hw4_1.asm, that uses one or several loops that go N times and that print all the words on separate lines, one after the other, such that each word is capitalized, i.e. its first letter is uppercase, and the others are lowercase.
If you observe the ASCII table, the difference between upper- and lower-case letters is always the same: 32. So, if you have an uppercase character in al and want to make it lowercase, you can do this:
sub al, 32
Better yet, you can write this instruction in a much more self-documenting fashion:
sub al, 'a'-'A'
In this case you ask nasm to figure out the difference between lower and uppercase letters, and subtract that difference from al. If al contained 'f', for example, then, after the sub instruction, it will contain 'F'.
Feel free to use the 231Lib.asm library for printing strings.
Submission
Submit your program in Moodle's Homework 4, Problem 1 section.
Problem #2: Documentation and Style
Take your solution program for Problem 1, above, and document it fully. Use past solution programs as examples.
Your program should have:
- A header, containing the name of the program (its file name), the name of the author, a description of what it does (and possible bugs you may know it to contain, and how one should assemble, link, and run it
- Markers highlighting where the data section and code section are located
- Comments throughout the code indicating what the various blocks of instructions do. Do not hesitate to add blank lines in your code to separate logical blocks. Make sure your comments help understand how the computation progresses, rather than what the instruction is doing.
- For example, here is a bad way of documenting an instruction:
inc ebx ; increment ebx
- This is not very helpful because we are not learning anything more about what the code is doing. Instead, if eax is a pointer to a list of characters, a more useful comment would have been:
inc ebx ; move ebx to the next character in string
- You do not have to document each instruction. Only those that are important, or where having some additional details would help.
- Make sure you use variables that have self-documenting names. x, a, for example, do not carry much information. But message, char, or index are much better.
Submission
You need to submit your fully documented program to a different section of Moodle. Your program will not be run or evaluated automatically. Instead I will download it from Moodle later, so that I can read it, annotate it, and comment on your programming style. You won't be able to run or evaluate this problem with Moodle.
Problem #3
Take your solution program (or my solution program) for Homework 3, Problem 5, and rewrite it (call it Hw4_3.asm), and this time make it use functions.
Your solution program should have several functions:
- One function called printLn that prints a new-line character (0x0a). It will replace our _println function. Your function must use int 0x80 to print the 0x0a char. Your function should not call _println! printLn does not receive any parameter through registers, and must save all the registers it uses. In other words, when we return from printLn, all the registers will contain the same values they had before we called the function.
- One function called printMsg that prints a string on the screen. printMsg will replace our _printString function. Your function must use int 0x80 to print the string. It will get the address of the string to print in ecx and the number of characters in the string in edx. This function should not call _printString. It must use the int 0x80 instruction.
- One function called printFibMsg that gets a number in eax and prints the string Fibonacci(###) = where ### is the decimal value of the number in eax. You should call _printDec inside printFibMsg to print the number passed in eax.
Your printFibMsg function should save all the registers it modifies and should return them to their original values.
Restrictions
- You can only use the _printDec library function in your program. No other function from the 231Lib.asm library should be used.
Submission
Submit your program to the Homework 4 Problem 3 section in Moodle.
Problem #4
Your assignment is to write a program in assembly that contains functions, one of which will display the contents of eax in hexadecimal. This function will be called repeatedly from a test program, and given dwords through eax. Your function will print the contents of eax in hexadecimal.
In order to get you started, you are given two helper programs. Program 1 shows you how to take a 4-bit value (i.e. a number between 0 and 15 decimal) and transform it into a character representing its hexadecimal equivalent. For example, 4 decimal, which is also 0x04, will get converted to the ASCII character '4'. 8, which is also 0x08, will be converted to '8', and 10, which is 0x0A, will be converted to the character 'A'.
Program 2 shows you how to shift the bits inside a register. We haven't covered shifts yet, but they are relatively easy to get. They are covered in Randy Hyde's e-text as well.
Helper Program 1
;;; ; hw4Prep.asm
;;; ; D. Thiebaut
;;; ;
;;; ; Takes a 4-bit value in al and find the ASCII char that represents
;;; ; the hex digit associated with this value.
;;; ;
;;; ; to assemble and run:
;;; ;
;;; ; nasm -f elf -F stabs hw4Prep.asm
;;; ; ld -melf_i386 -o hw4Prep hw4Prep.o
;;; ; ./hw4Prep
;;; ; -------------------------------------------------------------------
;;; ------------------------------------------------------------
;;; data areas
;;; ------------------------------------------------------------
section .data
bin2hex db "0123456789ABCDEF"
;table of all the hex characters from 0 to F
counter db 0 ;counter incremented from 0 to 15
;;; ------------------------------------------------------------
;;; code area
;;; ------------------------------------------------------------
section .text
global _start
;;; ------------------------------------------------------------
;;; printChar: prints the character in al. Does not modify any
;;; of the registers.
;;; ------------------------------------------------------------
printChar:
section .data
char db 0 ;temporary string holding char to print
section .text
push eax ;save data regs
push ebx
push ecx
push edx
mov byte[char],al
;save char in string
mov ecx, char ;print string using int 0x80
mov edx, 1
mov eax, 4
mov ebx, 1
int 0x80
pop edx ;restore data regs
pop ecx
pop ebx
pop eax
ret
;;; ------------------------------------------------------------
;;; main program.
;;; ------------------------------------------------------------
_start:
mov ecx, 16
for: mov ebx, bin2hex ;make ebx point to array of char
mov edx, 0 ;put counter into edx
mov dl, byte[counter]
mov al, byte[ebx+edx] ;get char at index edx from table
call printChar ;print it
mov al, 0x0a ;print new line
call printChar
inc byte[counter] ;get next index value in array
loop for ;keep on looping 16 times
;;; exit()
mov eax,1
mov ebx,0
int 0x80 ; final system call
Helper Program 2
;;; ; hw4Prep2.asm
;;; ; D. Thiebaut
;;; ;
;;; ; Puts 0x89 in al, then prints '9' and '8' on the screen.
;;; ; These happen to be the characters representing the hex
;;; ; digits of the number. Replace 0x89 but another 2-digit
;;; ; hex value, and see the digits printed on the screen.
;;; ;
;;; ; to assemble and run:
;;; ;
;;; ; nasm -f elf -F stabs hw4Prep2.asm
;;; ; ld -melf_i386 -o hw4Prep2 hw4Prep2.o
;;; ; ./hw4Prep2
;;; ; -------------------------------------------------------------------
extern _printDec
extern _println
;;; ------------------------------------------------------------
;;; code area
;;; ------------------------------------------------------------
section .text
global _start
_start: mov eax, 0 ;clear full register first
mov al,0x89 ;set lower part to 0x89: 1000 1001
push eax ;save eax for later.
and eax,0x0F ;clear all bits except last 4
call _printDec ;print digit (will print 9)
pop eax ;get eax back
shr eax,4 ;shift eax right 4 bits
;now eax contains 8
call _printDec ;print digit (will print 8)
call _println
;;; exit()
mov eax,1
mov ebx,0
int 0x80 ; final system call
Putting It All Together
You will notice if you play with Helper Program 2 that it prints the hex digits of what you put in al correctly (in reverse order), except if the digits are letters. 0xAB, for example, is not printed as 'B' followed by 'A'. Instead you will see 11, followed by 10.
But... if you combine Helper Program 1 with Helper Program 2, you should be able to.
In a first step, combined both program so that 0xAB prints as 'B' followed by 'A'.
When you are done, create a function that prints all 8 hexadecimal digits in eax, in the correct order. Call your function _printHex, and make it global (the same way that you make the _start label global):
global _start
global _printHex
This way, I will be able to link your program with my test program, which will call your function and pass it different values in eax.
Requirements
- Your program should be called Hw4_4.asm
- It should contain at least 1 global function called _printHex
- _printHex should print the 8 hex digits (even if they are 0s) corresponding to the 32-bit value in eax.
- _printHex should NOT modify any of the other registers
Submission
- Submit Hw4_4.asm to the Moodle Homework 4 Program 4 section. Your function will be tested with 3 numbers:
00000000 12345678 ABCDEF00
