Write a switch case driven X86/64 ALP to perform 64-bit hexadecimal arithmetic operations (+,-,*, /) using suitable macros. Define procedure for each operation.

 %macro scall 4

        mov rax,%1

        mov rdi,%2

        mov rsi,%3

        mov rdx,%4

        syscall

%endmacro

section .data

        arr dq 000000000000007h,0000000000000002h

        n equ 2

        menu db 10d,13d,"**********MENU**********"

             db 10d,13d,"1. Addition"

             db 10d,13d,"2. Subtraction"

             db 10d,13d,"3. Multiplication"

             db 10d,13d,"4. Division"

             db 10d,13d,"5. Exit"

             db 10d,13d,"Enter your Choice: "

        menu_len equ $-menu

        m1 db 10d,13d,"Addition: "

        l1 equ $-m1

        m2 db 10d,13d,"Substraction: "

        l2 equ $-m2

        m3 db 10d,13d,"Multiplication: "

        l3 equ $-m3

        m4 db 10d,13d,"Division: "

        l4 equ $-m4

section .bss

        answer resb 16 ;to store the result of operation

        choice resb 2

section .text

        global _start:

        _start:

        up: scall 1,1,menu,menu_len

        scall 0,0,choice,2

        cmp byte[choice],'1'

        je case1

        cmp byte[choice],'2'

        je case2

        cmp byte[choice],'3'

        je case3

        cmp byte[choice],'4'

        je case4

        cmp byte[choice],'5'

        je case5

        case1: scall 1,1,m1,l1

                call addition

                jmp up

        case2: scall 1,1,m2,l2

        call substraction

        jmp up

        case3: scall 1,1,m3,l3

        call multiplication

        jmp up

        case4: scall 1,1,m4,l4

        call division

        jmp up

        case5:  mov rax,60

        mov rdi,0

                syscall

;procedures for arithmetic and logical operations

addition:

        mov rcx,n

        dec rcx

        mov rsi,arr

        mov rax,[rsi]

up1:    add rsi,8

        mov rbx,[rsi]

        add rax,rbx

        loop up1

        call display

    ret

substraction:

        mov rcx,n

        dec rcx

        mov rsi,arr

        mov rax,[rsi]

up2:    add rsi,8

        mov rbx,[rsi]

        sub rax,rbx

        loop up2

        call display

ret

multiplication:

        mov rcx,n

        dec rcx

        mov rsi,arr

        mov rax,[rsi]

up3:    add rsi,8

        mov rbx,[rsi]

        mul rbx

        loop up3

        call display

ret

division:

        mov rcx,n

        dec rcx

        mov rsi,arr

        mov rax,[rsi]

up4:    add rsi,8

        mov rbx,[rsi]

        mov rdx,0

        div rbx

        loop up4

        call display

ret

display:

        mov rsi,answer+15

        mov rcx,16

cnt:    mov rdx,0

        mov rbx,16

        div rbx

        cmp dl,09h

        jbe add30

        add dl,07h

add30:  add dl,30h

        mov [rsi],dl

        dec rsi

        dec rcx

        jnz cnt

        scall 1,1,answer,16

ret

Write an X86/64 ALP to accept a string and to display its length.

 section .data

msg1 db 10,13,"Enter a string:"

len1 equ $-msg1

section .bss

str1 resb 200                 ;string declaration

result resb 16

section .text

global _start

_start:

;display

mov Rax,1

mov Rdi,1

mov Rsi,msg1

mov Rdx,len1

syscall

;store string 

mov rax,0

mov rdi,0

mov rsi,str1

mov rdx,200

syscall

call display

;exit system call

mov Rax ,60

mov Rdi,0

syscall

%macro dispmsg 2

mov Rax,1

mov Rdi,1

mov rsi,%1

mov rdx,%2

syscall

%endmacro

display:

mov rbx,rax                      ; store no in rbx

mov rdi,result                   ;point rdi to result variable 

mov cx,16                        ;load count of rotation in cl  

up1: 

rol rbx,04               ;rotate no of left by four bits

mov al,bl          ; move lower byte in dl

and al,0fh               ;get only LSB

cmp al,09h               ;compare with 39h

jg add_37                ;if greater than 39h skip add 37    

add al,30h                

jmp skip                 ;else add 30     

add_37: 

add al,37h                 

skip: 

mov [rdi],al             ;store ascii code in result variable

inc rdi                  ; point to next byte

dec cx                   ; decrement counter

jnz up1                  ; if not zero jump to repeat

dispmsg result,16        ;call to macro

ret

;when you accept string , length automatically returns in Rax register

;input welcome

; rax -> 0000000000000008

;copy rax to rbx

;rbx = 0000000000000008

; when you wnat to display no on screen you have to convert it from  hex  to ascii format

; hex 0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f

; ascii 30,31,32,33,34,35,36,37,38,39,(3a,3b,3c,3d,3e,3f,40), 41,42,43,44,45

;rbx = 0000000000000008

; we have to convert 0 to 30 and 8 to 38 in rbx

; so final rbx register contents must be 

; 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 38

;algorithm to display result

;1. take cnt value as 16 into cnt variable

;2. move address of "result" variable into rdi

;3. rotate left rbx register by 4 bits

;rbx reg=16 digit number you want to display

;4. move b1 into al 

;5. and al with 0fh

;6 compare al with 09h

;7 if greater add 37h into al

;8. else add 30 h into al

;9. move al into memory location pointed by rdi

;10. increment rdi

;11. loop the statement till count value becomes zero

;12. return from procedure

Write an X86/64 ALP to accept five 64 bit Hexadecimal numbers from user and store them in an array and display the accepted numbers.

 section .data

msg1 db 10,13,"Enter 5 64 bit numbers"

len1 equ $-msg1

msg2 db 10,13,"Entered 5 64 bit numbers"

len2 equ $-msg2

section .bss

array resd 200

counter resb 1

section .text

global _start

_start:

;display

mov Rax,1

mov Rdi,1

mov Rsi,msg1

mov Rdx,len1

syscall

;accept

mov byte[counter],05

mov rbx,00

loop1:

mov rax,0                  ; 0 for read

mov rdi,0                  ; 0 for keyboard   

mov rsi, array             ;move pointer to start of array

add rsi,rbx               

mov rdx,17                  

syscall

          add rbx,17                    ;to move counter

dec byte[counter]

JNZ loop1

;display

mov Rax,1

mov Rdi,1

mov Rsi,msg2

mov Rdx,len2

syscall

;display

mov byte[counter],05

mov rbx,00

loop2: 

mov rax,1                    ;1 for write 

mov rdi, 1                    ;1 for monitor

mov rsi, array                

add rsi,rbx

mov rdx,17                   ;16 bit +1 for enter 

syscall

add rbx,17

dec byte[counter]

JNZ loop2

;exit system call

mov rax ,60

mov rdi,0

syscall

;output

;vacoea@vacoea-Pegatron:~$ cd ~/Desktop

;vacoea@vacoea-Pegatron:~/Desktop$ nasm -f elf64 ass1.asm

;vacoea@vacoea-Pegatron:~/Desktop$ ld -o ass1 ass1.o

;vacoea@vacoea-Pegatron:~/Desktop$ ./ass1

;Enter 5 64 bit numbers12

;23

;34

;45

;56

;Entered 5 64 bit numbers12

;23

;34

;45

;56