1 files changed, 296 insertions, 0 deletions
diff --git a/src/cmd/compile/internal/noder/linker.go b/src/cmd/compile/internal/noder/linker.go
new file mode 100644
index 0000000000..2bc7f7c608
--- /dev/null
+++ b/src/cmd/compile/internal/noder/linker.go
@@ -0,0 +1,296 @@
+// UNREVIEWED
+
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package noder
+
+import (
+	"io"
+
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/reflectdata"
+	"cmd/compile/internal/types"
+	"cmd/internal/goobj"
+	"cmd/internal/obj"
+)
+
+// This file implements the unified IR linker, which combines the
+// local package's stub data with imported package data to produce a
+// complete export data file. It also rewrites the compiler's
+// extension data sections based on the results of compilation (e.g.,
+// the function inlining cost and linker symbol index assignments).
+//
+// TODO(mdempsky): Using the name "linker" here is confusing, because
+// readers are likely to mistake references to it for cmd/link. But
+// there's a shortage of good names for "something that combines
+// multiple parts into a cohesive whole"... e.g., "assembler" and
+// "compiler" are also already taken.
+
+type linker struct {
+	pw pkgEncoder
+
+	pkgs  map[string]int
+	decls map[*types.Sym]int
+}
+
+func (l *linker) relocAll(pr *pkgReader, relocs []relocEnt) []relocEnt {
+	res := make([]relocEnt, len(relocs))
+	for i, rent := range relocs {
+		rent.idx = l.relocIdx(pr, rent.kind, rent.idx)
+		res[i] = rent
+	}
+	return res
+}
+
+func (l *linker) relocIdx(pr *pkgReader, k reloc, idx int) int {
+	assert(pr != nil)
+
+	absIdx := pr.absIdx(k, idx)
+
+	if newidx := pr.newindex[absIdx]; newidx != 0 {
+		return ^newidx
+	}
+
+	var newidx int
+	switch k {
+	case relocString:
+		newidx = l.relocString(pr, idx)
+	case relocPkg:
+		newidx = l.relocPkg(pr, idx)
+	case relocObj:
+		newidx = l.relocObj(pr, idx)
+
+	default:
+		// Generic relocations.
+		//
+		// TODO(mdempsky): Deduplicate more sections? In fact, I think
+		// every section could be deduplicated. This would also be easier
+		// if we do external relocations.
+
+		w := l.pw.newEncoderRaw(k)
+		l.relocCommon(pr, &w, k, idx)
+		newidx = w.idx
+	}
+
+	pr.newindex[absIdx] = ^newidx
+
+	return newidx
+}
+
+func (l *linker) relocString(pr *pkgReader, idx int) int {
+	return l.pw.stringIdx(pr.stringIdx(idx))
+}
+
+func (l *linker) relocPkg(pr *pkgReader, idx int) int {
+	path := pr.peekPkgPath(idx)
+
+	if newidx, ok := l.pkgs[path]; ok {
+		return newidx
+	}
+
+	r := pr.newDecoder(relocPkg, idx, syncPkgDef)
+	w := l.pw.newEncoder(relocPkg, syncPkgDef)
+	l.pkgs[path] = w.idx
+
+	// TODO(mdempsky): We end up leaving an empty string reference here
+	// from when the package was originally written as "". Probably not
+	// a big deal, but a little annoying. Maybe relocating
+	// cross-references in place is the way to go after all.
+	w.relocs = l.relocAll(pr, r.relocs)
+
+	_ = r.string() // original path
+	w.string(path)
+
+	io.Copy(&w.data, &r.data)
+
+	return w.flush()
+}
+
+func (l *linker) relocObj(pr *pkgReader, idx int) int {
+	path, name, tag := pr.peekObj(idx)
+	sym := types.NewPkg(path, "").Lookup(name)
+
+	if newidx, ok := l.decls[sym]; ok {
+		return newidx
+	}
+
+	if tag == objStub && path != "builtin" && path != "unsafe" {
+		pri, ok := objReader[sym]
+		if !ok {
+			base.Fatalf("missing reader for %q.%v", path, name)
+		}
+		assert(ok)
+
+		pr = pri.pr
+		idx = pri.idx
+
+		path2, name2, tag2 := pr.peekObj(idx)
+		sym2 := types.NewPkg(path2, "").Lookup(name2)
+		assert(sym == sym2)
+		assert(tag2 != objStub)
+	}
+
+	w := l.pw.newEncoderRaw(relocObj)
+	wext := l.pw.newEncoderRaw(relocObjExt)
+	wname := l.pw.newEncoderRaw(relocName)
+	wdict := l.pw.newEncoderRaw(relocObjDict)
+
+	l.decls[sym] = w.idx
+	assert(wext.idx == w.idx)
+	assert(wname.idx == w.idx)
+	assert(wdict.idx == w.idx)
+
+	l.relocCommon(pr, &w, relocObj, idx)
+	l.relocCommon(pr, &wname, relocName, idx)
+	l.relocCommon(pr, &wdict, relocObjDict, idx)
+
+	var obj *ir.Name
+	if path == "" {
+		var ok bool
+		obj, ok = sym.Def.(*ir.Name)
+
+		// Generic types and functions and declared constraint types won't
+		// have definitions.
+		// For now, just generically copy their extension data.
+		// TODO(mdempsky): Restore assertion.
+		if !ok && false {
+			base.Fatalf("missing definition for %v", sym)
+		}
+	}
+
+	if obj != nil {
+		wext.sync(syncObject1)
+		switch tag {
+		case objFunc:
+			l.relocFuncExt(&wext, obj)
+		case objType:
+			l.relocTypeExt(&wext, obj)
+		case objVar:
+			l.relocVarExt(&wext, obj)
+		}
+		wext.flush()
+	} else {
+		l.relocCommon(pr, &wext, relocObjExt, idx)
+	}
+
+	return w.idx
+}
+
+func (l *linker) relocCommon(pr *pkgReader, w *encoder, k reloc, idx int) {
+	r := pr.newDecoderRaw(k, idx)
+	w.relocs = l.relocAll(pr, r.relocs)
+	io.Copy(&w.data, &r.data)
+	w.flush()
+}
+
+func (l *linker) pragmaFlag(w *encoder, pragma ir.PragmaFlag) {
+	w.sync(syncPragma)
+	w.int(int(pragma))
+}
+
+func (l *linker) relocFuncExt(w *encoder, name *ir.Name) {
+	w.sync(syncFuncExt)
+
+	l.pragmaFlag(w, name.Func.Pragma)
+	l.linkname(w, name)
+
+	// Relocated extension data.
+	w.bool(true)
+
+	// Record definition ABI so cross-ABI calls can be direct.
+	// This is important for the performance of calling some
+	// common functions implemented in assembly (e.g., bytealg).
+	w.uint64(uint64(name.Func.ABI))
+
+	// Escape analysis.
+	for _, fs := range &types.RecvsParams {
+		for _, f := range fs(name.Type()).FieldSlice() {
+			w.string(f.Note)
+		}
+	}
+
+	if inl := name.Func.Inl; w.bool(inl != nil) {
+		w.len(int(inl.Cost))
+		w.bool(inl.CanDelayResults)
+
+		pri, ok := bodyReader[name.Func]
+		assert(ok)
+		w.reloc(relocBody, l.relocIdx(pri.pr, relocBody, pri.idx))
+	}
+
+	w.sync(syncEOF)
+}
+
+func (l *linker) relocTypeExt(w *encoder, name *ir.Name) {
+	w.sync(syncTypeExt)
+
+	typ := name.Type()
+
+	l.pragmaFlag(w, name.Pragma())
+
+	// For type T, export the index of type descriptor symbols of T and *T.
+	l.lsymIdx(w, "", reflectdata.TypeLinksym(typ))
+	l.lsymIdx(w, "", reflectdata.TypeLinksym(typ.PtrTo()))
+
+	if typ.Kind() != types.TINTER {
+		for _, method := range typ.Methods().Slice() {
+			l.relocFuncExt(w, method.Nname.(*ir.Name))
+		}
+	}
+}
+
+func (l *linker) relocVarExt(w *encoder, name *ir.Name) {
+	w.sync(syncVarExt)
+	l.linkname(w, name)
+}
+
+func (l *linker) linkname(w *encoder, name *ir.Name) {
+	w.sync(syncLinkname)
+
+	linkname := name.Sym().Linkname
+	if !l.lsymIdx(w, linkname, name.Linksym()) {
+		w.string(linkname)
+	}
+}
+
+func (l *linker) lsymIdx(w *encoder, linkname string, lsym *obj.LSym) bool {
+	if lsym.PkgIdx > goobj.PkgIdxSelf || (lsym.PkgIdx == goobj.PkgIdxInvalid && !lsym.Indexed()) || linkname != "" {
+		w.int64(-1)
+		return false
+	}
+
+	// For a defined symbol, export its index.
+	// For re-exporting an imported symbol, pass its index through.
+	w.int64(int64(lsym.SymIdx))
+	return true
+}
+
+// @@@ Helpers
+
+// TODO(mdempsky): These should probably be removed. I think they're a
+// smell that the export data format is not yet quite right.
+
+func (pr *pkgDecoder) peekPkgPath(idx int) string {
+	r := pr.newDecoder(relocPkg, idx, syncPkgDef)
+	path := r.string()
+	if path == "" {
+		path = pr.pkgPath
+	}
+	return path
+}
+
+func (pr *pkgDecoder) peekObj(idx int) (string, string, codeObj) {
+	r := pr.newDecoder(relocName, idx, syncObject1)
+	r.sync(syncSym)
+	r.sync(syncPkg)
+	path := pr.peekPkgPath(r.reloc(relocPkg))
+	name := r.string()
+	assert(name != "")
+
+	tag := codeObj(r.code(syncCodeObj))
+
+	return path, name, tag
+}