cmd/link: fix duplicated "unresolved inter-package jump" errors

This is extension to https://golang.org/cl/113955 that handled
duplicated "unresolved relocation" errors.

For platforms with trampoline support, additional error is generated
per each undefined symbol. This breaks TestUndefinedRelocErrors test
on these platforms.

Proposed fix:

	1. Changes error text to be identical to normal undefined reloc.
	   If relocation is undefined, jump to it will be unresolved
	   as well.

	2. Introduces a map that can be used by all sites that
	   handle this kind of errors which makes it easier
	   to report such errors exactly once.

Errors on ppc64 before this change (note first 4 lines):

	main.defined1: unresolved inter-package jump to main.undefined()
	main.defined1: unresolved inter-package jump to main.undefined()
	main.defined2: unresolved inter-package jump to main.undefined()
	main.defined2: unresolved inter-package jump to main.undefined()
	main.defined1: relocation target main.undefined not defined
	main.defined2: relocation target main.undefined not defined
	runtime.main_main·f: function main is undeclared in the main package

After this change:

	main.defined1: relocation target main.undefined not defined
	main.defined2: relocation target main.undefined not defined
	runtime.main_main·f: function main is undeclared in the main package

Because of (1), errors output is the same on all platforms now.

Fixes #25753

Change-Id: Ic3084202a6fc5d4a6d2d0a93344f012b37fe58ed
Reviewed-on: https://go-review.googlesource.com/116676
Run-TryBot: Iskander Sharipov <iskander.sharipov@intel.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

diff --git a/src/cmd/link/internal/ld/data.go b/src/cmd/link/internal/ld/data.go
index 1cdb27970789387d6f3ccbd9500c926074ae4b49..be65b7be069f836dd824f7dedadc91070197f7ca 100644 (file)
--- a/src/cmd/link/internal/ld/data.go
+++ b/src/cmd/link/internal/ld/data.go
@@ -95,7 +95,7 @@ func trampoline(ctxt *Link, s *sym.Symbol) {
                if Symaddr(r.Sym) == 0 && r.Sym.Type != sym.SDYNIMPORT {
                        if r.Sym.File != s.File {
                                if !isRuntimeDepPkg(s.File) || !isRuntimeDepPkg(r.Sym.File) {
-                                       Errorf(s, "unresolved inter-package jump to %s(%s)", r.Sym, r.Sym.File)
+                                       ctxt.ErrorUnresolved(s, r)
                                }
                                // runtime and its dependent packages may call to each other.
                                // they are fine, as they will be laid down together.
@@ -110,10 +110,6 @@ func trampoline(ctxt *Link, s *sym.Symbol) {
 
 // resolve relocations in s.
 func relocsym(ctxt *Link, s *sym.Symbol) {
-       // undefinedSyms contains all undefined symbol names.
-       // For successfull builds, it remains nil and does not cause any overhead.
-       var undefinedSyms []string
-
        for ri := int32(0); ri < int32(len(s.R)); ri++ {
                r := &s.R[ri]
                if r.Done {
@@ -144,22 +140,7 @@ func relocsym(ctxt *Link, s *sym.Symbol) {
                                        continue
                                }
                        } else {
-                               reported := false
-                               for _, name := range undefinedSyms {
-                                       if name == r.Sym.Name {
-                                               reported = true
-                                               break
-                                       }
-                               }
-                               if !reported {
-                                       // Give a special error message for main symbol (see #24809).
-                                       if r.Sym.Name == "main.main" {
-                                               Errorf(s, "function main is undeclared in the main package")
-                                       } else {
-                                               Errorf(s, "relocation target %s not defined", r.Sym.Name)
-                                       }
-                                       undefinedSyms = append(undefinedSyms, r.Sym.Name)
-                               }
+                               ctxt.ErrorUnresolved(s, r)
                                continue
                        }
                }

diff --git a/src/cmd/link/internal/ld/link.go b/src/cmd/link/internal/ld/link.go
index a413353b9fb56c148cc9de9c3d5a1438d5659a97..a790fd084b5785b4ef3228d2c7a7a859799df7c9 100644 (file)
--- a/src/cmd/link/internal/ld/link.go
+++ b/src/cmd/link/internal/ld/link.go
@@ -81,6 +81,33 @@ type Link struct {
        PackageShlib map[string]string
 
        tramps []*sym.Symbol // trampolines
+
+       // unresolvedSymSet is a set of erroneous unresolved references.
+       // Used to avoid duplicated error messages.
+       unresolvedSymSet map[unresolvedSymKey]bool
+}
+
+type unresolvedSymKey struct {
+       from *sym.Symbol // Symbol that referenced unresolved "to"
+       to   *sym.Symbol // Unresolved symbol referenced by "from"
+}
+
+// ErrorUnresolved prints unresolved symbol error for r.Sym that is referenced from s.
+func (ctxt *Link) ErrorUnresolved(s *sym.Symbol, r *sym.Reloc) {
+       if ctxt.unresolvedSymSet == nil {
+               ctxt.unresolvedSymSet = make(map[unresolvedSymKey]bool)
+       }
+
+       k := unresolvedSymKey{from: s, to: r.Sym}
+       if !ctxt.unresolvedSymSet[k] {
+               ctxt.unresolvedSymSet[k] = true
+               // Give a special error message for main symbol (see #24809).
+               if r.Sym.Name == "main.main" {
+                       Errorf(s, "function main is undeclared in the main package")
+               } else {
+                       Errorf(s, "relocation target %s not defined", r.Sym.Name)
+               }
+       }
 }
 
 // The smallest possible offset from the hardware stack pointer to a local