.text
.globl _start
start = 0
max = 30
_start:
mov $start,%r15 /* starting value for the loop index*/
loop:
/*showing digit*/
mov $'0',%r14
mov $10,%r13
mov $0,%rdx
mov %r15,%rax
div %r13
cmp $0,%rax
je singledigit
mov %rax,%r13 /*store the second digit from right*/
add %r14,%r13
mov %r13,msg+5
singledigit:
mov %rdx,%r12
add %r14,%r12
mov %r12,msg+6
/*showing loop in front of digit*/
mov $len,%rdx
mov $msg,%rsi
mov $1,%rdi
mov $1,%rax
syscall
inc %r15 /* increment index*/
cmp $max,%r15 /* see if we're done */
jne loop /* loop if we're not */
movq $0,%rdi /* exit status */
movq $60,%rax /* syscall sys_exit */
syscall
.data
msg: .ascii "loop: '\n'"
.set len, . - msg .text
.global _start
_start:
start = 0
max = 30
mov x15,start /*starting value for the loop index*/
loop:
mov x28,0
mov x27,10
adr x12,msg /*loading the message*/
udiv x10,x15,x27 /*getting the quotient*/
msub x9,x10,x27,x15 /*getting the reminder*/
cmp x10,0 /*if quotient equals 0, then go to execute single digit*/
beq singledigit
add x14,x10,0x30 /*display quotient - second digit from right*/
str x14,[x12,6]
singledigit:
add x11,x9,0x30 /*display reminder - first digit from right*/
str x11,[x12,7]
/*system call write*/
mov x1,x12
mov x2,len
mov x0,1
mov x8,64
svc 0
/*loop*/
add x15,x15,1
cmp x15,max
blt loop
/*system exit*/
mov x0,0
mov x8,93
svc 0
.data
msg: .ascii "loop: ##\n\r"
len= . - msg 
Static
linking
|
Dynamic
linking
|
|
Sharing
external program
|
External
called program cannot be shared. It requires duplicate copies of programs in
memory.
|
Dynamic
linking lets several programs use a single copy of an executable module.
|
File size
|
Statically
linked files are significantly larger in size because external programs are
built into the executable files.
|
Dynamic
linking significantly reduces the size of executable programs because it uses
only one copy of shared library
|
Easiness
to update
|
In static
linking if any of the external programs has changed then they have to be
recompiled and re-linked again else the changes won't reflect in existing
executable file.
|
In dynamic
linking individual shared modules and bug fixes can be updated and
recompiled.
|
Speed
|
Programs
that use statically-linked libraries are usually faster than those that use
shared libraries.
|
Programs
that use shared libraries are usually slower than those that use
statically-linked libraries.
|
Compati-bility
|
In
statically-linked programs, all code is contained in a single executable
module. Therefore, they never run into compatibility issues.
|
Dynamically
linked programs are dependent on having a compatible library. If a library is
changed, applications might have to be reworked to be made compatible with
the new version of the library.
|
Static
linking
|
Dynamic
linking
|
•
Static linking is efficient at run time.
•
It has less system calls.
•
Static linking can make binaries easier to distribute to diverse user
environment.
•
It let the code run in very limited environments.
|
•
Dynamic linking is more flexible.
•
It is more efficient in resource utilization, taking less memory space,
cache space and disk space.
•
It is easy to update and fix the bugs.
|
Static linking
|
Dynamic linking
|
|
Source:
|
printf() call to a separate function named output(), and call that function from main().
-O0 and add -O3 to the gcc options. Note and explain the
difference in the compiled code.
