From a5b97a846d70cd8db7f33c24f2b9159f935ce318 Mon Sep 17 00:00:00 2001

From: Lynn Boger <laboger@linux.vnet.ibm.com>

Date: Tue, 13 Sep 2016 15:13:08 -0500

Subject: [PATCH] cmd/compile: large text sections on ppc64le

Additional fixes as submitted upstream.

---

 src/cmd/link/internal/ld/data.go   | 24 ++++++++++++------------

 src/cmd/link/internal/ld/lib.go    |  2 +-

 src/cmd/link/internal/ld/symtab.go |  2 +-

 src/runtime/type.go                | 28 ++++++++++++++++++----------

 4 files changed, 32 insertions(+), 24 deletions(-)

diff --git a/src/cmd/link/internal/ld/data.go b/src/cmd/link/internal/ld/data.go

index 58ce18c..d8e43ff 100644

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

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

@@ -531,7 +531,7 @@ func relocsym(s *LSym) {

 			// The method offset tables using this relocation expect the offset to be relative

 			// to the start of the first text section, even if there are multiple.

-			if Linkmode == LinkExternal && r.Sym.Sect.Name == ".text" && r.Sym.Sect.Vaddr != Segtext.Vaddr {

+			if r.Sym.Sect.Name == ".text" {

 				o = Symaddr(r.Sym) - int64(Segtext.Vaddr) + r.Add

 			} else {

 				o = Symaddr(r.Sym) - int64(r.Sym.Sect.Vaddr) + r.Add

@@ -1928,7 +1928,6 @@ func textaddress() {

 	sect.Align = int32(Funcalign)

 	Linklookup(Ctxt, "runtime.text", 0).Sect = sect

-	Linklookup(Ctxt, "runtime.etext", 0).Sect = sect

 	if HEADTYPE == obj.Hwindows {

 		Linklookup(Ctxt, ".text", 0).Sect = sect

 	}

@@ -1964,7 +1963,7 @@ func textaddress() {

 		// Only break at outermost syms.

-		if sym.Outer == nil && Iself && Linkmode == LinkExternal && SysArch.InFamily(sys.PPC64) && va-sect.Vaddr > uint64(0x1c00000) {

+		if sym.Outer == nil && Iself && Linkmode == LinkExternal && SysArch.InFamily(sys.PPC64) && va-sect.Vaddr > 0x1c00000 {

 			// Set the length for the previous text section

 			sect.Length = va - sect.Vaddr

@@ -1973,7 +1972,7 @@ func textaddress() {

 			sect = addsection(&Segtext, ".text", 05)

 			sect.Vaddr = va

-			// Create a symbol for the start and end of the secondary text section

+			// Create a symbol for the start of the secondary text section

 			Linklookup(Ctxt, fmt.Sprintf("runtime.text.%d", n), 0).Sect = sect

 			n++

 		}

@@ -2093,15 +2092,8 @@ func address() {

 		rodata = Segrodata.Sect

 	} else {

 		// Could be multiple .text sections

-		n := 1

-		for sect := Segtext.Sect.Next; sect != nil; sect = sect.Next {

-			if sect.Name != ".text" {

-				break

-			}

+		for sect := Segtext.Sect.Next; sect != nil && sect.Name == ".text"; sect = sect.Next {

 			lasttext = sect

-			symname := fmt.Sprintf("runtime.text.%d", n)

-			xdefine(symname, obj.STEXT, int64(sect.Vaddr))

-			n++

 		}

 		rodata = lasttext.Next

@@ -2155,6 +2147,14 @@ func address() {

 	xdefine("runtime.text", obj.STEXT, int64(text.Vaddr))

 	xdefine("runtime.etext", obj.STEXT, int64(lasttext.Vaddr+lasttext.Length))

+

+	n := 1

+	for sect := Segtext.Sect.Next; sect != nil && sect.Name == ".text"; sect = sect.Next {

+		symname := fmt.Sprintf("runtime.text.%d", n)

+		xdefine(symname, obj.STEXT, int64(sect.Vaddr))

+		n++

+	}

+

 	if HEADTYPE == obj.Hwindows {

 		xdefine(".text", obj.STEXT, int64(text.Vaddr))

 	}

diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go

index 709e7ca..c37ef92 100644

--- a/src/cmd/link/internal/ld/lib.go

+++ b/src/cmd/link/internal/ld/lib.go

@@ -1958,7 +1958,7 @@ func genasmsym(put func(*LSym, string, int, int64, int64, int, *LSym)) {

 	}

 	n := 0

-	// Generate base addresses for all text sections if there are multiple

+	// Generate base addresses for all text sections if there are multiple.

 	for sect := Segtext.Sect; sect != nil; sect = sect.Next {

 		if n == 0 {

 			n++

diff --git a/src/cmd/link/internal/ld/symtab.go b/src/cmd/link/internal/ld/symtab.go

index 80eb33d..ec26f88 100644

--- a/src/cmd/link/internal/ld/symtab.go

+++ b/src/cmd/link/internal/ld/symtab.go

@@ -331,7 +331,7 @@ func textsectionmap() uint32 {

 			break

 		}

 	}

-	Symgrow(Ctxt, t, nsections*3*8)

+	Symgrow(Ctxt, t, nsections*(2*int64(SysArch.IntSize)+int64(SysArch.PtrSize)))

 	off := int64(0)

 	n := 0

diff --git a/src/runtime/type.go b/src/runtime/type.go

index f641adc..d4df5a9 100644

--- a/src/runtime/type.go

+++ b/src/runtime/type.go

@@ -259,17 +259,25 @@ func (t *_type) textOff(off textOff) unsafe.Pointer {

 	}

 	res := uintptr(0)

-	// Find the text section range that contains the offset to determine the section's base

-	// address.  In cases where there are multiple text sections, the base address might be

-	// relocated by the linker.

-

-	for i := 0; i < len(md.textsectmap); i++ {

-		sectaddr := md.textsectmap[i].vaddr

-		sectlen := md.textsectmap[i].length

-		if uint64(off) >= sectaddr && uint64(off) <= sectaddr+sectlen {

-			res = md.textsectmap[i].baseaddr + uintptr(off) - uintptr(md.textsectmap[i].vaddr)

-			break

+	// The text, or instruction stream is generated as one large buffer.  The off (offset) for a method is

+	// its offset within this buffer.  If the total text size gets too large, there can be issues on platforms like ppc64 if

+	// the target of calls are too far for the call instruction.  To resolve the large text issue, the text is split

+	// into multiple text sections to allow the linker to generate long calls when necessary.  When this happens, the vaddr

+	// for each text section is set to its offset within the text.  Each method's offset is compared against the section

+	// vaddrs and sizes to determine the containing section.  Then the section relative offset is added to the section's

+	// relocated baseaddr to compute the method addess.

+

+	if len(md.textsectmap) > 1 {

+		for i := 0; i < len(md.textsectmap); i++ {

+			sectaddr := md.textsectmap[i].vaddr

+			sectlen := md.textsectmap[i].length

+			if uint64(off) >= sectaddr && uint64(off) <= sectaddr+sectlen {

+				res = md.textsectmap[i].baseaddr + uintptr(off) - uintptr(md.textsectmap[i].vaddr)

+				break

+			}

 		}

+	} else {

+		res = md.text + uintptr(off)

 	}

 	if res > md.etext {