aadit/MIT-Curricular
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

comm

Browse source
This commit is contained in:
sherlock 2025-08-28 10:11:40 +05:30
parent c37a788cbd
commit dbabb956d5
16 changed files with 1319 additions and 426 deletions
Download patch file Download diff file Expand all files Collapse all files

105
ES/Lab/LAB4/GCD.asm
View file

@ -1,41 +1,92 @@
AREA RESET, DATA, READONLY
EXPORT __Vectors
__Vectors
DCD 0x10001000
DCD Reset_Handler
ALIGN
; ========================================================================================
; GCD.asm - Greatest Common Divisor Using Euclidean Algorithm
; ========================================================================================
; This program implements the Euclidean algorithm to find the Greatest Common
; Divisor (GCD) of two numbers. The Euclidean algorithm is based on the principle
; that GCD(a, b) = GCD(b, a mod b), and it repeats this process until b = 0.
; When b = 0, the GCD is the value of a.
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 two numbers in registers R0 and R1 (48 and 18 in this example)
; 2. Enter the Euclidean algorithm loop:
; a. Compare the two numbers
; b. If equal, GCD is found (algorithm complete)
; c. If R0 > R1, subtract R1 from R0 (replace larger with difference)
; d. If R0 < R1, subtract R0 from R1 (replace larger with difference)
; e. Repeat until both numbers are equal
; 3. Store the GCD result to memory
; 4. Enter infinite loop for program termination
Reset_Handler
MOV r0, #48
MOV r1, #18
; Step 1: Initialize the two numbers for GCD calculation
; R0 and R1 hold the two numbers to find GCD of
MOV r0, #48 ; R0 = 48 (first number)
MOV r1, #18 ; R1 = 18 (second number)
; Step 2: Main Euclidean algorithm loop
GCD_Loop
CMP r0, r1
BEQ GCD_Done
BGT GT_A_B
SUB r1, r1, r0
B GCD_Loop
; Compare the two numbers to determine which is larger
CMP r0, r1 ; Compare R0 and R1, set condition flags
; If R0 == R1, we have found the GCD
BEQ GCD_Done ; Branch to GCD_Done if R0 == R1
; If R0 > R1 (GT condition), subtract R1 from R0
BGT GT_A_B ; Branch to GT_A_B if R0 > R1
; If R0 < R1, subtract R0 from R1 (replace larger with difference)
SUB r1, r1, r0 ; R1 = R1 - R0 (R1 was larger, now smaller)
B GCD_Loop ; Branch back to GCD_Loop
; Handle case where R0 > R1
GT_A_B
SUB r0, r0, r1
B GCD_Loop
SUB r0, r0, r1 ; R0 = R0 - R1 (R0 was larger, now smaller)
B GCD_Loop ; Branch back to GCD_Loop
; Step 3: GCD calculation complete
; When we reach here, R0 == R1 and contains the GCD
GCD_Done
LDR r2, =result
STR r0, [r2]
; Load address of result storage into R2
LDR r2, =result ; R2 = address of result storage
; Store the GCD (in R0) to memory
STR r0, [r2] ; Store GCD value to [R2]
; Step 4: Program termination
; Enter infinite loop to stop program execution
LoopForever
B LoopForever
B LoopForever ; Branch to LoopForever (infinite loop)
ALIGN
ALIGN ; Ensure proper alignment for data section
AREA MYDATA, DATA, READWRITE
numA DCD 48
numB DCD 18
result DCD 0
AREA MYDATA, DATA, READWRITE ; Define a read-write data section
END
; ========================================================================================
; Data Section - Input Numbers and Result Storage
; ========================================================================================
; numA: First number for GCD calculation (48 in this example)
; numB: Second number for GCD calculation (18 in this example)
; GCD(48, 18) = 6, as calculated by the Euclidean algorithm:
; GCD(48, 18) -> GCD(18, 48-18=30) -> GCD(30, 18) -> GCD(18, 30-18=12)
; -> GCD(12, 18) -> GCD(18, 12) -> GCD(12, 18-12=6) -> GCD(6, 12)
; -> GCD(12, 6) -> GCD(6, 12-6=0) -> GCD(6, 0) = 6
numA DCD 48 ; First number for GCD
numB DCD 18 ; Second number for GCD
result DCD 0 ; Storage for the GCD result
END ; End of the assembly program