mirror of
https://github.com/golang/go.git
synced 2025-12-08 06:10:04 +00:00
af8a2bde7b
This method is only used to find the path of the function being compiled for hash debugging, but it was instead returning the path of the package being compiled. These are typically the same, but can be different for certain functions compiled across package boundaries (e.g., method value wrappers and generic functions). It's redundant either with f.fe.Func().Sym().Pkg.Path (package path of the function being compiled) or f.Config.ctxt.Pkgpath (package path of the compilation unit), so just remove it instead. Change-Id: I1daae09055043d0ecb1fcc874a0b0006a6f8bddf Reviewed-on: https://go-review.googlesource.com/c/go/+/526516 Auto-Submit: Matthew Dempsky <mdempsky@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: Keith Randall <khr@golang.org>
129 lines
3.2 KiB
Go
129 lines
3.2 KiB
Go
// Copyright 2015 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 ssa
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"cmd/compile/internal/ir"
|
|
"cmd/compile/internal/typecheck"
|
|
"cmd/compile/internal/types"
|
|
"cmd/internal/obj"
|
|
"cmd/internal/obj/arm64"
|
|
"cmd/internal/obj/s390x"
|
|
"cmd/internal/obj/x86"
|
|
"cmd/internal/src"
|
|
)
|
|
|
|
var CheckFunc = checkFunc
|
|
var Opt = opt
|
|
var Deadcode = deadcode
|
|
var Copyelim = copyelim
|
|
|
|
var testCtxts = map[string]*obj.Link{
|
|
"amd64": obj.Linknew(&x86.Linkamd64),
|
|
"s390x": obj.Linknew(&s390x.Links390x),
|
|
"arm64": obj.Linknew(&arm64.Linkarm64),
|
|
}
|
|
|
|
func testConfig(tb testing.TB) *Conf { return testConfigArch(tb, "amd64") }
|
|
func testConfigS390X(tb testing.TB) *Conf { return testConfigArch(tb, "s390x") }
|
|
func testConfigARM64(tb testing.TB) *Conf { return testConfigArch(tb, "arm64") }
|
|
|
|
func testConfigArch(tb testing.TB, arch string) *Conf {
|
|
ctxt, ok := testCtxts[arch]
|
|
if !ok {
|
|
tb.Fatalf("unknown arch %s", arch)
|
|
}
|
|
if ctxt.Arch.PtrSize != 8 {
|
|
tb.Fatal("testTypes is 64-bit only")
|
|
}
|
|
c := &Conf{
|
|
config: NewConfig(arch, testTypes, ctxt, true, false),
|
|
tb: tb,
|
|
}
|
|
return c
|
|
}
|
|
|
|
type Conf struct {
|
|
config *Config
|
|
tb testing.TB
|
|
fe Frontend
|
|
}
|
|
|
|
func (c *Conf) Frontend() Frontend {
|
|
if c.fe == nil {
|
|
f := ir.NewFunc(src.NoXPos, src.NoXPos, &types.Sym{
|
|
Pkg: types.NewPkg("my/import/path", "path"),
|
|
Name: "function",
|
|
}, nil)
|
|
f.LSym = &obj.LSym{Name: "my/import/path.function"}
|
|
|
|
c.fe = TestFrontend{
|
|
t: c.tb,
|
|
ctxt: c.config.ctxt,
|
|
f: f,
|
|
}
|
|
}
|
|
return c.fe
|
|
}
|
|
|
|
// TestFrontend is a test-only frontend.
|
|
// It assumes 64 bit integers and pointers.
|
|
type TestFrontend struct {
|
|
t testing.TB
|
|
ctxt *obj.Link
|
|
f *ir.Func
|
|
}
|
|
|
|
func (TestFrontend) StringData(s string) *obj.LSym {
|
|
return nil
|
|
}
|
|
func (TestFrontend) Auto(pos src.XPos, t *types.Type) *ir.Name {
|
|
n := ir.NewNameAt(pos, &types.Sym{Name: "aFakeAuto"}, t)
|
|
n.Class = ir.PAUTO
|
|
return n
|
|
}
|
|
func (d TestFrontend) SplitSlot(parent *LocalSlot, suffix string, offset int64, t *types.Type) LocalSlot {
|
|
return LocalSlot{N: parent.N, Type: t, Off: offset}
|
|
}
|
|
func (TestFrontend) AllocFrame(f *Func) {
|
|
}
|
|
func (d TestFrontend) Syslook(s string) *obj.LSym {
|
|
return d.ctxt.Lookup(s)
|
|
}
|
|
func (TestFrontend) UseWriteBarrier() bool {
|
|
return true // only writebarrier_test cares
|
|
}
|
|
|
|
func (d TestFrontend) Logf(msg string, args ...interface{}) { d.t.Logf(msg, args...) }
|
|
func (d TestFrontend) Log() bool { return true }
|
|
|
|
func (d TestFrontend) Fatalf(_ src.XPos, msg string, args ...interface{}) { d.t.Fatalf(msg, args...) }
|
|
func (d TestFrontend) Warnl(_ src.XPos, msg string, args ...interface{}) { d.t.Logf(msg, args...) }
|
|
func (d TestFrontend) Debug_checknil() bool { return false }
|
|
|
|
func (d TestFrontend) Func() *ir.Func {
|
|
return d.f
|
|
}
|
|
|
|
var testTypes Types
|
|
|
|
func init() {
|
|
// TODO(mdempsky): Push into types.InitUniverse or typecheck.InitUniverse.
|
|
types.PtrSize = 8
|
|
types.RegSize = 8
|
|
types.MaxWidth = 1 << 50
|
|
|
|
typecheck.InitUniverse()
|
|
testTypes.SetTypPtrs()
|
|
}
|
|
|
|
func (d TestFrontend) DerefItab(sym *obj.LSym, off int64) *obj.LSym { return nil }
|
|
|
|
func (d TestFrontend) CanSSA(t *types.Type) bool {
|
|
// There are no un-SSAable types in test land.
|
|
return true
|
|
}
|