misc: Implement two-pass linking to separate rodata sections.

This patch changes the build to perform two-pass linking to separate rodata
with relocations (copied to RAM) from rodata with no relocations (pure data)
that can be kept in flash by llext.

For dynamic linking mode:
- First pass: Link with build-dynamic.ld to create temp ELF (unchanged).
- Analyze the elf and extract, sort and write out the sections:
    - .rodata: sections WITH relocations → copied to RAM (LLEXT_MEM_RODATA)
    - .rodata_noreloc: sections WITHOUT relocations → kept in flash (LLEXT_MEM_RODATA_NO_RELOC)
- Second pass: Link with generated rodata_split.ld + build-dynamic.ld.

For static linking mode:
- Generates empty rodata_split.ld (no section separation needed)

Signed-off-by: iabdalkader <i.abdalkader@gmail.com>

Author: iabdalkader

extra/gen_rodata_ld.go

@@ -0,0 +1,146 @@
+package main
+
+import (
+	"debug/elf"
+	"flag"
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+)
+
+func main() {
+	flag.Usage = func() {
+		fmt.Fprintf(os.Stderr, "Usage: %s <input.elf> [output_script.ld] [link_mode]\n\n", os.Args[0])
+		fmt.Fprintf(os.Stderr, "Analyzes an ELF file and generates a linker script fragment that\n")
+		fmt.Fprintf(os.Stderr, "separates .rodata sections into:\n")
+		fmt.Fprintf(os.Stderr, "  .rodata          - sections WITH relocations (copied to RAM)\n")
+		fmt.Fprintf(os.Stderr, "  .rodata.noreloc  - sections WITHOUT relocations (kept in flash)\n")
+		fmt.Fprintf(os.Stderr, "\nIf link_mode is 'static', generates an empty linker script.\n")
+	}
+
+	flag.Parse()
+	if flag.NArg() < 1 {
+		flag.Usage()
+		os.Exit(1)
+	}
+
+	inputFile := flag.Arg(0)
+	outputFile := "rodata_split.ld"
+	if flag.NArg() >= 2 {
+		outputFile = flag.Arg(1)
+	}
+	linkMode := "dynamic"
+	if flag.NArg() >= 3 {
+		linkMode = flag.Arg(2)
+	}
+
+	fmt.Printf("Generate rodata linker script (mode: %s)\n", linkMode)
+
+	// For static linking, generate empty linker script
+	if linkMode == "static" {
+		out, err := os.Create(outputFile)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+			os.Exit(1)
+		}
+		defer out.Close()
+
+		fmt.Fprintf(out, "/* Empty linker script for static linking mode */\n")
+	    fmt.Printf("Generated: %s\n", outputFile)
+		return
+	}
+
+	f, err := elf.Open(inputFile)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		os.Exit(1)
+	}
+	defer f.Close()
+
+	// First pass: find all .rodata sections, indexed by section number
+	type RodataSection struct {
+		Name      string
+		HasRelocs bool
+	}
+
+	rodataSections := make(map[uint32]*RodataSection)
+
+	for i, section := range f.Sections {
+		if strings.HasPrefix(section.Name, ".rodata") {
+			rodataSections[uint32(i)] = &RodataSection{Name: section.Name}
+		}
+	}
+
+	// Second pass: mark which rodata sections have relocations
+	for _, section := range f.Sections {
+		if section.Type == elf.SHT_REL || section.Type == elf.SHT_RELA {
+			if rodata, exists := rodataSections[section.Info]; exists {
+				rodata.HasRelocs = true
+			}
+		}
+	}
+
+	// Separate and sort
+	withRelocs := []string{}
+	withoutRelocs := []string{}
+
+	for _, rodata := range rodataSections {
+		if rodata.HasRelocs {
+			withRelocs = append(withRelocs, rodata.Name)
+		} else {
+			withoutRelocs = append(withoutRelocs, rodata.Name)
+		}
+	}
+
+	sort.Strings(withRelocs)
+	sort.Strings(withoutRelocs)
+
+	// Display
+	fmt.Printf("rodata with relocations\n")
+	for _, name := range withRelocs {
+		fmt.Printf("  -%s\n", name)
+	}
+	fmt.Printf("\nrodata without relocations:\n")
+	for _, name := range withoutRelocs {
+		fmt.Printf("  -%s\n", name)
+	}
+
+	// Generate linker script
+	out, err := os.Create(outputFile)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		os.Exit(1)
+	}
+	defer out.Close()
+
+	// Helper function to print a section
+	printSection := func(out *os.File, sectionName string, sections []string) {
+		fmt.Fprintf(out, "    %s : {\n", sectionName)
+		for _, name := range sections {
+			fmt.Fprintf(out, "        *(%s)\n", name)
+		}
+		fmt.Fprintf(out, "    }\n\n")
+	}
+
+	fmt.Fprintf(out, "/* Auto-generated linker script fragment for LLEXT\n")
+	fmt.Fprintf(out, " * Separates .rodata sections based on relocation status\n")
+	fmt.Fprintf(out, " */\n\n")
+	fmt.Fprintf(out, "SECTIONS\n{\n")
+
+	fmt.Fprintf(out, "    /* Read-only data WITH relocations - will be copied to RAM by LLEXT */\n")
+	printSection(out, ".rodata", withRelocs)
+
+	fmt.Fprintf(out, "    /* Read-only data WITHOUT relocations - kept in flash by LLEXT */\n")
+	printSection(out, ".rodata.noreloc", withoutRelocs)
+
+	fmt.Fprintf(out, "    /* Merge all .rel.rodata.* sections into .rel.rodata */\n")
+	printSection(out, ".rel.rodata", []string{".rel.rodata", ".rel.rodata.*"})
+
+	fmt.Fprintf(out, "    /* Merge all .rela.rodata.* sections into .rela.rodata */\n")
+	printSection(out, ".rela.rodata", []string{".rela.rodata", ".rela.rodata.*"})
+
+	fmt.Fprintf(out, "}\n")
+
+	fmt.Printf("Generated: %s\n", outputFile)
+}

