lk

Author: litecreator

README.md

@@ -83,9 +83,10 @@
     - `R_AARCH64_LD_PREL_LO19`, `R_AARCH64_ADR_PREL_LO21`, `R_AARCH64_ADR_PREL_PG_HI21`, `R_AARCH64_ADR_PREL_PG_HI21_NC`
     - `R_AARCH64_ADD_ABS_LO12_NC`, `R_AARCH64_LDST8/16/32/64/128_ABS_LO12_NC`
     - MOVW families: `R_AARCH64_MOVW_UABS_*`, `R_AARCH64_MOVW_SABS_*`, `R_AARCH64_MOVW_PREL_*`
-  - AArch64 TLS starter coverage:
-    - `TLSGD` / `TLSLD` / `TLSDESC` instruction-form relocations (ADR/ADRP/ADD/LD literal/LD lo12/CALL subset)
-    - `R_AARCH64_TLS_DTPMOD`, `R_AARCH64_TLS_DTPREL`, `R_AARCH64_TLS_TPREL`
+  - AArch64 TLS relocation coverage (parse/validate surface):
+    - `TLSGD` / `TLSLD` / `TLSDESC` instruction-form relocation IDs are recognized by ELF ingest and relocation validation
+    - `R_AARCH64_TLS_DTPMOD`, `R_AARCH64_TLS_DTPREL`, `R_AARCH64_TLS_TPREL` are recognized as AArch64 TLS data relocation IDs
+    - relocation application currently returns `ERR_NOT_IMPLEMENTED_YET` for AArch64 TLS-family relocations pending TLS layout/module metadata in the host linker runtime ABI
 
 ## CLI Compatibility Surface
 
@@ -142,7 +143,10 @@ These compatibility no-op paths now emit diagnostics, and become hard failures w
 - `--hash-style` now affects ELF dynamic-tag emission (`DT_HASH` / `DT_GNU_HASH`) in Dust runtime host writer output.
 - `--print-gc-sections` now prints section-drop diagnostics during GC-aware alloc-section selection.
 - Unsupported flag/target failures now emit explicit diagnostics instead of returning only status codes.
-- AArch64 ELF relocation coverage now includes instruction bitfield patching (`ADR_PREL_LO21`, MOVW families, `LD/ST` lo12 variants, branch/literal forms) and starter TLS relocation plumbing (`TLSGD`/`TLSLD`/`TLSDESC`, `TLS_DTPMOD`/`TLS_DTPREL`/`TLS_TPREL`).
+- AArch64 ELF relocation coverage now includes instruction bitfield patching (`ADR_PREL_LO21`, MOVW families, `LD/ST` lo12 variants, branch/literal forms) and stricter TLS-family handling:
+  - `TLSDESC_CALL` now validates `BLR` instruction encoding instead of acting as a generic no-op
+  - AArch64 TLS-family relocation application now fails with `ERR_NOT_IMPLEMENTED_YET` instead of silently patching placeholder values
+- Shared-library ingest now propagates shared-object ingest failures directly (no Dust-side `ERR_NOT_IMPLEMENTED_YET` swallow path).
 
 ## Build
 

changelog.md

@@ -57,11 +57,12 @@
 - AArch64 ELF relocation parity expansions in Dust linker modules:
   - instruction-form bitfield patching for `CALL26`, `JUMP26`, `CONDBR19`, `TSTBR14`, `LD_PREL_LO19`, `ADR_PREL_LO21`, `ADR_PREL_PG_HI21(_NC)`, `ADD_ABS_LO12_NC`, and `LDST*_ABS_LO12_NC` (including `LDST128`)
   - MOVW relocation families (`UABS`, `SABS`, `PREL`)
