Lab 4 - Part 2 x86_64

-

 Hello everyone in this lab we are test some piece of code to make the loop in the AArch64 system and lets start with the base code which is given by Chris Tyler.

So in this lab we just need to work with the AArch64 system and x86_64 and make use more familiar with this ssh system that is call israel and portugal which are two different system working on AArch64 an x86-64.

So for the first time we need to make the code that will run on the x86_64 system which is going to print the loop from 0 to 9 and the base was given to us by Chris Tyler.

So making it we have to useful but dugging is was hard enough to find one single error. so starting with the error like when i start searching i am not able to figure out which increments and loop skiping variables are going to used and then i read some notes and watch the lecture again to find it out.

Now for 0 to 30 we just need to change some thing like add ,max values and add some varibale to balance it out. Like the max value should be like 31 so it start from 0 till 30 and has some more handler.

.text
.globl    _start

min = 0                       /* starting value for the loop index; note that this is a symbol (constant), not a variable */
max = 10                        /* loop exits when the index hits this number (loop condition is i<max) */
cvt = 48

_start:
    mov     $min,%r15         /* loop index */

loop:
    /* ... body of the loop ... do something useful here ... */
    movq    $len,%rdx
    movq    $msg,%rsi
    movq    $cvt,%r14
    movq    %r15,%r13
    add     %r13,%r14 
    movb    %r14b,msg+6
    movq    $1,%rdi
    movq    $1,%rax
   
    syscall

    inc     %r15                
    cmp     $max,%r15          
    jne     loop                

    mov     $0,%rdi             
    mov     $60,%rax            
    syscall


.section .data

msg:     .ascii     "Loop:      \n"
	 len = . - msg



.text
.globl    _start

min = 0                       /* starting value for the loop index; note that this is a symbol (constant), not a variable */
max = 31                       /* loop exits when the index hits this number (loop condition is i<max) */
cvt = 48

d = 10
_start:
    mov     $min,%r15         /* loop index */

loop:
   
    movq    $len,%rcx
    movq    $msg,%rsi
    movq    $cvt,%r14
    movq    $d,%r10
    movq    %r15,%rax 
    div     %r10      
    movq    %rax,%r9  
    movq    %rdx,%r8  
    movq    %r9,msg+6
 
    movq    $1,%rdi
    movq    $1,%rax
   
    syscall

    inc     %r15                
    cmp     $max,%r15           
    jne     loop                

    mov     $0,%rdi             
    mov     $60,%rax            
    syscall


.section .data

msg:     .ascii     "Loop:      \n"
	 len = . - msg

Comments

Post a Comment

Popular posts from this blog

ifunc function

-
IFUNC What is IFUNC? With the aid of a resolver function that was also written by the developer, numerous implementations of a particular function can be created using the GNU indirect function support (IFUNC) feature of the GNU toolchain. During early startup, the dynamic loader calls the resolver function to determine which implementation the application will use. Once a decision on implementation is made, it cannot be modified for the duration of the procedure. How to use it? As you can see, there are already a few limitations on how IFUNC can be used.                                                             It is t he implementations and the resolver must both be defined in the same translation unit. functions that cannot be weakly specified.    Since the resolution of an IFUNC might occur ver...
Read more

Lab5 Part 2 Algorithm 2

-
 According to the loudness factor, another algorithm simply shifted everything by an order of magnitude to the right. I haven't had time to talk about the outcomes of this algorithm with the group or with individuals, so I'm at a loss for words. I'd say it's definitely off if I had to guess which would be the best option. Multiplication takes longer than bit shifting, which is one of the reasons I say this. Why then is it so slow? This is so that the CPU doesn't merely shuffle bits around in memory but also compute values. The term implies that this is a bit shift. I would anticipate that bit shifting would also be favourable in terms of memory utilisation. Other techniques call for the lookup table to be stored and accessed somewhere in memory. Even though we're only working with 16-bit numbers, the largest possible values are 65, 536, etc., and the majority of contemporary PCs can hold 64k bits in registers, making them simple to store in registers. Without ac...
Read more

Lab2 - 6502 Assembly Language Lab(Calculation)

-
Image
 In this lab we need to find how much is time need to complete the process of code. So here we need to find the number of the cycles that are need to complete the process of one line of code to processed. So as shown in photo  The load accumulator need two cycle to complete the process and only one time this code is run. After that store accumulator will run and same as load accumulator it will run ones with two cycle. After all the function will be run as shown above but when the loop will be there t process will be change there are 256 bytes in one page and there are total 4 page to this will run 12 time and as shown above it will be executed.  And the time will be 5935us when there was 1Mhz clock speed is there. To change the speed we need to make change like we need to change the loop of pages to only one  which can change the part of time but I am not able to make that one. 
Read more