[abi] AsmJit v1.17 - cumulative & breaking changes

* Reworked register operands - all vector registers are now
    platform::Vec deriving from UniVec (universal vector operand),
    additionally, there is no platform::Reg, instead asmjit::Reg
    provides all necessary features to make it a base register for
    each target architecture
  * Reworked casting between registers - now architecture agnostic
    names are preferred - use Gp32 instead of Gpd or GpW, Gp64
    instead of Gpq and GpX, etc...
  * Reworked vector registers and their names - architecture
    agnostic naming is now preferred Vec32, Vec64, Vec128, etc...
  * Reworked naming conventions used across AsmJit - for clarity
    Identifiers are now prefixed with the type, like sectionId(),
    labelId(), etc...
  * Reworked how Zone and ZoneAllocator are used across AsmJit,
    prefering Zone in most cases and ZoneAllocator only for
    containers - this change alone achieves around 5% better
    performance of Builder and Compiler
  * Reworked LabelEntry - decreased the size of the base entry
    to 16 bytes for anonymous and unnamed labels. Avoided an
    indirection when using labelEntries() - LabelEntry is now
    a value and not a pointer
  * Renamed LabelLink to Fixup
  * Added a new header <asmjit/host.h> which would include
    <asmjit/core.h> + target tools for the host architecture,
    if enabled and supported
  * Added new AArch64 instructions (BTI, CSSC, CHKFEAT)
  * Added a mvn_ alternative of mvn instruction (fix for Windows
    ARM64 SDK)
  * Added more AArch64 CPU features to CpuInfo
  * Added better support for Apple CPU detection (Apple M3, M4)
  * Added a new benchmarking tool asmjit_bench_overhead, which
    benchmarks the overhead of CodeHolder::init()/reset() and
    creating/attaching emitters to it. Thanks to the benchmark the
    most common code-paths were optimized
  * Added a new benchmarking tool asmjit_bench_regalloc, which
    aims to benchmark the cost and complexity of register allocation.
  * Renamed asmjit_test_perf to asmjit_bench_codegen to make it
    clear what is a test and what is a benchmark

test/asmjit_test_x86_sections.cpp

@@ -1,6 +1,6 @@
 // This file is part of AsmJit project <https://asmjit.com>
 //
-// See asmjit.h or LICENSE.md for license and copyright information
+// See <asmjit/core.h> or LICENSE.md for license and copyright information
 // SPDX-License-Identifier: Zlib
 
 // ----------------------------------------------------------------------------
@@ -10,8 +10,8 @@
 // important to handle the following cases:
 //
 //   - Assign offsets to sections when the code generation is finished.
-//   - Tell the CodeHolder to resolve unresolved links and check whether
-//     all links were resolved.
+//   - Tell the CodeHolder to resolve unresolved fixups and check whether
+//     all fixups were resolved.
 //   - Relocate the code
 //   - Copy the code to the destination address.
 // ----------------------------------------------------------------------------
@@ -95,9 +95,8 @@ int main() {
     a.embed(dataArray, sizeof(dataArray));
   }
 
-  // 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.
+  // 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.sectionsByOrder()) {
@@ -108,22 +107,23 @@ int main() {
     printf("  [0x%08X %s] {Id=%u Size=%u}\n",
            uint32_t(section->offset()),
            section->name(),
-           section->id(),
+           section->sectionId(),
            uint32_t(section->realSize()));
   }
   size_t codeSize = size_t(offset);
   printf("  Final code size: %zu\n", codeSize);
 
-  // Resolve cross-section links (if any). On 32-bit X86 this is not necessary
+  // 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.hasUnresolvedLinks()) {
-    printf("\nResolving cross-section links:\n");
-    printf("  Before 'resolveUnresolvedLinks()': %zu\n", code.unresolvedLinkCount());
+  if (code.hasUnresolvedFixups()) {
+    printf("\nResolving cross-section fixups:\n");
+    printf("  Before 'resolveCrossSectionFixups()': %zu\n", code.unresolvedFixupCount());
 
-    err = code.resolveUnresolvedLinks();
-    if (err)
-      fail("Failed to resolve cross-section links", err);
-    printf("  After 'resolveUnresolvedLinks()': %zu\n", code.unresolvedLinkCount());
+    err = code.resolveCrossSectionFixups();
+    if (err) {
+      fail("Failed to resolve cross-section fixups", err);
+    }
+    printf("  After 'resolveCrossSectionFixups()': %zu\n", code.unresolvedFixupCount());
   }
 
   // Allocate memory for the function and relocate it there.
@@ -163,7 +163,7 @@ int main() {
 
 #else
 int main() {
-  printf("AsmJit X86 Sections Test is disabled on non-x86 host or when compiled with ASMJIT_NO_JIT\n\n");
+  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