initial commit

Author: Kevaundray

src/cmd/link/elf_test.go

@@ -59,6 +59,12 @@ package main
 func main() {}
 `
 
+var goSourceWithData = `
+package main
+var globalVar = 42
+func main() { println(&globalVar) }
+`
+
 // The linker used to crash if an ELF input file had multiple text sections
 // with the same name.
 func TestSectionsWithSameName(t *testing.T) {
@@ -569,3 +575,150 @@ func TestFlagR(t *testing.T) {
 		t.Errorf("executable failed to run: %v\n%s", err, out)
 	}
 }
+
+func TestFlagD(t *testing.T) {
+	// Test that using the -D flag to specify data section address generates
+	// a working binary with data at the specified address.
+	// (Test only on ELF for now.)
+	testenv.MustHaveGoBuild(t)
+	t.Parallel()
+	tmpdir := t.TempDir()
+	src := filepath.Join(tmpdir, "x.go")
+	if err := os.WriteFile(src, []byte(goSourceWithData), 0444); err != nil {
+		t.Fatal(err)
+	}
+	exe := filepath.Join(tmpdir, "x.exe")
+
+	dataAddr := "0x10000000"
+	expectedAddr := uint64(0x10000000)
+
+	cmd := testenv.Command(t, testenv.GoToolPath(t), "build", "-ldflags=-D="+dataAddr, "-o", exe, src)
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("build failed: %v, output:\n%s", err, out)
+	}
+
+	cmd = testenv.Command(t, exe)
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Errorf("executable failed to run: %v\n%s", err, out)
+	}
+
+	ef, err := elf.Open(exe)
+	if err != nil {
+		t.Fatalf("open elf file failed: %v", err)
+	}
+	defer ef.Close()
+
+	// Find the first data-related section to verify segment placement
+	var firstDataSectionAddr uint64
+	var found bool = false
+	for _, sec := range ef.Sections {
+		if sec.Type == elf.SHT_PROGBITS || sec.Type == elf.SHT_NOBITS {
+
+			// These sections are writable, allocated at runtime, but not executable
+			isWrite := sec.Flags&elf.SHF_WRITE != 0
+			isExec := sec.Flags&elf.SHF_EXECINSTR != 0
+			isAlloc := sec.Flags&elf.SHF_ALLOC != 0
+
+			if isWrite && !isExec && isAlloc {
+				addrLower := sec.Addr < firstDataSectionAddr
+				if !found || addrLower {
+					firstDataSectionAddr = sec.Addr
+					found = true
+				}
+			}
+		}
+	}
+
+	if !found {
+		t.Fatalf("can't find any writable data sections")
+	}
+	if firstDataSectionAddr != expectedAddr {
+		t.Errorf("data section starts at 0x%x, expected 0x%x", firstDataSectionAddr, expectedAddr)
+	}
+}
+
+func TestFlagDWithR(t *testing.T) {
+	// Test that using the -D flag with -R flag works together.
+	// Note: The data address gets rounded to the specified alignment quantum.
+	testenv.MustHaveGoBuild(t)
+	t.Parallel()
+	tmpdir := t.TempDir()
+	src := filepath.Join(tmpdir, "x.go")
+	if err := os.WriteFile(src, []byte(goSourceWithData), 0444); err != nil {
+		t.Fatal(err)
+	}
+	exe := filepath.Join(tmpdir, "x.exe")
+
+	// Use an unaligned address that tests -D and -R rounding
+	dataAddr := "0x30001234"
+	roundQuantum := "8192"
+	expectedAddr := uint64(0x30002000) // Should be rounded up to next 8KB boundary
+
+	cmd := testenv.Command(t, testenv.GoToolPath(t), "build", "-ldflags=-D="+dataAddr+" -R="+roundQuantum, "-o", exe, src)
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("build failed: %v, output:\n%s", err, out)
+	}
+
+	cmd = testenv.Command(t, exe)
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Errorf("executable failed to run: %v\n%s", err, out)
+	}
+
+	ef, err := elf.Open(exe)
+	if err != nil {
+		t.Fatalf("open elf file failed: %v", err)
+	}
+	defer ef.Close()
+
+	// Find the first data-related section to verify segment placement
+	var firstDataSectionAddr uint64
+	var found bool = false
+	for _, sec := range ef.Sections {
+		if sec.Type == elf.SHT_PROGBITS || sec.Type == elf.SHT_NOBITS {
+
+			// These sections are writable, allocated at runtime, but not executable
+			isWrite := sec.Flags&elf.SHF_WRITE != 0
+			isExec := sec.Flags&elf.SHF_EXECINSTR != 0
+			isAlloc := sec.Flags&elf.SHF_ALLOC != 0
+
+			if isWrite && !isExec && isAlloc {
+				addrLower := sec.Addr < firstDataSectionAddr
+				if !found || addrLower {
+					firstDataSectionAddr = sec.Addr
+					found = true
+				}
+			}
+		}
+	}
+
+	if !found {
+		t.Fatalf("can't find any writable data sections")
+	}
+	if firstDataSectionAddr != expectedAddr {
+		t.Errorf("data section starts at 0x%x, expected 0x%x",
+			firstDataSectionAddr, expectedAddr)
+	}
+}
+
+// TODO: sanity check, delete this
+func TestRounding(t *testing.T) {
+	testCases := []struct {
+		input    int64
+		quantum  int64
+		expected int64
+	}{
+		{0x30000000, 0x2000, 0x30000000}, // Already aligned
+		{0x30002000, 0x2000, 0x30002000}, // Exactly on boundary
+		{0x30001234, 0x2000, 0x30002000},
+		{0x30001000, 0x2000, 0x30002000},
+		{0x30001fff, 0x2000, 0x30002000},
+	}
+
+	for _, tc := range testCases {
+		result := ld.Rnd(tc.input, tc.quantum)
+		if result != tc.expected {
+			t.Errorf("Rnd(0x%x, 0x%x) = 0x%x, expected 0x%x",
+				tc.input, tc.quantum, result, tc.expected)
+		}
+	}
+}

src/cmd/link/internal/ld/data.go

@@ -2881,7 +2881,12 @@ func (ctxt *Link) address() []*sym.Segment {
 	}
 	order = append(order, &Segdata)
 	Segdata.Rwx = 06
-	Segdata.Vaddr = va
+	if *FlagDataAddr != -1 {
+		Segdata.Vaddr = uint64(Rnd(*FlagDataAddr, *FlagRound))
+		va = Segdata.Vaddr
+	} else {
+		Segdata.Vaddr = va
+	}
 	var data *sym.Section
 	var noptr *sym.Section
 	var bss *sym.Section
@@ -3135,6 +3140,19 @@ func (ctxt *Link) layout(order []*sym.Segment) uint64 {
 				// should ensure that this segment's
 				// VA ≡ Fileoff mod FlagRound.
 				seg.Fileoff = uint64(Rnd(int64(prev.Fileoff+prev.Filelen), *FlagRound))
+				// If -D flag was used to place data segment at a specific address,
+				// we may have a non-contiguous layout. In this case, we need to
+				// adjust the file offset to maintain the congruence requirement.
+				if seg == &Segdata && *FlagDataAddr != -1 {
+					// Adjust file offset to maintain VA ≡ Fileoff mod FlagRound
+					adjustment := int64(seg.Vaddr%uint64(*FlagRound)) - int64(seg.Fileoff%uint64(*FlagRound))
+					if adjustment != 0 {
+						seg.Fileoff = uint64(int64(seg.Fileoff) + adjustment)
+						if adjustment < 0 {
+							seg.Fileoff += uint64(*FlagRound)
+						}
+					}
+				}
 				if seg.Vaddr%uint64(*FlagRound) != seg.Fileoff%uint64(*FlagRound) {
 					Exitf("bad segment rounding (Vaddr=%#x Fileoff=%#x FlagRound=%#x)", seg.Vaddr, seg.Fileoff, *FlagRound)
 				}

src/cmd/link/internal/ld/main.go

@@ -105,6 +105,7 @@ var (
 	FlagStrictDups    = flag.Int("strictdups", 0, "sanity check duplicate symbol contents during object file reading (1=warn 2=err).")
 	FlagRound         = flag.Int64("R", -1, "set address rounding `quantum`")
 	FlagTextAddr      = flag.Int64("T", -1, "set the start address of text symbols")
+	FlagDataAddr      = flag.Int64("D", -1, "set the start address of data symbols")
 	FlagFuncAlign     = flag.Int("funcalign", 0, "set function align to `N` bytes")
 	flagEntrySymbol   = flag.String("E", "", "set `entry` symbol name")
 	flagPruneWeakMap  = flag.Bool("pruneweakmap", true, "prune weak mapinit refs")