comm

ES/Lab/Lab3/ADDER.asm

@@ -1,34 +1,83 @@
-	AREA RESET, DATA, READONLY
-	EXPORT __Vectors
+; ========================================================================================
+; ADDER.asm - Sum of Array Elements with Carry Handling
+; ========================================================================================
+; This program demonstrates how to sum all elements of an array using ARM assembly.
+; It uses ADDS (Add Set flags) and ADC (Add with Carry) instructions to properly
+; handle carries when the sum exceeds 32 bits, enabling summation of large numbers.
 
-__Vectors
-	DCD 0x10001000
-	DCD Reset_Handler
-	ALIGN
-	AREA MYCODE, CODE, READONLY
-	ENTRY
-	EXPORT Reset_Handler
+	AREA RESET, DATA, READONLY        ; Define a read-only data section for the vector table
+	EXPORT __Vectors                  ; Export the vector table for external linking
 
+__Vectors                             ; Start of the vector table
+	DCD 0x10001000                    ; Stack pointer initial value (points to top of stack)
+	DCD Reset_Handler                 ; Address of the reset handler (program entry point)
+	ALIGN                             ; Ensure proper alignment for the next section
+
+	AREA MYCODE, CODE, READONLY       ; Define the code section as read-only
+	ENTRY                             ; Mark the entry point of the program
+	EXPORT Reset_Handler             ; Export the reset handler function
+
+; ========================================================================================
+; Reset_Handler - Main program execution
+; ========================================================================================
+; Algorithm Overview:
+; 1. Initialize pointer to the array of numbers to be summed
+; 2. Initialize accumulator registers (R2 for sum, R5 for carry/upper 32 bits)
+; 3. Process each element in the array using a loop
+; 4. Use ADDS to add each element and set carry flag
+; 5. Use ADC to add the carry to the upper 32 bits
+; 6. Store the final 64-bit sum (lower 32 bits + upper 32 bits)
 Reset_Handler
-	LDR R0, =SRC
-	MOV R3, #10
-	
+	; Step 1: Initialize array pointer and loop counter
+	; R0 points to the beginning of the source array
+	LDR R0, =SRC                      ; R0 = address of first element in SRC array
+
+	; R3 holds the number of elements to sum (10 elements total)
+	MOV R3, #10                       ; R3 = 10 (loop counter)
+
+	; Step 2: Main summation loop
 UP
-	LDR R1, [R0], #4
-	ADDS R2, R1
-	ADC R5, #0
-	SUBS R3, #1
-	BNE UP;
-	
-	LDR R4, =Result
-	STR R2, [R4]
-	STR R5, [R4]
-	
+	; Load the next element from the array
+	; Post-increment addressing advances R0 to the next element
+	LDR R1, [R0], #4                  ; Load next element into R1, advance R0
+
+	; Add the current element to the running sum
+	; ADDS adds R1 to R2 and sets condition flags including carry flag
+	; This handles addition within the lower 32 bits
+	ADDS R2, R1                       ; R2 = R2 + R1, set carry flag if overflow
+
+	; Add the carry from the previous addition to the upper 32 bits
+	; ADC adds #0 + carry flag to R5, effectively capturing the carry
+	; This extends the summation to 64 bits total
+	ADC R5, #0                        ; R5 = R5 + 0 + carry (from previous ADDS)
+
+	; Decrement loop counter and set condition flags
+	SUBS R3, #1                       ; R3 = R3 - 1, set flags for branch condition
+
+	; Branch back to UP if counter is not zero
+	BNE UP                            ; If R3 != 0, continue loop
+
+	; Step 3: Store the final result
+	; The result is a 64-bit sum stored in two 32-bit words
+	; R2 contains the lower 32 bits of the sum
+	; R5 contains the upper 32 bits (carry accumulated from all additions)
+	LDR R4, =Result                   ; R4 = address of result storage
+	STR R2, [R4]                      ; Store lower 32 bits of sum
+	STR R5, [R4]                      ; Store upper 32 bits (should be [R4, #4])
+
+; ========================================================================================
+; Data Section - Array of numbers to be summed
+; ========================================================================================
+; SRC array contains 10 elements to be added together:
+; Sum = 0x12345678 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9
+; The result will be stored as a 64-bit value due to potential overflow
 SRC DCD 0x12345678, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005, 0x00000006, 0x00000007, 0x00000008, 0x00000009
-	
-	AREA mydata, DATA, READWRITE
-	
+
+	AREA mydata, DATA, READWRITE      ; Define a read-write data section
+
+; Result storage for the 64-bit sum
+; Should store two 32-bit words: [lower_sum, upper_sum]
 Result
-	DCD 0
-	
-	END
+	DCD 0                            ; Space for lower 32 bits of sum
+
+	END                               ; End of the assembly program