Handling Arrays Completion of ideas needed for a

Handling Arrays Completion of ideas needed for a general and complete program Final concepts needed for Final Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada

Tackled today ¢ Review of handling external arrays from assembly code l l l ¢ Arrays declared on the stack l l 2 Arrays declared in another file Arrays declared in this file -- NEW Needed for arrays used by ISRs Pointers passed as parameters to a subroutine Can’t use arrays on the stack when used by ISR Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

LINK – what does it do A correction – Processor Programming Reference 4: 17 LINK 16 LINK (200 + 16) Does all the following in one instruction [--SP] = RETS; [--SP] = FP; FP = SP; SP – 16; [--SP] = RETS; [--SP] = FP; FP = SP; SP – 200; (Space for an array) SP – 16; 3 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

UNLINK – what does it do LINK 16 LINK (200 + 16) UNLINK Unlink does all the following in one instruction SP = FP; FP = [SP++]; RETS = [SP++]; 4 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

Example C++ function Translate into Assembly code extern short foo_startarray[40]; extern short far_finalarray[40]; void Half. Wave. Rectify. ASM( ) { // Take the signal from foo_startarray[ ] and rectify the signal // Half wave rectify – if > 0 keep the same; if < 0 make zero // Full wave rectify – if > 0 keep the same; if < 0 then abs value // Rectify startarray[ ] and place result in finalarray[ ] for (int count = 0; count < 40; count++) { if (foo_startarray[count] < 0) far_finalarray[count] = 0; else far_finalarray[count] = foo_startarray[count]; } } That we know how to code 5 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

What about this? Memory issues have changed short foo_startarray[40]; -- Not external any more short far_finalarray[40]; -- We must put in L 1_data void Half. Wave. Rectify. ASM( ) { // Take the signal from foo_startarray[ ] and rectify the signal // Half wave rectify – if > 0 keep the same; if < 0 make zero // Full wave rectify – if > 0 keep the same; if < 0 then abs value // Rectify startarray[ ] and place result in finalarray[ ] for (int count = 0; count < 40; count++) { if (foo_startarray[count] < 0) far_finalarray[count] = 0; else far_finalarray[count] = foo_startarray[count]; } } The program code is the same – but the data part is not 6 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

The program part. section program; . global _Half. Wave. Rectify. ASM; _Halfwave. Rectify. ASM: short foo_startarray[40]; short far_finalarray[40]; void Half. Wave. Rectify( ) { for (int count = 0; count < 40; count++) { if (foo_startarray[count] < 0) far_finalarray[count] = 0; else far_finalarray[count] = foo_startarray[count]; } Suggest you use this as an exercise to practice for the final Be able to demonstrate both Hardware and software loops } _Halfwave. Rectify. END; ANSWER: This function has been declared as a “C” function and not as a “C++” function. QUESTION: How come no name mangling of the function name; How to do this is shown in next slide. 7 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

CPP array declared in memory outside a function– not on the stack 8 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

The data part The obvious . section L 1_data 1; . global _foo_startarray; . global _far_finalarray short foo_startarray[40]; short far_finalarray[40]; void Half. Wave. Rectify( ) { for (int count = 0; count < 40; count++) { if (foo_startarray[count] < 0) far_finalarray[count] = 0; else far_finalarray[count] = foo_startarray[count]; } Use section L 1_data 1 as we are not dealing with program (instruction code) Use. global as we are declaring the space needed to place this array into memory NOW Use. extern if the array was declared in a different file (Assembly code or in “C++) 9 } THE DECLARATION IS THE EASY PART HOW ABOUT THE ARRAYS THEMSELVES Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

What we already know how to do! EXTERN DECLARATION STUFF FOR VARIABLE AND ARRAYS NO MEMORY ALLOCATION NEEDED HERE SINCE DONE ELSE WHERE . section program We already can do Assignments 1 and 2 Labs 1, 2, 3, 4 10 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

Attempt 1 . section data 1 Tells linker to place this stuff in memory map location data 1. align 4 We know processor works best when we start things on a boundary between groups of 4 bytes [N * 2] We need N short ints We know the processor works with address working in bytes Therefore need N * 2 bytes 11 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

Wrong when we do a simple Test – look at Blackfin Memory 20 bytes (16 bits) for Main. cpp 12 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada N short value in C++ = N * 2 bytes 12/16/2021

Correct Approach NOT what I expected ASM Array with space for N long ints . var array. ASM[N]; ASM Array with space for N short ints var array. ASM[N / 2]; ASM Array with space for N chars var array. ASM[N / 4]; 13 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

Quick check -- Make sure that array pointers behave as expected Use Same Approach As Always EH? ? 14 OLD ASSEMBLER use hi( ) lo( ) Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

Need to run the code to check what is happening What we expect 15 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada Value 0 x 02 CC must have some special meaning to dis-assembler 12/16/2021

Problem short int foo_start[N]; short int far_final[N]; extern short int foo_start. ASM[N]; extern short int far_final. ASM[N]; extern "C" void Half. Wave. ASM( ); int main( ) { int i; for (i = 0; i < N; i++) foo_start[i] = i - N/2; for (i = 0; i < N; i++) foo_start. ASM[i] = i - N / 2; for (i = 0; i < N; i++) far_final[i] = 0; for (i = 0; i < N; i++) far_final. ASM[i] = 0; } Half. Wave. ASM( ); 16 Problem: We need a different version of Half. Wave. ASM( ) for every array we process Better Approach Place arrays on the stack, which is the standard C / C++ way of handling arrays Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

Solution extern "C" void Half. Wave. ASM(short int *inarray, short int *outarray ); int main( ) { short int foo_start[N]; short int far_final[N]; short int foo_startversion 2[N]; short int far_finalstartversion 2[N]; int i; for (i = 0; i < N; i++) foo_start[i] = i - N/2; for (i = 0; i < N; i++) foo_startversion 2 [i] = i - N / 2; for (i = 0; i < N; i++) far_final[i] = 0; for (i = 0; i < N; i++) far_finalstartversion 2 [i] = 0; Problems to solve? ANSWER – Use the same techniques as you did on the MIPS! How do you PUT things on the stack? Then how do you PASS the address of something you have put onto the stack as a parameter? Then how do you USE the address of something put on the stack and passed as a parameter? Half. Wave. ASM(foo_start, far_final ); Half. Wave. ASM(foo_startversion 2, finalstartversion 2); } 17 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

Last thing is the easiest to Then how do you USE answer the address of something put on the stack and passed as a parameter? How come we are using LINK 0 and not LINK 16? This is a LEAF routine not calling another function 18 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

Solution extern "C" void Half. Wave. ASM(short int *inarray, short int *outarray ); int main( ) { short int foo_start[N]; short int far_final[N]; short int foo_startversion 2[N]; short int far_finalstartversion 2[N]; int i; for (i = 0; i < N; i++) foo_start[i] = i - N/2; for (i = 0; i < N; i++) foo_startversion 2 [i] = i - N / 2; for (i = 0; i < N; i++) far_final[i] = 0; for (i = 0; i < N; i++) far_finalstartversion 2 [i] = 0; Problems to solve What do you need to put on the stack? We need N / 2 bytes for each array Since N = 10 that means 20 bytes 5 32 bit locations Half. Wave. ASM(foo_start, far_final ); Half. Wave. ASM(foo_startversion 2, finalstartversion 2); } 19 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

Problems to solve Solution extern "C" void Half. Wave. ASM(short int *inarray, short int *outarray ); int main( ) { short int foo_start[N]; short int far_final[N]; short int foo_startversion 2[N]; short int far_finalstartversion 2[N]; int i; for (i = 0; i < N; i++) foo_start[i] = i - N/2; for (i = 0; i < N; i++) foo_startversion 2 [i] = i - N / 2; for (i = 0; i < N; i++) far_final[i] = 0; for (i = 0; i < N; i++) far_finalstartversion 2 [i] = 0; What do you need to put on the stack? We need N / 2 bytes for each array Since N = 10 that means 20 bytes 5 32 bit locations So we need 20 32 bit locations for the 4 arrays PLUS we need 4 32 -bit locations because we are about to call a subroutine THAT’S THAT MYSTICAL LINK 16 That’s total of 24 locations needed NOTE: CODE REVIEW -- CHECK THAT’S (20 + 4) * 4 BYTES WHEN Half. Wave. ASM(foo_start, far_final ); WE WRITE CODE FOR THE MIDTERM OR FINAL Half. Wave. ASM(foo_startversion 2, finalstartversion 2); } 20 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

Undocumented solution of things placed on the stack extern "C" void Half. Wave. ASM(short int *inarray, short int *outarray ); int main( ) { short int foo_start[N]; short int far_final[N]; short int foo_startversion 2[N]; short int far_finalstartversion 2[N]; int i; for (i = 0; i < N; i++) foo_start[i] = i - N/2; for (i = 0; i < N; i++) foo_startversion 2 [i] = i - N / 2; for (i = 0; i < N; i++) far_final[i] = 0; for (i = 0; i < N; i++) far_finalstartversion 2 [i] = 0; Half. Wave. ASM(foo_start, far_final ); Half. Wave. ASM(foo_startversion 2, finalstartversion 2); NO – NEED 24 * 4 } 21 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

Full Documented solution of things on the stack – Model needed in your mind extern "C" void Half. Wave. ASM(short int *inarray, short int *outarray ); int main( ) { short int foo_start[N]; short int far_final[N]; short int foo_startversion 2[N]; short int far_finalstartversion 2[N]; int i; for (i = 0; i < N; i++) foo_start[i] = i - N/2; for (i = 0; i < N; i++) foo_startversion 2 [i] = i - N / 2; for (i = 0; i < N; i++) far_final[i] = 0; for (i = 0; i < N; i++) far_finalstartversion 2 [i] = 0; SAME IDEAS AS FOR MIPS Half. Wave. ASM(foo_start, far_final ); Half. Wave. ASM(foo_startversion 2, finalstartversion 2); } 22 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 24 * 4 HIGH MEMORY STACK LOCATIONS (ADDRESSES) LOWER MEMO ADDRESSES NO NEED 24 *4 12/16/2021

Exam solution Step 1 24 * 4 extern "C" void Half. Wave. ASM(short int *inarray, short int *outarray ); int main( ) { short int foo_start[N]; short int far_final[N]; short int foo_startversion 2[N]; short int far_finalstartversion 2[N]; int i; for (i = 0; i < N; i++) foo_start[i] = i - N/2; for (i = 0; i < N; i++) foo_startversion 2 [i] = i - N / 2; for (i = 0; i < N; i++) far_final[i] = 0; for (i = 0; i < N; i++) far_finalstartversion 2 [i] = 0; HIGH MEMO ADDRESSE SAME IDEAS AS FOR MIPS LOWER MEMO ADDRESSES 24 * 4 Half. Wave. ASM(foo_start, far_final ); Half. Wave. ASM(foo_startversion 2, finalstartversion 2); } 23 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

Exam solution Step 2 24 * 4 extern "C" void Half. Wave. ASM(short int *inarray, short int *outarray ); int main( ) { short int foo_start[N]; short int far_final[N]; short int foo_startversion 2[N]; short int far_finalstartversion 2[N]; int i; for (i = 0; i < N; i++) foo_start[i] = i - N/2; for (i = 0; i < N; i++) foo_startversion 2 [i] = i - N / 2; for (i = 0; i < N; i++) far_final[i] = 0; for (i = 0; i < N; i++) far_finalstartversion 2 [i] = 0; SAME IDEAS AS FOR MIPS HIGH MEM ADDRESSE LOWER MEMO ADDRESSES 24 * 4 Half. Wave. ASM(foo_start, far_final ); Half. Wave. ASM(foo_startversion 2, finalstartversion 2); } 24 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

OK? extern "C" void Half. Wave. ASM(short int *inarray, short int *outarray ); int main( ) { short int foo_start[N]; short int far_final[N]; short int foo_startversion 2[N]; short int far_finalstartversion 2[N]; int i; for (i = 0; i < N; i++) foo_start[i] = i - N/2; for (i = 0; i < N; i++) foo_startversion 2 [i] = i - N / 2; for (i = 0; i < N; i++) far_final[i] = 0; for (i = 0; i < N; i++) far_finalstartversion 2 [i] = 0; SAME IDEAS AS FOR MIPS 24 * 4 HIGH MEMOR ADDRESSES LOWER MEMO ADDRESSES 24 * 4 Half. Wave. ASM(foo_start, far_final ); Half. Wave. ASM(foo_startversion 2, finalstartversion 2); } 25 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

What we would now like to be able to do extern "C" void Half. Wave. ASM(short int *inarray, short int *outarray ); int main( ) { short int foo_start[N]; short int far_final[N]; short int foo_startversion 2[N]; short int far_finalstartversion 2[N]; int i; 24 * 4 for (i = 0; i < N; i++) foo_start[i] = i - N/2; for (i = 0; i < N; i++) foo_startversion 2 [i] = i - N / 2; for (i = 0; i < N; i++) far_final[i] = 0; for (i = 0; i < N; i++) far_finalstartversion 2 [i] = 0; SAME IDEAS AS FOR MIPS Half. Wave. ASM(foo_start, far_final ); Half. Wave. ASM(foo_startversion 2, finalstartversion 2); } 26 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

24 * 4 This format correct? extern "C" void Half. Wave. ASM(short int *inarray, short int *outarray ); int main( ) { short int foo_start[N]; short int far_final[N]; short int foo_startversion 2[N]; short int far_finalstartversion 2[N]; int i; Not using SP in #define 24 * 4 Instead use in instruction for (i = 0; i < N; i++) foo_start[i] = i - N/2; for (i = 0; i < N; i++) foo_startversion 2 [i] = i - N / 2; for (i = 0; i < N; i++) far_final[i] = 0; for (i = 0; i < N; i++) far_finalstartversion 2 [i] = 0; IMPROVED ONLY 1 ERROR Half. Wave. ASM(foo_start, far_final ); Half. Wave. ASM(foo_startversion 2, finalstartversion 2); } 27 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

Final exam version of code 24 * 4 METHOD 1 Large offsets must be done like this R 1 = LARGE_NUM R 0 = R 0 + R 1; 24 * 4 METHOD 2 Small offsets can be done like this R 0 += SMALL_NUM Personally, I don’t want to worry about whether the number is large or small So I always use method 1 28 ALWAYS – AS OFTEN 12/16/2021 AS I REMEMBER Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada

What would happen IF we had run the code and left in my original mistake 24 * 4 Would destroy the RETS and FP values on the stack – and the operating system would crash when main( ) exited -- DEFECT 24 * 4 29 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021

How does the compiler handle things? The same way on the stack -- different approach Compiler does LINK (24 * 4) THEN compiler uses FP (a pointer which never moves) rather than SP – a pointer that might move as new things are added to the stack Keeps additions always in the range -64 to 63 Can’t use R 0 = FP; R 0 +- 80; NOT SHOWN When that technique of adding is not possible, the compiler uses same approach as we did 30 I never change the SP after the link when I code to solve many (stupidity) issues Since I can count up easier than down Handling Stack Arrays 12/16/2021 I will use code, it my way Copyright M. Smith, ECE, University of Calgary, Canada My approach also works for MC 68000 and MIPS

Tackled today ¢ Review of handling external arrays from assembly code l l l ¢ Arrays declared on the stack l l 31 Arrays declared in another file Arrays declared in this file -- NEW Needed for arrays used by ISRs Pointers passed as parameters to a subroutine Can’t use arrays on the stack when used by ISR Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/16/2021