Rick's b.log - 2011/08/07
It is the 21st of November 2024 You are 3.144.42.233, pleased to meet you!

ARM vs x86

This is a difficult thing to write, for the only sane way to think of a processor is "as an x86" or "as an ARM". Trying to co-relate one to another will always be sub-optimal; like a BASIC coder writing C as if it was BASIC...

However, of late I have been asked a few times for a comparison chart between the two, so here goes. And note, I'm not familiar with the x86, so I'm just going to ignore instructions I don't know...

Basic instruction set comparisons

Caveats

With the exception of PC and R14 (LR), there is no specific use for any of the other registers. Tradition dictates that R13 is the stack pointer, and as far as I know, most systems keep to this, however it is not written in stone.

Conditional execution rocks!

  #include "stdio.h"

  void write_char(int);

  int  main(void)
  {
     int  loop = 0;

     for (loop = 0; loop <= 256; loop++)
        write_char(loop);

     return 0;
  }


  void write_char(int mychr)
  {
     if (mychr < 32)
        mychr = '.';
     else
        if (mychr >= 127)
           mychr = '.';

     printf("%c", mychr);

     return;
  }

This is a wrapper code around a little function that is useful for "cooking" data for display, for times when throwing control codes at the terminal may result in all manner of weirdness.

In the following examples, I shall ignore code involved in setting up the C runtime, etc, and will concentrate purely upon the code that relates to the above bit of code.

Example - TurboC++ v1.0

     ; int  main(void)
     ; {
     ;    int  loop = 0;
   mov word ptr [bp-2],0
     ; 
     ;    for (loop = 0; loop <= 256; loop++)
   mov word ptr [bp-2],0
   jmp short @1@98
  @1@50:
     ; 
     ;       write_char(loop);
   push word ptr [bp-2]
   call near ptr _write_char
   pop cx
   inc word ptr [bp-2]
  @1@98:
   cmp word ptr [bp-2],256
   jle short @1@50
     ; 
     ;    return 0;
   xor ax,ax
     ; }
   leave 
   ret 
  _main endp
     ; 
     ; void write_char(int mychr)
   assume cs:_TEXT
  _write_char proc near
   push bp
   mov bp,sp
     ;    if (mychr < 32)
   cmp word ptr [bp+4],32
   jge short @2@74
   jmp short @2@98
  @2@74:
     ;       mychr = '.';
     ;    else
     ;       if (mychr >= 127)
   cmp word ptr [bp+4],127
   jl short @2@122
  @2@98:
     ;          mychr = '.';
   mov word ptr [bp+4],46
  @2@122:
     ; 
     ;    printf("%c", mychr);
   push word ptr [bp+4]
   push offset DGROUP:s@
   call near ptr _printf
   pop cx
   pop cx
     ;    return;
     ; }
   pop bp
   ret 

Essentially, the code character comparison works as follows:

    compare char with 32
      is it less?
        if no go to '2-74', otherwise go to '2-98'.

  2-74:
    compare char with 127
    if less than, go to '2-122'.

    = falls through =

  2-98:
    set char to 46 (ASCII code for '.')

    = falls through =

  2-122:
    print the character

Example - OpenWatcom v1.2

  ; {
  ;    if (mychr < 32)
      cmp         dword ptr -8[ebp],20H 
      jge         L$3 

  ;    {
  ;       mychr = '.';
      mov         dword ptr -8[ebp],2eH 

  ;    }
  ;    else
      jmp         L$4 

  ;    {
  ;       if (mychr >= 127)
  L$3:
      cmp         dword ptr -8[ebp],7fH 
      jl          L$4 

  ;       {
  ;          mychr = '.';
      mov         dword ptr -8[ebp],2eH 

  ;       }
  ;    }
  ; 
  ;    printf("%c", mychr);
  L$4:
      mov         eax,dword ptr -8[ebp] 
      push        eax 
      mov         eax,offset FLAT:L$5 
      push        eax 
      call        near ptr FLAT:printf_ 
      add         esp,8 

    compare byte with 32
    if it is greater or equal, go to "L-3"

    set byte to '.'
    go to "L-4"

  L-3:
    compare byte with 127
    if it is less than, go to "L-4"

    set byte to '.'

    = falls through =

  L-4:
    print the character

ARM code - C compiler suite v5

          MOV      v1,#0                   ; initialise loop counter
  |L000024.J4.main|
          MOV      a1,v1
          BL       write_char              ; call "write_char"
          ADD      v1,v1,#1                ; loop = loop + 1
          CMP      v1,#&100                ; compare loop with 256
          BLE      |L000024.J4.main|       ; if less or equal, repeat
          MOV      a1,#0
          LDMDB    fp,{v1,fp,sp,pc}        ; exit :-)

          IMPORT  _printf
  write_char
          CMP      a1,#&20                 ; compare byte with 32
          MOVLT    a1,#&2e                 ; if less than, set to '.'
          BLT      |L000054.J6.write_char| ; if less than, branch to print
          CMP      a1,#&7f                 ; compare byte with 127
          MOVGE    a1,#&2e                 ; if greater or equal, set to '.'
  |L000054.J6.write_char|
          MOV      a2,a1                   ; call CLib "_printf" function
          ADD      a1,pc,#L000060-.-8
          B        _printf

Note also that we BL to write_char (writes return address in R14) but we B (no return address) to the _printf function. This is a nifty piece of optimisation meaning that the return from _printf will pick up on the return address in R14, and thus go right back to the main loop.
Note also the LDMFD (shown by its "proper" "DB" suffix) restores all of the important registers from the frame pointer - v1 that we corrupted, the previous frame pointer address, the previous stack address, and the return address pushed directly into the program counter. All in one instruction. No chains of pop, pop, pop, pop...

Your comments:

opal, 16th September 2011, 15:22

Hello,  My guess for your little problem is that the range of characters is one char larger than needed. It should have been:  for (loop = 0; loop <= 255; loop++)   Regards