CSC231 Exercises On Functions

Back to Weekly Schedule.

---

Note: Highlight the white section on the right hand-side of each code section to see the solution.

Exercise 1

• Write a program that prints all the letters of the alphabet in a loop. Do not use a function. Use ecx and loop to control the looping. Make your program print 1 letter in each loop.

• use int 0x80 to print the character (which you'll store in a string).

Exercise 2

• Same exercise, but this time use a function that receives the character to be printed in al.
• Explore ways to save ecx in a temporary variable
• Explore alternative ways using the push and pop operations

Exercise 3

• What is the behavior of the stack, and the resulting values in the registers as this program is executing:

        mov	eax, 0x01234567
	mov	ebx, 0x89ABCDEF
	xor	ecx, ecx

	push	ax
        pop	cx

        push	ax
        push	bx
        pop	ecx

        call	next
next:	pop     ecx

Exercise 4

What is the behavior of this loop?

mov eax, 0 mov ecx, 10 for: call func1 ... loop for jmp theEnd func1: add eax, 1 ret theEnd: ...	The loop goes 10 times and the function is called 10 times, adding 1 to eax every time. Eax ends with 10 in it.

Exercise 5

What is the behavior of the loop below? Could it ever be endless?

mov eax, 0 mov ecx, 10 for: call func1 ... loop for jmp theEnd func1: sub ecx, 1 ret theEnd: ...

The function decrements ecx by 1 every time through the loop. So ecx is decremented once by the function, once by the loop instruction. The loop is going to go twice as fast. The loop instruction stops if ecx is 1 when the instruction is executed. We risk endless looping if ecx is either 2 or 0 when the loop instruction executes. This will happen if we start with an odd number in ecx outside the loop.

Exercise 6

What is the behavior of this program? Draw the stack as the processor executes this program:

mov eax, 0 mov ebx, 0 mov ecx, 10 for: call func1 ... loop for func1: add eax, 1 call func2 ret func2: add ebx, 1 ret	Just go through the motion and draw the stack. The return address of the instruction after the call gets pushed in the stack every time the processor executes a call. It is popped out of the stack every time the processor executes a ret.

Exercise 7

Same question, but now observe that the programmer forgot the ret instruction at the end of the first function.

mov eax, 0 mov ebx, 0 mov ecx, 10 for: call func1 ... loop for func1: add eax, 1 call func2 func2: add ebx, 1 ret

Just go through the motion and draw the stack. Now the problem is that when the main program calls func1 the first time, the return address for the ellipses is pushed in the stack, then the processor starts executing the add eax,1 function. Then it executes the call func2 instruction and pushes the address of the add ebx,1 instruction in the stack. Then, when it executes the ret instruction, the address of add ebx,1 is popped out, and ebx is incremented by 1. Then the ret is executed and we return to the main function. The end result is that func1 is executed once, and func2 twice!

Exercise 8 (Push and Pop)

What are the numbers stored in eax and ebx when the loop terminates? If we assume that the default stack is 2 KB long, what is the largest number of times the loop can iterate before the stack overflows (trick question :-)?

mov eax, 0 mov ebx, 0 mov ecx, 10 for: push ebx call func1 pop ebx loop for ... func1: add eax, 1 call func2 ret func2: add ebx, 1 ret	The loop does not modify ebx!

Exercise 9

Same question, but now observe that we pop eax, not ebx...

mov eax, 0 mov ebx, 0 mov ecx, 10 for: push ebx call func1 pop eax loop for ... func1: add eax, 1 call func2 ret func2: add ebx, 1 ret	This one requires the use of the debugger for fully understanding it! :-)

Exercise 10

What do these 2 code sections do?

push eax mov eax, ebx pop ebx and xor eax, ebx xor ebx, eax xor eax, ebx	They both swap the contents of eax and ebx.