1. Help for Assignment 2

2. Topics Tackled Handling some “C++” keywords when programming assembly code –Programming “subroutines called by subroutines” –Programming “extern” variables –Programming “volatile” variables Understanding what I did when –Programming “subroutines called by subroutines” –Programming “extern” variables –Programming “volatile” variables

3. Subroutine calling subroutine All void functions File “bloodEnglishmanASM.asm”.extern _Fee__Fv;.extern _Fi__Fv;.extern _Fo__Fv;.section program;.global _Fum__Fv; _Fum__Fv: LINK 16; CALL _Fee __Fv; LINK 16; CALL _Fee __Fv; CALL _Fi __Fv; CALL _Fi __Fv; CALL _Fo__Fv; CALL _Fo__Fv; P0 = [FP +4]; UNLINK; UNLINK;_Fum__Fv.END: JUMP (P0); JUMP (P0); File “bloodEnglishmanCPP.cpp” void Fee(void); void Fi(void); void Fo(void); void Fum(void); void Fum(void) { Fee( ); Fee( ); Fi( ); Fi( ); Fo( ); Fo( );}

4. What nursery rhyme? Fe,Fi,Fo,Fum, I smell the blood of an Englishman?

5. Subroutine calling subroutine All integer functions File “bloodEnglishmanASM.asm”.extern _Fee__Fi;.extern _Fi__Fi;.extern _Fo__Fi;.section program;.global _Fum__Fi; _Fum__Fi: // value passed in R0 LINK 16; LINK 16; R0 += 6; // pass parameter in R0 R0 += 6; // pass parameter in R0 CALL _Fee __Fi; CALL _Fee __Fi; R0 = 7; // pass parameter in R0 CALL _Fi __Fi; CALL _Fi __Fi; R0 = 8; // pass parameter in R0 CALL _Fo__Fi; CALL _Fo__Fi; P0 = [FP +4]; UNLINK; UNLINK;_Fum__Fi.END: JUMP (P0); JUMP (P0); File “bloodEnglishmanCPP.cpp” void Fee(int); void Fi(int); void Fo(int); void Fum(int); void Fum(int value) { Fee(6 + value); Fee(6 + value); Fi(7); Fi(7); Fo(8); Fo(8);}

6. Subroutine calling subroutine All integer functions.extern _Fee__Fi;.extern _Fi__Fi;.extern _Fo__Fi;.section program;.global _Fum__Fi; _Fum__Fi: // value passed in R0 LINK 16; LINK 16; [--SP] = R0; // Save passed value [--SP] = R0; // Save passed value R0 = 6; // pass parameter in R0 R0 = 6; // pass parameter in R0 CALL _Fee __Fi; CALL _Fee __Fi; R0 = 7; // pass parameter in R0 CALL _Fi __Fi; CALL _Fi __Fi; R0 = [SP++]; // Recover passed value R0 += 8; // pass parameter in R0 R0 += 8; // pass parameter in R0 CALL _Fo__Fi; CALL _Fo__Fi; P0 = [FP +4]; UNLINK; UNLINK;_Fum__Fi.END: JUMP (P0); JUMP (P0); File “bloodEnglishmanCPP.cpp” void Fee(int); void Fi(int); void Fo(int); void Fum(int); void Fum(int value) { Fee(6); Fee(6); Fi(7); Fi(7); Fo(8 + value); Fo(8 + value);}

7. Subroutine calling subroutine All integer functions -- Better.extern _Fee__Fi;.extern _Fi__Fi;.extern _Fo__Fi;.section program;.global _Fum__Fi; _Fum__Fi: // value passed in R0 LINK 16; LINK 16; [FP + 8] = R0; // Save passed value [FP + 8] = R0; // Save passed value R0 = 6; // pass parameter in R0 R0 = 6; // pass parameter in R0 CALL _Fee __Fi; CALL _Fee __Fi; R0 = 7; // pass parameter in R0 CALL _Fi __Fi; CALL _Fi __Fi; R0 = [FP + 8]; // Recover passed value R0 += 8; // pass parameter in R0 R0 += 8; // pass parameter in R0 CALL _Fo__Fi; CALL _Fo__Fi; P0 = [FP +4]; UNLINK; UNLINK;_Fum__Fi.END: JUMP (P0); JUMP (P0); File “bloodEnglishmanCPP.cpp” void Fee(int); void Fi(int); void Fo(int); void Fum(int); void Fum(int value) { Fee(6); Fee(6); Fi(7); Fi(7); Fo(8 + value); Fo(8 + value);}