-  - starter TLS relocation families (`TLSGD`, `TLSLD`, `TLSDESC` instruction forms) and AArch64 TLS data relocs (`TLS_DTPMOD`, `TLS_DTPREL`, `TLS_TPREL`)
+  - AArch64 TLS relocation ID recognition/validation for starter TLS families (`TLSGD`, `TLSLD`, `TLSDESC` instruction forms) and AArch64 TLS data relocs (`TLS_DTPMOD`, `TLS_DTPREL`, `TLS_TPREL`)
 - Additional Dust relocation/math tests for AArch64:
   - `ADR_PREL_LO21` patching
   - MOVW patching and overflow validation
   - AArch64 TLS data relocation value validation
+  - `TLSDESC_CALL` instruction-shape validation (`BLR` accepted, non-`BLR` rejected)
 
 ### Changed
 
@@ -83,13 +84,16 @@
 - `--print-gc-sections` now emits drop diagnostics during GC-based section pruning.
 - COFF and Mach-O object ingest relocation mapping is now machine-aware/refined instead of coarse fallback-only classification.
 - ELF relocation ingest validation and linker relocation pipeline now accept/process a broader AArch64 relocation surface (including MOVW and TLS starter forms) instead of rejecting them as unsupported.
+- Shared-library ingest in `linker_archive.ds` now propagates shared-object ingest errors directly instead of swallowing `ERR_NOT_IMPLEMENTED_YET`.
 
 ### Fixed
 
 - Unsupported flag/target failures now print explicit diagnostics instead of returning a status code with no CLI context.
 - Linker script parser no longer silently accepts unknown directive heads.
 - Linker script `OUTPUT_FORMAT`, `TARGET`, and `OUTPUT_ARCH` invalid values now fail with explicit invalid/unsupported statuses instead of silently succeeding.
 - AArch64 64-bit TLS data relocations no longer fall through 32-bit relocation validation constraints in the Dust relocation validator.
+- AArch64 TLS-family relocation application no longer silently patches placeholder values; it now returns `ERR_NOT_IMPLEMENTED_YET` until TLS layout/module metadata is exposed to the Dust relocation pipeline.
+- `R_AARCH64_TLSDESC_CALL` patch helper no longer accepts arbitrary non-zero instructions; it now validates `BLR`-class encoding.
 
 ## 2026-02-21
 

docs/README.md

@@ -61,6 +61,8 @@ This directory contains complete Markdown documentation for `dustlink`.
 - Compatibility no-op families now emit diagnostics and can hard-fail under `--fatal-warnings` / `/WX`.
 - `--dependency-file` and `--emit-relocs` are state-wired (depfile output + relocation map-row reporting).
 - ELF writer now consumes `--hash-style` state for dynamic hash-tag emission and host runtime consumes `--print-gc-sections` for GC drop diagnostics.
-- AArch64 ELF relocation coverage now includes instruction bitfield patching (branches/literals/ADR/ADRP/ADD/LDST, including `LDST128`), MOVW relocation families, and starter TLS relocation plumbing (`TLSGD`/`TLSLD`/`TLSDESC`, `TLS_DTPMOD`/`TLS_DTPREL`/`TLS_TPREL`).
+- AArch64 ELF relocation coverage now includes instruction bitfield patching (branches/literals/ADR/ADRP/ADD/LDST, including `LDST128`) and MOVW relocation families.
+- AArch64 TLS-family relocation IDs (`TLSGD`/`TLSLD`/`TLSDESC`, `TLS_DTPMOD`/`TLS_DTPREL`/`TLS_TPREL`) are recognized/validated, but relocation application is currently strict `ERR_NOT_IMPLEMENTED_YET` pending TLS layout/module metadata in the host linker runtime ABI.
+- Shared-library ingest now propagates shared-object ingest failures directly (no Dust-side `ERR_NOT_IMPLEMENTED_YET` swallow).
 - `lld-link` spellings: `/OUT`, `/ENTRY`, `/MACHINE`, `/LIBPATH`, `/DEFAULTLIB`, `/MAP`, `/DLL`, `/SUBSYSTEM`, `/OPT`, `/WX`, `/NOENTRY`, `/DYNAMICBASE`, `/NXCOMPAT`, `/LARGEADDRESSAWARE`.
 - soft-compatibility flag-family acceptance for broader ld/lld/lld-link compatibility while preserving deterministic internal link behavior.

