// --------------------------------------------------------------------------
  // [Relocations]
  // --------------------------------------------------------------------------

  //! Create a new relocation entry of type `type` and size `size`.
  //!
  //! Additional fields can be set after the relocation entry was created.
  ASMJIT_API Error newRelocEntry(RelocEntry** dst, uint32_t type, uint32_t size) noexcept;

  //! Get if the code contains relocations.
  ASMJIT_INLINE bool hasRelocations() const noexcept { return !_relocations.isEmpty(); }
  //! Get array of `RelocEntry*` records.
  ASMJIT_INLINE const ZoneVector<RelocEntry*>& getRelocEntries() const noexcept { return _relocations; }

  ASMJIT_INLINE RelocEntry* getRelocEntry(uint32_t id) const noexcept { return _relocations[id]; }

  //! Relocate the code to `baseAddress` and copy it to `dst`.
  //!
  //! \param dst Contains the location where the relocated code should be
  //! copied. The pointer can be address returned by virtual memory allocator
  //! or any other address that has sufficient space.
  //!
  //! \param baseAddress Base address used for relocation. `JitRuntime` always
  //! sets the `baseAddress` to be the same as `dst`.
  //!
  //! \return The number bytes actually used. If the code emitter reserved
  //! space for possible trampolines, but didn't use it, the number of bytes
  //! used can actually be less than the expected worst case. Virtual memory
  //! allocator can shrink the memory it allocated initially.
  //!
  //! A given buffer will be overwritten, to get the number of bytes required,
  //! use `getCodeSize()`.
  ASMJIT_API size_t relocate(void* dst, uint64_t baseAddress = Globals::kNoBaseAddress) const noexcept;

 using namespace asmjit::x86;            // Easier access to x86/x64 registers.

    CodeHolder code;                        // Create a CodeHolder.
    code.init(CodeInfo(ArchInfo::kTypeX86));// Initialize it for a 32-bit X86 target.

                                            // Generate a 32-bit function that sums 4 floats and looks like:
                                            //   void func(float* dst, const float* a, const float* b)
    X86Assembler a(&code);                  // Create and attach X86Assembler to `code`.

    a.mov(eax, dword_ptr(esp, 4));          // Load the destination pointer.
    a.mov(ecx, dword_ptr(esp, 8));          // Load the first source pointer.
    a.mov(edx, dword_ptr(esp, 12));         // Load the second source pointer.

    a.movups(xmm0, ptr(ecx));               // Load 4 floats from [ecx] to XMM0.
    a.movups(xmm1, ptr(edx));               // Load 4 floats from [edx] to XMM1.
    a.addps(xmm0, xmm1);                    // Add 4 floats in XMM1 to XMM0.
    a.movups(ptr(eax), xmm0);               // Store the result to [eax].
    unsigned long addr = 0x401000;
    
    a.jmp(addr);
    a.ret();                                // Return from function.

                                            // Now we have two options if we want to do something with the code hold
                                            // by CodeHolder. In order to use it we must first sync X86Assembler with
                                            // the CodeHolder as it doesn't do it for every instruction it generates for
                                            // performance reasons. The options are:
                                            //
                                            //   1. Detach X86Assembler from CodeHolder (will automatically sync).
                                            //   2. Sync explicitly, allows to use X86Assembler again if needed.
                                            //
                                            // NOTE: AsmJit always syncs internally when CodeHolder needs to access these
                                            // buffers and knows that there is an Assembler attached, so you have to sync
                                            // explicitly only if you bypass CodeHolder and intend to do something on your
                                            // own.
    code.sync();                            // So let's sync, it's easy.

                                            // We have no Runtime this time, it's on us what we do with the code.
                                            // CodeHolder stores code in SectionEntry, which embeds CodeSection
                                            // and CodeBuffer structures. We are interested in section's CodeBuffer only.
                                            //
                                            // NOTE: The first section is always '.text', so it's safe to just use 0 index.
    CodeBuffer& buf = code.getSectionEntry(0)->getBuffer();

    // Print the machine-code generated or do something more interesting with it?
    for (size_t i = 0; i < buf._length; i++)
        printf("%02X", buf.getData()[i]);