comm

2025-08-28 10:11:40 +05:30 · 2025-08-28 10:11:40 +05:30 · dbabb956d5
commit dbabb956d5
parent c37a788cbd
16 changed files with 1319 additions and 426 deletions
--- a/ES/Lab/Lab2/swap/SWAP.asm
+++ b/ES/Lab/Lab2/swap/SWAP.asm
@ -1,40 +1,93 @@
-	AREA RESET, DATA, READONLY
-	EXPORT __Vectors
-__Vectors
-	DCD 0x10001000
-	DCD Reset_Handler
-	ALIGN
-	AREA mycode,CODE,READONLY
-	ENTRY
-	EXPORT Reset_Handler
-Reset_Handler
-	LDR R0, =SRC
-	LDR R1, =DST
-	LDR R2, [R0]
-	STR R2, [R1]
-	LDR R3, [R0,#4]!
-	STR R3, [R1,#4]!
-	LDR R4, [R0,#4]!
-	STR R4, [R1,#4]!
-	LDR R5, [R0,#4]!
-	STR R5, [R1,#4]!
-	LDR R6, [R0,#4]!
-	STR R6, [R1,#4]!
-	LDR R7, [R0,#4]!
-	STR R7, [R1,#4]!
-	LDR R8, [R0,#4]!
-	STR R8, [R1,#4]!
-	LDR R9, [R0,#4]!
-	STR R9, [R1,#4]!
-	LDR R10, [R0,#4]!
-	STR R10, [R1,#4]!
-	LDR R11, [R0,#4]!
-	STR R11, [R1,#4]!
+; ========================================================================================
+; SWAP.asm - Basic Array Copy Using Post-Increment Addressing
+; ========================================================================================
+; This program demonstrates how to copy data from one array to another using
+; post-increment addressing mode. Each load/store operation automatically
+; advances the pointer to the next array element, eliminating the need for
+; separate pointer arithmetic instructions.

+	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. Load addresses of source (SRC) and destination (DST) arrays
+; 2. Copy each element individually using post-increment addressing
+; 3. The '!' symbol after the offset means post-increment addressing:
+;    - Load from [R0, #4]! means: load from R0+4, then R0 = R0 + 4
+;    - Store to [R1, #4]! means: store to R1+4, then R1 = R1 + 4
+; 4. This approach copies 10 elements (using registers R2-R11)
+Reset_Handler
+	; Step 1: Initialize array pointers
+	; R0 points to the beginning of the source array
+	LDR R0, =SRC                      ; R0 = address of first element in SRC array
+
+	; R1 points to the beginning of the destination array
+	LDR R1, =DST                      ; R1 = address of first element in DST array
+
+	; Step 2: Copy first element (no post-increment for initial load)
+	; Load from SRC[0] into R2, store to DST[0]
+	LDR R2, [R0]                      ; R2 = SRC[0] (no increment yet)
+	STR R2, [R1]                      ; DST[0] = R2 (no increment yet)
+
+	; Step 3: Copy remaining elements using post-increment addressing
+	; Each load/store pair advances both pointers by 4 bytes automatically
+	LDR R3, [R0,#4]!                  ; R3 = SRC[1], then R0 = R0 + 4
+	STR R3, [R1,#4]!                  ; DST[1] = R3, then R1 = R1 + 4
+
+	LDR R4, [R0,#4]!                  ; R4 = SRC[2], then R0 = R0 + 4
+	STR R4, [R1,#4]!                  ; DST[2] = R4, then R1 = R1 + 4
+
+	LDR R5, [R0,#4]!                  ; R5 = SRC[3], then R0 = R0 + 4
+	STR R5, [R1,#4]!                  ; DST[3] = R5, then R1 = R1 + 4
+
+	LDR R6, [R0,#4]!                  ; R6 = SRC[4], then R0 = R0 + 4
+	STR R6, [R1,#4]!                  ; DST[4] = R6, then R1 = R1 + 4
+
+	LDR R7, [R0,#4]!                  ; R7 = SRC[5], then R0 = R0 + 4
+	STR R7, [R1,#4]!                  ; DST[5] = R7, then R1 = R1 + 4
+
+	LDR R8, [R0,#4]!                  ; R8 = SRC[6], then R0 = R0 + 4
+	STR R8, [R1,#4]!                  ; DST[6] = R8, then R1 = R1 + 4
+
+	LDR R9, [R0,#4]!                  ; R9 = SRC[7], then R0 = R0 + 4
+	STR R9, [R1,#4]!                  ; DST[7] = R9, then R1 = R1 + 4
+
+	LDR R10, [R0,#4]!                 ; R10 = SRC[8], then R0 = R0 + 4
+	STR R10, [R1,#4]!                 ; DST[8] = R10, then R1 = R1 + 4
+
+	LDR R11, [R0,#4]!                 ; R11 = SRC[9], then R0 = R0 + 4
+	STR R11, [R1,#4]!                 ; DST[9] = R11, then R1 = R1 + 4
+
+	; Step 4: Program termination
+	; Create an infinite loop to stop program execution
 STOP
-	B STOP
-	ALIGN
+	B STOP                            ; Branch to STOP label (infinite loop)
+
+	ALIGN                             ; Ensure proper alignment for data section
+
+; ========================================================================================
+; Data Section - Source and Destination Arrays
+; ========================================================================================
+; SRC array contains 10 elements (40 bytes total):
+; Each element is a 32-bit word in hexadecimal format
 SRC DCD 0x00000032, 0x12345644, 0x00000005, 0x00000098, 0x000000AB, 0x000000CD, 0x00000055, 0x00000032, 0x000000CA, 0x00000045
-	AREA mydate, DATA, READWRITE
+
+	AREA mydate, DATA, READWRITE      ; Define a read-write data section
+
+; DST array - initially contains one zero, but will be expanded during copy operations
+; The actual size will be determined by how many elements are copied
 DST DCD 0
-	END
+
+	END                               ; End of the assembly program