i need your help troubleshooting. I have a .c file, linked with multiple .S files. when…

i need your help troubleshooting. I have a .c file, linked with multiple .S files. when I am executing the test command that tests all the different mathematical functions with given values, I am receiving a segmentation fault. go through my code and tell me why:

my .c file: #include <stdio.h> int beginProgram(); int add(int n1, int n2); int subtract(int n1, int n2); int multiply(int n1, int n2); int exponentiation(int n1, int n2); int floordivision(int n1, int n2); int bitcounting(int n); int summation(int n1, n2); int factorial(int n); int modulus(int n1, int n2);

int main () { while (1) {

  int input;
  printf ("Welcome to DanBurr Calcutron\n");
  printf ("----------------------------\n");
  printf ("Press 1 to begin and list all available commands\n");
  printf ("Press 9 to exit program\n");
  scanf ("%d", &input);
  if (input == 1)
{
  beginProgram ();
}
  else if (input == 9)
{
  printf ("Exit command executed\n\n");
  break;
}
else
    continue;

}

return 0; }

int beginProgram() { while (1) { int input; printf("Press 0 to add two numbers\n"); printf("Press 1 to subtract two numbers\n"); printf("Press 2 to multiply two numbers\n"); printf("Press 3 to get exponentiation of a number\n"); printf("Press 4 to perform floor division of two numbers\n"); printf("Press 5 to perform bitcounting of a number\n"); printf("Press 6 to find integer summation of two numbers\n"); printf("Press 7 to find factorial of a number\n"); printf("Press 8 to perform modulo division of two numbers\n"); printf("Press 9 to go back to main screen\n"); printf("Enter 10 for test command\n\n"); scanf("%d", &input);

if (input == 9) { printf("Exit called code 9\n\n"); break; }

else if (input == 0) { int n1, n2; printf("Enter first number: \n"); scanf("%d", &n1); printf("Enter second number: \n"); scanf("%d", &n2); int result = add(n1, n2); printf("The result is:%d\n\n", result); }

else if (input == 1) { int n1, n2; printf("Enter first (larger) number: \n"); scanf("%d", &n1); printf("Enter second (smaller) number: \n"); scanf("%d", &n2); int result = subtract(n1, n2); printf("The result is:%d\n\n", result); }

else if (input == 2) { int n1, n2; printf("Enter first number: \n"); scanf("%d", &n1); printf("Enter second number: \n"); scanf("%d", &n2); int result = multiply(n1, n2); printf("The result is:%d\n\n", result); }

else if (input == 3) { int n1, n2; printf("Enter base number: \n"); scanf("%d", &n1); printf("Enter power raising the number to: \n"); scanf("%d", &n2); int result = exponentiation(n1, n2); if(result<0){ printf("Illegal arguments. Try again\n\n"); continue; } else printf("The result is: %d\n\n", result); }

else if (input == 4) { int n1, n2; printf("Enter larger number: \n"); scanf("%d", &n1); printf("Enter number dividing the larger number by: \n"); scanf("%d", &n2); int result = floordivision(n1, n2); if(result<0){ printf("Illegal arguments. Try again\n\n"); continue; } else printf("The result is: %d\n\n", result); }

else if (input == 5) {
int n; printf("Enter number to count bits. Number cannot exceed 32 bits: \n"); scanf("%d", &n); int result = bitcounting(n); printf("The result is:%d\n\n", result); }

else if (input == 6) {
int n1, n2; printf("Enter starting(smaller) number: \n"); scanf("%d", &n1); printf("Enter ending(larger) number: \n"); scanf("%d", &n2); int result = summation(n1, n2); printf("The result is:%d\n\n", result); }

else if (input == 7)
{ int n; printf("Enter positive number to find factorial. Number cannot exceed 12: \n"); scanf("%d", &n); int result = factorial(n); printf("The result is:%d\n\n", result); }

else if (input == 8)
{ int n1, n2; printf("Enter larger number: \n"); scanf("%d", &n1); printf("Enter number dividing the larger number by: \n"); scanf("%d", &n2); int result = modulus(n1, n2); if(result<0){ printf("Illegal arguments. Try again\n\n"); continue; } else printf("The result is: %d\n\n", result); }

else if (input == 10) { int n1 = add(100, 199); int n2 = subtract(211999, 9876); int n3 = exponentiation(5, 5); int n4 = floordivision(2004, 5); int n5 = bitcounting(0b100101010001011110011); int n6 = summation(10, 100); int n7 = factorial(6);

   printf("100 + 199 = %d", n1);
   printf("211999 - 9876 = %d", n2);
   printf("5^5 = %d", n3);
   printf("floor 2004/5 = %d", n4);
   printf("1s in 100101010001011110011 = %d", n5);
   printf("sum [10,100] = %d", n6);
   printf("6! = %d", n7);

} else { printf("Wrong input. Please try again\n\n"); continue; }

} return 0; }

