1. Hints for Post-Lab Quiz 1 Works for other quizzes and exams too

2. Three types of questions  Basic Knowledge Questions  Translation Questions You are given the C++ and must convert into Blackfin assembly codeYou are given the C++ and must convert into Blackfin assembly code  Design questions Work out what is neededWork out what is needed Generate the design – in C++ or in pseudo codeGenerate the design – in C++ or in pseudo code Most often – convert design code into Blackfin assembly codeMost often – convert design code into Blackfin assembly code

3. Knowledge type question example A)Circle and label with an A -- the icon (menu item) that causes VisualDSP to compile the C++ code, but not build or rebuild the full project. B) Circle and label with a B -- a Blackfin instruction where a non-volatile register is recovered from the stack. CORRECT OR WRONG ANSWER NO PARTIAL MARKS Sometimes more than one correct

4. The Rosetta Stone Engineering version C++ code Used as extern “C” long int Return1( ); long int Return1( ){ return 1; } Blackfin code.section program;.global _Return1;.section program;.global _Return1; _Return1: LINK 16; R0 = 1; R0 = 1; UNLINK; RTS; UNLINK; RTS; 68K code.section code;.global _Return1;.section code;.global _Return1; _Return1: LINK #-16, A4; MOVE.L #1, D0; MOVE.L #1, D0; UNLINK A4; RTS; UNLINK A4; RTS; Demonstrates ability to transfer knowledge Which register is used as the 68K return register? In this code, which register is used as the 68K frame pointer?

5. C++ to assembly Example ACCURACY IMPORTANT TRY TO MATCH ASSEMBLY CODE TO C++ ON A BOX BY BOX BASIS THEN EASIER TO GIVE PARTIAL MARKS #define count_R1 R1 count_R1 = 0;

6. Design question example Acts like one part of the laboratory

7. Design Question  Next to impossible to mark if not well documented Therefore many marks are given for the C++ or pseudo-code commentsTherefore many marks are given for the C++ or pseudo-code comments  More chance of partial marks if the registers are self documenting

8. Register documentation example ID_R1.L = lo(CHIPID); // Marker know that ID_R1.H = hi(CHIPID); // R1 used to store ID CC = ID_R1 == version_INPAR_R0; // Marker knows that // R0 used for version // Marker also know that you know first parameter is passed in R0 // and not on the stack – later if you make a mistake version_R1 then still a good chanace for partial (or full) mark

9. Avoid errors that would take a lot of time to fix in the laboratory  Always check for possible return address and stack errors LINK -- at the start of a functionLINK -- at the start of a function UNLINK -- at the end of a functionUNLINK -- at the end of a function  Always check for NAME_MANGLING Variable _fooarray;Variable _fooarray; Function _FeeFunction__Fv (void)Function _FeeFunction__Fv (void) _FeeFunction__Fl (long int) _FeeFunction__NM (not sure) _FeeFunction__NM2 (different not sure) _FeeFunction__Fl (long int) _FeeFunction__NM (not sure) _FeeFunction__NM2 (different not sure) WITH NAME MANGLING – under exam conditions, more interested in that you understand the concept than whether you are getting it exactly correct

10. Avoid pointer errors that would take a lot of time to fix in the laboratory  If the memory location is shown as extern in C++ or.extern in Assembly extern long int funVariable; extern long int funVariable;.extern _funVariable;.extern _funVariable;.section program // will accept code.section program // will accept code P0.L = _funVariable; P0.H = _funVariable; P0.L = _funVariable; P0.H = _funVariable;

11. Avoid pointer errors that would take a lot of time to fix in the laboratory  If the memory location is shown without the word EXTERN long int funVariable = 0; long int funVariable = 0;.section data1; // will accept data, L1_data.section data1; // will accept data, L1_data.global _funVariable;.global _funVariable;.var _funVariable = 0; // Follow the C++.var _funVariable = 0; // Follow the C++.section program.section program P0.L = _funVariable; P0.H = _funVariable; P0.L = _funVariable; P0.H = _funVariable; HINT: If it is name mangled DON’T use hi( ) or lo( )

12. Avoid pointer errors that would take a lot of time to fix in the laboratory  If the memory location is known to be part of the special MEMORY LOCATIONS (MMR) used to control special operations of the Blackfin “peripherals” #include // will accept // will accept <defs #include // will accept #include // will accept.section program.section program P0.L = lo(TCOUNT); // will accept HI( ) and LO ( ) P0.H = hi(TCOUNT); P0.L = lo(TCOUNT); // will accept HI( ) and LO ( ) P0.H = hi(TCOUNT); HINT: If it is name mangled DON’T use hi( ) or lo( ) DON’T use hi( ) or lo( )

13. HINT – #define CONSTANTS don’t use CONSTANTS #define MAXVALUE 44000 Either hex or decimal is okay.section program.section program R0.L = lo(MAXVALUE); R0.H = hi(MAXVALUE); R0.L = lo(MAXVALUE); R0.H = hi(MAXVALUE); HINT: If the person is following “standard” coding conventions then CAPITIALS MEAN CONSTANT – use hi( ), lo( )

