none/tests/arm/ldrt_arm.c

   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 }