[dev.link] cmd/link: move macho host files to new loader format

Change-Id: I823b19c0742992dd760c6372428a1936bb7c7e70
Reviewed-on: https://go-review.googlesource.com/c/go/+/200768
Reviewed-by: Jeremy Faller <jeremy@golang.org>
Reviewed-by: Than McIntosh <thanm@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>

diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index d030340cc0e3201785cd8ac5da6514a521724510..dd759a0ab1d199e4082c7cd03e22a5c73a26184c 100644 (file)
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -1621,15 +1621,26 @@ func ldobj(ctxt *Link, f *bio.Reader, lib *sym.Library, length int64, pn string,
        }
 
        if magic&^1 == 0xfeedface || magic&^0x01000000 == 0xcefaedfe {
-               ldmacho := func(ctxt *Link, f *bio.Reader, pkg string, length int64, pn string) {
-                       textp, err := loadmacho.Load(ctxt.Arch, ctxt.Syms, f, pkg, length, pn)
-                       if err != nil {
-                               Errorf(nil, "%v", err)
-                               return
+               if *flagNewobj {
+                       ldmacho := func(ctxt *Link, f *bio.Reader, pkg string, length int64, pn string) {
+                               err := loadmacho.Load(ctxt.loader, ctxt.Arch, ctxt.Syms, f, pkg, length, pn)
+                               if err != nil {
+                                       Errorf(nil, "%v", err)
+                                       return
+                               }
                        }
-                       ctxt.Textp = append(ctxt.Textp, textp...)
+                       return ldhostobj(ldmacho, ctxt.HeadType, f, pkg, length, pn, file)
+               } else {
+                       ldmacho := func(ctxt *Link, f *bio.Reader, pkg string, length int64, pn string) {
+                               textp, err := loadmacho.LoadOld(ctxt.Arch, ctxt.Syms, f, pkg, length, pn)
+                               if err != nil {
+                                       Errorf(nil, "%v", err)
+                                       return
+                               }
+                               ctxt.Textp = append(ctxt.Textp, textp...)
+                       }
+                       return ldhostobj(ldmacho, ctxt.HeadType, f, pkg, length, pn, file)
                }
-               return ldhostobj(ldmacho, ctxt.HeadType, f, pkg, length, pn, file)
        }
 
        if c1 == 0x4c && c2 == 0x01 || c1 == 0x64 && c2 == 0x86 {

diff --git a/src/cmd/link/internal/loadmacho/ldmacho.go b/src/cmd/link/internal/loadmacho/ldmacho.go
index c303752992713045ff5561a130680d5ff3cd316d..7a0e18fe71c09165091856a81dee930b11dfa1c6 100644 (file)
--- a/src/cmd/link/internal/loadmacho/ldmacho.go
+++ b/src/cmd/link/internal/loadmacho/ldmacho.go
@@ -10,6 +10,7 @@ import (
        "cmd/internal/bio"
        "cmd/internal/objabi"
        "cmd/internal/sys"
+       "cmd/link/internal/objfile"
        "cmd/link/internal/sym"
        "encoding/binary"
        "fmt"
@@ -423,14 +424,40 @@ func macholoadsym(m *ldMachoObj, symtab *ldMachoSymtab) int {
        return 0
 }
 
-// Load loads the Mach-O file pn from f.
+func Load(l *objfile.Loader, arch *sys.Arch, syms *sym.Symbols, f *bio.Reader, pkg string, length int64, pn string) error {
+       lookup := func(name string, version int) *sym.Symbol {
+               // Check to see if we've already defined the symbol.
+               if i := l.Lookup(name, version); i != 0 {
+                       return l.Syms[i]
+               }
+               // Not defined, let's make one.
+               if s := l.AddExtSym(name, version); s == 0 {
+                       panic("AddExtSym returned bad index")
+               } else if int(s) != len(l.Syms) {
+                       panic("unexpected length of loaded symbols")
+               }
+               newSym := syms.Newsym(name, version)
+               l.Syms = append(l.Syms, newSym)
+               return newSym
+       }
+       _, err := load(arch, syms.IncVersion(), lookup, f, pkg, length, pn)
+       return err
+}
+
+func LoadOld(arch *sys.Arch, syms *sym.Symbols, f *bio.Reader, pkg string, length int64, pn string) (textp []*sym.Symbol, err error) {
+       lookup := func(name string, version int) *sym.Symbol {
+               return syms.Lookup(name, version)
+       }
+       return load(arch, syms.IncVersion(), lookup, f, pkg, length, pn)
+}
+
+// load the Mach-O file pn from f.
 // Symbols are written into syms, and a slice of the text symbols is returned.
-func Load(arch *sys.Arch, syms *sym.Symbols, f *bio.Reader, pkg string, length int64, pn string) (textp []*sym.Symbol, err error) {
+func load(arch *sys.Arch, localSymVersion int, lookup func(string, int) *sym.Symbol, f *bio.Reader, pkg string, length int64, pn string) (textp []*sym.Symbol, err error) {
        errorf := func(str string, args ...interface{}) ([]*sym.Symbol, error) {
                return nil, fmt.Errorf("loadmacho: %v: %v", pn, fmt.Sprintf(str, args...))
        }
 
-       localSymVersion := syms.IncVersion()
        base := f.Offset()
 
        var hdr [7 * 4]uint8
@@ -562,7 +589,7 @@ func Load(arch *sys.Arch, syms *sym.Symbols, f *bio.Reader, pkg string, length i
                        continue
                }
                name := fmt.Sprintf("%s(%s/%s)", pkg, sect.segname, sect.name)
-               s := syms.Lookup(name, localSymVersion)
+               s := lookup(name, localSymVersion)
                if s.Type != 0 {
                        return errorf("duplicate %s/%s", sect.segname, sect.name)
                }
@@ -610,7 +637,7 @@ func Load(arch *sys.Arch, syms *sym.Symbols, f *bio.Reader, pkg string, length i
                if machsym.type_&N_EXT == 0 {
                        v = localSymVersion
                }
-               s := syms.Lookup(name, v)
+               s := lookup(name, v)
                if machsym.type_&N_EXT == 0 {
                        s.Attr |= sym.AttrDuplicateOK
                }

diff --git a/src/cmd/link/internal/objfile/objfile2.go b/src/cmd/link/internal/objfile/objfile2.go
index ad3ea8577da653de533873ac3d8880f556988d59..8208125cba9584bf824e58b8c0968003c7477da9 100644 (file)
--- a/src/cmd/link/internal/objfile/objfile2.go
+++ b/src/cmd/link/internal/objfile/objfile2.go
@@ -477,8 +477,8 @@ func loadObjReloc(l *Loader, r *oReader) {
                }
 
                if s.Type != 0 && s.Type != sym.SXREF {
-                       fmt.Println("symbol already processed:", lib, i, s)
-                       panic("symbol already processed")
+                       // We've already seen this symbol, it likely came from a host object.
+                       continue
                }
 
                t := sym.AbiSymKindToSymKind[objabi.SymKind(osym.Type)]