diff options
Diffstat (limited to '3rdparty/asmjit/asmjit-testing/tests/asmjit_test_x86_sections.cpp')
| -rw-r--r-- | 3rdparty/asmjit/asmjit-testing/tests/asmjit_test_x86_sections.cpp | 169 |
1 files changed, 169 insertions, 0 deletions
diff --git a/3rdparty/asmjit/asmjit-testing/tests/asmjit_test_x86_sections.cpp b/3rdparty/asmjit/asmjit-testing/tests/asmjit_test_x86_sections.cpp new file mode 100644 index 00000000000..2084ddb637a --- /dev/null +++ b/3rdparty/asmjit/asmjit-testing/tests/asmjit_test_x86_sections.cpp @@ -0,0 +1,169 @@ +// This file is part of AsmJit project <https://asmjit.com> +// +// See <asmjit/core.h> or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +// ---------------------------------------------------------------------------- +// This is a working example that demonstrates how multiple sections can be +// used in a JIT-based code generator. It shows also the necessary tooling +// that is expected to be done by the user when the feature is used. It's +// important to handle the following cases: +// +// - Assign offsets to sections when the code generation is finished. +// - Tell the CodeHolder to resolve unresolved fixups and check whether +// all fixups were resolved. +// - Relocate the code +// - Copy the code to the destination address. +// ---------------------------------------------------------------------------- + +#include <asmjit/core.h> +#if ASMJIT_ARCH_X86 && !defined(ASMJIT_NO_X86) && !defined(ASMJIT_NO_JIT) + +#include <asmjit/x86.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +using namespace asmjit; + +// The generated function is very simple, it only accesses the built-in data +// (from .data section) at the index as provided by its first argument. This +// data is inlined into the resulting function so we can use it this array +// for verification that the function returns correct values. +static const uint8_t data_array[] = { 2, 9, 4, 7, 1, 3, 8, 5, 6, 0 }; + +static void fail(const char* message, Error err) { + printf("** FAILURE: %s (%s) **\n", message, DebugUtils::error_as_string(err)); + exit(1); +} + +int main() { + printf("AsmJit X86 Sections Test\n\n"); + + Environment env = Environment::host(); + JitAllocator allocator; + +#ifndef ASMJIT_NO_LOGGING + FileLogger logger(stdout); + logger.set_indentation(FormatIndentationGroup::kCode, 2); +#endif + + CodeHolder code; + code.init(env); + +#ifndef ASMJIT_NO_LOGGING + code.set_logger(&logger); +#endif + + Section* data_section; + Error err = code.new_section(Out(data_section), ".data", SIZE_MAX, SectionFlags::kNone, 8); + + if (err != Error::kOk) { + fail("Failed to create a .data section", err); + } + else { + printf("Generating code:\n"); + x86::Assembler a(&code); + x86::Gp idx = a.zax(); + x86::Gp addr = a.zcx(); + + Label data = a.new_label(); + + FuncDetail func; + func.init(FuncSignature::build<size_t, size_t>(), code.environment()); + + FuncFrame frame; + frame.init(func); + frame.add_dirty_regs(idx, addr); + + FuncArgsAssignment args(&func); + args.assign_all(idx); + args.update_func_frame(frame); + frame.finalize(); + + a.emit_prolog(frame); + a.emit_args_assignment(frame, args); + + a.lea(addr, x86::ptr(data)); + a.movzx(idx, x86::byte_ptr(addr, idx)); + + a.emit_epilog(frame); + + a.section(data_section); + a.bind(data); + + a.embed(data_array, sizeof(data_array)); + } + + // Manually change he offsets of each section, start at 0. This code is very similar to + // what `CodeHolder::flatten()` does, however, it's shown here how to do it explicitly. + printf("\nCalculating section offsets:\n"); + uint64_t offset = 0; + for (Section* section : code.sections_by_order()) { + offset = Support::align_up(offset, section->alignment()); + section->set_offset(offset); + offset += section->real_size(); + + printf(" [0x%08X %s] {Id=%u Size=%u}\n", + uint32_t(section->offset()), + section->name(), + section->section_id(), + uint32_t(section->real_size())); + } + size_t code_size = size_t(offset); + printf(" Final code size: %zu\n", code_size); + + // Resolve cross-section fixups (if any). On 32-bit X86 this is not necessary + // as this is handled through relocations as the addressing is different. + if (code.has_unresolved_fixups()) { + printf("\nResolving cross-section fixups:\n"); + printf(" Before 'resolve_cross_section_fixups()': %zu\n", code.unresolved_fixup_count()); + + err = code.resolve_cross_section_fixups(); + if (err != Error::kOk) { + fail("Failed to resolve cross-section fixups", err); + } + printf(" After 'resolve_cross_section_fixups()': %zu\n", code.unresolved_fixup_count()); + } + + // Allocate memory for the function and relocate it there. + JitAllocator::Span span; + err = allocator.alloc(Out(span), code_size); + if (err != Error::kOk) + fail("Failed to allocate executable memory", err); + + // Relocate to the base-address of the allocated memory. + code.relocate_to_base(uint64_t(uintptr_t(span.rx()))); + + allocator.write(span, [&](JitAllocator::Span& span) noexcept -> Error { + // Copy the flattened code into `mem.rw`. There are two ways. You can either copy + // everything manually by iterating over all sections or use `copy_flattened_data`. + // This code is similar to what `copy_flattened_data(p, code_size, 0)` would do: + for (Section* section : code.sections_by_order()) + memcpy(static_cast<uint8_t*>(span.rw()) + size_t(section->offset()), section->data(), section->buffer_size()); + return Error::kOk; + }); + + // Execute the function and test whether it works. + using Func = size_t (*)(size_t idx); + Func fn = (Func)span.rx(); + + printf("\n"); + if (fn(0) != data_array[0] || + fn(3) != data_array[3] || + fn(6) != data_array[6] || + fn(9) != data_array[9] ) { + printf("** FAILURE: The generated function returned incorrect result(s) **\n"); + return 1; + } + + printf("** SUCCESS **\n"); + return 0; +} + +#else +int main() { + printf("!! This test is disabled: ASMJIT_NO_JIT or unsuitable target architecture !!\n\n"); + return 0; +} +#endif // ASMJIT_ARCH_X86 && !ASMJIT_NO_X86 && !ASMJIT_NO_JIT |
