xref: /aosp_15_r20/external/XNNPACK/test/aarch32-assembler.cc (revision 4bdc94577ba0e567308109d787f7fec7b531ce36) 
1 // Copyright 2021 Google LLC
2 //
3 // This source code is licensed under the BSD-style license found in the
4 // LICENSE file in the root directory of this source tree.
5 
6 #include <xnnpack.h>
7 #include <xnnpack/aarch32-assembler.h>
8 #include <xnnpack/allocator.h>
9 #include <xnnpack/common.h>
10 
11 #include <ios>
12 
13 #include "assembler-helpers.h"
14 #include <gtest/gtest.h>
15 
16 namespace xnnpack {
17 namespace aarch32 {
TEST(AArch32Assembler,InstructionEncoding)18 TEST(AArch32Assembler, InstructionEncoding) {
19   ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr));
20   xnn_code_buffer b;
21   xnn_allocate_code_memory(&b, XNN_DEFAULT_CODE_BUFFER_SIZE);
22   Assembler a(&b);
23 
24   CHECK_ENCODING(0xE086600B, a.add(r6, r11));
25   CHECK_ENCODING(0xE0810002, a.add(r0, r1, r2));
26   CHECK_ENCODING(0xE28A9080, a.add(r9, r10, 128));
27   CHECK_ENCODING(0xE29D5008, a.adds(r5, r13, 8));
28 
29   CHECK_ENCODING(0xE2025007, a.and_(r5, r2, 7));
30 
31   CHECK_ENCODING(0xE3CC2003, a.bic(r2, r12, 3));
32 
33   CHECK_ENCODING(0xE12FFF1E, a.bx(lr));
34 
35   CHECK_ENCODING(0xE3500002, a.cmp(r0, 2));
36   CHECK_ENCODING(0xE1530007, a.cmp(r3, r7));
37 
38   // Offset addressing mode.
39   CHECK_ENCODING(0xE59D7060, a.ldr(r7, mem[sp, 96]));
40   // Post-indexed addressing mode.
41   CHECK_ENCODING(0xE490B000, a.ldr(r11, mem[r0], 0));
42   CHECK_ENCODING(0xE490B060, a.ldr(r11, mem[r0], 96));
43   // Offsets out of bounds.
44   EXPECT_ERROR(Error::kInvalidOperand, a.ldr(r7, MemOperand(sp, 4096)));
45   EXPECT_ERROR(Error::kInvalidOperand, a.ldr(r7, MemOperand(sp, -4096)));
46 
47   CHECK_ENCODING(0xE1CD66D8, a.ldrd(r6, r7, mem[sp, 104]));
48   CHECK_ENCODING(0xE0CD66D8, a.ldrd(r6, r7, MemOperand(sp, 104, AddressingMode::kPostIndexed)));
49   EXPECT_ERROR(Error::kInvalidOperand, a.ldrd(r6, r8, mem[sp, 104]));
50   EXPECT_ERROR(Error::kInvalidOperand, a.ldrd(r6, r7, mem[sp, 4096]));
51 
52   CHECK_ENCODING(0x01A0C007, a.moveq(r12, r7));
53   CHECK_ENCODING(0x31A0C003, a.movlo(r12, r3));
54   CHECK_ENCODING(0x91A0A00C, a.movls(r10, r12));
55   CHECK_ENCODING(0xE1A0A00C, a.mov(r10, r12));
56 
57   CHECK_ENCODING(0xE320F000, a.nop());
58 
59   CHECK_ENCODING(0xE8BD0FF0, a.pop({r4, r5, r6, r7, r8, r9, r10, r11}));
60   EXPECT_ERROR(Error::kInvalidOperand, a.pop({}));
61   EXPECT_ERROR(Error::kInvalidOperand, a.pop({r1}));
62 
63   CHECK_ENCODING(0xE92D0FF0, a.push({r4, r5, r6, r7, r8, r9, r10, r11}));
64   EXPECT_ERROR(Error::kInvalidOperand, a.push({}));
65   EXPECT_ERROR(Error::kInvalidOperand, a.push({r1}));
66 
67   CHECK_ENCODING(0xF5D3F000, a.pld(MemOperand(r3, 0)));
68   CHECK_ENCODING(0xF5D3F040, a.pld(MemOperand(r3, 64)));
69 
70   CHECK_ENCODING(0xE58D5068, a.str(r5, mem[sp, 104]));
71   EXPECT_ERROR(Error::kInvalidOperand, a.str(r5, MemOperand(sp, 4096)));
72   EXPECT_ERROR(Error::kInvalidOperand, a.str(r5, MemOperand(sp, -4096)));
73 
74   CHECK_ENCODING(0xE0487002, a.sub(r7, r8, r2));
75   CHECK_ENCODING(0xE2425010, a.sub(r5, r2, 16));
76   CHECK_ENCODING(0xE2525010, a.subs(r5, r2, 16));
77 
78   CHECK_ENCODING(0xE315000F, a.tst(r5, 15));
79 
80   CHECK_ENCODING(0xF3B9676E, a.vabs_f32(q3, q15));
81 
82   CHECK_ENCODING(0xF24E2DC2, a.vadd_f32(q9, q15, q1));
83 
84   CHECK_ENCODING(0xEEB44AC8, a.vcmpe_f32(s8, s16));
85 
86   CHECK_ENCODING(0xF3FBE646, a.vcvt_f32_s32(q15, q3));
87   CHECK_ENCODING(0xF3FB6748, a.vcvt_s32_f32(q11, q4));
88 
89   CHECK_ENCODING(0xF3FB6148, a.vcvtn_s32_f32(q11, q4));
90 
91   CHECK_ENCODING(0xF3FF8C4F, a.vdup_8(q12, d15[7]));
92   EXPECT_ERROR(Error::kInvalidLaneIndex, a.vdup_8(q12, d15[8]));
93   CHECK_ENCODING(0xF3FE8C4F, a.vdup_16(q12, d15[3]));
94   EXPECT_ERROR(Error::kInvalidLaneIndex, a.vdup_16(q12, d15[4]));
95   CHECK_ENCODING(0xF3FC8C4F, a.vdup_32(q12, d15[1]));
96   EXPECT_ERROR(Error::kInvalidLaneIndex, a.vdup_32(q12, d15[2]));
97 
98   CHECK_ENCODING(0xF2BE04C6, a.vext_8(q0, q15, q3, 4));
99   EXPECT_ERROR(Error::kInvalidOperand, a.vext_8(q0, q15, q3, 16));
100 
101   CHECK_ENCODING(0xF423070F, a.vld1_8({d0}, mem[r3]));
102   CHECK_ENCODING(0xF423070D, a.vld1_8({d0}, mem[r3]++));
103   CHECK_ENCODING(0xF4230A0F, a.vld1_8({d0-d1}, mem[r3]));
104   CHECK_ENCODING(0xF423060F, a.vld1_8({d0-d2}, mem[r3]));
105   CHECK_ENCODING(0xF423020F, a.vld1_8({d0-d3}, mem[r3]));
106   CHECK_ENCODING(0xF42A4705, a.vld1_8({d4}, mem[r10], r5));
107   CHECK_ENCODING(0xF4294A0D, a.vld1_8({q2}, mem[r9]++));
108 
109   CHECK_ENCODING(0xF42C178F, a.vld1_32({d1}, mem[r12]));
110   CHECK_ENCODING(0xF42C178D, a.vld1_32({d1}, mem[r12]++));
111   CHECK_ENCODING(0xF42C1A8D, a.vld1_32({d1-d2}, mem[r12]++));
112   CHECK_ENCODING(0xF42C168D, a.vld1_32({d1-d3}, mem[r12]++));
113   CHECK_ENCODING(0xF42C128D, a.vld1_32({d1-d4}, mem[r12]++));
114 
115   CHECK_ENCODING(0xF4A8780F, a.vld1_32({d7[0]}, mem[r8]));
116   CHECK_ENCODING(0xF4A3488D, a.vld1_32({d4[1]}, mem[r3]++));
117   EXPECT_ERROR(Error::kInvalidLaneIndex, a.vld1_32({d0[2]}, mem[r3]));
118 
119   CHECK_ENCODING(0xF4294A8D, a.vld1_32({q2}, mem[r9]++));
120 
121   CHECK_ENCODING(0xF4A54C8F, a.vld1r_32({d4}, mem[r5]));
122   CHECK_ENCODING(0xF4A54CAF, a.vld1r_32({d4, d5}, mem[r5]));
123   CHECK_ENCODING(0xF4A54CAD, a.vld1r_32({d4, d5}, mem[r5]++));
124   EXPECT_ERROR(Error::kInvalidOperand, a.vld1r_32({d4, d5}, mem[r5, 4]));
125   EXPECT_ERROR(Error::kInvalidOperand, a.vld1r_32({d4, d6}, mem[r5]));
126 
127   CHECK_ENCODING(0xF4A54D8F, a.vld2r_32({d4, d5}, mem[r5]));
128   CHECK_ENCODING(0xF4A54DAF, a.vld2r_32({d4, d6}, mem[r5]));
129   EXPECT_ERROR(Error::kInvalidOperand, a.vld2r_32({d4, d5}, mem[r5, 4]));
130   EXPECT_ERROR(Error::kInvalidOperand, a.vld2r_32({d4, d7}, mem[r5]));
131 
132   CHECK_ENCODING(0xF4A54E8F, a.vld3r_32({d4, d5, d6}, mem[r5]));
133   CHECK_ENCODING(0xF4A54EAF, a.vld3r_32({d4, d6, d8}, mem[r5]));
134   EXPECT_ERROR(Error::kInvalidOperand, a.vld3r_32({d4, d5, d6}, mem[r5, 4]));
135   EXPECT_ERROR(Error::kInvalidOperand, a.vld3r_32({d4, d5, d7}, mem[r5]));
136   EXPECT_ERROR(Error::kInvalidOperand, a.vld3r_32({d4, d6, d7}, mem[r5]));
137   EXPECT_ERROR(Error::kInvalidOperand, a.vld3r_32({d4, d6, d9}, mem[r5]));
138 
139   CHECK_ENCODING(0xECD90B08, a.vldm(mem[r9], {d16-d19}));
140   CHECK_ENCODING(0xECF90B08, a.vldm(mem[r9]++, {d16-d19}));
141   EXPECT_ERROR(Error::kInvalidRegisterListLength, a.vldm(mem[r9], {d8-d0}));
142   EXPECT_ERROR(Error::kInvalidRegisterListLength, a.vldm(mem[r9], {d0-d16}));
143   EXPECT_ERROR(Error::kInvalidRegisterListLength, a.vldm(mem[r9], DRegisterList(d31, 2)));
144 
145   CHECK_ENCODING(0xEC930A01, a.vldm(mem[r3], {s0}));
146   CHECK_ENCODING(0xECB30A01, a.vldm(mem[r3]++, {s0}));
147   EXPECT_ERROR(Error::kInvalidRegisterListLength, a.vldm(mem[r3], {s4-s0}));
148   EXPECT_ERROR(Error::kInvalidRegisterListLength, a.vldm(mem[r3], SRegisterList(s31, 2)));
149 
150   CHECK_ENCODING(0xEDD97A0E, a.vldr(s15, mem[r9, 56]));
151   CHECK_ENCODING(0xEDD97AFF, a.vldr(s15, mem[r9, 1020]));
152   CHECK_ENCODING(0xED597AFF, a.vldr(s15, mem[r9, -1020]));
153   EXPECT_ERROR(Error::kInvalidOperand, a.vldr(s15, MemOperand(r9, 56, AddressingMode::kPostIndexed)));
154   EXPECT_ERROR(Error::kInvalidOperand, a.vldr(s15, mem[r9, 1024]));
155   EXPECT_ERROR(Error::kInvalidOperand, a.vldr(s15, mem[r9, -1024]));
156   EXPECT_ERROR(Error::kInvalidOperand, a.vldr(s15, mem[r9, 1018]));
157 
158   CHECK_ENCODING(0xED99FB0E, a.vldr(d15, mem[r9, 56]));
159   CHECK_ENCODING(0xED99FBFF, a.vldr(d15, mem[r9, 1020]));
160   CHECK_ENCODING(0xED19FBFF, a.vldr(d15, mem[r9, -1020]));
161   EXPECT_ERROR(Error::kInvalidOperand, a.vldr(d15, MemOperand(r9, 56, AddressingMode::kPostIndexed)));
162   EXPECT_ERROR(Error::kInvalidOperand, a.vldr(d15, mem[r9, 1024]));
163   EXPECT_ERROR(Error::kInvalidOperand, a.vldr(d15, mem[r9, -1024]));
164   EXPECT_ERROR(Error::kInvalidOperand, a.vldr(d15, mem[r9, 1018]));
165 
166   CHECK_ENCODING(0xF20E26C6, a.vmax_s8(q1, q15, q3));
167   CHECK_ENCODING(0xF24ECFC4, a.vmax_f32(q14, q15, q2));
168 
169   CHECK_ENCODING(0xF20E26D6, a.vmin_s8(q1, q15, q3));
170   CHECK_ENCODING(0xF220EFC6, a.vmin_f32(q7, q8, q3));
171 
172   CHECK_ENCODING(0xEE04AA01, a.vmla_f32(s20, s8, s2));
173 
174   CHECK_ENCODING(0xF3E80140, a.vmla_f32(q8, q4, d0[0]));
175   CHECK_ENCODING(0xF3EC0160, a.vmla_f32(q8, q6, d0[1]));
176   EXPECT_ERROR(Error::kInvalidLaneIndex, a.vmla_f32(q8, q4, d0[2]));
177 
178   CHECK_ENCODING(0xF2D9E246, a.vmlal_s16(q15, d9, d6[0]));
179   CHECK_ENCODING(0xF2D8424A, a.vmlal_s16(q10, d8, d2[1]));
180   CHECK_ENCODING(0xF2D88264, a.vmlal_s16(q12, d8, d4[2]));
181   CHECK_ENCODING(0xF2D8626A, a.vmlal_s16(q11, d8, d2[3]));
182   EXPECT_ERROR(Error::kInvalidLaneIndex, a.vmlal_s16(q15, d9, d6[4]));
183 
184   CHECK_ENCODING(0xF2C0E050, a.vmov(q15, 0));
185   EXPECT_ERROR(Error::kInvalidOperand, a.vmov(q15, 1));
186 
187   CHECK_ENCODING(0xEEB0EA4F, a.vmov(s28, s30));
188   CHECK_ENCODING(0xF2245114, a.vmov(d5, d4));
189   CHECK_ENCODING(0xF26101B1, a.vmov(d16, d17));
190   CHECK_ENCODING(0xEC420B1F, a.vmov(d15, r0, r2));
191   CHECK_ENCODING(0xF26041F0, a.vmov(q10, q8));
192 
193   CHECK_ENCODING(0xEEB08A49, a.vmov_f32(s16, s18));
194   CHECK_ENCODING(0x5EB08A44, a.vmovpl_f32(s16, s8));
195   CHECK_ENCODING(0x4EB08A64, a.vmovmi_f32(s16, s9));
196 
197   CHECK_ENCODING(0xEEB0AB48, a.vmov_f64(d10, d8));
198 
199   CHECK_ENCODING(0xF2880A10, a.vmovl_s8(q0, d0));
200 
201   CHECK_ENCODING(0xEEF1FA10, a.vmrs(APSR_nzcv, FPSCR));
202 
203   CHECK_ENCODING(0xF34E2DD2, a.vmul_f32(q9, q15, q1));
204 
205   CHECK_ENCODING(0xF3F927EE, a.vneg_f32(q9, q15));
206 
207   CHECK_ENCODING(0xECBD8B10, a.vpop({d8-d15}));
208   EXPECT_ERROR(Error::kInvalidRegisterListLength, a.vpop({d0-d16}));
209   EXPECT_ERROR(Error::kInvalidRegisterListLength, a.vpop({d4-d0}));
210   EXPECT_ERROR(Error::kInvalidRegisterListLength, a.vpop(DRegisterList(d31, 2)));
211 
212   CHECK_ENCODING(0xED2D8B10, a.vpush({d8-d15}));
213   CHECK_ENCODING(0xED6D4B08, a.vpush({d20-d23}));
214   EXPECT_ERROR(Error::kInvalidRegisterListLength, a.vpush({d8-d7}));
215   EXPECT_ERROR(Error::kInvalidRegisterListLength, a.vpush({d0-d16}));
216   EXPECT_ERROR(Error::kInvalidRegisterListLength, a.vpush(DRegisterList(d31, 2)));
217 
218   CHECK_ENCODING(0xED2D4A08, a.vpush({s8-s15}));
219   CHECK_ENCODING(0xED2DAA04, a.vpush({s20-s23}));
220   EXPECT_ERROR(Error::kInvalidRegisterListLength, a.vpush({s8-s2}));
221   EXPECT_ERROR(Error::kInvalidRegisterListLength, a.vpush(SRegisterList(s31, 2)));
222 
223   CHECK_ENCODING(0xF25E00D2, a.vqadd_s16(q8, q15, q1));
224 
225   CHECK_ENCODING(0xF3A82CCE, a.vqdmulh_s32(q1, q12, d14[0]));
226   CHECK_ENCODING(0xF3A82CEE, a.vqdmulh_s32(q1, q12, d14[1]));
227   EXPECT_ERROR(Error::kInvalidLaneIndex, a.vqdmulh_s32(q1, q12, d14[2]));
228   EXPECT_ERROR(Error::kInvalidOperand, a.vqdmulh_s32(q1, q12, d16[0]));
229 
230   CHECK_ENCODING(0xF3B232A6, a.vqmovn_s16(d3, q11));
231   CHECK_ENCODING(0xF3F602A0, a.vqmovn_s32(d16, q8));
232 
233   CHECK_ENCODING(0xF22C247E, a.vqshl_s32(q1, q15, q6));
234 
235   CHECK_ENCODING(0xF264C560, a.vrshl_s32(q14, q8, q2));
236 
237   CHECK_ENCODING(0xFE666D41, a.vsdot_s8(q11, q3, d1[0]));
238   EXPECT_ERROR(Error::kInvalidLaneIndex, a.vsdot_s8(q11, q3, d1[2]));
239 
240   CHECK_ENCODING(0xF40B070F, a.vst1_8({d0}, mem[r11]));
241   CHECK_ENCODING(0xF40B070D, a.vst1_8({d0}, mem[r11]++));
242   CHECK_ENCODING(0xF40B0707, a.vst1_8({d0}, mem[r11], r7));
243   CHECK_ENCODING(0xF48B000F, a.vst1_8({d0[0]}, mem[r11]));
244   CHECK_ENCODING(0xF48B00EF, a.vst1_8({d0[7]}, mem[r11]));
245   EXPECT_ERROR(Error::kInvalidLaneIndex, a.vst1_8(d0[8], mem[r11]));
246 
247   CHECK_ENCODING(0xF40B074F, a.vst1_16({d0}, mem[r11]));
248   CHECK_ENCODING(0xF40B074D, a.vst1_16({d0}, mem[r11]++));
249   CHECK_ENCODING(0xF40B0747, a.vst1_16({d0}, mem[r11], r7));
250   CHECK_ENCODING(0xF48B040F, a.vst1_16({d0[0]}, mem[r11]));
251   CHECK_ENCODING(0xF48B04CF, a.vst1_16({d0[3]}, mem[r11]));
252   EXPECT_ERROR(Error::kInvalidLaneIndex, a.vst1_16(d0[4], mem[r11]));
253 
254   CHECK_ENCODING(0xF44B0280, a.vst1_32({d16-d19}, mem[r11], r0));
255   EXPECT_ERROR(Error::kInvalidRegisterListLength, a.vst1_32({d0-d4}, mem[r11], r0));
256   EXPECT_ERROR(Error::kInvalidOperand, a.vst1_32({d16-d19}, mem[r11], sp));
257   EXPECT_ERROR(Error::kInvalidOperand, a.vst1_32({d16-d19}, mem[r11], pc));
258   CHECK_ENCODING(0xF404168F, a.vst1_32({d1-d3}, mem[r4]));
259   CHECK_ENCODING(0xF44B0A8D, a.vst1_32({d16-d17}, mem[r11]++));
260   CHECK_ENCODING(0xF4CB080F, a.vst1_32({d16[0]}, mem[r11]));
261   // The surrounding braces are optional, but makes it look closer to native assembly.
262   CHECK_ENCODING(0xF4CB080F, a.vst1_32(d16[0], mem[r11]));
263   CHECK_ENCODING(0xF4CB088F, a.vst1_32(d16[1], mem[r11]));
264   EXPECT_ERROR(Error::kInvalidLaneIndex, a.vst1_32(d16[2], mem[r11]));
265   CHECK_ENCODING(0xF4C6C80D, a.vst1_32({d28[0]}, mem[r6]++));
266 
267   CHECK_ENCODING(0xEC868B04, a.vstm(mem[r6], {d8-d9}));
268   CHECK_ENCODING(0xECA7EB02, a.vstm(mem[r7]++, {d14}));
269   EXPECT_ERROR(Error::kInvalidRegisterListLength, a.vstm(mem[r6], {d8-d28}));
270   EXPECT_ERROR(Error::kInvalidRegisterListLength, a.vstm(mem[r6], DRegisterList(d31, 2)));
271 
272   CHECK_ENCODING(0xED868A00, a.vstr(s16, mem[r6]));
273   CHECK_ENCODING(0xED868A02, a.vstr(s16, mem[r6, 8]));
274   CHECK_ENCODING(0xED868AFF, a.vstr(s16, mem[r6, 1020]));
275   CHECK_ENCODING(0xED068AFF, a.vstr(s16, mem[r6, -1020]));
276   EXPECT_ERROR(Error::kInvalidOperand, a.vstr(s16, MemOperand(r6, 8, AddressingMode::kPostIndexed)));
277   EXPECT_ERROR(Error::kInvalidOperand, a.vstr(s16, mem[r6, 1024]));
278   EXPECT_ERROR(Error::kInvalidOperand, a.vstr(s16, mem[r6, -1024]));
279   EXPECT_ERROR(Error::kInvalidOperand, a.vstr(s16, mem[r6, 1018]));
280 
281   ASSERT_EQ(xnn_status_success, xnn_release_code_memory(&b));
282 }
283 
TEST(AArch32Assembler,Label)284 TEST(AArch32Assembler, Label) {
285   ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr));
286   xnn_code_buffer b;
287   xnn_allocate_code_memory(&b, XNN_DEFAULT_CODE_BUFFER_SIZE);
288   Assembler a(&b);
289 
290   Label l1;
291   a.add(r0, r0, r0);
292 
293   // Branch to unbound label.
294   auto b1 = a.offset<uint32_t*>();
295   a.beq(l1);
296 
297   a.add(r1, r1, r1);
298 
299   auto b2 = a.offset<uint32_t*>();
300   a.bne(l1);
301 
302   a.add(r2, r2, r2);
303 
304   a.bind(l1);
305 
306   // Check that b1 and b2 are both patched after binding l1.
307   EXPECT_INSTR(0x0A000002, *b1);
308   EXPECT_INSTR(0x1A000000, *b2);
309 
310   a.add(r0, r1, r2);
311 
312   // Branch to bound label.
313   auto b3 = a.offset<uint32_t*>();
314   a.bhi(l1);
315   auto b4 = a.offset<uint32_t*>();
316   a.bhs(l1);
317   auto b5 = a.offset<uint32_t*>();
318   a.blo(l1);
319   auto b6 = a.offset<uint32_t*>();
320   a.b(l1);
321 
322   EXPECT_INSTR(0x8AFFFFFD, *b3);
323   EXPECT_INSTR(0x2AFFFFFC, *b4);
324   EXPECT_INSTR(0x3AFFFFFB, *b5);
325   EXPECT_INSTR(0xEAFFFFFA, *b6);
326 
327   // Binding a bound label is an error.
328   a.bind(l1);
329   EXPECT_ERROR(Error::kLabelAlreadyBound, a.bind(l1));
330 
331   // Check for bind failure due to too many users of label.
332   Label lfail;
333   a.reset();
334   // Arbitrary high number of users that we probably won't support.
335   for (int i = 0; i < 1000; i++) {
336     a.beq(lfail);
337   }
338   EXPECT_EQ(Error::kLabelHasTooManyUsers, a.error());
339 
340   ASSERT_EQ(xnn_status_success, xnn_release_code_memory(&b));
341 }
342 
TEST(AArch32Assembler,Align)343 TEST(AArch32Assembler, Align) {
344   ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr));
345   xnn_code_buffer b;
346   xnn_allocate_code_memory(&b, XNN_DEFAULT_CODE_BUFFER_SIZE);
347   Assembler a(&b);
348 
349   a.add(r0, r1, r2);
350   a.align(4);
351   EXPECT_EQ(0, reinterpret_cast<uintptr_t>(a.offset<uint32_t*>()) & 0x3);
352   EXPECT_EQ(4, a.code_size_in_bytes());
353 
354   a.align(8);
355   EXPECT_EQ(0, reinterpret_cast<uintptr_t>(a.offset<uint32_t*>()) & 0x7);
356   EXPECT_EQ(8, a.code_size_in_bytes());
357 
358   a.add(r0, r1, r2);
359   a.align(8);
360   EXPECT_EQ(0, reinterpret_cast<uintptr_t>(a.offset<uint32_t*>()) & 0x7);
361   EXPECT_EQ(16, a.code_size_in_bytes());
362 
363   a.add(r0, r1, r2);
364   EXPECT_EQ(20, a.code_size_in_bytes());
365 
366   a.align(16);
367   EXPECT_EQ(0, reinterpret_cast<uintptr_t>(a.offset<uint32_t*>()) & 0xF);
368   EXPECT_EQ(32, a.code_size_in_bytes());
369 
370   a.add(r0, r1, r2);
371   a.add(r0, r1, r2);
372   EXPECT_EQ(40, a.code_size_in_bytes());
373 
374   a.align(16);
375   EXPECT_EQ(0, reinterpret_cast<uintptr_t>(a.offset<uint32_t*>()) & 0xF);
376   EXPECT_EQ(48, a.code_size_in_bytes());
377 
378   // Not power-of-two.
379   EXPECT_ERROR(Error::kInvalidOperand, a.align(6));
380   // Is power-of-two but is not a multiple of instruction size.
381   EXPECT_ERROR(Error::kInvalidOperand, a.align(2));
382 
383   ASSERT_EQ(xnn_status_success, xnn_release_code_memory(&b));
384 }
385 
TEST(AArch32Assembler,CoreRegisterList)386 TEST(AArch32Assembler, CoreRegisterList) {
387   EXPECT_EQ(0x3, CoreRegisterList({r0, r1}));
388   EXPECT_EQ(0xFC00, CoreRegisterList({r10, r11, r12, r13, r14, r15}));
389 
390   EXPECT_FALSE(CoreRegisterList({}).has_more_than_one_register());
391   EXPECT_FALSE(CoreRegisterList({r0}).has_more_than_one_register());
392   EXPECT_FALSE(CoreRegisterList({r1}).has_more_than_one_register());
393   EXPECT_TRUE(CoreRegisterList({r0, r1}).has_more_than_one_register());
394 }
395 
TEST(AArch32Assembler,ConsecutiveRegisterList)396 TEST(AArch32Assembler, ConsecutiveRegisterList) {
397   SRegisterList s_list_1 = SRegisterList(s0, s9);
398   EXPECT_EQ(s_list_1.start, s0);
399   EXPECT_EQ(s_list_1.length, 10);
400 
401   SRegisterList s_list_2 = {s4 - s11};
402   EXPECT_EQ(s_list_2.start, s4);
403   EXPECT_EQ(s_list_2.length, 8);
404 
405   DRegisterList d_list_1 = DRegisterList(d4, d5);
406   EXPECT_EQ(d_list_1.start, d4);
407   EXPECT_EQ(d_list_1.length, 2);
408 
409   DRegisterList d_list_2 = {d4 - d11};
410   EXPECT_EQ(d_list_2.start, d4);
411   EXPECT_EQ(d_list_2.length, 8);
412 
413   QRegisterList q_list_1 = {q3-q3};
414   EXPECT_EQ(q_list_1.start, q3);
415   EXPECT_EQ(q_list_1.length, 1);
416 
417   DRegisterList d_from_q_1 = static_cast<DRegisterList>(q_list_1);
418   EXPECT_EQ(d_from_q_1.start, d6);
419   EXPECT_EQ(d_from_q_1.length, 2);
420 
421   QRegisterList q_list_2 = {q4-q9};
422   EXPECT_EQ(q_list_2.start, q4);
423   EXPECT_EQ(q_list_2.length, 6);
424 
425   DRegisterList d_from_q_2 = static_cast<DRegisterList>(q_list_2);
426   EXPECT_EQ(d_from_q_2.start, d8);
427   EXPECT_EQ(d_from_q_2.length, 12);
428 }
429 
TEST(AArch32Assembler,MemOperand)430 TEST(AArch32Assembler, MemOperand) {
431   EXPECT_EQ(MemOperand(r0, 4, AddressingMode::kOffset), (mem[r0, 4]));
432 }
433 
TEST(AArch32Assembler,DRegisterLane)434 TEST(AArch32Assembler, DRegisterLane) {
435   EXPECT_EQ((DRegisterLane{2, 0}), d2[0]);
436   EXPECT_EQ((DRegisterLane{2, 1}), d2[1]);
437 }
438 
TEST(AArch32Assembler,QRegister)439 TEST(AArch32Assembler, QRegister) {
440   EXPECT_EQ(q0.low(), d0);
441   EXPECT_EQ(q0.high(), d1);
442   EXPECT_EQ(q1.low(), d2);
443   EXPECT_EQ(q1.high(), d3);
444   EXPECT_EQ(q15.low(), d30);
445   EXPECT_EQ(q15.high(), d31);
446 }
447 
TEST(AArch32Assembler,CodeBufferOverflow)448 TEST(AArch32Assembler, CodeBufferOverflow) {
449   ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr));
450   xnn_code_buffer b;
451   // Requested memory is rounded to page size.
452   xnn_allocate_code_memory(&b, 4);
453   Assembler a(&b);
454   for (int i = 0; i < b.capacity; i += 1 << kInstructionSizeInBytesLog2) {
455     a.add(r0, r0, 2);
456   }
457   EXPECT_EQ(Error::kNoError, a.error());
458 
459   a.bx(lr);
460   EXPECT_EQ(Error::kOutOfMemory, a.error());
461 
462   ASSERT_EQ(xnn_status_success, xnn_release_code_memory(&b));
463 }
464 
TEST(AArch32Assembler,BoundOverflow)465 TEST(AArch32Assembler, BoundOverflow) {
466   ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr));
467   xnn_code_buffer b;
468   // Requested memory is rounded to page size.
469   xnn_allocate_code_memory(&b, 4);
470   Assembler a(&b);
471   Label l1;
472   for (int i = 0; i < b.capacity; i += 1 << kInstructionSizeInBytesLog2) {
473     a.add(r0, r0, 2);
474   }
475   EXPECT_EQ(Error::kNoError, a.error());
476 
477   // This is out of bounds, not written.
478   a.bhi(l1);
479   EXPECT_EQ(Error::kOutOfMemory, a.error());
480 
481   a.bind(l1);
482   EXPECT_EQ(false, l1.bound);
483 
484   ASSERT_EQ(xnn_status_success, xnn_release_code_memory(&b));
485 }
486 
487 #if XNN_ARCH_ARM && XNN_PLATFORM_JIT
TEST(AArch32Assembler,JitAllocCodeBuffer)488 TEST(AArch32Assembler, JitAllocCodeBuffer) {
489   ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr));
490   typedef uint32_t (*Func)(uint32_t);
491 
492   xnn_code_buffer b;
493   xnn_allocate_code_memory(&b, XNN_DEFAULT_CODE_BUFFER_SIZE);
494 
495   Assembler a(&b);
496   a.add(r0, r0, 2);
497   a.bx(lr);
498 
499   Func fn = reinterpret_cast<Func>(a.finalize());
500 
501   ASSERT_EQ(3, fn(1));
502 
503   ASSERT_EQ(xnn_status_success, xnn_release_code_memory(&b));
504 }
505 #endif  // XNN_ARCH_ARM && XNN_PLATFORM_JIT
506 }  // namespace aarch32
507 }  // namespace xnnpack
508