odin-blend2d

asmjit_test_x86_sections.cpp (5623B)

---

 // 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