| // Copyright 2016, VIXL authors |
| // All rights reserved. |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are met: |
| // |
| // * Redistributions of source code must retain the above copyright notice, |
| // this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above copyright notice, |
| // this list of conditions and the following disclaimer in the documentation |
| // and/or other materials provided with the distribution. |
| // * Neither the name of ARM Limited nor the names of its contributors may be |
| // used to endorse or promote products derived from this software without |
| // specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND |
| // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
| // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE |
| // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
| // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| |
| #include "code-buffer-vixl.h" |
| #include "test-runner.h" |
| |
| namespace vixl { |
| |
| #define TEST(name) TEST_(CODE_BUFFER_##name) |
| |
| TEST(align_grow) { |
| CodeBuffer code_buffer(2); |
| VIXL_CHECK(code_buffer.GetCapacity() == 2); |
| VIXL_CHECK(code_buffer.GetRemainingBytes() == 2); |
| |
| code_buffer.Emit16(0); |
| VIXL_CHECK(code_buffer.GetCapacity() == 2); |
| VIXL_CHECK(code_buffer.GetRemainingBytes() == 0); |
| |
| // Check that the buffer can automatically grow when aligning the cursor. |
| VIXL_CHECK(IsAligned<2>(code_buffer.GetCursorOffset())); |
| code_buffer.Align(); |
| VIXL_CHECK(IsWordAligned(code_buffer.GetCursorOffset())); |
| VIXL_CHECK(code_buffer.GetCapacity() > 2); |
| |
| code_buffer.SetClean(); |
| } |
| |
| static void TestDefaultsHelper(const CodeBuffer& buffer) { |
| VIXL_CHECK(buffer.GetCapacity() == CodeBuffer::kDefaultCapacity); |
| VIXL_CHECK(buffer.HasSpaceFor(CodeBuffer::kDefaultCapacity)); |
| VIXL_CHECK(!buffer.HasSpaceFor(CodeBuffer::kDefaultCapacity + 1)); |
| VIXL_CHECK(buffer.GetCursorOffset() == 0); |
| VIXL_CHECK(buffer.GetOffsetFrom(0) == 0); |
| VIXL_CHECK(buffer.IsManaged()); |
| VIXL_CHECK(!buffer.IsDirty()); |
| VIXL_CHECK(buffer.GetRemainingBytes() == CodeBuffer::kDefaultCapacity); |
| VIXL_CHECK(buffer.GetSizeInBytes() == 0); |
| VIXL_CHECK(buffer.GetEndAddress<uintptr_t>() == |
| buffer.GetStartAddress<uintptr_t>()); |
| } |
| |
| TEST(defaults) { |
| CodeBuffer buffer; |
| TestDefaultsHelper(buffer); |
| } |
| |
| TEST(reset) { |
| CodeBuffer buffer; |
| // Update the buffer by writing to it. |
| buffer.Emit("dummy data"); |
| VIXL_CHECK(buffer.IsDirty()); |
| VIXL_CHECK(buffer.GetSizeInBytes() > 0); |
| // Calling Reset() should reset it back to its default state. (It does not |
| // shrink the capacity, but it should not have grown here.) |
| VIXL_ASSERT(buffer.GetCapacity() == CodeBuffer::kDefaultCapacity); |
| buffer.Reset(); |
| TestDefaultsHelper(buffer); |
| } |
| |
| TEST(ensure_space) { |
| const size_t initial_capacity = 1234; |
| CodeBuffer buffer(initial_capacity); |
| |
| // Requesting less space than we already have should have no effect. |
| for (size_t space = 0; space < initial_capacity; space++) { |
| buffer.EnsureSpaceFor(space); |
| VIXL_CHECK(buffer.GetCapacity() == initial_capacity); |
| } |
| |
| // Requesting more memory grows the buffer by an unspecified amount. |
| buffer.EnsureSpaceFor(initial_capacity + 1); |
| VIXL_CHECK(buffer.GetCapacity() > initial_capacity); |
| } |
| |
| TEST(emit) { |
| CodeBuffer buffer; |
| VIXL_ASSERT(buffer.GetSizeInBytes() == 0); |
| |
| uint64_t base_value = 0x0100001000100101; |
| const char* test_string = "test string"; |
| size_t expected_size = 0; |
| |
| // Simple emissions. This should not align or pad in any way. |
| buffer.EmitData(&base_value, 7); |
| expected_size += 7; |
| |
| buffer.EmitString(test_string); |
| expected_size += strlen(test_string) + 1; // EmitString() emits the '\0'. |
| |
| buffer.Emit64(static_cast<uint64_t>(base_value * 1)); |
| buffer.Emit(static_cast<uint64_t>(base_value * 2)); |
| expected_size += 16; |
| |
| buffer.Emit32(static_cast<uint32_t>(base_value * 3)); |
| buffer.Emit(static_cast<uint32_t>(base_value * 4)); |
| expected_size += 8; |
| |
| buffer.Emit16(static_cast<uint16_t>(base_value * 5)); |
| buffer.Emit(static_cast<uint16_t>(base_value * 6)); |
| expected_size += 4; |
| |
| buffer.Emit8(static_cast<uint8_t>(base_value * 7)); |
| buffer.Emit(static_cast<uint8_t>(base_value * 8)); |
| expected_size += 2; |
| |
| VIXL_CHECK(buffer.GetSizeInBytes() == expected_size); |
| |
| buffer.SetClean(); |
| |
| // clang-format off |
| uint8_t expected[] = { |
| // EmitData |
| 0x01, 0x01, 0x10, 0x00, 0x10, 0x00, 0x00, |
| // EmitString |
| 't', 'e', 's', 't', ' ', 's', 't', 'r', 'i', 'n', 'g', '\0', |
| // Emit64 |
| 0x01, 0x01, 0x10, 0x00, 0x10, 0x00, 0x00, 0x01, |
| // Emit<uint64_t> |
| 0x02, 0x02, 0x20, 0x00, 0x20, 0x00, 0x00, 0x02, |
| // Emit32 |
| 0x03, 0x03, 0x30, 0x00, |
| // Emit<uint32_t> |
| 0x04, 0x04, 0x40, 0x00, |
| // Emit16 |
| 0x05, 0x05, |
| // Emit<uint16_t> |
| 0x06, 0x06, |
| // Emit8 |
| 0x07, |
| // Emit<uint8_t> |
| 0x08 |
| }; |
| // clang-format on |
| |
| VIXL_ASSERT(expected_size == sizeof(expected)); |
| VIXL_CHECK(memcmp(buffer.GetStartAddress<const void*>(), |
| expected, |
| expected_size) == 0); |
| } |
| |
| } // namespace vixl |