my .S files: .syntax unified .align 4 .type add %function .section .text .global add

add: ADD r0, r0, r1 BX lr

.syntax unified .align 4 .type bitcounting %function .section .text .global bitcounting

bitcounting:

PUSH {R4, r5, LR} @ Save registers and link register MOV r5, #0x0 @counter

bitcount_loop: CMP r0, #0x0 BEQ bitcount_end AND r4, r0, #0x1 @extracting first bit in string, storing in r4 CMP r4, #0x1 BLEQ bitcount_increment @if r4=1, counter will be incremented. LSR r0, r0, #0x1 B bitcount_loop

bitcount_increment:

ADD r5, r5, #0x1 BX lr

bitcount_end:

MOV r0, r5 POP {r4, r5, lr} BX lr

.syntax unified .align 4 .type exponentiation %function .section .text .global exponentiation

exponentiation: MOV r0, #0x5 MOV r1, #0x5

CMP r0, #0x0 @ Check if r0=0 BEQ exp_error_check B exp_start

exp_error_check: CMP r1, #0x0 @ Check if r1=0 BNE exp_start MOV r0, #0xFFFFFFFF @if 0^0 condition, error. returns -1 BX lr

exp_start: PUSH {r2, sp, lr} @ To clear r2 once loop is finished MOV r2, #0x1 @ Initialize result to 1 CMP r1, #0x0 @ Compare exponent to 0 BEQ exp_done @ If exponent is 0, return 1

exp_loop: MUL r2, r2, r0 @ Multiply result by base SUB r1, r1, #1 @ Decrement exponent by 1 CMP r1, #0x0 BNE exp_loop @ If exponent is not 0, continue loop

exp_done: MOV r0, r2 @ Move result to r0 for return POP {r2, sp, lr} @ Clear all registers BX lr @ Return

.syntax unified .align 4 .type factorial %function .section .text .global factorial

factorial: CMP r0, #0x0 BEQ baseCase0 BL factorialHelper POP {sp, lr} BX LR

factorialHelper: PUSH {r4, lr} MOV r4, r0 CMP r0, #0x1 BEQ baseCase1 SUB r0, r0, #0x1 BL factorialHelper

baseCase1: MUL r0, r0, r4 POP {r4, lr} BX LR

baseCase0: MOV r0, #0x1 BX LR

.syntax unified .align 4 .type floordivision %function .section .text .global floordivision

floordivision:

cmp r1, #0 @ Compare divisor to 0 bne floordivstart
MOV r0, #0xFFFFFFFF @ If divisor is 0, return -1 BX lr

floordivstart: PUSH {r4, sp, lr} @ To clear registers after returning MOV r4, #0x0 @ To store result

floor_div_loop: cmp r0, r1 @ Compare dividend to divisor blt floor_div_done @ If dividend < divisor, break loop sub r0, r0, r1 @ Subtract divisor from dividend add r4, r4, #1 @ Increment quotient by 1 b floor_div_loop @ Repeat loop

floor_div_done: mov r0, r4 @ Move quotient to r0 for return POP {r4, sp, lr} bx lr @ Return

.syntax unified .align 4 .type modulus %function .section .text .global modulus

modulus: CMP r1, #0x0 @check if dividing by zero. return -1 if yes BEQ modulus_error B modulus_loop

modulus_error: MOV r0, #0xFFFFFFFF POP {sp, lr} BX lr

modulus_loop: CMP r0, r1 @if r0<r1 BLT modulus_end SUB r0, r0, r1 @r0=r0-r1 B modulus_loop

modulus_end: POP {sp, lr} BX lr

.syntax unified .align 4 .type multiply %function .section .text .global multiply

multiply: MUL r0, r0, r1 BX lr

.syntax unified .align 4 .type subtract %function .section .text .global subtract

subtract: CMP r0, r1 @if r0<r1, swap the values BLT subtract_swap B subtract_start

subtract_swap: PUSH {r4} MOV r4, r0 MOV r0, r1 MOV r1, r4 POP {r4} BX lr

subtract_start: SUB r0, r0, r1 BX lr

.syntax unified .align 4 .type summation %function .section .text .global summation

summation:

CMP r0, r1 @if r0>r1, swap BGT sum_swap BEQ sum_equal @if r0==r1, return r0+r1 PUSH {r4, sp, lr} @pushing register to clear them once result is returned B sum_loop

sum_equal: ADD r0, r0, r1 BX lr

sum_swap: PUSH {r4} @pushing temp r4 to clear it once swap is done MOV r4, r0 MOV r0, r1 MOV r1, r4 POP {r4} B summation

sum_loop:

ADD r4, r4, r0 @r4=r4+r0 ADD r0, #0x1 @r0++ CMP r0, r1 @if r0!=r1, loop BLT sum_loop

ADD r4, r4, r1 @to add last number to result MOV r0, r4 POP {r4, sp, lr} BX lr