platform.txt

@@ -58,7 +58,8 @@ build.link_command="{compiler.path}{compiler.c.elf.cmd}" "-L{build.path}" "-L{bu
 build.check_command-dynamic={build.link_command} {build.link_args.check-dynamic} -o "{build.path}/{build.project_name}_check.tmp"
 build.check_command-static=/bin/true
 build.check_command-static.windows=cmd /C cd .
-build.combine_command={build.link_command} {build.link_args.build-{build.link_mode}} {build.link_args.build-common}
+build.combine_command={build.link_command} {build.link_args.build-{build.link_mode}} "-Wl,-Map,{build.path}/{build.project_name}_temp.map" -o "{build.path}/{build.project_name}_temp.elf"
+build.combine_command_final={build.link_command} "-T{build.path}/rodata_split.ld" {build.link_args.build-{build.link_mode}} {build.link_args.build-common}
 
 # link_args.* are included by any link_command depending on the link_mode
 build.link_args.dynamic=-e main
@@ -116,9 +117,11 @@ recipe.S.o.pattern="{compiler.path}{compiler.S.cmd}" {compiler.S.flags} -DARDUIN
 ## Create archives
 recipe.ar.pattern="{compiler.path}{compiler.ar.cmd}" {compiler.ar.flags} {compiler.ar.extra_flags} "{archive_file_path}" "{object_file}"
 
-## Combine gc-sections, archives, and objects
+## Combine gc-sections, archives, and objects - Two-pass linking
 recipe.c.combine.1.pattern={build.check_command-{build.link_mode}}
 recipe.c.combine.2.pattern={build.combine_command}
+recipe.c.combine.3.pattern="{runtime.platform.path}/extra/gen_rodata_ld" "{build.path}/{build.project_name}_temp.elf" "{build.path}/rodata_split.ld" "{build.link_mode}"
+recipe.c.combine.4.pattern={build.combine_command_final}
 recipe.c.combine.pattern={build.combine_command}
 recipe.hooks.linking.postlink.1.pattern="{compiler.path}{build.crossprefix}strip" --strip-debug "{build.path}/{build.project_name}_debug.elf" -o "{build.path}/{build.project_name}.elf"
 

variants/_ldscripts/build-dynamic.ld

@@ -42,12 +42,6 @@ SECTIONS {
         __static_thread_data_list_end = .;
     }
 
-    .rodata : {
-        *(.rodata)
-        *(.rodata1)
-        *(.rodata.*)
-    }
-
     .data : {
         *(.data .data.*)
     }
@@ -82,10 +76,6 @@ SECTIONS {
         KEEP(*(.shstrtab))
     }
 
-    .rel : {
-        KEEP(*(.rel .rel.*))
-    }
-
     .got : {
         KEEP(*(.got .got.* .got.plt .got.plt*))
     }