qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-09-24 03:20:12 -06:00
Code Releases Activity

cmd/link: enforce larger alignment on split ppc64 text sections

Browse Source 
When laying out, we lazily increase the alignment for text sections
as symbols are found requiring more. This works if the start of
the virtual address (VA) for the section is greater than or equal
to the alignment required by any symbols placed in this section.

The minimum alignment of the section is only known after all
symbols are placed. The starting VA of this section is adjusted
upwards in ld.(*Link).address to meet the requested alignment.

This is a problem if the starting VA of the text section is not
already aligned. This can happen when the final symbol placed
into the previous section results in an insufficiently aligned
start VA of the next text section.

To workaround this, additional text sections are split, and both
the starting VA, and alignment of the section are aligned up to
match the known worst case alignment.

64B is chosen as the worst case alignment for all ppc64 targets,
as it will respect PCALIGN and eventually prefixed instructions
which will be introduced in the future.

Likewise, the xcoff size calculations need to be improved to
handle padding bytes when function symbols have been aligned.
This is done by tracking the largest valid VA offset encountered
when placing symbols.

Change-Id: Iefef09a1ee7c963fb8dfce2288a084a95cb77fca
Reviewed-on: https://go-review.googlesource.com/c/go/+/307431
Run-TryBot: Paul Murphy <murp@ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
This commit is contained in:
Paul E. Murphy 2021-04-05 13:40:48 -05:00 committed by Lynn Boger
parent 1eca6aa747
commit 6edd573218
2 changed files with 36 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/cmd/link/internal/ld/data.go
View File

@ -2298,12 +2298,23 @@ func assignAddress(ctxt *Link, sect *sym.Section, n int, s loader.Sym, va uint64
}
if va-sect.Vaddr+funcsize+maxSizeTrampolinesPPC64(ldr, s, isTramp) > textSizelimit {
// Align the next text section to the worst case function alignment likely
// to be encountered when processing function symbols. The start address
// is rounded against the final alignment of the text section later on in
// (*Link).address. This may happen due to usage of PCALIGN directives
// larger than Funcalign, or usage of ISA 3.1 prefixed instructions
// (see ISA 3.1 Book I 1.9).
const ppc64maxFuncalign = 64
va = uint64(Rnd(int64(va), ppc64maxFuncalign))
// Set the length for the previous text section
sect.Length = va - sect.Vaddr
// Create new section, set the starting Vaddr
sect = addsection(ctxt.loader, ctxt.Arch, &Segtext, ".text", 05)
sect.Vaddr = va
sect.Align = ppc64maxFuncalign
ldr.SetSymSect(s, sect)
// Create a symbol for the start of the secondary text sections
@ -2316,6 +2327,7 @@ func assignAddress(ctxt *Link, sect *sym.Section, n int, s loader.Sym, va uint64
ntext.SetType(sym.STEXT)
ntext.SetSize(int64(MINFUNC))
ntext.SetOnList(true)
ntext.SetAlign(ppc64maxFuncalign)
ctxt.tramps = append(ctxt.tramps, ntext.Sym())
ntext.SetValue(int64(va))

37
src/cmd/link/internal/ld/xcoff.go
View File

@ -28,8 +28,11 @@ const (
// Total amount of space to reserve at the start of the file
// for File Header, Auxiliary Header, and Section Headers.
// May waste some.
XCOFFHDRRESERVE = FILHSZ_64 + AOUTHSZ_EXEC64 + SCNHSZ_64*23
XCOFFSECTALIGN int64 = 32 // base on dump -o
XCOFFHDRRESERVE = FILHSZ_64 + AOUTHSZ_EXEC64 + SCNHSZ_64*23
// base on dump -o, then rounded from 32B to 64B to
// match worst case elf text section alignment on ppc64.
XCOFFSECTALIGN int64 = 64
// XCOFF binaries should normally have all its sections position-independent.
// However, this is not yet possible for .text because of some R_ADDR relocations
@ -555,11 +558,12 @@ func Xcoffinit(ctxt *Link) {
// type records C_FILE information needed for genasmsym in XCOFF.
type xcoffSymSrcFile struct {
name string
file *XcoffSymEnt64 // Symbol of this C_FILE
csectAux *XcoffAuxCSect64 // Symbol for the current .csect
csectSymNb uint64 // Symbol number for the current .csect
csectSize int64
name string
file *XcoffSymEnt64 // Symbol of this C_FILE
csectAux *XcoffAuxCSect64 // Symbol for the current .csect
csectSymNb uint64 // Symbol number for the current .csect
csectVAStart int64
csectVAEnd int64
}
var (
@ -746,7 +750,8 @@ func (f *xcoffFile) writeSymbolNewFile(ctxt *Link, name string, firstEntry uint6
f.addSymbol(aux)
currSymSrcFile.csectAux = aux
currSymSrcFile.csectSize = 0
currSymSrcFile.csectVAStart = int64(firstEntry)
currSymSrcFile.csectVAEnd = int64(firstEntry)
}
// Update values for the previous package.
@ -768,8 +773,9 @@ func (f *xcoffFile) updatePreviousFile(ctxt *Link, last bool) {
// update csect scnlen in this auxiliary entry
aux := currSymSrcFile.csectAux
aux.Xscnlenlo = uint32(currSymSrcFile.csectSize & 0xFFFFFFFF)
aux.Xscnlenhi = uint32(currSymSrcFile.csectSize >> 32)
csectSize := currSymSrcFile.csectVAEnd - currSymSrcFile.csectVAStart
aux.Xscnlenlo = uint32(csectSize & 0xFFFFFFFF)
aux.Xscnlenhi = uint32(csectSize >> 32)
}
// Write symbol representing a .text function.
@ -832,8 +838,13 @@ func (f *xcoffFile) writeSymbolFunc(ctxt *Link, x loader.Sym) []xcoffSym {
ldr.SetSymDynid(x, int32(xfile.symbolCount))
syms = append(syms, s)
// Update current csect size
currSymSrcFile.csectSize += ldr.SymSize(x)
// Keep track of the section size by tracking the VA range. Individual
// alignment differences may introduce a few extra bytes of padding
// which are not fully accounted for by ldr.SymSize(x).
sv := ldr.SymValue(x) + ldr.SymSize(x)
if currSymSrcFile.csectVAEnd < sv {
currSymSrcFile.csectVAEnd = sv
}
// create auxiliary entries
a2 := &XcoffAuxFcn64{
@ -1549,7 +1560,7 @@ func (f *xcoffFile) writeFileHeader(ctxt *Link) {
f.xahdr.Otoc = uint64(ldr.SymValue(toc))
f.xahdr.Osntoc = f.getXCOFFscnum(ldr.SymSect(toc))
f.xahdr.Oalgntext = int16(logBase2(int(Funcalign)))
f.xahdr.Oalgntext = int16(logBase2(int(XCOFFSECTALIGN)))
f.xahdr.Oalgndata = 0x5
binary.Write(ctxt.Out, binary.BigEndian, &f.xfhdr)