CODEWITHSUNDEEP
cassemblyarm
VerilogCoder
VerilogCoder

Reputation: 106

Unable to implement C Logic in ARM assembly

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?

Upvotes: 0

Views: 126

Answers (3)

Peter Cordes
Peter Cordes

Reputation: 366036

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.

Upvotes: 1

0___________
0___________

Reputation: 68059

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

Upvotes: 1

old_timer
old_timer

Reputation: 71606

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

Upvotes: 1

Related Questions