docs/linker_reloc.md

@@ -27,7 +27,7 @@ Source: `src/linker_reloc.ds`
   - branch/literal/ADR forms: `R_AARCH64_CALL26`, `R_AARCH64_JUMP26`, `R_AARCH64_CONDBR19`, `R_AARCH64_TSTBR14`, `R_AARCH64_LD_PREL_LO19`, `R_AARCH64_ADR_PREL_LO21`, `R_AARCH64_ADR_PREL_PG_HI21`, `R_AARCH64_ADR_PREL_PG_HI21_NC`
   - lo12 forms: `R_AARCH64_ADD_ABS_LO12_NC`, `R_AARCH64_LDST8/16/32/64/128_ABS_LO12_NC`
   - MOVW families: `R_AARCH64_MOVW_UABS_*`, `R_AARCH64_MOVW_SABS_*`, `R_AARCH64_MOVW_PREL_*`
-  - starter TLS forms: `TLSGD`, `TLSLD`, `TLSDESC` instruction relocations plus `R_AARCH64_TLS_DTPMOD`, `R_AARCH64_TLS_DTPREL`, `R_AARCH64_TLS_TPREL`
+  - TLS families: `TLSGD`, `TLSLD`, `TLSDESC` instruction relocations plus `R_AARCH64_TLS_DTPMOD`, `R_AARCH64_TLS_DTPREL`, `R_AARCH64_TLS_TPREL`
 
 ## `K` Domain Procedures
 
@@ -45,7 +45,9 @@ Source: `src/linker_reloc.ds`
 - `resolve_reloc_address(reloc, sym_addr, base_addr) -> UInt64`
 
 `K` domain validates relocation records, computes relocation values, and applies patch operations through host runtime patch intrinsics (`host_linker_patch_u32`/`host_linker_patch_u64`).
-Current AArch64 support includes instruction bitfield patching for branch/literal/ADR/ADRP/ADD/LDST relocations, MOVW family relocations, and starter TLS relocation plumbing.
+Current AArch64 support includes instruction bitfield patching for branch/literal/ADR/ADRP/ADD/LDST relocations and MOVW family relocations.
+AArch64 TLS-family relocations are recognized/validated in this module, but application currently returns `ERR_NOT_IMPLEMENTED_YET` until TLS layout/module metadata is exposed by the host linker runtime ABI.
+`R_AARCH64_TLSDESC_CALL` helper now validates `BLR` instruction encoding before preserving the instruction word.
 
 ## `Q` and `Phi`
 

docs/testing.md

@@ -47,6 +47,7 @@ Both files define forge-based test procedures with this pattern:
   - `LDST128` scaling/alignment behavior
   - `ADR_PREL_LO21` and MOVW patch/validation paths
   - starter AArch64 TLS data relocation value validation (`TLS_DTPMOD`, `TLS_TPREL`)
+  - `TLSDESC_CALL` instruction-shape validation (`BLR` accepted, `BR` rejected)
 
 ## Recent Integration Checks
 
@@ -72,6 +73,7 @@ Both files define forge-based test procedures with this pattern:
 - Linker core tests include AArch64 target acceptance in internal target validation.
 - `dust check src` passes for current Dust-source linker modules (host CLI + runtime parity changes).
 - `dust check src` passes after AArch64 relocation parity expansions (MOVW, `ADR_PREL_LO21`, and starter TLS relocation plumbing).
+- `dust check src` passes after stricter AArch64 TLS-family relocation handling (explicit `ERR_NOT_IMPLEMENTED_YET` apply path until TLS metadata support) and shared-ingest error propagation tightening.
 
 ## Current Limitations
 

src/linker_archive.ds

