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/15/2021

Example 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 3 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/15/2021

What about this short foo_startarray[40]; 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]; } } The program code is the same – but the data part is not 4 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/15/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 – less than 3 weeks away Hardware and software loops } _Halfwave. Rectify. END; 5 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/15/2021

CPP array – not on the stack 6 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/15/2021

The data part The obvious . section 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 data 1 as we are not dealing with program (instruction code) Use. global as we are declaring the array now Use. extern if the array was declared in a different file (Assembly code or in “C++) 7 } THE DECLARATION IS THE EASY PART HOW ABOUT THE ARRAYS THEMSELVES Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/15/2021

What we already know EXTERN STUFF NO MEMORY ALLOCATION NEEDED HERE SINCE DONE ELSE WHERE . section program We already can do Labs 1, 2, 3, 4 and 5 8 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/15/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 byes Therefore need N * 2 bytes 9 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/15/2021

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

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

Quick check -- Make sure that pointers behave as expected Use Same Approach As Always EH? ? 12 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/15/2021

Need to run the code to check what is happening What we expect 13 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/15/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( ); 14 Problem: We need a different version of Half. Wave. ASM( ) for every array we process Better Approach Place arrays on the stack Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/15/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; Half. Wave. ASM(foo_start, far_final ); Half. Wave. ASM(foo_startversion 2, finalstartversion 2); Problems to solve 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? } 15 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/15/2021

Last thing is the easiest to answer Then how do you USE the address of something put on the stack and passed as a parameter? 16 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/15/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 How do you PUT things 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); } 17 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/15/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; Half. Wave. ASM(foo_start, far_final ); Half. Wave. ASM(foo_startversion 2, finalstartversion 2); How do you PUT things on the stack? We need N / 2 bytes for each array Since N = 10 that means 20 bytes 5 32 bit locations So we 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 total of 24 locations needed NOTE: CODE REVIEW CHECK THAT’S 24 * 4 BYTES } 18 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/15/2021

Undocumented solution That’s total of 24 locations needed 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 } 19 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/15/2021

Full Documented 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; Half. Wave. ASM(foo_start, far_final ); Half. Wave. ASM(foo_startversion 2, finalstartversion 2); } 20 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada HIGH MEMORY ADDRESSES LOWER MEMO ADDRESSES NO – NEED 24 * 4 12/15/2021

Exam 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; HIGH MEMO ADDRESSE LOWER MEMO ADDRESSES NO – NEED 24 * 4 Half. Wave. ASM(foo_start, far_final ); Half. Wave. ASM(foo_startversion 2, finalstartversion 2); } 21 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/15/2021

Exam 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; HIGH MEMO ADDRESSE LOWER MEMO ADDRESSES NO – NEED 24 * 4 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 12/15/2021

OK -- Exam 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; HIGH MEMOR ADDRESSES LOWER MEMO ADDRESSES NO – NEED 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/15/2021

What we would now like 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; NO – NEED 24 * 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); } 24 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/15/2021

What we would now like 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; NO – NEED 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; IMPROVED for (i = 0; i ONLY < N; i++)1 ERROR 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); } 25 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/15/2021

Final version NO – NEED 24 * 4 26 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/15/2021

What would the compiler do? Compiler uses FP (which never moves) rather than SP – which might move Keeps things in range -64 to 63 When not possible, uses same approach as we did I never change the SP after the link and since I can count up easier than down I will use it my way – also works for MC 68000 27 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/15/2021

Tackled today ¢ Review of handling external arrays from assembly code l l l ¢ Arrays declared on the stack l l 28 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/15/2021

¢ Information taken from Analog Devices On-line Manuals with permission http: //www. analog. com/processors/resources/technical. Library/manuals/ ¢ Information furnished by Analog Devices is believed to be accurate and reliable. However, Analog Devices assumes no responsibility for its use or for any infringement of any patent other rights of any third party which may result from its use. No license is granted by implication or otherwise under any patent or patent right of Analog Devices. Copyright Analog Devices, Inc. All rights reserved. 29 Handling Stack Arrays , Copyright M. Smith, ECE, University of Calgary, Canada 12/15/2021