ARM assembly language assignment:

The assignment is to write a memory test program that will be capable of testing memory as words (32-bits at a time) in the region from 0x20000000 to 0x2000FFFF.

It should test up to, and including 0x2000FFFF, but not past it. A memory test program works as follows: Fill every memory location in the region being tested with the word data value. Read back each memory location and compare it to the data value that you wrote. Compare the value that you read back with the value that you wrote. If they are not the same, then you have a bad memory location. Start testing the memory using two different test patterns: 0xFFFFFFFF and 0xAAAAAAAA. After you complete a memory test with one of the patterns, complement the bits (change 1's to 0's and 0's to 1's) and repeat the test with the new pattern. Thus, you will be cycling through the test a total of 4 times using these patterns. Repeat the test one more time using the starting test pattern 0x00000001. Use the LSL instruction to move the 1 bit one position to the left each time through the memory test until you have run the memory test 32 times, shifting the 1 to the left each time you repeat the test. Complement the test pattern that you just used and repeat the above bit shifting test. Here are the particulars for the assignment:

Part A: Program specification: The program should begin execution at memory address 0x00000000. The program tests the memory from0x20000000 to 0x20000FFFF, inclusive. The stack pointer should be located above your test region. The starting memory test patterns are: 0xFFFFFFFF, 0xAAAAAAAA and 0x00000001. The test will fill all of the memory regions of interest with one of the patterns. Next, it reads the pattern back and compares the values read to the values written. If you write the program in a way that writes a longword to memory, then reads it back immediately to test if you are not following the instructions. This is called "adhering to the specifications". Get used to it. The test is repeated for each of the two starting test patterns, their complement, and the shifted bit pattern, and finally, its bit pattern. If an error is detected, the address of the memory location where the error occurred, the data written and the data read back is stored in memory variables. If more than one error occurs the program should store the total error count (number of bad locations found) and keep only the address and data information for the last error detected. You should allow for a count of up to 65,535 bad memory locations. Place your memory variables immediately after the instruction code in a data block.