Create an HLA Assembly language program that prompts for a single integer value

Question

Create an HLA Assembly language program that prompts for a single integer value from the user and prints an triangular pattern like the one shown below. If the number is negative, don't print anything at all.

Here are some example program dialogues to guide your efforts:

Feed Me: 3
X
XX
XXX

Feed Me: -6


Feed Me: 5
X
XX
XXX
XXXX
XXXXX

In an effort to help you focus on building an Assembly program, I’d like to offer you the following C statements matches the program specifications stated above. If you like, use them as the basis for building your Assembly program.

SAMPLE C CODE:
------------------------
int i, j, n, space, x;
printf( "Feed Me:" );
scanf( "%d", &n );
// the top half of the arrow...
for( i = 1; i <= n; i++ ) {

space = n - i;
x = n - space;
for (j = 1; j <= space; j++) {
printf( " " );
}

for (j = 1; j <= x; j++ ) {
printf( "X" );
}
printf( " " );

}

Explanation / Answer

ARM gcc 5.4 Assembly code: The c code have been written in the gcc 5.4 version.Please go through...

.LC0:
.ascii "Feed Me:"
.LC1:
.ascii " "
.LC2:
.ascii "X"
.LC3:
.ascii " "
main:
stmfd sp!, {fp, lr}
add fp, sp, #4
sub sp, sp, #24
ldr r1, .L9
ldr r0, .L9+4
bl std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)
sub r3, fp, #24
mov r1, r3
ldr r0, .L9+8
bl std::basic_istream<char, std::char_traits<char> >::operator>>(int&)
mov r3, #1
str r3, [fp, #-8]
.L7:
ldr r3, [fp, #-24]
ldr r2, [fp, #-8]
cmp r2, r3
bgt .L2
ldr r2, [fp, #-24]
ldr r3, [fp, #-8]
rsb r3, r3, r2
str r3, [fp, #-16]
ldr r2, [fp, #-24]
ldr r3, [fp, #-16]
rsb r3, r3, r2
str r3, [fp, #-20]
mov r3, #1
str r3, [fp, #-12]
.L4:
ldr r2, [fp, #-12]
ldr r3, [fp, #-16]
cmp r2, r3
bgt .L3
ldr r1, .L9+12
ldr r0, .L9+4
bl std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)
ldr r3, [fp, #-12]
add r3, r3, #1
str r3, [fp, #-12]
b .L4
.L3:
mov r3, #1
str r3, [fp, #-12]
.L6:
ldr r2, [fp, #-12]
ldr r3, [fp, #-20]
cmp r2, r3
bgt .L5
ldr r1, .L9+16
ldr r0, .L9+4
bl std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)
ldr r3, [fp, #-12]
add r3, r3, #1
str r3, [fp, #-12]
b .L6
.L5:
ldr r1, .L9+20
ldr r0, .L9+4
bl std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)
ldr r3, [fp, #-8]
add r3, r3, #1
str r3, [fp, #-8]
b .L7
.L2:
mov r3, #0
mov r0, r3
sub sp, fp, #4
ldmfd sp!, {fp, lr}
bx lr
.L9:
.word .LC0
.word std::cout
.word std::cin
.word .LC1
.word .LC2
.word .LC3
__static_initialization_and_destruction_0(int, int):
stmfd sp!, {fp, lr}
add fp, sp, #4
sub sp, sp, #8
str r0, [fp, #-8]
str r1, [fp, #-12]
ldr r3, [fp, #-8]
cmp r3, #1
bne .L13
ldr r3, [fp, #-12]
ldr r2, .L14
cmp r3, r2
bne .L13
ldr r0, .L14+4
bl std::ios_base::Init::Init()
ldr r2, .L14+8
ldr r1, .L14+12
ldr r0, .L14+4
bl __aeabi_atexit
.L13:
mov r0, r0 @ nop
sub sp, fp, #4
ldmfd sp!, {fp, lr}
bx lr
.L14:
.word 65535
.word std::__ioinit
.word __dso_handle
.word std::ios_base::Init::~Init()
_GLOBAL__sub_I_main:
stmfd sp!, {fp, lr}
add fp, sp, #4
ldr r1, .L17
mov r0, #1
bl __static_initialization_and_destruction_0(int, int)
sub sp, fp, #4
ldmfd sp!, {fp, lr}
bx lr
.L17:
.word 65535

===============================================================================
X86-64 gcc 6.3: The below code in the format of x86 gcc

.LC0:
.string "Feed Me:"
.LC1:
.string " "
.LC2:
.string "X"
.LC3:
.string " "
main:
push rbp
mov rbp, rsp
sub rsp, 32
mov esi, OFFSET FLAT:.LC0
mov edi, OFFSET FLAT:std::cout
call std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)
lea rax, [rbp-20]
mov rsi, rax
mov edi, OFFSET FLAT:std::cin
call std::basic_istream<char, std::char_traits<char> >::operator>>(int&)
mov DWORD PTR [rbp-4], 1
.L7:
mov eax, DWORD PTR [rbp-20]
cmp DWORD PTR [rbp-4], eax
jg .L2
mov eax, DWORD PTR [rbp-20]
sub eax, DWORD PTR [rbp-4]
mov DWORD PTR [rbp-12], eax
mov eax, DWORD PTR [rbp-20]
sub eax, DWORD PTR [rbp-12]
mov DWORD PTR [rbp-16], eax
mov DWORD PTR [rbp-8], 1
.L4:
mov eax, DWORD PTR [rbp-8]
cmp eax, DWORD PTR [rbp-12]
jg .L3
mov esi, OFFSET FLAT:.LC1
mov edi, OFFSET FLAT:std::cout
call std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)
add DWORD PTR [rbp-8], 1
jmp .L4
.L3:
mov DWORD PTR [rbp-8], 1
.L6:
mov eax, DWORD PTR [rbp-8]
cmp eax, DWORD PTR [rbp-16]
jg .L5
mov esi, OFFSET FLAT:.LC2
mov edi, OFFSET FLAT:std::cout
call std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)
add DWORD PTR [rbp-8], 1
jmp .L6
.L5:
mov esi, OFFSET FLAT:.LC3
mov edi, OFFSET FLAT:std::cout
call std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)
add DWORD PTR [rbp-4], 1
jmp .L7
.L2:
mov eax, 0
leave
ret
__static_initialization_and_destruction_0(int, int):
push rbp
mov rbp, rsp
sub rsp, 16
mov DWORD PTR [rbp-4], edi
mov DWORD PTR [rbp-8], esi
cmp DWORD PTR [rbp-4], 1
jne .L11
cmp DWORD PTR [rbp-8], 65535
jne .L11
mov edi, OFFSET FLAT:std::__ioinit
call std::ios_base::Init::Init()
mov edx, OFFSET FLAT:__dso_handle
mov esi, OFFSET FLAT:std::__ioinit
mov edi, OFFSET FLAT:std::ios_base::Init::~Init()
call __cxa_atexit
.L11:
nop
leave
ret
_GLOBAL__sub_I_main:
push rbp
mov rbp, rsp
mov esi, 65535
mov edi, 1
call __static_initialization_and_destruction_0(int, int)
pop rbp
ret

Related Questions

Navigate

• Browse (All)
• Browse C
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.