8. extern long int.extern _thumb;.section L1_cache;.global _plumb[5] = {1, 2, 3, 4, 5};.section program;.global _Jack__FPl; // Pointer long _Jack__FPl: // pointer passed in R0 LINK 16; LINK 16; P0 = R0; // Use passed value as a pointer P0 = R0; // Use passed value as a pointer P1.L = _thumb; P1.L = _thumb; P1.H = _thumb; P1.H = _thumb; R0 = [P1 + (2 * 4)]; // LOAD R0 = [P1 + (2 * 4)]; // LOAD P1.L = _plumb; P1.L = _plumb; P1.H = _plumb; P1.H = _plumb; R1= [P1 + (1 * 4)]; // LOAD R1= [P1 + (1 * 4)]; // LOAD R0 = R0 + R1; R0 = R0 + R1; [P0 + (1 * 4)] = R0; // STORE [P0 + (1 * 4)] = R0; // STORE P0 = [FP +4]; UNLINK; UNLINK; _ Jack__FPl.END:: JUMP (P0); JUMP (P0); File “PutInHisThumb.cpp” extern long int thumb[10]; long int plumb[5] = {1, 2, 3, 4, 5} long int Jack(long int *goodboy) long int Jack(long int *goodboy{ long int sum; long int sum; goodboy[3] = thumb[2] + plumb[1] goodboy[3] = thumb[2] + plumb[1]}

9. extern volatile long int.extern _thumb;.section L1_cache;.global _plumb[5] = {1, 2, 3, 4, 5};.section program;.global _Jack__FPl; // Pointer long _Jack__FPl: // pointer passed in R0 LINK 16; LINK 16; P0 = R0; // Use passed value as a pointer P0 = R0; // Use passed value as a pointer P1.L = _thumb; P1.L = _thumb; P1.H = _thumb; P1.H = _thumb; R0 = [P1 + (2 * 4)]; // LOAD R0 = [P1 + (2 * 4)]; // LOAD P1.L = _plumb; P1.L = _plumb; P1.H = _plumb; P1.H = _plumb; R1= [P1 + (1 * 4)]; // LOAD R1= [P1 + (1 * 4)]; // LOAD R0 = R0 + R1; R0 = R0 + R1; [P0 + (1 * 4)] = R0; // STORE [P0 + (1 * 4)] = R0; // STORE P0 = [FP +4]; UNLINK; UNLINK;_Jack__FPl.END: JUMP (P0); JUMP (P0); File “PutInHisThumb.cpp” extern volatile long int thumb[10]; long int plumb[5] = {1, 2, 3, 4, 5} long int Jack(long int *goodboy) long int Jack(long int *goodboy{ long int sum; long int sum; goodboy[3] = thumb[2] + plumb[1] goodboy[3] = thumb[2] + plumb[1]}

10. extern long int – optimized code.extern _star;.extern _BlinkLight__Fv;.section program;.global _Wonderwhat__Fv; _Wonderwhat__Fv: LINK 16; P0 = R0; // Use passed value as a pointer P0 = R0; // Use passed value as a pointer P1.L = _thumb; P1.L = _thumb; P1.H = _thumb; P1.H = _thumb; R0 = [P1 + (2 * 4)]; // LOAD R0 = [P1 + (2 * 4)]; // LOAD CC = R0 == 2; CC = R0 == 2; IF !CC JUMP DONE; IF !CC JUMP DONE; LOOP: CALL _BlinkLight__Fv; JUMP LOOP; DONE: P0 = [FP +4]; UNLINK; UNLINK; _Wonderwhat__Fv.END: JUMP (P0); JUMP (P0); File “TwinkleTwinkle.cpp” extern long int star[10]; void WonderWhat(void); void BlinkLight(void); void WonderWhat(void) { while (star[2] == 2) { while (star[2] == 2) { BlinkLight( ); BlinkLight( ); }} Either star[2] == 2, or it does not If star[2] == 2 then get an infinite loop

