Unable to implement C Logic in ARM assembly

Question

I have a C code in my mind which I want to implement in ARM Programming Language. The C code I have in my mind is something of this sort:

int a;
scanf("%d",&a);
if(a == 0 || a == 1){
   a = 1;
}
else{
   a = 2;
}

What I have tried:

//arm equivalent of taking input to reg r0

//check for first condition
cmp r0,#1
moveq r0,#1

//if false 
movne r0,#2

//check for second condition
cmp r0,#0
moveq r0,#1

Is this the correct way of implementing it?

@EugeneSh. This was just a toy example.I actually want to scanf an input from the user for variable a — VerilogCoder, Apr 06 '21 at 17:52
I would suggest moving false condition to the end.It should be after second condition check.Because if you enter zero then according to your c logic answer should be 1 but the arm code will generate 2 — DevDaemon, Apr 06 '21 at 17:58

old_timer · Answer 1 · 2021-04-06T19:39:25.520

No that does not work.

cmp r0,#1    is it a one
moveq r0,#1  yes, make it a one again?
movne r0,#2  otherwise make it a 2, what if it was a zero to start, now it is a 2
cmp r0,#0    at this point it is either a 1 or a 2 you forced it so it cannot be zero, what it started off is is now lost.
moveq r0,#1

You have the right concept but need to order things better.

following that line of thinking though

maybe use another register

x = 2;
if(a==0) x = 1;
if(a==1) x = 1;
a = x;

Ponder this

if(a==0) a = 1;
if(a!=1) a = 2;

Or as everyone else is going to say ask the compiler.

because of the or, test OR test, generically they need to be done separately the false condition of the first test does not mean the else condition you have to then do the other test before declaring false. But if true you need to hop over everything and not fall into the second test because that might (in this case will) be false...

As Peter points out you can use unsigned less than or equal and greater than conditions (even though in C it is a signed int, bits is bits).

LS Unsigned lower or same
HI Unsigned higher

Given this specific condition, it's equivalent to `a <= 1U`, so you could do a single cmp and `movls` / `movhi`. (Compilers already spot this optimization: https://godbolt.org/z/dcevfocrh) — Peter Cordes, Apr 06 '21 at 19:31
it is signed, so you cant do a less than or equal 1 because half the possible bit conditions would pass. I was thinking of that during my first edit. — old_timer, Apr 06 '21 at 19:34
I know, that's why I compared against `1U`, leading to implicit conversion of `a` to unsigned to match. And also what compilers do if you actually write `(a == 0 || a==1)` — Peter Cordes, Apr 06 '21 at 19:35

score 1 · Answer 2 · answered Apr 06 '21 at 19:48

Depending the ARM instruction sets is can be:

        cmp     r0, #1
        movls   r0, #1
        movhi   r0, #2
        bx      lr

or

        cmp     r0, #1
        ite     ls
        movls   r0, #1
        movhi   r0, #2
        bx      lr

Am I smarter than you? NO I simply use the compiler to compile the C code. https://godbolt.org/z/dqxv64Eb9

score 1 · Accepted Answer · answered Apr 06 '21 at 19:50

Your code is broken for a=0 - single step through it in your head, or in a debugger, to see what happens.

Given this specific condition, it's equivalent to (unsigned)a <= 1U (because negative integer convert to huge unsigned values). You can do a single cmp and movls / movhi. Compilers already spot this optimization; here's how to ask a compiler to make asm for you so you can learn the tricks clever humans programmed into them:

int foo(int a) {
    if(a == 0 || a == 1){
       a = 1;
    }
    else{
       a = 2;
    }
    return a;
}

With ARM GCC10 -O3 -marm on the Godbolt compiler explorer:

foo:
        cmp     r0, #1
        movls   r0, #1
        movhi   r0, #2
        bx      lr

See How to remove "noise" from GCC/clang assembly output? for more about making functions that will have useful asm output. In this case, r0 is the first arg-passing register in the calling convention, and also the return-value register.

I also included another C version using if (a <= 1U) to show that it compiles to the same asm. (1U is an unsigned constant, so C integer promotion rules implicitly convert a to unsigned so the types match for the <= operator. You don't need to explicitly do (unsigned)a <= 1U.)

General case: not a single range

For a case like a==0 || a==3 that isn't a single range-check, you can predicate a 2nd cmp. (Godbolt)

foo:
        cmp     r0, #3             # sets Z if a was 3
        cmpne   r0, #0             # leaves Z unmodified if it was already set, else sets it according to a == 0
        moveq   r0, #1
        movne   r0, #2
        bx      lr

You can similarly chain && like a==3 && b==4, or for checks like a >= 3 && a <= 7 you can sub / cmp, using the same unsigned-compare trick as the 0 or 1 range check after sub maps a values into the 0..n range. See the Godbolt link for that.

Unable to implement C Logic in ARM assembly

3 Answers3

General case: not a single range