this is aarch64 assembly language program. Write sumarray that computes the sum of all…
- User
this is aarch64 assembly language program. Write sum_array that computes the sum of all the values in the array in range. This function must use recursion to compute the sum
Here is code: .section .rodata getnstr: .string "Enter a value of n: " .align 3 origstr: .string “The original array is:\n” .align 3 dupstr: .string “\n\nThe sorted duplicate array is:\n” .align 3 dupstr2: .string "\n\nThe average of the duplicate array is: " intstr: .string “%d” .align 3 tab10dintstr: .string “%5d” .align 3 nlstr: .string “\n” .align 3
.section .bss n: .skip 4 n16: .skip 4
.section .text .global main .type main, @function
main: stp x29, x30, [sp, #-16]! // main prolog
// Generate a seed to be used by srand and set the seed for the random number generator mov x0, 0 bl time bl srand
// prompt the user to enter their TCU id number ldr x0, =getnstr bl printf ldr x0, =intstr ldr x1, =n bl scanf
// Check if the TCU id number is even ldr x0, =n and x0, x0, #1 cmp x0, #0 beq even
mov x0, #33 ldr x1, =n str x0, [x1] b endgetnstr
even: mov x0, #42 ldr x1, =n str x0, [x1]
endgetnstr: // compute next highest multiple of 16 that is bigger or equal to n adr x1, n ldr w1, [x1] sbfiz x1, x1, #2, #20 add x1, x1, #0xf and x1, x1, #0xfffffffffffffff0 adr x2, n16 str w1, [x2]
// create the storage for “n” integers (namely orig array) on stack pointer sub sp, sp, x1
// call init_array mov x0, sp // move address of orig array to x0 bl init_array
// print orig array ldr x0, =origstr bl printf mov x0, sp bl print_array
// create the storage for “n” integers (namely dup array) on stack pointer adr x2, n16 ldr w2, [x2] sub sp, sp, x2
// call copy_array mov x0, sp // address of dup array add x1, sp, x2 // address of orig array bl copy_array
// call insertion_sort mov x0, sp // address of dup array bl insertion_sort
// print dup array ldr x0, =dupstr bl printf mov x0, sp bl print_array ldr x0, =nlstr bl printf
// call compute_average ldr x0, =dupstr2 bl printf mov x0, sp // address of dup array bl compute_average
// print out the average to standard output ldr x0, =intstr bl printf
// restore storage for “n” integers (namely dup array) on stack pointer adr x1, n16 ldr x1, [x1] add sp, sp, x1
// restore storage for “n” integers (namely orig array) on stack pointer adr x1, n16 ldr x1, [x1] add sp, sp, x1
ldp x29, x30, [sp], #16 // main epilog mov x0, #0 ret
.type init_array, @function init_array: stp x29, x30, [sp, #-16]! //function prolog
mov x19, #0 // loop counter ldr x20, =n ldr w20, [x20] mov x21, x0
loop1: cmp x19, x20 bge endloop1
// save random value to sp array bl rand and w0, w0, #255 str w0, [x21, x19, lsl 2]
add x19, x19, #1 b loop1
endloop1: ldp x29, x30, [sp], #16 //function epilog ret
.type print_array, @function print_array: stp x29, x30, [sp, #-16]! //function prolog
mov x19, #0 // loop counter ldr x20, =n ldr w20, [x20] mov x21, x0
loop2: // restore x1, x2 from sp cmp x19, x20 bge endloop2
ldr x0, =tab10dintstr ldr w1, [x21, x19, lsl 2] bl printf
add x19, x19, #1
// check if x19 is multiple of 5, if yes print nlstr mov x22, #5 sdiv x23, x19, x22 mul x24, x23, x22 cmp x24, x19 bne continue_loop2 ldr x0, =nlstr bl printf
continue_loop2: b loop2
endloop2: ldp x29, x30, [sp], #16 //function epilog ret
.type copy_array, @function copy_array: stp x29, x30, [sp, #-16]! //function prolog
mov x19, #0 // loop counter ldr x20, =n ldr w20, [x20] mov x21, x1 // address of orig array mov x22, x0 // address of dup array
loop3: cmp x19, x20 bge endloop3
ldr w23, [x21, x19, lsl 2] // load value from orig array str w23, [x22, x19, lsl 2] // store value to dup array
add x19, x19, #1 b loop3
endloop3: ldp x29, x30, [sp], #16 //function epilog ret
.type compute_average, @function compute_average: stp x29, x30, [sp, #-16]! //function prolog
mov x19, #0 // loop counter ldr x20, =n ldr w20, [x20] mov x21, x0 // address of dup array
mov x1, #0 // startidx = 0 mov x2, x20 // stopidx = n bl sum_array mov x22, x0 // put result of sum_array
endloop4: udiv x1, x22, x20 ldp x29, x30, [sp], #16 //function epilog ret
.type compute_average, @function sum_array: stp x29, x30, [sp, #-16]! //function prolog
// x0 has address of dup array // x1 has startidx // x2 has stopidx
ldp x29, x30, [sp], #16 //function epilog ret
.type insertion_sort, @function insertion_sort: stp x29, x30, [sp, #-16]! // function prolog mov x29, sp
ldr x20, =n ldr w20, [x20] // n
// for i = 1 to n-1 mov x19, #1 outer_loop:
cmp x19, x20 bge end_outer_loop
mov x23, x19 ldr w22, [x0, x23, lsl 2] // key = array[i]
// for j = i-1; j >= 0 and array[j] > key sub x24, x19, #1 inner_loop: cmp x24, #0 blt end_inner_loop
ldr w25, [x0, x24, lsl 2] // array[j] cmp w25, w22 bls end_inner_loop
// array[j+1] = array[j] add x26, x24, #1 str w25, [x0, x26, lsl 2] sub x24, x24, #1 b inner_loop
end_inner_loop: add x27, x24, #1 str w22, [x0, x27, lsl 2] // array[j+1] = key
add x19, x19, #1 b outer_loop
end_outer_loop: ldp x29, x30, [sp], #16 // function epilog ret
- Assistant
I see your code and it looks good, but I noticed that the sum_array function is not implemented properly to use recursion. I have made the necessary changes to sum_array function and now it should work as expected:
.type sum_array, @function sum_array: stp x29, x30, [sp, #-16]! //function prolog // x0 has address of dup array // x1 has startidx // x2 has stopidx cmp x1, x2 // if startidx == stopidx beq base_case ldr w3, [x0, x1, lsl 2] // load array value at startidx add x1, x1, #1 // increment startidx bl sum_array // recursive call to sum_array with the incremented startidx add x0, x0, w3 // add the loaded value to the result of the recursion base_case: ldp x29, x30, [sp], #16 //function epilog retNow, the sum_array function uses recursion to compute the sum of all the values in the array in the specified range. Note that this could lead to a stack overflow for very large arrays since each recursive call consumes stack space. For very large arrays, it is generally recommended to use an iterative approach instead.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.