// Copyright 2022 Google LLC // // This source code is licensed under the BSD-style license found in the // LICENSE file in the root directory of this source tree. #include #include #include #include #include "assembler-helpers.h" #include namespace xnnpack { namespace aarch64 { TEST(AArch64Assembler, Initialization) { ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr)); xnn_code_buffer b; xnn_allocate_code_memory(&b, XNN_DEFAULT_CODE_BUFFER_SIZE); Assembler a(&b); ASSERT_EQ(xnn_status_success, xnn_release_code_memory(&b)); } TEST(AArch64Assembler, BaseInstructionEncoding) { ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr)); xnn_code_buffer b; xnn_allocate_code_memory(&b, XNN_DEFAULT_CODE_BUFFER_SIZE); Assembler a(&b); CHECK_ENCODING(0x91008041, a.add(x1, x2, 32)); CHECK_ENCODING(0x913FFC41, a.add(x1, x2, 4095)); EXPECT_ERROR(Error::kInvalidOperand, a.add(x1, x2, 4096)); CHECK_ENCODING(0x8B040069, a.add(x9, x3, x4)); CHECK_ENCODING(0xF100081F, a.cmp(x0, 2)); EXPECT_ERROR(Error::kInvalidOperand, a.cmp(x0, 4096)); CHECK_ENCODING(0xEB0C02DF, a.cmp(x22, x12)); CHECK_ENCODING(0x9A8F322E, a.csel(x14, x17, x15, kLO)); CHECK_ENCODING(0xD4400000, a.hlt()); CHECK_ENCODING(0xA9403FEE, a.ldp(x14, x15, mem[sp])); CHECK_ENCODING(0xA8C13FEE, a.ldp(x14, x15, mem[sp], 16)); CHECK_ENCODING(0xA9413FEE, a.ldp(x14, x15, mem[sp, 16])); CHECK_ENCODING(0xA9603FEE, a.ldp(x14, x15, mem[sp, -512])); CHECK_ENCODING(0xA95FBFEE, a.ldp(x14, x15, mem[sp, 504])); EXPECT_ERROR(Error::kInvalidOperand, a.ldp(x14, x15, mem[sp], 15)); EXPECT_ERROR(Error::kInvalidOperand, a.ldp(x14, x15, mem[sp], -520)); EXPECT_ERROR(Error::kInvalidOperand, a.ldp(x14, x15, mem[sp], 512)); EXPECT_ERROR(Error::kInvalidOperand, a.ldp(x14, x15, mem[sp, 16], 16)); CHECK_ENCODING(0xF9400BE8, a.ldr(x8, mem[sp, 16])); CHECK_ENCODING(0xF97FFFE8, a.ldr(x8, mem[sp, 32760])); EXPECT_ERROR(Error::kInvalidOperand, a.ldr(x8, mem[sp, -8])); EXPECT_ERROR(Error::kInvalidOperand, a.ldr(x8, mem[sp, 7])); EXPECT_ERROR(Error::kInvalidOperand, a.ldr(x8, mem[sp, 32768])); EXPECT_ERROR(Error::kInvalidOperand, a.ldr(x8, MemOperand(sp, 16, AddressingMode::kPostIndex))); CHECK_ENCODING(0xF8408488, a.ldr(x8, mem[x4], 8)); CHECK_ENCODING(0xF84FF488, a.ldr(x8, mem[x4], 255)); CHECK_ENCODING(0xF8500488, a.ldr(x8, mem[x4], -256)); EXPECT_ERROR(Error::kInvalidOperand, a.ldr(x8, mem[x4], 256)); EXPECT_ERROR(Error::kInvalidOperand, a.ldr(x8, mem[x4], -257)); CHECK_ENCODING(0xAA0303E9, a.mov(x9, x3)); CHECK_ENCODING(0xD503201F, a.nop()); CHECK_ENCODING(0xF98000A0, a.prfm(kPLDL1KEEP, mem[x5])); CHECK_ENCODING(0xF98020A0, a.prfm(kPLDL1KEEP, mem[x5, 64])); EXPECT_ERROR(Error::kInvalidOperand, a.prfm(kPLDL1KEEP, mem[x5, -8])); EXPECT_ERROR(Error::kInvalidOperand, a.prfm(kPLDL1KEEP, mem[x5, 32761])); CHECK_ENCODING(0xD65F03C0, a.ret()); CHECK_ENCODING(0xCB020083, a.sub(x3, x4, x2)); CHECK_ENCODING(0xA90457F4, a.stp(x20, x21, mem[sp, 64])); CHECK_ENCODING(0xA98457F4, a.stp(x20, x21, mem[sp, 64]++)); CHECK_ENCODING(0xA91FD7F4, a.stp(x20, x21, mem[sp, 504])); CHECK_ENCODING(0xA92057F4, a.stp(x20, x21, mem[sp, -512])); EXPECT_ERROR(Error::kInvalidOperand, a.stp(x20, x21, mem[sp, 3])); EXPECT_ERROR(Error::kInvalidOperand, a.stp(x20, x21, mem[sp, 512])); EXPECT_ERROR(Error::kInvalidOperand, a.stp(x20, x21, mem[sp, -520])); CHECK_ENCODING(0xF80FFFF4, a.str(x20, mem[sp, 255]++)); CHECK_ENCODING(0xF81B0FF4, a.str(x20, mem[sp, -80]++)); CHECK_ENCODING(0xF8100FF4, a.str(x20, mem[sp, -256]++)); CHECK_ENCODING(0xF90003F4, a.str(x20, mem[sp, 0])); CHECK_ENCODING(0xF93FFFF4, a.str(x20, mem[sp, 32760])); EXPECT_ERROR(Error::kInvalidOperand, a.str(sp, mem[sp, -257]++)); EXPECT_ERROR(Error::kInvalidOperand, a.str(sp, mem[sp, 256]++)); EXPECT_ERROR(Error::kInvalidOperand, a.str(sp, mem[sp, 3])); EXPECT_ERROR(Error::kInvalidOperand, a.str(sp, mem[sp, -1])); EXPECT_ERROR(Error::kInvalidOperand, a.str(sp, mem[sp, 32768])); CHECK_ENCODING(0xF1008040, a.subs(x0, x2, 32)); CHECK_ENCODING(0xF13FFC40, a.subs(x0, x2, 4095)); EXPECT_ERROR(Error::kInvalidOperand, a.subs(x0, x2, -32)); EXPECT_ERROR(Error::kInvalidOperand, a.subs(x0, x2, 4096)); CHECK_ENCODING(0xF240043F, a.tst(x1, 3)); CHECK_ENCODING(0xF2400C3F, a.tst(x1, 15)); CHECK_ENCODING(0xF240103F, a.tst(x1, 31)); EXPECT_ERROR(Error::kUnimplemented, a.tst(x1, 32)); ASSERT_EQ(xnn_status_success, xnn_release_code_memory(&b)); } TEST(AArch64Assembler, SIMDInstructionEncoding) { ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr)); xnn_code_buffer b; xnn_allocate_code_memory(&b, XNN_DEFAULT_CODE_BUFFER_SIZE); Assembler a(&b); CHECK_ENCODING(0x5E180610, a.dup(d16, v16.d()[1])); EXPECT_ERROR(Error::kInvalidOperand, a.dup(d16, v16.d()[2])); EXPECT_ERROR(Error::kInvalidOperand, a.dup(d16, v16.s()[1])); CHECK_ENCODING(0x4EA0F8B0, a.fabs(v16.v4s(), v5.v4s())); EXPECT_ERROR(Error::kInvalidOperand, a.fabs(v16.v4s(), v5.v2s())); CHECK_ENCODING(0x4E25D690, a.fadd(v16.v4s(), v20.v4s(), v5.v4s())); EXPECT_ERROR(Error::kInvalidOperand, a.fadd(v16.v4s(), v20.v4s(), v5.v2s())); CHECK_ENCODING(0x4E30F7E3, a.fmax(v3.v4s(), v31.v4s(), v16.v4s())); EXPECT_ERROR(Error::kInvalidOperand, a.fmax(v3.v8h(), v31.v4s(), v16.v4s())); CHECK_ENCODING(0x4EB1F7C2, a.fmin(v2.v4s(), v30.v4s(), v17.v4s())); EXPECT_ERROR(Error::kInvalidOperand, a.fmin(v2.v4s(), v30.v16b(), v17.v4s())); CHECK_ENCODING(0x4F801290, a.fmla(v16.v4s(), v20.v4s(), v0.s()[0])); EXPECT_ERROR(Error::kInvalidOperand, a.fmla(v16.v4s(), v20.v2s(), v0.s()[0])); EXPECT_ERROR(Error::kInvalidOperand, a.fmla(v16.v2d(), v20.v2d(), v0.s()[0])); EXPECT_ERROR(Error::kInvalidLaneIndex, a.fmla(v16.v4s(), v20.v4s(), v0.s()[4])); CHECK_ENCODING(0x6E29DC61, a.fmul(v1.v4s(), v3.v4s(), v9.v4s())); EXPECT_ERROR(Error::kInvalidOperand, a.fmul(v16.v4s(), v20.v4s(), v5.v2s())); CHECK_ENCODING(0x6EA0FBC2, a.fneg(v2.v4s(), v30.v4s())); EXPECT_ERROR(Error::kInvalidOperand, a.fneg(v2.v4s(), v30.v16b())); CHECK_ENCODING(0x0CDF7060, a.ld1({v0.v8b()}, mem[x3], 8)); EXPECT_ERROR(Error::kInvalidOperand, a.ld1({v0.v8b()}, mem[x3], 16)); EXPECT_ERROR(Error::kInvalidOperand, a.ld1({v0.v16b()}, mem[x3], 8)); CHECK_ENCODING(0x0CDFA060, a.ld1({v0.v8b(), v1.v8b()}, mem[x3], 16)); EXPECT_ERROR(Error::kInvalidOperand, a.ld1({v0.v8b(), v1.v8b()}, mem[x3], 32)); EXPECT_ERROR(Error::kInvalidOperand, a.ld1({v0.v16b(), v1.v16b()}, mem[x3], 16)); EXPECT_ERROR(Error::kInvalidOperand, a.ld1({v0.v8b(), v2.v8b()}, mem[x3], 16)); CHECK_ENCODING(0x4CDF61F0, a.ld1({v16.v16b(), v17.v16b(), v18.v16b()}, mem[x15], 48)); EXPECT_ERROR(Error::kInvalidOperand, a.ld1({v16.v8b(), v17.v16b(), v18.v16b()}, mem[x15], 48)); EXPECT_ERROR(Error::kInvalidOperand, a.ld1({v16.v16b(), v17.v16b(), v18.v8b()}, mem[x15], 48)); EXPECT_ERROR(Error::kInvalidOperand, a.ld1({v16.v16b(), v17.v16b(), v18.v16b()}, mem[x15], 24)); EXPECT_ERROR(Error::kInvalidOperand, a.ld1({v16.v8b(), v17.v8b(), v18.v8b()}, mem[x15], 48)); CHECK_ENCODING(0x6D433FEE, a.ldp(d14, d15, mem[sp, 48])); CHECK_ENCODING(0x6DC33FEE, a.ldp(d14, d15, mem[sp, 48]++)); CHECK_ENCODING(0x6CC427E8, a.ldp(d8, d9, mem[sp], 64)); EXPECT_ERROR(Error::kInvalidOperand, a.ldp(d14, d15, mem[sp, 7])); CHECK_ENCODING(0xACC154B4, a.ldp(q20, q21, mem[x5], 32)); CHECK_ENCODING(0xACE054B4, a.ldp(q20, q21, mem[x5], -1024)); CHECK_ENCODING(0xACDFD4B4, a.ldp(q20, q21, mem[x5], 1008)); EXPECT_ERROR(Error::kInvalidOperand, a.ldp(q20, q21, mem[x5], 15)); EXPECT_ERROR(Error::kInvalidOperand, a.ldp(q20, q21, mem[x5], -1040)); EXPECT_ERROR(Error::kInvalidOperand, a.ldp(q20, q21, mem[x5], 1024)); CHECK_ENCODING(0xFC408460, a.ldr(d0, mem[x3], 8)); CHECK_ENCODING(0xBC404460, a.ldr(s0, mem[x3], 4)); CHECK_ENCODING(0x3CC10460, a.ldr(q0, mem[x3], 16)); CHECK_ENCODING(0x3CCFF460, a.ldr(q0, mem[x3], 255)); CHECK_ENCODING(0x3CD00460, a.ldr(q0, mem[x3], -256)); EXPECT_ERROR(Error::kInvalidOperand, a.ldr(q0, mem[x3], -257)); EXPECT_ERROR(Error::kInvalidOperand, a.ldr(q0, mem[x3], 256)); EXPECT_ERROR(Error::kInvalidOperand, a.ldr(q0, mem[x3, 16], 16)); CHECK_ENCODING(0x4D40C904, a.ld1r({v4.v4s()}, mem[x8])); EXPECT_ERROR(Error::kInvalidOperand, a.ld1r({v4.v4s(), v5.v4s()}, mem[x8])); EXPECT_ERROR(Error::kInvalidOperand, a.ld1r({v4.v4s()}, mem[x8, 16])); CHECK_ENCODING(0x4D60C902, a.ld2r({v2.v4s(), v3.v4s()}, mem[x8])); EXPECT_ERROR(Error::kInvalidOperand, a.ld2r({v2.v4s(), v3.v4s()}, mem[x8, 16])); EXPECT_ERROR(Error::kInvalidOperand, a.ld2r({v2.v4s(), v4.v4s()}, mem[x8])); EXPECT_ERROR(Error::kInvalidOperand, a.ld2r({v2.v4s(), v3.v8b()}, mem[x8])); CHECK_ENCODING(0x4D40E906, a.ld3r({v6.v4s(), v7.v4s(), v8.v4s()}, mem[x8])); EXPECT_ERROR(Error::kInvalidOperand, a.ld3r({v6.v4s(), v7.v4s(), v8.v4s()}, mem[x8, 16])); EXPECT_ERROR(Error::kInvalidOperand, a.ld3r({v6.v4s(), v7.v4s(), v9.v4s()}, mem[x8])); EXPECT_ERROR(Error::kInvalidOperand, a.ld3r({v6.v4s(), v7.v2s(), v8.v4s()}, mem[x8])); CHECK_ENCODING(0x4EB21E50, a.mov(v16.v16b(), v18.v16b())); CHECK_ENCODING(0x0EB21E50, a.mov(v16.v8b(), v18.v8b())); EXPECT_ERROR(Error::kInvalidOperand, a.mov(v16.v16b(), v18.v8b())); CHECK_ENCODING(0x4F000405, a.movi(v5.v4s(), 0)); CHECK_ENCODING(0x4F008405, a.movi(v5.v8h(), 0)); CHECK_ENCODING(0x4F00E405, a.movi(v5.v16b(), 0)); EXPECT_ERROR(Error::kUnimplemented, a.movi(v5.v16b(), 0xFF)); CHECK_ENCODING(0x4C82746F, a.st1({v15.v8h()}, mem[x3], x2)); CHECK_ENCODING(0x4C95AA8F, a.st1({v15.v4s(), v16.v4s()}, mem[x20], x21)); EXPECT_ERROR(Error::kInvalidOperand, a.st1({v15.v4s(), v17.v4s()}, mem[x20], x21)); EXPECT_ERROR(Error::kInvalidOperand, a.st1({v15.v4s(), v16.v8h()}, mem[x20], x21)); CHECK_ENCODING(0x4C8E60D0, a.st1({v16.v16b(), v17.v16b(), v18.v16b() }, mem[x6], x14)); EXPECT_ERROR(Error::kInvalidOperand, a.st1({v15.v16b(), v17.v16b(), v18.v16b()}, mem[x6], x14)); EXPECT_ERROR(Error::kInvalidOperand, a.st1({v16.v16b(), v17.v16b(), v18.v4s()}, mem[x6], x14)); CHECK_ENCODING(0x4C812FB4, a.st1({v20.v2d(), v21.v2d(), v22.v2d(), v23.v2d()}, mem[x29], x1)); EXPECT_ERROR(Error::kInvalidOperand, a.st1({v20.v2d(), v21.v2d(), v22.v2d(), v23.v2s()}, mem[x29], x1)); EXPECT_ERROR(Error::kInvalidOperand, a.st1({v20.v2d(), v21.v2d(), v22.v2d(), v27.v2d()}, mem[x29], x1)); CHECK_ENCODING(0x6D012FEA, a.stp(d10, d11, mem[sp, 16])); CHECK_ENCODING(0x6D202FEA, a.stp(d10, d11, mem[sp, -512])); CHECK_ENCODING(0x6D1FAFEA, a.stp(d10, d11, mem[sp, 504])); EXPECT_ERROR(Error::kInvalidOperand, a.stp(d10, d11, mem[sp, -520])); EXPECT_ERROR(Error::kInvalidOperand, a.stp(d10, d11, mem[sp, 512])); CHECK_ENCODING(0x6D812FEA, a.stp(d10, d11, mem[sp, 16]++)); CHECK_ENCODING(0xAD0075BC, a.stp(q28, q29, mem[x13])); CHECK_ENCODING(0xAD80F5BC, a.stp(q28, q29, mem[x13, 16]++)); EXPECT_ERROR(Error::kInvalidOperand, a.stp(q28, q28, mem[x13, 7])); CHECK_ENCODING(0xAC8144D0, a.stp(q16, q17, mem[x6], 32)); CHECK_ENCODING(0xAC9FC4D0, a.stp(q16, q17, mem[x6], 1008)); CHECK_ENCODING(0xACA044D0, a.stp(q16, q17, mem[x6], -1024)); EXPECT_ERROR(Error::kInvalidOperand, a.stp(q16, q17, mem[x6], 34)); EXPECT_ERROR(Error::kInvalidOperand, a.stp(q16, q17, mem[x6], 1024)); EXPECT_ERROR(Error::kInvalidOperand, a.stp(q16, q17, mem[x6], -1040)); CHECK_ENCODING(0xFC0084D0, a.str(d16, mem[x6], 8)); CHECK_ENCODING(0x3C8104D0, a.str(q16, mem[x6], 16)); CHECK_ENCODING(0x3C8FF4D0, a.str(q16, mem[x6], 255)); CHECK_ENCODING(0x3C9004D0, a.str(q16, mem[x6], -256)); EXPECT_ERROR(Error::kInvalidOperand, a.str(q16, mem[x6], 256)); EXPECT_ERROR(Error::kInvalidOperand, a.str(q16, mem[x6], -257)); CHECK_ENCODING(0xBD0000D0, a.str(s16, mem[x6])); CHECK_ENCODING(0xBD3FFCD0, a.str(s16, mem[x6, 16380])); EXPECT_ERROR(Error::kInvalidOperand, a.str(s16, mem[x6, 3])); EXPECT_ERROR(Error::kInvalidOperand, a.str(s16, mem[x6, -4])); EXPECT_ERROR(Error::kInvalidOperand, a.str(s16, mem[x6, 16384])); CHECK_ENCODING(0xBC0044D0, a.str(s16, mem[x6], 4)); CHECK_ENCODING(0xBC0FF4D0, a.str(s16, mem[x6], 255)); CHECK_ENCODING(0xBC1004D0, a.str(s16, mem[x6], -256)); EXPECT_ERROR(Error::kInvalidOperand, a.str(s16, mem[x6], 256)); EXPECT_ERROR(Error::kInvalidOperand, a.str(s16, mem[x6], -257)); ASSERT_EQ(xnn_status_success, xnn_release_code_memory(&b)); } TEST(AArch64Assembler, Label) { ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr)); xnn_code_buffer b; xnn_allocate_code_memory(&b, XNN_DEFAULT_CODE_BUFFER_SIZE); Assembler a(&b); Label l1; a.movi(v0.v4s(), 0); // Branch to unbound label. auto b1 = a.offset(); a.b_eq(l1); a.movi(v1.v4s(), 0); auto b2 = a.offset(); a.b_ne(l1); a.movi(v2.v4s(), 0); a.bind(l1); // Check that b1 and b2 are both patched after binding l1. EXPECT_INSTR(0x54000080, *b1); EXPECT_INSTR(0x54000041, *b2); a.movi(v3, 0); // Branch to bound label. auto b3 = a.offset(); a.b_hi(l1); auto b4 = a.offset(); a.b_hs(l1); auto b5 = a.offset(); a.b_lo(l1); EXPECT_INSTR(0x54FFFFE8, *b3); EXPECT_INSTR(0x54FFFFC2, *b4); EXPECT_INSTR(0x54FFFFA3, *b5); // Binding a bound label is an error. a.bind(l1); EXPECT_ERROR(Error::kLabelAlreadyBound, a.bind(l1)); // Check for bind failure due to too many users of label. Label lfail; a.reset(); // Arbitrary high number of users that we probably won't support. for (int i = 0; i < 1000; i++) { a.b_eq(lfail); } EXPECT_EQ(Error::kLabelHasTooManyUsers, a.error()); ASSERT_EQ(xnn_status_success, xnn_release_code_memory(&b)); } TEST(AArch64Assembler, Tbnz) { ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr)); xnn_code_buffer b; xnn_allocate_code_memory(&b, XNN_DEFAULT_CODE_BUFFER_SIZE); Assembler a(&b); Label l1; a.movi(v0.v4s(), 0); // Branch to unbound label. auto b1 = a.offset(); a.tbnz(x0, 4, l1); a.movi(v1.v4s(), 0); a.bind(l1); EXPECT_INSTR(0x37200040, *b1); a.movi(v2.v4s(), 0); // Branch to bound label. auto b2 = a.offset(); a.tbnz(x1, 6, l1); EXPECT_INSTR(0x3737FFE1, *b2); ASSERT_EQ(xnn_status_success, xnn_release_code_memory(&b)); } TEST(AArch64Assembler, Tbz) { ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr)); xnn_code_buffer b; xnn_allocate_code_memory(&b, XNN_DEFAULT_CODE_BUFFER_SIZE); Assembler a(&b); Label l1; a.movi(v0.v4s(), 0); // Branch to unbound label. auto b1 = a.offset(); a.tbz(x0, 4, l1); a.movi(v1.v4s(), 0); a.bind(l1); EXPECT_INSTR(0x36200040, *b1); a.movi(v2.v4s(), 0); // Branch to bound label. auto b2 = a.offset(); a.tbz(x1, 6, l1); EXPECT_INSTR(0x3637FFE1, *b2); ASSERT_EQ(xnn_status_success, xnn_release_code_memory(&b)); } TEST(AArch64Assembler, UnconditionalBranch) { ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr)); xnn_code_buffer b; xnn_allocate_code_memory(&b, XNN_DEFAULT_CODE_BUFFER_SIZE); Assembler a(&b); Label l1; a.movi(v0.v4s(), 0); // Branch to unbound label. auto b1 = a.offset(); a.b(l1); a.movi(v1.v4s(), 0); a.bind(l1); EXPECT_INSTR(0x14000002, *b1); a.movi(v2.v4s(), 0); // Branch to bound label. auto b2 = a.offset(); a.b(l1); EXPECT_INSTR(0x17FFFFFF, *b2); ASSERT_EQ(xnn_status_success, xnn_release_code_memory(&b)); } TEST(AArch64Assembler, Align) { ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr)); xnn_code_buffer b; xnn_allocate_code_memory(&b, XNN_DEFAULT_CODE_BUFFER_SIZE); Assembler a(&b); a.add(x0, x1, x2); a.align(4); EXPECT_EQ(0, reinterpret_cast(a.offset()) & 0x3); EXPECT_EQ(4, a.code_size_in_bytes()); a.align(8); EXPECT_EQ(0, reinterpret_cast(a.offset()) & 0x7); EXPECT_EQ(8, a.code_size_in_bytes()); a.add(x0, x1, x2); a.align(8); EXPECT_EQ(0, reinterpret_cast(a.offset()) & 0x7); EXPECT_EQ(16, a.code_size_in_bytes()); a.add(x0, x1, x2); EXPECT_EQ(20, a.code_size_in_bytes()); a.align(16); EXPECT_EQ(0, reinterpret_cast(a.offset()) & 0xF); EXPECT_EQ(32, a.code_size_in_bytes()); a.add(x0, x1, x2); a.add(x0, x1, x2); EXPECT_EQ(40, a.code_size_in_bytes()); a.align(16); EXPECT_EQ(0, reinterpret_cast(a.offset()) & 0xF); EXPECT_EQ(48, a.code_size_in_bytes()); // Not power-of-two. EXPECT_ERROR(Error::kInvalidOperand, a.align(6)); // Is power-of-two but is not a multiple of instruction size. EXPECT_ERROR(Error::kInvalidOperand, a.align(2)); ASSERT_EQ(xnn_status_success, xnn_release_code_memory(&b)); } TEST(AArch64Assembler, AssembleToEndOfBuffer) { ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr)); xnn_code_buffer b; xnn_allocate_code_memory(&b, XNN_DEFAULT_CODE_BUFFER_SIZE); Assembler a1(&b); a1.emit32(1); a1.finalize(); // Different assembler, but same code buffer. Assembler a2(&b); a2.emit32(2); a2.finalize(); // Check that we wrote to end of buffer and did not overwrite. uint32_t* p = (uint32_t*) b.start; ASSERT_EQ(1, *p); ASSERT_EQ(2, *(p+1)); ASSERT_EQ(8, b.size); a2.reset(); ASSERT_EQ(4, b.size); ASSERT_EQ((byte*)b.start + 4, a2.offset()); a2.emit32(3); ASSERT_EQ(3, *(p+1)); ASSERT_EQ(xnn_status_success, xnn_release_code_memory(&b)); } TEST(AArch64Assembler, FinalizeWithError) { ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr)); xnn_code_buffer b; xnn_allocate_code_memory(&b, XNN_DEFAULT_CODE_BUFFER_SIZE); Assembler a(&b); // Write a valid instruction. a.add(x1, x2, 32); // Then write an invalid instruction. a.ldp(x14, x15, mem[sp], 15); // Since we have an error, size should not be updated. a.finalize(); ASSERT_EQ(0, b.size); ASSERT_EQ(xnn_status_success, xnn_release_code_memory(&b)); } TEST(AArch64Assembler, BindOverflow) { ASSERT_EQ(xnn_status_success, xnn_initialize(/*allocator=*/nullptr)); xnn_code_buffer b; // Requested memory is rounded to page size. xnn_allocate_code_memory(&b, 4); Assembler a(&b); Label l1; for (int i = 0; i < b.capacity; i += 1 << kInstructionSizeInBytesLog2) { a.add(x0, x0, 2); } EXPECT_EQ(Error::kNoError, a.error()); // This is out of bounds, not written. a.tbz(x1, 1, l1); EXPECT_EQ(Error::kOutOfMemory, a.error()); a.bind(l1); ASSERT_EQ(false, l1.bound); ASSERT_EQ(xnn_status_success, xnn_release_code_memory(&b)); } } // namespace aarch64 } // namespace xnnpack