11. extern volatile long int optimized code.extern _star;.extern _BlinkLight__Fv;.section program;.global _Wonderwhat__Fv; _Wonderwhat__Fv: LINK 16; P0 = R0; // Use passed value as a pointer P0 = R0; // Use passed value as a pointer P1.L = _thumb; P1.L = _thumb; P1.H = _thumb; P1.H = _thumb;LOOP: R0 = [P1 + (2 * 4)]; // KEEP LOADING R0 = [P1 + (2 * 4)]; // KEEP LOADING CC = R0 == 2; // LOOP NEEDED CC = R0 == 2; // LOOP NEEDED IF !CC JUMP DONE; IF !CC JUMP DONE; CALL _BlinkLight__Fv; JUMP LOOP; CALL _BlinkLight__Fv; JUMP LOOP;DONE: P0 = [FP +4]; UNLINK; UNLINK; _Wonderwhat__Fv.END: JUMP (P0); JUMP (P0); File “TwinkleTwinkle.cpp” extern volatile long int star[10]; void WonderWhat(void); void BlinkLight(void); void WonderWhat(void) { while (star[2] == 2) { while (star[2] == 2) { BlinkLight( ); BlinkLight( ); }} star[2] == 2 MAY START OFF BEING 2 But since star is “volatile” then some external action may change it. Loop needed in optimized code if “volatile” memory value

12. Understanding what I did Will look at things in more detail later in class But here are some ideas of why we did what we did

13. Subroutine calling subroutine All void functions File “bloodEnglishmanASM.asm”.extern _Fee__Fv;.extern _Fi__Fv;.extern _Fo__Fv;.section program;.global _Fum__Fv; _Fum__Fv: Since the other functions are coded “outside” or “external” to this file then we indicate that with the keyword.extern File “bloodEnglishmanCPP.cpp” void Fee(void); void Fi(void); void Fo(void); void Fum(void); void Fum(void) { }

14. Subroutine calling subroutine All void functions File “bloodEnglishmanASM.asm”.extern _Fee__Fv;.extern _Fi__Fv;.extern _Fo__Fv;.section program;.global _Fum__Fv; _Fum__Fv: Since we want other functions (coded “outside” or “external” to this file) to be able to use Fum( ) coded in this file we must “globalize” (tell everybody) this functions name with the keyword.global File “bloodEnglishmanCPP.cpp” void Fee(void); void Fi(void); void Fo(void); void Fum(void); void Fum(void) { }

15. Subroutine calling subroutine All void functions File “bloodEnglishmanASM.asm”.extern _Fee__Fv;.extern _Fi__Fv;.extern _Fo__Fv;.section program;.global _Fum__Fv; _Fum__Fv: LINK 16; CALL _Fee __Fv; LINK 16; CALL _Fee __Fv; CALL _Fi __Fv; CALL _Fi __Fv; CALL _Fo__Fv; CALL _Fo__Fv; P0 = [FP +4]; UNLINK; UNLINK;_Fum__Fv.END: JUMP (P0); JUMP (P0); The LINK 16; operation saves this subroutine’s return address (stored in the “RETurn from Subroutine register” RETS) onto the stack. This allows the processor to use register RETS when it calls other subroutines – same was as the MIPS – different register name UNLINK restores (recovers, reads) RETS from the stack so we can exit this subroutine.

16. Subroutine calling subroutine All integer functions.extern _Fee__Fi;.extern _Fi__Fi;.extern _Fo__Fi;.section program;.global _Fum__Fi; _Fum__Fi: // value passed in R0 LINK 16; LINK 16; [--SP] = R0; // Save passed value [--SP] = R0; // Save passed value R0 = 6; // pass parameter in R0 R0 = 6; // pass parameter in R0 CALL _Fee __Fi; CALL _Fee __Fi; R0 = 7; // pass parameter in R0 CALL _Fi __Fi; CALL _Fi __Fi; R0 = [SP++]; // Recover passed value R0 += 8; // pass parameter in R0 R0 += 8; // pass parameter in R0 CALL _Fo__Fi; CALL _Fo__Fi; P0 = [FP +4]; UNLINK; UNLINK;_Fum__Fi.END: JUMP (P0); JUMP (P0); Name mangle changes (Do not need to remember details in quizzes and exams – critical to get correct in labs) void Foo(void)  _Foo__Fv int Foo(void)  _Foo__Fv int Foo(int)  _Foo__Fi int Foo(long int)  _Foo__Fl int Foo(int *)  _Foo__FPi Int Foo(long int *)  _Foo_FPl Can’t overload on the basis of return value