@@ -5,7 +5,6 @@ forge LinkerArchive {
     const ERR_FILE_NOT_FOUND: UInt32 = 1;
     const ERR_INVALID_FORMAT: UInt32 = 2;
     const ERR_CONFLICTING_OPTIONS: UInt32 = 16;
-    const ERR_NOT_IMPLEMENTED_YET: UInt32 = 17;
 
     const TARGET_NONE: UInt32 = 0;
     const TARGET_X86_64_LINUX: UInt32 = 1;
@@ -684,9 +683,7 @@ forge LinkerArchive {
             let unresolved_before = host_linker_unresolved_symbol_count();
             let shared_status = host_linker_ingest_shared_object(path);
             if shared_status ! ERR_OK {
-                if shared_status ! ERR_NOT_IMPLEMENTED_YET {
-                    return shared_status;
-                }
+                return shared_status;
             }
             let unresolved_after = host_linker_unresolved_symbol_count();
             let contributed = shared_contribution(unresolved_before, unresolved_after);

src/linker_math_tests.ds

@@ -25,6 +25,7 @@ forge LinkerMathTests {
     const R_AARCH64_LDST32_ABS_LO12_NC: UInt32 = 285;
     const R_AARCH64_LDST64_ABS_LO12_NC: UInt32 = 286;
     const R_AARCH64_LDST128_ABS_LO12_NC: UInt32 = 299;
+    const R_AARCH64_TLSDESC_CALL: UInt32 = 569;
     const R_AARCH64_TLS_DTPMOD: UInt32 = 1028;
     const R_AARCH64_TLS_TPREL: UInt32 = 1030;
 
@@ -190,6 +191,18 @@ forge LinkerMathTests {
         return expect_u64(patched, 0);
     }
 
+    proc K::test_aarch64_tlsdesc_call_patch_word_accepts_blr() -> UInt32 {
+        let blr_x17 = 3594453536;
+        let patched = LinkerReloc::K::aarch64_tlsdesc_call_patch_word(blr_x17);
+        return expect_u64(patched, blr_x17);
+    }
+
+    proc K::test_aarch64_tlsdesc_call_patch_word_rejects_br() -> UInt32 {
+        let br_x17 = 3592356384;
+        let patched = LinkerReloc::K::aarch64_tlsdesc_call_patch_word(br_x17);
+        return expect_u64(patched, 0);
+    }
+
     proc K::test_aarch64_tls_dtpmod_accepts_64bit_value() -> UInt32 {
         let status = LinkerReloc::K::validate_relocation_value(R_AARCH64_TLS_DTPMOD, EM_AARCH64, 4294967296);
         return expect_u32(status, ERR_OK);
@@ -228,6 +241,8 @@ forge LinkerMathTests {
             + test_aarch64_ldst128_lo12_patch_word_scaled()
             + test_aarch64_ldst_lo12_patch_word_alignment_rejects()
             + test_aarch64_ldst128_lo12_patch_word_alignment_rejects()
+            + test_aarch64_tlsdesc_call_patch_word_accepts_blr()
+            + test_aarch64_tlsdesc_call_patch_word_rejects_br()
             + test_aarch64_tls_dtpmod_accepts_64bit_value()
             + test_aarch64_tls_tprel_accepts_64bit_value();
         return passed;

src/linker_reloc.ds

@@ -87,6 +87,7 @@ forge LinkerReloc {
     const ERR_INVALID_SECTION: UInt32 = 3;
     const ERR_UNDEFINED_SYMBOL: UInt32 = 4;
     const ERR_INVALID_RELOCATION: UInt32 = 6;
+    const ERR_NOT_IMPLEMENTED_YET: UInt32 = 17;
 
     proc K::is_supported_reloc_x86_64(reloc_type: UInt32) -> UInt32 {
         if reloc_type == R_X86_64_NONE { return 1; }
@@ -464,6 +465,36 @@ forge LinkerReloc {
         return 0;
     }
 
+    proc K::aarch64_is_tls_family_reloc(reloc_type: UInt32) -> UInt32 {
+        if reloc_type == R_AARCH64_TLSGD_ADR_PREL21 { return 1; }
+        if reloc_type == R_AARCH64_TLSGD_ADR_PAGE21 { return 1; }
+        if reloc_type == R_AARCH64_TLSGD_ADD_LO12_NC { return 1; }
+        if reloc_type == R_AARCH64_TLSGD_MOVW_G1 { return 1; }
+        if reloc_type == R_AARCH64_TLSGD_MOVW_G0_NC { return 1; }
+        if reloc_type == R_AARCH64_TLSLD_ADR_PREL21 { return 1; }
+        if reloc_type == R_AARCH64_TLSLD_ADR_PAGE21 { return 1; }
+        if reloc_type == R_AARCH64_TLSLD_ADD_LO12_NC { return 1; }
+        if reloc_type == R_AARCH64_TLSLD_MOVW_G1 { return 1; }
+        if reloc_type == R_AARCH64_TLSLD_MOVW_G0_NC { return 1; }
+        if reloc_type == R_AARCH64_TLSLD_LD_PREL19 { return 1; }
+        if reloc_type == R_AARCH64_TLSLD_ADD_DTPREL_LO12_NC { return 1; }
+        if reloc_type == R_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC { return 1; }
+        if reloc_type == R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC { return 1; }
+        if reloc_type == R_AARCH64_TLSLE_ADD_TPREL_LO12_NC { return 1; }
+        if reloc_type == R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC { return 1; }
+        if reloc_type == R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC { return 1; }
+        if reloc_type == R_AARCH64_TLSDESC_LD_PREL19 { return 1; }
+        if reloc_type == R_AARCH64_TLSDESC_ADR_PREL21 { return 1; }
+        if reloc_type == R_AARCH64_TLSDESC_ADR_PAGE21 { return 1; }
+        if reloc_type == R_AARCH64_TLSDESC_LD64_LO12 { return 1; }
+        if reloc_type == R_AARCH64_TLSDESC_ADD_LO12 { return 1; }
+        if reloc_type == R_AARCH64_TLSDESC_CALL { return 1; }
+        if reloc_type == R_AARCH64_TLS_DTPMOD { return 1; }
+        if reloc_type == R_AARCH64_TLS_DTPREL { return 1; }
+        if reloc_type == R_AARCH64_TLS_TPREL { return 1; }
+        return 0;
+    }
+
     proc K::aarch64_page_delta_bytes(symbol_plus_addend: UInt64, place_addr: UInt64) -> UInt64 {
         let page_mask = 0 - 4096;
         let sym_page = symbol_plus_addend & page_mask;
@@ -677,10 +708,16 @@ forge LinkerReloc {
     }
 
     proc K::aarch64_tlsdesc_call_patch_word(instr: UInt64) -> UInt64 {
+        let blr_mask = 4294966303;
+        let blr_opcode = 3594452992;
         if instr == 0 {
             return 0;
         } else {
-            return instr;
+            if (instr & blr_mask) ! blr_opcode {
+                return 0;
+            } else {
+                return instr;
+            }
         }
     }
 
@@ -1499,6 +1536,13 @@ forge LinkerReloc {
         } else {
             let symbol_defined = host_linker_object_symbol_defined(object_index, sym_index);
             let symbol_addr = host_linker_resolved_symbol_address(object_index, sym_index);
+            if machine == EM_AARCH64 {
+                if aarch64_is_tls_family_reloc(reloc_type) == 1 {
+                    // AArch64 TLS relocations require TLS block/layout/module metadata not yet surfaced
+                    // through the current Dust host linker runtime ABI.
+                    return ERR_NOT_IMPLEMENTED_YET;
+                }
+            }
             if symbol_defined == 0 {
                 if symbol_addr == 0 {
                     if is_dynamic_placeholder_reloc(reloc_type, machine) == 1 {