I would like to calculate the sum of the first n integers in assembly language-CodePudding

I have just started to learn assembly language at school, and as an exercise I have to make a program that calculate the sum of the first n integers (1 2 3 4 5 ... n). I managed to build this program but during the comparison (line.9) I only compare the even numbers in register R1, so I would have to do another comparison for the odd numbers in R0.

    MOV R0,#1       ; I put a register at 1 to start the sequence
    INP R2,2        ; I ask the user up to what number the program should calculate, and I put its response in the R2 register
    B myloop        ; I define a loop 
myloop:
    ADD R1,R0,#1    ; I calculate n 1 and put it in register 1
    ADD R3,R1,R0    ; I add R0 and R1, and I put the result in the register R3
    ADD R0,R1,#1    ; I calculate n 2 and I put in the register R0, and so on...
    ADD R4,R4,R3    ; R4 is the total result of all additions between R0 and R1
    CMP R1,R2       ; I compare R1 and the maximum number to calculate
    BNE myloop      ; I only exit the loop if R1 and R2 are equal
    STR R4,100      ; I store the final result in memory 100
    OUT R4,4        ; I output the final result of the sequence
    HALT            ; I stop the execution of the program

I've tried several methods but I can't manage to perform this double comparison... (a bit like an "elif" in python) Basically I would like to add this piece of code to also compare odd numbers:

CMP R0,R2
BNE myloop

But adding this like this directly after comparing even numbers doesn't work no matter if I put "BNE" or not.

CodePudding user response：

First of all your code assumes that R4 is 0 at the beginning. This might not be true.

Your program becomes simpler and easier to understand if you add each number in a smaller loop, like this:

    INP R2,2        ; I ask the user up to what number the program should calculate, and I put its response in the R2 register
    MOV R0,#0       ; I put a register at 0 to start the sequence
    MOV R4,#0       ; I put a register at 0 to start the sum
    B testdone      ; Jump straight to test if done
myloop:
    ADD R0,R0,#1    ; I calculate n 1 and keep it in register 0
    ADD R4,R4,R0    ; I add R4 and R0, and I put the result in the register R4
testdone:
    CMP R0,R2       ; I compare R0 and the maximum number to calculate
    BNE myloop      ; I only exit the loop if R0 and R2 are equal
    STR R4,100      ; I store the final result in memory 100
    OUT R4,4        ; I output the final result of the sequence
    HALT            ; I stop the execution of the program

You only need 3 registers: R0 for current n, R2 for limit and R4 for the sum.

However, if you really have to add the even and odd numbers separately, you could do this way:

    INP R2,2        ; I ask the user up to what number the program should calculate, and I put its response in the R2 register
    MOV R0,#0       ; I put a register at 0 to start the sequence
    MOV R4,#0       ; I put a register at 0 to start the sum
    B testdone      ; Jump straight to test if done
myloop:
    ADD R0,R0,#1    ; I calculate n 1 (odd numbers), still register 0
    ADD R4,R4,R0    ; I add R4 and R0, keep the result in the register R4
    CMP R0,R2       ; I compare R0 and the maximum number to calculate
    BEQ done        ; I only exit the loop if R0 and R2 are equal
    ADD R0,R0,#1    ; I calculate n 1 (even numbers) and keep it in register 0
    ADD R4,R4,R0    ; I add R4 and R0, and I put the result in the register R4
    
testdone:
    CMP R0,R2       ; I compare R0 and the maximum number to calculate
    BNE myloop      ; I only exit the loop if R0 and R2 are equal
done:
    STR R4,100      ; I store the final result in memory 100
    OUT R4,4        ; I output the final result of the sequence
    HALT            ; I stop the execution of the program

CodePudding user response：

You're trying to do a conjunction, in context, something like this:

do {
   ...
} while ( odd != n && even != n );

Both tests must pass in order to continue the loop. However, if either test fails, then the loop should stop.

First, we'll convert this loop into the if-goto-label form of assembly (while still using the C language!):

loop1:
     ...
     if ( odd != n && even != n ) goto loop1;

Next, let's break down the conjunction to get rid of it. The intent of the conjunction is that if the first component fails, to stop the loop, without even checking the second component. However, if the first component succeeds, then go on to check the second component. And if the second also succeeds, then, and only then return to the top of the loop (knowing both have succeeded), and otherwise fall off the bottom. Either way, whether the first component fails or the second component fails, the loop stops.

loop1:
    ...
    if ( odd == n ) goto endLoop1; 
    if ( even != n ) goto loop1;
endLoop1:
    ...

Can you figure out how to follow this logic in assembly?

Also, as @vorrade says, programs generally should not make assumptions about register values — so suggest to load 0 into the registers at the beginning of the program to ensure their initialization. We generally don't clear registers after their use but rather set them before use. So, in another large program, your code might run with other values from some other code left over in those registers.