17. Subroutine calling subroutine All integer functions.extern _Fee__Fi;.extern _Fi__Fi;.extern _Fo__Fi;.section program;.global _Fum__Fi; _Fum__Fi: // value passed in R0 LINK 16; LINK 16; [--SP] = R0; // Save passed value [--SP] = R0; // Save passed value R0 = 6; // pass parameter in R0 R0 = 6; // pass parameter in R0 CALL _Fee __Fi; CALL _Fee __Fi; R0 = 7; // pass parameter in R0 CALL _Fi __Fi; CALL _Fi __Fi; R0 = [SP++]; // Recover passed value R0 += 8; // pass parameter in R0 R0 += 8; // pass parameter in R0 CALL _Fo__Fi; CALL _Fo__Fi; P0 = [FP +4]; UNLINK; UNLINK;_Fum__Fi.END: JUMP (P0); JUMP (P0); void Fum(int value) { Fee(6); Fee(6); Fi(7); Fi(7); Fo(8 + value); Fo(8 + value);} ALWAYS pass the parameter to the subroutine in R0 – very similar to MIPS

18. Subroutine calling subroutine All integer functions.extern _Fee__Fi;.extern _Fi__Fi;.extern _Fo__Fi;.section program;.global _Fum__Fi; _Fum__Fi: // value passed in R0 LINK 16; LINK 16; [--SP] = R0; // Save passed value [--SP] = R0; // Save passed value R0 = 6; // pass parameter in R0 R0 = 6; // pass parameter in R0 CALL _Fee __Fi; CALL _Fee __Fi; R0 = 7; // pass parameter in R0 CALL _Fi __Fi; CALL _Fi __Fi; R0 = [SP++]; // Recover passed value R0 += 8; // pass parameter in R0 R0 += 8; // pass parameter in R0 CALL _Fo__Fi; CALL _Fo__Fi; P0 = [FP +4]; UNLINK; UNLINK;_Fum__Fi.END: JUMP (P0); JUMP (P0); void Fum(int value) { Fee(6); Fee(6); Fi(7); Fi(7); Fo(8 + value); Fo(8 + value);} Must save the passed value (in R0) onto the stack, otherwise it will be destroyed when we call the other subroutines while we use R0 to pass the parameter

19. Note – We can store on the stack using SP or FP (same as MIPS).extern _Fee__Fi;.extern _Fi__Fi;.extern _Fo__Fi;.section program;.global _Fum__Fi; _Fum__Fi: // value passed in R0 LINK 16; LINK 16; [FP + 8] = R0; // Save passed value [FP + 8] = R0; // Save passed value R0 = 6; // pass parameter in R0 R0 = 6; // pass parameter in R0 CALL _Fee __Fi; CALL _Fee __Fi; R0 = 7; // pass parameter in R0 CALL _Fi __Fi; CALL _Fi __Fi; R0 = [FP + 8]; // Recover passed value R0 += 8; // pass parameter in R0 R0 += 8; // pass parameter in R0 CALL _Fo__Fi; CALL _Fo__Fi; P0 = [FP +4]; UNLINK; UNLINK;_Fum__Fi.END: JUMP (P0); JUMP (P0);.extern _Fee__Fi;.extern _Fi__Fi;.extern _Fo__Fi;.section program;.global _Fum__Fi; _Fum__Fi: // value passed in R0 LINK 16; LINK 16; [SP + 16 + 8] = R0; // Save passed value [SP + 16 + 8] = R0; // Save passed value R0 = 6; // pass parameter in R0 R0 = 6; // pass parameter in R0 CALL _Fee __Fi; CALL _Fee __Fi; R0 = 7; // pass parameter in R0 CALL _Fi __Fi; CALL _Fi __Fi; R0 = [SP + 16 + 8] // Recover passed value R0 += 8; // pass parameter in R0 R0 += 8; // pass parameter in R0 CALL _Fo__Fi; CALL _Fo__Fi; P0 = [FP +4]; UNLINK; UNLINK;_Fum__Fi.END: JUMP (P0); JUMP (P0);

