Merge "cmd/link: merge branch 'dev.link' into master"

Author: Gerrit Code Review

src/cmd/internal/goobj/funcinfo.go

@@ -23,12 +23,11 @@ type FuncInfo struct {
 	Locals uint32
 	FuncID objabi.FuncID
 
-	Pcsp        uint32
-	Pcfile      uint32
-	Pcline      uint32
-	Pcinline    uint32
-	Pcdata      []uint32
-	PcdataEnd   uint32
+	Pcsp        SymRef
+	Pcfile      SymRef
+	Pcline      SymRef
+	Pcinline    SymRef
+	Pcdata      []SymRef
 	Funcdataoff []uint32
 	File        []CUFileIndex
 
@@ -41,20 +40,24 @@ func (a *FuncInfo) Write(w *bytes.Buffer) {
 		binary.LittleEndian.PutUint32(b[:], x)
 		w.Write(b[:])
 	}
+	writeSymRef := func(s SymRef) {
+		writeUint32(s.PkgIdx)
+		writeUint32(s.SymIdx)
+	}
 
 	writeUint32(a.Args)
 	writeUint32(a.Locals)
 	writeUint32(uint32(a.FuncID))
 
-	writeUint32(a.Pcsp)
-	writeUint32(a.Pcfile)
-	writeUint32(a.Pcline)
-	writeUint32(a.Pcinline)
+	writeSymRef(a.Pcsp)
+	writeSymRef(a.Pcfile)
+	writeSymRef(a.Pcline)
+	writeSymRef(a.Pcinline)
 	writeUint32(uint32(len(a.Pcdata)))
-	for _, x := range a.Pcdata {
-		writeUint32(x)
+	for _, sym := range a.Pcdata {
+		writeSymRef(sym)
 	}
-	writeUint32(a.PcdataEnd)
+
 	writeUint32(uint32(len(a.Funcdataoff)))
 	for _, x := range a.Funcdataoff {
 		writeUint32(x)
@@ -75,21 +78,23 @@ func (a *FuncInfo) Read(b []byte) {
 		b = b[4:]
 		return x
 	}
+	readSymIdx := func() SymRef {
+		return SymRef{readUint32(), readUint32()}
+	}
 
 	a.Args = readUint32()
 	a.Locals = readUint32()
 	a.FuncID = objabi.FuncID(readUint32())
 
-	a.Pcsp = readUint32()
-	a.Pcfile = readUint32()
-	a.Pcline = readUint32()
-	a.Pcinline = readUint32()
-	pcdatalen := readUint32()
-	a.Pcdata = make([]uint32, pcdatalen)
+	a.Pcsp = readSymIdx()
+	a.Pcfile = readSymIdx()
+	a.Pcline = readSymIdx()
+	a.Pcinline = readSymIdx()
+	a.Pcdata = make([]SymRef, readUint32())
 	for i := range a.Pcdata {
-		a.Pcdata[i] = readUint32()
+		a.Pcdata[i] = readSymIdx()
 	}
-	a.PcdataEnd = readUint32()
+
 	funcdataofflen := readUint32()
 	a.Funcdataoff = make([]uint32, funcdataofflen)
 	for i := range a.Funcdataoff {
@@ -127,11 +132,13 @@ type FuncInfoLengths struct {
 func (*FuncInfo) ReadFuncInfoLengths(b []byte) FuncInfoLengths {
 	var result FuncInfoLengths
 
-	const numpcdataOff = 28
+	// Offset to the number of pcdata values. This value is determined by counting
+	// the number of bytes until we write pcdata to the file.
+	const numpcdataOff = 44
 	result.NumPcdata = binary.LittleEndian.Uint32(b[numpcdataOff:])
 	result.PcdataOff = numpcdataOff + 4
 
-	numfuncdataoffOff := result.PcdataOff + 4*(result.NumPcdata+1)
+	numfuncdataoffOff := result.PcdataOff + 8*result.NumPcdata
 	result.NumFuncdataoff = binary.LittleEndian.Uint32(b[numfuncdataoffOff:])
 	result.FuncdataoffOff = numfuncdataoffOff + 4
 
@@ -154,29 +161,28 @@ func (*FuncInfo) ReadLocals(b []byte) uint32 { return binary.LittleEndian.Uint32
 
 func (*FuncInfo) ReadFuncID(b []byte) uint32 { return binary.LittleEndian.Uint32(b[8:]) }
 
-// return start and end offsets.
-func (*FuncInfo) ReadPcsp(b []byte) (uint32, uint32) {
-	return binary.LittleEndian.Uint32(b[12:]), binary.LittleEndian.Uint32(b[16:])
+func (*FuncInfo) ReadPcsp(b []byte) SymRef {
+	return SymRef{binary.LittleEndian.Uint32(b[12:]), binary.LittleEndian.Uint32(b[16:])}
 }
 
-// return start and end offsets.
-func (*FuncInfo) ReadPcfile(b []byte) (uint32, uint32) {
-	return binary.LittleEndian.Uint32(b[16:]), binary.LittleEndian.Uint32(b[20:])
+func (*FuncInfo) ReadPcfile(b []byte) SymRef {
+	return SymRef{binary.LittleEndian.Uint32(b[20:]), binary.LittleEndian.Uint32(b[24:])}
 }
 
-// return start and end offsets.
-func (*FuncInfo) ReadPcline(b []byte) (uint32, uint32) {
-	return binary.LittleEndian.Uint32(b[20:]), binary.LittleEndian.Uint32(b[24:])
+func (*FuncInfo) ReadPcline(b []byte) SymRef {
+	return SymRef{binary.LittleEndian.Uint32(b[28:]), binary.LittleEndian.Uint32(b[32:])}
 }
 
-// return start and end offsets.
-func (*FuncInfo) ReadPcinline(b []byte, pcdataoffset uint32) (uint32, uint32) {
-	return binary.LittleEndian.Uint32(b[24:]), binary.LittleEndian.Uint32(b[pcdataoffset:])
+func (*FuncInfo) ReadPcinline(b []byte) SymRef {
+	return SymRef{binary.LittleEndian.Uint32(b[36:]), binary.LittleEndian.Uint32(b[40:])}
 }
 
-// return start and end offsets.
-func (*FuncInfo) ReadPcdata(b []byte, pcdataoffset uint32, k uint32) (uint32, uint32) {
-	return binary.LittleEndian.Uint32(b[pcdataoffset+4*k:]), binary.LittleEndian.Uint32(b[pcdataoffset+4+4*k:])
+func (*FuncInfo) ReadPcdata(b []byte) []SymRef {
+	syms := make([]SymRef, binary.LittleEndian.Uint32(b[44:]))
+	for i := range syms {
+		syms[i] = SymRef{binary.LittleEndian.Uint32(b[48+i*8:]), binary.LittleEndian.Uint32(b[52+i*8:])}
+	}
+	return syms
 }
 
 func (*FuncInfo) ReadFuncdataoff(b []byte, funcdataofffoff uint32, k uint32) int64 {

src/cmd/internal/goobj/objfile.go

@@ -433,8 +433,11 @@ const (
 	AuxDwarfLoc
 	AuxDwarfRanges
 	AuxDwarfLines
-
-	// TODO: more. Pcdata?
+	AuxPcsp
+	AuxPcfile
+	AuxPcline
+	AuxPcinline
+	AuxPcdata
 )
 
 func (a *Aux) Type() uint8 { return a[0] }
@@ -839,11 +842,6 @@ func (r *Reader) Data(i uint32) []byte {
 	return r.BytesAt(base+off, int(end-off))
 }
 
-// AuxDataBase returns the base offset of the aux data block.
-func (r *Reader) PcdataBase() uint32 {
-	return r.h.Offsets[BlkPcdata]
-}
-
 // NRefName returns the number of referenced symbol names.
 func (r *Reader) NRefName() int {
 	return int(r.h.Offsets[BlkRefName+1]-r.h.Offsets[BlkRefName]) / RefNameSize

src/cmd/internal/obj/link.go

@@ -634,11 +634,12 @@ func (s *LSym) CanBeAnSSASym() {
 }
 
 type Pcln struct {
-	Pcsp        Pcdata
-	Pcfile      Pcdata
-	Pcline      Pcdata
-	Pcinline    Pcdata
-	Pcdata      []Pcdata
+	// Aux symbols for pcln
+	Pcsp        *LSym
+	Pcfile      *LSym
+	Pcline      *LSym
+	Pcinline    *LSym
+	Pcdata      []*LSym
 	Funcdata    []*LSym
 	Funcdataoff []int64
 	UsedFiles   map[goobj.CUFileIndex]struct{} // file indices used while generating pcfile
@@ -660,10 +661,6 @@ type Auto struct {
 	Gotype  *LSym
 }
 
-type Pcdata struct {
-	P []byte
-}
-
 // Link holds the context for writing object code from a compiler
 // to be linker input or for reading that input into the linker.
 type Link struct {

src/cmd/internal/obj/objfile.go

@@ -185,7 +185,11 @@ func WriteObjFile(ctxt *Link, b *bio.Writer) {
 	// Pcdata
 	h.Offsets[goobj.BlkPcdata] = w.Offset()
 	for _, s := range ctxt.Text { // iteration order must match genFuncInfoSyms
-		if s.Func != nil {
+		// Because of the phase order, it's possible that we try to write an invalid
+		// object file, and the Pcln variables haven't been filled in. As such, we
+		// need to check that Pcsp exists, and assume the other pcln variables exist
+		// as well. Tests like test/fixedbugs/issue22200.go demonstrate this issue.
+		if s.Func != nil && s.Func.Pcln.Pcsp != nil {
 			pc := &s.Func.Pcln
 			w.Bytes(pc.Pcsp.P)
 			w.Bytes(pc.Pcfile.P)
@@ -372,6 +376,19 @@ func contentHash64(s *LSym) goobj.Hash64Type {
 // hashed symbols.
 func (w *writer) contentHash(s *LSym) goobj.HashType {
 	h := sha1.New()
+	var tmp [14]byte
+
+	// Include the size of the symbol in the hash.
+	// This preserves the length of symbols, preventing the following two symbols
+	// from hashing the same:
+	//
+	//    [2]int{1,2} ≠ [10]int{1,2,0,0,0...}
+	//
+	// In this case, if the smaller symbol is alive, the larger is not kept unless
+	// needed.
+	binary.LittleEndian.PutUint64(tmp[:8], uint64(s.Size))
+	h.Write(tmp[:8])
+
 	// Don't dedup type symbols with others, as they are in a different
 	// section.
 	if strings.HasPrefix(s.Name, "type.") {
@@ -382,7 +399,6 @@ func (w *writer) contentHash(s *LSym) goobj.HashType {
 	// The compiler trims trailing zeros _sometimes_. We just do
 	// it always.
 	h.Write(bytes.TrimRight(s.P, "\x00"))
-	var tmp [14]byte
 	for i := range s.R {
 		r := &s.R[i]
 		binary.LittleEndian.PutUint32(tmp[:4], uint32(r.Off))
@@ -473,6 +489,22 @@ func (w *writer) Aux(s *LSym) {
 		if s.Func.dwarfDebugLinesSym != nil && s.Func.dwarfDebugLinesSym.Size != 0 {
 			w.aux1(goobj.AuxDwarfLines, s.Func.dwarfDebugLinesSym)
 		}
+		if s.Func.Pcln.Pcsp != nil && s.Func.Pcln.Pcsp.Size != 0 {
+			w.aux1(goobj.AuxPcsp, s.Func.Pcln.Pcsp)
+		}
+		if s.Func.Pcln.Pcfile != nil && s.Func.Pcln.Pcfile.Size != 0 {
+			w.aux1(goobj.AuxPcfile, s.Func.Pcln.Pcfile)
+		}
+		if s.Func.Pcln.Pcline != nil && s.Func.Pcln.Pcline.Size != 0 {
+			w.aux1(goobj.AuxPcline, s.Func.Pcln.Pcline)
+		}
+		if s.Func.Pcln.Pcinline != nil && s.Func.Pcln.Pcinline.Size != 0 {
+			w.aux1(goobj.AuxPcinline, s.Func.Pcln.Pcinline)
+		}
+		for _, pcSym := range s.Func.Pcln.Pcdata {
+			w.aux1(goobj.AuxPcdata, pcSym)
+		}
+
 	}
 }
 
@@ -554,14 +586,37 @@ func nAuxSym(s *LSym) int {
 		if s.Func.dwarfDebugLinesSym != nil && s.Func.dwarfDebugLinesSym.Size != 0 {
 			n++
 		}
+		if s.Func.Pcln.Pcsp != nil && s.Func.Pcln.Pcsp.Size != 0 {
+			n++
+		}
+		if s.Func.Pcln.Pcfile != nil && s.Func.Pcln.Pcfile.Size != 0 {
+			n++
+		}
+		if s.Func.Pcln.Pcline != nil && s.Func.Pcln.Pcline.Size != 0 {
+			n++
+		}
+		if s.Func.Pcln.Pcinline != nil && s.Func.Pcln.Pcinline.Size != 0 {
+			n++
+		}
+		n += len(s.Func.Pcln.Pcdata)
 	}
 	return n
 }
 
 // generate symbols for FuncInfo.
 func genFuncInfoSyms(ctxt *Link) {
 	infosyms := make([]*LSym, 0, len(ctxt.Text))
-	var pcdataoff uint32
+	hashedsyms := make([]*LSym, 0, 4*len(ctxt.Text))
+	preparePcSym := func(s *LSym) *LSym {
+		if s == nil {
+			return s
+		}
+		s.PkgIdx = goobj.PkgIdxHashed
+		s.SymIdx = int32(len(hashedsyms) + len(ctxt.hasheddefs))
+		s.Set(AttrIndexed, true)
+		hashedsyms = append(hashedsyms, s)
+		return s
+	}
 	var b bytes.Buffer
 	symidx := int32(len(ctxt.defs))
 	for _, s := range ctxt.Text {
@@ -574,20 +629,14 @@ func genFuncInfoSyms(ctxt *Link) {
 			FuncID: objabi.FuncID(s.Func.FuncID),
 		}
 		pc := &s.Func.Pcln
-		o.Pcsp = pcdataoff
-		pcdataoff += uint32(len(pc.Pcsp.P))
-		o.Pcfile = pcdataoff
-		pcdataoff += uint32(len(pc.Pcfile.P))
-		o.Pcline = pcdataoff
-		pcdataoff += uint32(len(pc.Pcline.P))
-		o.Pcinline = pcdataoff
-		pcdataoff += uint32(len(pc.Pcinline.P))
-		o.Pcdata = make([]uint32, len(pc.Pcdata))
-		for i, pcd := range pc.Pcdata {
-			o.Pcdata[i] = pcdataoff
-			pcdataoff += uint32(len(pcd.P))
-		}
-		o.PcdataEnd = pcdataoff
+		o.Pcsp = makeSymRef(preparePcSym(pc.Pcsp))
+		o.Pcfile = makeSymRef(preparePcSym(pc.Pcfile))
+		o.Pcline = makeSymRef(preparePcSym(pc.Pcline))
+		o.Pcinline = makeSymRef(preparePcSym(pc.Pcinline))
+		o.Pcdata = make([]goobj.SymRef, len(pc.Pcdata))
+		for i, pcSym := range pc.Pcdata {
+			o.Pcdata[i] = makeSymRef(preparePcSym(pcSym))
+		}
 		o.Funcdataoff = make([]uint32, len(pc.Funcdataoff))
 		for i, x := range pc.Funcdataoff {
 			o.Funcdataoff[i] = uint32(x)
@@ -637,9 +686,9 @@ func genFuncInfoSyms(ctxt *Link) {
 		}
 	}
 	ctxt.defs = append(ctxt.defs, infosyms...)
+	ctxt.hasheddefs = append(ctxt.hasheddefs, hashedsyms...)
 }
 
-// debugDumpAux is a dumper for selected aux symbols.
 func writeAuxSymDebug(ctxt *Link, par *LSym, aux *LSym) {
 	// Most aux symbols (ex: funcdata) are not interesting--
 	// pick out just the DWARF ones for now.