kit

reloc_apply.c (9082B)

---

 /* Arch-neutral relocation byte application (the obj-core half).
  *
  * reloc_apply_neutral() patches the kinds whose byte encoding is a plain
  * little-endian data word — absolute / pc-relative writes, the x86-64 GOT/PLT/
  * dynamic data slots, the RISC-V data ADD/SUB/SET arithmetic, and the ULEB128
  * codec — i.e. everything that carries NO instruction-field knowledge.  It is
  * pure obj-core: no link or arch dependency, so it stays usable by every
  * loader (static linker, JIT linker, assembler, emulator) without pulling in
  * the link layer.
  *
  * The instruction-immediate encoders (AArch64 imm19/imm26/ADRP page math;
  * RISC-V U/I/S/B/J + RVC scatter and the 0x800 HI20 bias; x86-64 rel8) live in
  * each backend's src/arch/<arch>/reloc.c and are reached through
  * LinkArchDesc.reloc_apply_insn.  The single public byte-patcher entry,
  * link_reloc_apply(), dispatches neutral-then-arch from src/link/
  * link_reloc_apply.c — housed in the link layer because resolving the per-arch
  * slice needs link_arch_desc_for() (same boundary call as WS-B's reloc_desc()).
  * See doc/plan/RELOC.md (WS-C). */
 
 #include "obj/reloc_apply.h"
 
 #include <string.h>
 
 #include "core/bytes.h"
 
 /* ---- ULEB128 codec for R_RISCV_{SET,SUB}_ULEB128 ----
  *
  * These RISC-V relocs patch a variable-length ULEB128 field in place
  * (DWARF .debug_rnglists / .debug_loclists / .debug_line encode
  * symbol differences this way). The crux: ULEB128 is variable-length,
  * but rewriting it must NOT shift the section layout, so we re-encode
  * the new value into the SAME number of bytes the assembler reserved
  * at the site. ULEB128 permits "redundant" encodings: extra low-order
  * groups of zero with the continuation bit set, terminated by a final
  * group whose continuation bit is clear (RISC-V psABI / DWARF v5
  * §7.6). We exploit that to pad to a fixed width.
  *
  * RELOC_ULEB128_MAX_BYTES bounds a 64-bit value: ceil(64/7) = 10. */
 #define RELOC_ULEB128_MAX_BYTES 10u
 #define RELOC_ULEB128_CONT 0x80u /* continuation bit */
 #define RELOC_ULEB128_MASK 0x7fu /* 7 payload bits per byte */
 
 /* Length of the ULEB128 field encoded at p: count bytes up to and
  * including the first whose continuation bit is clear. */
 static u32 reloc_uleb128_len(const u8* p) {
   u32 n = 0;
   for (;;) {
     u8 byte = p[n++];
     if (!(byte & RELOC_ULEB128_CONT)) break;
     if (n >= RELOC_ULEB128_MAX_BYTES) break;
   }
   return n;
 }
 
 /* Decode the ULEB128 value encoded at p (assumes a well-formed field
  * of at most RELOC_ULEB128_MAX_BYTES). */
 static u64 reloc_uleb128_read(const u8* p) {
   u64 v = 0;
   u32 shift = 0;
   u32 n = 0;
   for (;;) {
     u8 byte = p[n++];
     if (shift < 64) v |= (u64)(byte & RELOC_ULEB128_MASK) << shift;
     shift += 7;
     if (!(byte & RELOC_ULEB128_CONT)) break;
     if (n >= RELOC_ULEB128_MAX_BYTES) break;
   }
   return v;
 }
 
 /* Re-encode v as a ULEB128 occupying exactly `width` bytes, padding
  * with redundant continuation groups so the in-place field size is
  * preserved. The final byte's continuation bit is clear; every prior
  * byte's is set, carrying the next 7 value bits (or zero once v is
  * exhausted). */
 static void reloc_uleb128_write_fixed(u8* p, u64 v, u32 width) {
   u32 i;
   for (i = 0; i < width; ++i) {
     u8 byte = (u8)(v & RELOC_ULEB128_MASK);
     v >>= 7;
     if (i + 1u < width) byte |= RELOC_ULEB128_CONT;
     p[i] = byte;
   }
 }
 
 int reloc_apply_neutral(Compiler* c, RelocKind k, u8* P_bytes, u64 S, i64 A,
                         u64 P) {
   switch (k) {
     case R_ABS32:
     case R_X64_32S:
     case R_X64_TPOFF32: {
       /* All three write a 32-bit value at the site.  ABS32 / _32S
        * take an absolute (unsigned / sign-extended) symbol address;
        * TPOFF32 takes the (caller-precomputed) TP-relative offset.
        * At the byte level the encoding is identical. */
       u64 v = S + (u64)A;
       wr_u32_le(P_bytes, (u32)(v & 0xffffffffu));
       return 1;
     }
     case R_ABS64:
     case R_TPOFF64:
     case R_X64_RELATIVE: {
       /* R_X64_RELATIVE: (S + A) — for static-with-relocs paths the
        * linker writes the relocated value directly; the dynamic
        * loader would otherwise do the same fixup at load time. */
       u64 v = S + (u64)A;
       wr_u64_le(P_bytes, v);
       return 1;
     }
     case R_X64_GLOB_DAT:
     case R_X64_JUMP_SLOT: {
       /* Dynamic linker normally applies these; for static-with-relocs
        * paths we write the resolved symbol value (S) into the GOT/PLT
        * slot. Addend is unused per the x86_64 psABI. */
       wr_u64_le(P_bytes, S);
       return 1;
     }
     case R_X64_COPY:
       compiler_panic(c, SRCLOC_NONE,
                      "link: R_X64_COPY belongs in dynamic loader, "
                      "not static link");
       return 1;
     case R_REL32:
     case R_PC32:
     case R_X64_PLT32:
     case R_X64_GOTPCREL:
     case R_X64_GOTPCRELX:
     case R_X64_REX_GOTPCRELX:
     case R_X64_GOTPC32:
     case R_X64_GOTTPOFF: {
       /* GOTTPOFF (TLS Initial-Exec) is a RIP-relative load of a GOT slot
        * that the linker fills with the symbol's TP-relative offset; the
        * fixup is identical to GOTPCREL once the target has been redirected
        * to that slot (see link_layout_got). */
       /* AArch64 ELF: PREL32 maps to either of these; both encode a
        * 32-bit signed PC-relative displacement. The kit-canonical
        * distinction (section-relative vs PC-relative) collapses on
        * AArch64 because the linker resolves to absolute vaddrs.
        *
        * x86_64 PLT32: in a static link there is no PLT, so the
        * displacement collapses to a plain 32-bit PC-relative call. */
       i64 v = (i64)S + A - (i64)P;
       wr_u32_le(P_bytes, (u32)((u64)v & 0xffffffffu));
       return 1;
     }
     case R_REL64:
     case R_PC64: {
       /* 64-bit PC-relative; AArch64 R_AARCH64_PREL64. Used by
        * `.quad sym1 - sym2` style symbol-difference encodings (e.g.
        * the arm64 kernel image_size header field). */
       i64 v = (i64)S + A - (i64)P;
       wr_u64_le(P_bytes, (u64)v);
       return 1;
     }
     case R_ABS8:
       P_bytes[0] = (u8)((S + (u64)A) & 0xffu);
       return 1;
     case R_ABS16: {
       u64 v = S + (u64)A;
       wr_u16_le(P_bytes, (u16)(v & 0xffffu));
       return 1;
     }
     case R_PREL16: {
       i64 v = (i64)S + A - (i64)P;
       wr_u16_le(P_bytes, (u16)((u64)v & 0xffffu));
       return 1;
     }
     case R_ADD8: {
       /* word8 += S + A. Used (paired with a SUB8 against another sym
        * at the same site) to encode symbol differences. */
       u8 cur = P_bytes[0];
       P_bytes[0] = (u8)(cur + (u8)((S + (u64)A) & 0xffu));
       return 1;
     }
     case R_SUB8: {
       u8 cur = P_bytes[0];
       P_bytes[0] = (u8)(cur - (u8)((S + (u64)A) & 0xffu));
       return 1;
     }
     case R_ADD16: {
       u16 cur = rd_u16_le(P_bytes);
       wr_u16_le(P_bytes, (u16)(cur + (u16)((S + (u64)A) & 0xffffu)));
       return 1;
     }
     case R_SUB16: {
       u16 cur = rd_u16_le(P_bytes);
       wr_u16_le(P_bytes, (u16)(cur - (u16)((S + (u64)A) & 0xffffu)));
       return 1;
     }
     case R_ADD32: {
       u32 cur = rd_u32_le(P_bytes);
       wr_u32_le(P_bytes, (u32)(cur + (u32)((S + (u64)A) & 0xffffffffu)));
       return 1;
     }
     case R_SUB32: {
       u32 cur = rd_u32_le(P_bytes);
       wr_u32_le(P_bytes, (u32)(cur - (u32)((S + (u64)A) & 0xffffffffu)));
       return 1;
     }
     case R_ADD64: {
       u64 cur = rd_u64_le(P_bytes);
       wr_u64_le(P_bytes, cur + S + (u64)A);
       return 1;
     }
     case R_SUB64: {
       u64 cur = rd_u64_le(P_bytes);
       wr_u64_le(P_bytes, cur - S - (u64)A);
       return 1;
     }
     case R_SUB6: {
       /* Bottom 6 bits of byte = (byte - (S + A)) & 0x3f. */
       u8 cur = P_bytes[0];
       u8 v = (u8)((cur & 0x3fu) - (u8)((S + (u64)A) & 0x3fu));
       P_bytes[0] = (u8)((cur & 0xc0u) | (v & 0x3fu));
       return 1;
     }
     case R_SET6: {
       u8 cur = P_bytes[0];
       P_bytes[0] = (u8)((cur & 0xc0u) | (u8)((S + (u64)A) & 0x3fu));
       return 1;
     }
     case R_SET_ULEB128: {
       /* Variable-length ULEB128 field set to (S + A). These come as a
        * PAIR at the same offset (RISC-V psABI): SET_ULEB128 sets the
        * field, a following SUB_ULEB128 then subtracts the second
        * symbol — net encoding (sym_hi - sym_lo) for DWARF symbol
        * differences. Re-encode into the original field width so the
        * section layout doesn't shift. */
       u32 width = reloc_uleb128_len(P_bytes);
       u64 v = S + (u64)A;
       reloc_uleb128_write_fixed(P_bytes, v, width);
       return 1;
     }
     case R_SUB_ULEB128: {
       /* field -= (S + A), preserving the original ULEB128 width. The
        * paired SET_ULEB128 ran first (same offset); we read back the
        * value it wrote and subtract this symbol's resolved address. */
       u32 width = reloc_uleb128_len(P_bytes);
       u64 cur = reloc_uleb128_read(P_bytes);
       u64 v = cur - (S + (u64)A);
       reloc_uleb128_write_fixed(P_bytes, v, width);
       return 1;
     }
     default:
       return 0; /* not an arch-neutral kind — caller tries the arch hook */
   }
 }