20. This does not link and run Why not? A project containing only the file “PutInHisThumb.cpp” will not link and run because All projects must have a main( ) in them File “PutInHisThumb.cpp” extern long int thumb[10]; long int plumb[5] = {1, 2, 3, 4, 5} long int Jack(long int *goodboy) long int Jack(long int *goodboy{ long int sum; long int sum; goodboy[3] = thumb[2] + plumb[1] goodboy[3] = thumb[2] + plumb[1]}

21. This does not link and run Why not? File “main.cpp” extern long int thumb[10]; extern long int plumb[5] ; long int goodboy[10]; long int Jack(long int *goodboy) int main(void) { for (int count = 0; count < 10; count++) goodboy[count] = 0; goodboy[count] = 0; Jack(goodboy); Jack(goodboy); printf(“%d\n”, goodboy[3]); printf(“%d\n”, goodboy[3]);} File “PutInHisThumb.cpp” extern long int thumb[10]; long int plumb[5] = {1, 2, 3, 4, 5} long int Jack(long int *goodboy) long int Jack(long int *goodboy{ long int sum; long int sum; goodboy[3] = thumb[2] + plumb[1] goodboy[3] = thumb[2] + plumb[1]}

22. This does not link and run Why not? DECLARED IN ANOTHER FILE DECLARED IN THIS FILE File “main.cpp” extern long int thumb[10]; extern long int plumb[5] ; long int goodboy[10]; File “PutInHisThumb.cpp” extern long int thumb[10]; long int plumb[5] = {1, 2, 3, 4, 5} DECLARED IN ANOTHER FILE DECLARED IN THIS FILE IN NO FILE HAS MEMORY SPACE BEEN SET ASIDE FOR THE “THUMB” ARRAY

23. This does link and run -- because all arrays have been given “space” File “main.cpp” long int thumb[10] = {2, 4, 6, 8, 10}; extern long int plumb[5] ; long int goodboy[10]; long int Jack(long int *goodboy) int main(void) { for (int count = 0; count < 10; count++) goodboy[count] = 0; goodboy[count] = 0; Jack(goodboy); Jack(goodboy); printf(“%d\n”, goodboy[3]); printf(“%d\n”, goodboy[3]);} File “PutInHisThumb.cpp” extern long int thumb[10]; long int plumb[5] = {1, 2, 3, 4, 5} long int Jack(long int *goodboy) long int Jack(long int *goodboy{ long int sum; long int sum; goodboy[3] = thumb[2] + plumb[1] goodboy[3] = thumb[2] + plumb[1]}

24. How can something in memory change like this.extern _star;.extern _BlinkLight__Fv;.section program;.global _Wonderwhat__Fv; _Wonderwhat__Fv: LINK 16; P0 = R0; // Use passed value as a pointer P0 = R0; // Use passed value as a pointer P1.L = _thumb; P1.L = _thumb; P1.H = _thumb; P1.H = _thumb;LOOP: R0 = [P1 + (2 * 4)]; // KEEP LOADING R0 = [P1 + (2 * 4)]; // KEEP LOADING CC = R0 == 2; // LOOP NEEDED CC = R0 == 2; // LOOP NEEDED IF !CC JUMP DONE; IF !CC JUMP DONE; CALL _BlinkLight__Fv; JUMP LOOP; CALL _BlinkLight__Fv; JUMP LOOP;DONE: P0 = [FP +4]; UNLINK; UNLINK; _Wonderwhat__Fv.END: JUMP (P0); JUMP (P0); File “TwinkleTwinkle.cpp” extern volatile long int star[10]; void WonderWhat(void); void BlinkLight(void); void WonderWhat(void) { while (star[2] == 2) { while (star[2] == 2) { BlinkLight( ); BlinkLight( ); }} star[2] == 2 MAY START OFF BEING 2 But since star is “volatile” then some external action may change it. Loop with repeated read needed in optimized code if “volatile” memory value

25. Example from Lab. 1 Task 4 Lab. 1 Task 4 There is a main routine There is an “interrupt audio” routine. Every 1 / 40000 s the interrupt routine “interrupts” (temporarily halts) main( ), then runs itself, and then returns control to main Interrupts run under “external control” when “something happens” –switch changes or voltage changes -- unexpected Subroutines run under “internal control” –ONLY WHEN CALLED – NEVER UNEXPECTED

26. Example from Lab. 1 Task 4 File “main.cpp” volatile boolean mute_on = FALSE; long int ReadSwitches(void); int main( ) InitializeSwitches( ); InitializeSwitches( ); InitializeAudio( ); StartInterrupts( ); InitializeAudio( ); StartInterrupts( ); while (1) { while (1) { int value = ReadSwitches( ); int value = ReadSwitches( ); // If switch pressed // – turn off sound; if (value == 0x100) mute_on = TRUE; else mute_on = FALSE; if (value == 0x100) mute_on = TRUE; else mute_on = FALSE; }} File “interruptservice.cpp” extern volatile boolean mute_on; void Process_DataASM(void); EX_INTERRUPT_HANDLER(Sport0_RX_ISR){ …….. /// Lots of good stuff Process_DataASM( ); Process_DataASM( ); // Make the sound occur // Make the sound occur …….. // Lots of more good stuff;} void Process_DataASM(void) { if (mute_on = = FALSE) MakeTheSound( ); if (mute_on = = FALSE) MakeTheSound( );} WORRY ABOUT WHAT EX_INTERRUPT_HANDLER( ) MEANS IN LAB. 2