ldrt_arm.c revision 436e89c602e787e7a27dd6624b09beed41a0da8a 
1// This should be compiled as ARM code.
2
3#include <stdio.h>
4#include <malloc.h>
5
6typedef 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
172int 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