64-Bit Assembly Language Lab
Published: 2024-03-20 00:14:23

The very first thing to do is setup the the servers: 

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/8eg4ld7qccqe4h09vz2s.png)
Go to the folder:  `cd spo600/examples/hello/assembler/`
Then using `make` building the c files: 

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/r8m84t3lovcnnar8p1mp.png)



Open the files using `cat` command and By `objdump -d objectfile`  we can look at the code:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fpztuhnw1gbupcmfge5g.png)


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/1k614y525fpwtt03t4p0.png)
The code to include loop index values, showing each digit from 0 to 30 in AArch64 assembly language:

```
.text
.global _start

start = 0                               /* loop index starting value */
max = 31                                /* loop exits when the index hits this number */

_start:
        mov     x3,start                /* set loop index */

loop:
        mov     x9,10			/* store divisor in register */
        udiv    x10,x3,x9		/* divide and store quotient in register */
        msub    x11,x9,x10,x3		/* store remainder in register */
	adr     x1,msg                  /* message location */
	cmp     x10,0			/* check if quotient is 0 */ 
	b.eq    next			/* jump if quotient is 0 */
	add     x12,x10,0x30            /* convert to ascii and store in register */
	strb    w12,[x1,6]              /* place quotient in msg */


next:
	add     x13,x11,0x30            /* convert to ascii and store in register */
	strb    w13,[x1,7]              /* place remainder in msg */
        mov     x2,len                  /* message length */
        mov     x0,1                    /* file descriptor stdout */
        mov     x8,64                   /* syscall sys_write */
        svc     0                       /* syscall */

        add     x3,x3,1                 /* increment index */
        cmp     x3,max                  /* check if index is at max */
        b.ne    loop                    /* loop if index not at max */

        mov     x0,0                    /* exit status */
        mov     x8,93                   /* syscall sys_exit */
        svc     0                       /* syscall */

.data

msg:	.ascii	"Loop:   \n"
.set len, . - msg

```


 In x86_64 assembly language program:

```
.text
.global  _start

start = 0				/* loop index starting value */
max = 31				/* loop exits when the index hits this number */

_start:
	mov     $start,%r15		/* set loop index */

loop:
	mov	$0,%rdx			/* clear register */
	mov	%r15,%rax		/* store dividend in register */
	mov	$10,%r10		/* store divisor in register */
	div	%r10			/* divide */
	mov	%rax,%r11		/* store quotient in register */
	mov	%rdx,%r12		/* store remainder in register */
	cmp	$0,%r11			/* check if quotient is 0 */
	je	next			/* jump if quotient is 0 */
	add	$0x30,%r11		/* convert to ascii */
	mov	%r11b,msg+6		/* place quotient in msg */
	
next:
	add	$0x30,%r12		/* convert to ascii */
	mov	%r12b,msg+7		/* place remainder in msg */
        mov	$len,%rdx		/* message length */
        mov	$msg,%rsi		/* message location */
        mov	$1,%rdi			/* file descriptor stdout */
        mov	$1,%rax			/* syscall sys_write */
        syscall				/* syscall */

	inc     %r15			/* increment index */
	cmp     $max,%r15		/* check if index is at max */
	jne     loop			/* loop if index not at max */

        mov	$0,%rdi			/* exit status */
        mov	$60,%rax		/* syscall sys_exit */
        syscall				/* syscall */

.data

msg:    .ascii      "Loop:   \n"
.set len , . - msg

```
In conclusion, exploring assembly programming across diverse architectures provided invaluable insights into low-level computing. From the nostalgic simplicity of 6502 to the complex optimizations of x86_64 and AArch64, each architecture challenged and expanded my understanding, enriching my programming journey with hands-on experience and newfound