Home | History | Annotate | Download | only in arm 
      1 // This should be compiled as ARM code.
      2 
      3 #include <stdio.h>
      4 #include <malloc.h>
      5 
      6 typedef unsigned int UInt;
      7 
      8 __attribute__((noinline)) UInt do_ldrt_A1_imm_132 ( unsigned char* p )
      9 {
     10   UInt res;
     11   __asm__ __volatile__(
     12   // Twice do ldrt for testing post-indexed.
     13      "mov r5, %1 ; ldrt r6, [r5], #+132 ; ldrt r6, [r5], #132 ; mov %0, r6"
     14       : "=r"(res) : "r"(p) : "r5", "r6"
     15   );
     16   return res;
     17 }
     18 
     19 __attribute__((noinline)) UInt do_ldrt_A2_imm_132 ( unsigned char* p )
     20 {
     21   UInt res;
     22   __asm__ __volatile__(
     23   // Twice ldrt for testing post-indexed.
     24      "mov r5, %1 ; mov r6, #33; ldrt r7, [r5], +r6, lsl #2 ; ldrt r7, [r5], +r6, lsl #2 ; mov %0, r7"
     25       : "=r"(res) : "r"(p) : "r5", "r6", "r7"
     26   );
     27   return res;
     28 }
     29 
     30 __attribute__((noinline)) UInt do_ldrbt_A1_imm_2 (unsigned char* val)
     31 {
     32   UInt res;
     33   __asm__ __volatile__(
     34   // Twice ldrbt for testing post-indexed.
     35      "mov r4, %1 ; ldrbt r5, [r4], #+2; ldrbt r5, [r4], #+2; mov %0, r5"
     36      : "=r"(res) : "r"(val) : "r4", "r5"
     37   );
     38   return res;
     39 }
     40 
     41 __attribute__((noinline)) UInt do_ldrbt_A2_imm_2 (unsigned char* val)
     42 {
     43   UInt res;
     44   __asm__ __volatile__(
     45   // Twice ldrbt for testing post-indexed.
     46      "mov r4, %1 ; mov r5, #4; ldrbt r6, [r4], +r5, lsr #2 ; ldrbt r6, [r4], +r5, lsr #2; mov %0, r6"
     47      : "=r"(res) : "r"(val) : "r4", "r5", "r6"
     48   );
     49   return res;
     50 }
     51 
     52 __attribute__((noinline)) UInt do_ldrht_A1_imm_m2 (unsigned char* val)
     53 {
     54   UInt res;
     55   __asm__ __volatile__(
     56   // Twice ldrht for testing post-indexed.
     57      "mov r4, %1 ; ldrht r5, [r4], #-2 ; ldrht r5, [r4], #-2 ; mov %0, r5"
     58      : "=r"(res) : "r"(val) : "r4", "r5"
     59   );
     60   return res;
     61 }
     62 
     63 __attribute__((noinline)) UInt do_ldrht_A2_imm_m2 (unsigned char* val)
     64 {
     65   UInt res;
     66   __asm__ __volatile__(
     67   // Twice ldrht for testing post-indexed.
     68      "mov r4, %1 ; mov r5, #2 ; ldrht r6, [r4], -r5 ; ldrht r6, [r4], -r5 ; mov %0, r6"
     69      : "=r"(res) : "r"(val) : "r4", "r5", "r6"
     70   );
     71   return res;
     72 }
     73 
     74 __attribute__((noinline)) UInt do_ldrsht_A1_imm_m2 (unsigned char* val)
     75 {
     76   UInt res;
     77   __asm__ __volatile__(
     78   // Twice ldrsht for testing post-indexed.
     79      "mov r4, %1 ; ldrsht r5, [r4], #-2 ; ldrsht r5, [r4], #-2 ; mov %0, r5"
     80      : "=r"(res) : "r"(val) : "r4", "r5"
     81   );
     82   return res;
     83 }
     84 
     85 __attribute__((noinline)) UInt do_ldrsht_A2_imm_1 (unsigned char* val)
     86 {
     87   UInt res;
     88   __asm__ __volatile__(
     89   // Twice ldrsht for testing post-indexed.
     90      "mov r4, %1 ; mov r5, #1 ; ldrsht r6, [r4], r5 ; ldrsht r6, [r4], r5 ; mov %0, r6"
     91      : "=r"(res) : "r"(val) : "r4", "r5", "r6"
     92   );
     93   return res;
     94 }
     95 
     96 __attribute__((noinline)) UInt do_ldrsbt_A1_imm_1 (unsigned char* val)
     97 {
     98   UInt res;
     99   __asm__ __volatile__(
    100   // Twice ldrsbt for testing post-indexed.
    101      "mov r4, %1 ; ldrsbt r5, [r4], #1 ; ldrsbt r5, [r4], #1 ; mov %0, r5"
    102      : "=r"(res) : "r"(val) : "r4", "r5"
    103   );
    104   return res;
    105 }
    106 
    107 __attribute__((noinline)) UInt do_ldrsbt_A2_imm_1 (unsigned char* val)
    108 {
    109   UInt res;
    110   __asm__ __volatile__(
    111   // Twice ldrsbt for testing post-indexed.
    112      "mov r4, %1 ; mov r5, #1 ; ldrsbt r6, [r4], r5 ; ldrsbt r6, [r4], r5 ; mov %0, r6"
    113      : "=r"(res) : "r"(val) : "r4", "r5", "r6"
    114   );
    115   return res;
    116 }
    117 
    118 __attribute__((noinline)) void do_strbt_A1_imm_1 (unsigned char* val)
    119 {
    120   __asm__ __volatile__(
    121   // Twice strbt for testing post-indexed.
    122      "mov r4, %0 ; mov r5, #0xCD ; strbt r5, [r4], #1 ; strbt r5, [r4], #1"
    123      : : "r"(val) : "r4", "r5"
    124   );
    125 }
    126 
    127 __attribute__((noinline)) void do_strbt_A2_imm_1 (unsigned char* val)
    128 {
    129   __asm__ __volatile__(
    130   // Twice strbt for testing post-indexed.
    131      "mov r4, %0 ; mov r5, #1 ; mov r6, #0xCD ; strbt r6, [r4], r5, LSL #1 ; strbt r6, [r4], r5"
    132      : : "r"(val) : "r4", "r5", "r6"
    133   );
    134 }
    135 
    136 __attribute__((noinline)) void do_strht_A1_imm_1 (unsigned char* val)
    137 {
    138   __asm__ __volatile__(
    139   // Twice strht for testing post-indexed.
    140      "mov r4, %0 ; ldr r5, =0xABCD ; strht r5, [r4], #1 ; strht r5, [r4], #1"
    141      : : "r"(val) : "r4", "r5"
    142   );
    143 }
    144 
    145 __attribute__((noinline)) void do_strht_A2_imm_1 (unsigned char* val)
    146 {
    147   __asm__ __volatile__(
    148   // Twice strht for testing post-indexed.
    149      "mov r4, %0 ; mov r5, #1 ; ldr r6, =0xDCBA ; strht r6, [r4], r5  ; strht r6, [r4], r5"
    150      : : "r"(val) : "r4", "r5", "r6"
    151   );
    152 }
    153 
    154 __attribute__((noinline)) void do_strt_A1_imm_4 (unsigned char* val)
    155 {
    156   __asm__ __volatile__(
    157   // Twice strt for testing post-indexed.
    158      "mov r4, %0 ; ldr r5, =0xABCDEFFF ; strt r5, [r4], #4  ; ldr r5, =0x01234567 ; strt r5, [r4], #0"
    159      : : "r"(val) : "r4", "r5"
    160   );
    161 }
    162 
    163 __attribute__((noinline)) void do_strt_A2_imm_4 (unsigned char* val)
    164 {
    165   __asm__ __volatile__(
    166   // Twice strt for testing post-indexed.
    167      "mov r4, %0 ; mov r5, #2 ; ldr r6, =0xFFFEDCBA ; strt r6, [r4], -r5, LSL #1  ; mov r5, #0 ; ldr r6, =0x76543210 ; strt r6, [r4], +r5"
    168      : : "r"(val) : "r4", "r5", "r6"
    169   );
    170 }
    171 
    172 int main ( void )
    173 {
    174   UInt i;
    175   unsigned char* b = malloc(256);
    176   for (i = 0; i < 256; i++) b[i] = (unsigned char)i;
    177   UInt r = do_ldrt_A1_imm_132(b);
    178   free(b);
    179   printf("result is 0x%08x (should be 0x%08x)\n", r, 0x87868584);
    180 
    181   UInt j;
    182   unsigned char* c = malloc(256);
    183   for (j = 0; j < 256; j++) c[j] = (unsigned char)j;
    184   UInt k = do_ldrt_A2_imm_132(c);
    185   free(c);
    186   printf("result is 0x%08x (should be 0x%08x)\n", k, 0x87868584);
    187 
    188   UInt val_ldrbt = (200 << 0) | (150 << 8) | (137 << 16) | (10 << 24);
    189   printf("result is %u (should be %u)\n", do_ldrbt_A1_imm_2((unsigned char*)&val_ldrbt), 137);
    190 
    191   UInt val_ldrbt_A2 = (200 << 0) | (150 << 8) | (137 << 16) | (10 << 24);
    192   printf("result is %u (should be %u)\n", do_ldrbt_A2_imm_2((unsigned char*)&val_ldrbt_A2), 150);
    193 
    194   UInt val_ldrht_A1 = (0xC8 << 0) | (0xF6 << 8) | (0xBB << 16) | (0x0A << 24);
    195   printf("result is %u (should be %u)\n", do_ldrht_A1_imm_m2((unsigned char*)&val_ldrht_A1 + 2), 0x0000F6C8);
    196 
    197   UInt val_ldrht_A2 = (0xC8 << 0) | (0xF7 << 8) | (0xBB << 16) | (0x0A << 24);
    198   printf("result is %u (should be %u)\n", do_ldrht_A2_imm_m2((unsigned char*)&val_ldrht_A2 + 2), 0x0000F7C8);
    199 
    200   UInt val_ldrsht_A1 = (0x08 << 0) | (0xFC << 8) | (0x0B << 16) | (0x0A << 24);
    201   printf("result is %u (should be %u)\n", do_ldrsht_A1_imm_m2((unsigned char*)&val_ldrsht_A1 + 2), 0xFFFFFC08);
    202 
    203   UInt val_ldrsht_A2 = (0xC8 << 0) | (0x0B << 8) | (0xFB << 16) | (0x0A << 24);
    204   printf("result is %u (should be %u)\n", do_ldrsht_A2_imm_1((unsigned char*)&val_ldrsht_A2), 0xFFFFFB0B);
    205 
    206   UInt val_ldrsbt_A1 = (0xC8 << 0) | (0xF0 << 8) | (0xCD << 16) | (0x0A << 24);
    207   printf("result is %u (should be %u)\n", do_ldrsbt_A1_imm_1((unsigned char*)&val_ldrsbt_A1), 0xFFFFFFF0);
    208 
    209   UInt val_ldrsbt_A2 = (0xC8 << 0) | (0xF0 << 8) | (0xFD << 16) | (0x0A << 24);
    210   printf("result is %u (should be %u)\n", do_ldrsbt_A2_imm_1((unsigned char*)&val_ldrsbt_A2 + 1), 0xFFFFFFFD);
    211 
    212   UInt val_strbt_A1 = (0xC8 << 0) | (0xF0 << 8) | (0xFD << 16) | (0x0A << 24);
    213   do_strbt_A1_imm_1((unsigned char*)&val_strbt_A1);
    214   printf("result is %u (should be %u)\n", val_strbt_A1, 0x0AFDCDCD);
    215 
    216   UInt val_strbt_A2 = (0xC8 << 0) | (0xF0 << 8) | (0xFD << 16) | (0x0A << 24);
    217   do_strbt_A2_imm_1((unsigned char*)&val_strbt_A2);
    218   printf("result is %u (should be %u)\n", val_strbt_A2, 0x0ACDF0CD);
    219 
    220   UInt val_strht_A1 = 0xFFFFFFFF;
    221   do_strht_A1_imm_1((unsigned char*)&val_strht_A1);
    222   printf("result is %u (should be %u)\n", val_strht_A1, 0xFFABCDCD);
    223 
    224   UInt val_strht_A2 = 0xFFFFFFFF;
    225   do_strht_A2_imm_1((unsigned char*)&val_strht_A2);
    226   printf("result is %u (should be %u)\n", val_strht_A2, 0xFFDCBABA);
    227 
    228   UInt val_strt_A1[2] = {0xFFFFFFFF, 0xFFFFFFFF};
    229   do_strt_A1_imm_4((unsigned char*)&val_strt_A1[0]);
    230   printf("result is %u %u (should be %u %u)\n", val_strt_A1[0], val_strt_A1[1], 0xABCDEFFF, 0x01234567);
    231 
    232   UInt val_strt_A2[2] = {0xFFFFFFFF, 0xFFFFFFFF};
    233   do_strt_A2_imm_4((unsigned char*)&val_strt_A2[1]);
    234   printf("result is %u %u (should be %u %u)\n", val_strt_A2[0], val_strt_A2[1], 0x76543210, 0xFFFEDCBA);
    235 
    236   return 0;
    237 }
    238