14. HINT – Will work for small constants too #define MAXVALUE 22000 Either hex or decimal is okay.section program.section program R0.L = lo(MAXVALUE); R0.H = hi(MAXVALUE); R0.L = lo(MAXVALUE); R0.H = hi(MAXVALUE); BUT IN THIS CASE – since the constant is small (short int size) R0 = MAXVALUE; R0 = MAXVALUE; Or R0 = 6; HINT: If it looks like IT MIGHT BE a big constant, then let the assembler worry about it -- use hi( ) and lo( )

15. Condition codes  99999 times out of 100000 the following is wrong CC = R0 < number; CC = R0 < number; So play the odds R1 = number; R1 = number; CC = R0 < R1; CC = R0 < R1; Will accept CC = (R0 < R1); WILL NOT ACCEPT CC = R1 > R0; CC conditions are always checked VERY closely as they cause so much problem in the laboratory and in “real life”

16. LOAD AND STORE OPERATIONS  Rule to remember – if the operation would not work on the MIPS, then it will not work on the Blackfin or any other RISC processor register  memory R0 = [P1]; memory  register [P1] = R0; register  memory R0 = [P1]; memory  register [P1] = R0; NEVER add to memory, [P1] = [P0] +1; add to register R0 = R0 + [P0];

17. Register operations Add a small number Make sure that you get the common instructions correct – there are not many R0 += pretty_small_number R0 += 6 or R0 += -10; NOT R0 = R0 + 6; R0 += pretty_small_number R0 += 6 or R0 += -10; NOT R0 = R0 + 6;  Pretty_small_numbers are just that – pretty small numbers -64 <= num <= +63

18. Register operations Add a larger number  Make sure that you get the common instructions correct – there are not many R1 = larger_number; R0 = R0 + R1; R1 = 0x2000; R1 = 0x2000; R0 = R0 + R1; NOT R0 += R1; R1 = 20000; R0 = R0 + R1; R0 = R0 + R1; NOT R0 += R1; R1 = 20000; R0 = R0 + R1; R1.L = lo(40000); R1.H = hi(40000); R0 = R0 + R1; R1.L = lo(40000); R1.H = hi(40000); R0 = R0 + R1; HINT: Hexadecimal numbers are easy to work out if they are small (need 16-bits) or very large (need 32-bits). Decimal numbers are not – PLAY THE ODDS – if it looks large in decimal – then use lo( ), hi( ) approach

19. Other instructions we have used  Make sure that you get the common instructions correct – there are not many  JUMP LABEL_END; // OFTEN JUMP (P0); // typically end of function

20. Other instructions we have used  Make sure that you get the common instructions correct – there are not many  CALL _FeePassVoidFunction__Fv // void FeePassVoidFunction(void); NOTE: CALL _FeePassVoidFunction__Fv // long int FeePassVoidFunction(void); // Returns a value in R0; NOTE: CALL _FeePassVoidFunction__Fv // long int FeePassVoidFunction(void); // Returns a value in R0;

21. Other instructions we have used  Make sure that you get the common instructions correct – there are not many // void FeePassLongIntFunction(long int);  CALL _FeePassLongIntFunction__Fl (little L) CALL _FeePassLongIntFunction__NM -- okay in exam  CALL _FeePassIntFunction__Fi (little I) // void FeePassIntFunction(long int); CALL _FeePassIntFunction__NM2 -- okay in exam CALL _FeePassIntFunction__NM2 -- okay in exam

22. Other instructions we have used  Make sure that you get the common instructions correct – there are not many  R0 = 7; CALL _FeeFunction__Fl; // FeeFunction( );  R1 = 6; R0 = 7; CALL _FumFunction__NM; // FumFunction(7, 6 );

23. Other instructions we have used  Make sure that you get the common instructions correct – there are not many  R0 = 7; CALL _FeeFunction__Fl; // FeeFunction( );  R1 = 6; R0 = 7; CALL _FumFunction__NM; // FumFunction(7, 6 );

24. When to use a register and when to use memory..extern _value; // extern long int value.section L1_data_a;.global _fum_value; // long int fum_value;.var _fum_value;.section program;.global _FooFunction__Fl; // void FooFunction(long int passed_Fickle) { _FooFunction__Fl: LINK 16; passed_Fickle_R0 += 6; // passed_Fickle = passed_Fickle +6; P0.H = _value; // value = value + 6; P0.L = _value; R1 = [P0]; R1 += 6; [P0] = R1; P1.H = _fum_value; // fum_value = fum_value + 6; P1.L = _fum_value; R2 = [P1]; R2 += 6; [P1] = R2; ……… // Rest of the function ……… // Rest of the function

25. When to use a register and when to use memory.section program;.global _FooFunction__Fl; // void FooFunction(long int passed_Fickle) { _FooFunction__Fl: LINK 16; passed_Fickle_R0 += 6; // passed_Fickle = passed_Fickle +6; #define value_R1 R1 // long int value value_R1 += 6; // value = value + 6; #define fum_valueR2 R2 // long int fum_value; fum_value_R2 += 6; // fum_value = fum_value + 6; ……… // Rest of the function ……… // Rest of the function

26.  Other requested question and answers