go.tools/cmd/godex: a tool to dump export information
Initial implementation. Lots of missing pieces.
Example use:
godex math
godex math.Sin
godex math.Sin math.Cos
LGTM=adonovan
R=adonovan
CC=golang-codereviews
https://golang.org/cl/76890044
This commit is contained in:
Robert Griesemer
parent
a1c1cf19ba
commit
4a27ee3a1b
|
|
@ -0,0 +1,38 @@
|
||||||
|
// Copyright 2014 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.
|
||||||
|
|
||||||
|
// The godex command prints (dumps) exported information of packages
|
||||||
|
// or selected package objects.
|
||||||
|
//
|
||||||
|
// In contrast to godoc, godex extracts this information from compiled
|
||||||
|
// object files. Hence the exported data is truly what a compiler will
|
||||||
|
// see, at the cost of missing commentary.
|
||||||
|
//
|
||||||
|
// Usage: godex [flags] {path|qualifiedIdent}
|
||||||
|
//
|
||||||
|
// Each argument must be a package path, or a qualified identifier.
|
||||||
|
//
|
||||||
|
// The flags are:
|
||||||
|
//
|
||||||
|
// -s=src
|
||||||
|
// only consider packages from src, where src is one of the supported compilers
|
||||||
|
// -v
|
||||||
|
// verbose mode
|
||||||
|
//
|
||||||
|
// The following sources are supported:
|
||||||
|
//
|
||||||
|
// gc
|
||||||
|
// gc-generated object files
|
||||||
|
// gccgo
|
||||||
|
// gccgo-generated object files
|
||||||
|
// gccgo-new
|
||||||
|
// gccgo-generated object files using a condensed format (experimental)
|
||||||
|
// source
|
||||||
|
// (uncompiled) source code (not yet implemented)
|
||||||
|
//
|
||||||
|
// If no -s argument is provided, godex will try to find a matching source.
|
||||||
|
//
|
||||||
|
// TODO(gri) expand this documentation
|
||||||
|
//
|
||||||
|
package main
|
||||||
|
|
@ -0,0 +1,15 @@
|
||||||
|
// Copyright 2014 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.
|
||||||
|
|
||||||
|
// This file implements access to gc-generated export data.
|
||||||
|
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"code.google.com/p/go.tools/go/gcimporter"
|
||||||
|
)
|
||||||
|
|
||||||
|
func init() {
|
||||||
|
register("gc", protect(gcimporter.Import))
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,88 @@
|
||||||
|
// Copyright 2014 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.
|
||||||
|
|
||||||
|
// This file implements access to gccgo-generated export data.
|
||||||
|
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"debug/elf"
|
||||||
|
"fmt"
|
||||||
|
"io"
|
||||||
|
"os"
|
||||||
|
|
||||||
|
"code.google.com/p/go.tools/go/gccgoimporter"
|
||||||
|
"code.google.com/p/go.tools/go/importer"
|
||||||
|
"code.google.com/p/go.tools/go/types"
|
||||||
|
)
|
||||||
|
|
||||||
|
func init() {
|
||||||
|
// importer for default gccgo
|
||||||
|
var inst gccgoimporter.GccgoInstallation
|
||||||
|
inst.InitFromDriver("gccgo")
|
||||||
|
register("gccgo", protect(inst.GetImporter(nil)))
|
||||||
|
|
||||||
|
// importer for gccgo using condensed export format (experimental)
|
||||||
|
register("gccgo-new", protect(gccgoNewImporter))
|
||||||
|
}
|
||||||
|
|
||||||
|
func gccgoNewImporter(packages map[string]*types.Package, path string) (*types.Package, error) {
|
||||||
|
reader, closer, err := openGccgoExportFile(path)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
defer closer.Close()
|
||||||
|
|
||||||
|
// TODO(gri) importer.ImportData takes a []byte instead of an io.Reader;
|
||||||
|
// hence the need to read some amount of data. At the same time we don't
|
||||||
|
// want to read the entire, potentially very large object file. For now,
|
||||||
|
// read 10K. Fix this!
|
||||||
|
var data = make([]byte, 10<<10)
|
||||||
|
n, err := reader.Read(data)
|
||||||
|
if err != nil && err != io.EOF {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
|
||||||
|
return importer.ImportData(packages, data[:n])
|
||||||
|
}
|
||||||
|
|
||||||
|
// openGccgoExportFile was copied from gccgoimporter.
|
||||||
|
func openGccgoExportFile(fpath string) (reader io.ReadSeeker, closer io.Closer, err error) {
|
||||||
|
f, err := os.Open(fpath)
|
||||||
|
if err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
defer func() {
|
||||||
|
if err != nil {
|
||||||
|
f.Close()
|
||||||
|
}
|
||||||
|
}()
|
||||||
|
closer = f
|
||||||
|
|
||||||
|
var magic [4]byte
|
||||||
|
_, err = f.ReadAt(magic[:], 0)
|
||||||
|
if err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
if string(magic[:]) == "v1;\n" {
|
||||||
|
// Raw export data.
|
||||||
|
reader = f
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
ef, err := elf.NewFile(f)
|
||||||
|
if err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
sec := ef.Section(".go_export")
|
||||||
|
if sec == nil {
|
||||||
|
err = fmt.Errorf("%s: .go_export section not found", fpath)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
reader = sec.Open()
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,143 @@
|
||||||
|
// Copyright 2014 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 main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"errors"
|
||||||
|
"flag"
|
||||||
|
"fmt"
|
||||||
|
"os"
|
||||||
|
"strings"
|
||||||
|
|
||||||
|
"code.google.com/p/go.tools/go/types"
|
||||||
|
)
|
||||||
|
|
||||||
|
var (
|
||||||
|
source = flag.String("s", "", "only consider packages from this source")
|
||||||
|
verbose = flag.Bool("v", false, "verbose mode")
|
||||||
|
)
|
||||||
|
|
||||||
|
var (
|
||||||
|
importFailed = errors.New("import failed")
|
||||||
|
importers = make(map[string]types.Importer)
|
||||||
|
packages = make(map[string]*types.Package)
|
||||||
|
)
|
||||||
|
|
||||||
|
func usage() {
|
||||||
|
fmt.Fprintln(os.Stderr, "usage: godex [flags] {path|qualifiedIdent}")
|
||||||
|
flag.PrintDefaults()
|
||||||
|
os.Exit(2)
|
||||||
|
}
|
||||||
|
|
||||||
|
func report(msg string) {
|
||||||
|
fmt.Fprintln(os.Stderr, "error: "+msg)
|
||||||
|
os.Exit(2)
|
||||||
|
}
|
||||||
|
|
||||||
|
func main() {
|
||||||
|
flag.Usage = usage
|
||||||
|
flag.Parse()
|
||||||
|
|
||||||
|
if flag.NArg() == 0 {
|
||||||
|
report("no package name, path, or file provided")
|
||||||
|
}
|
||||||
|
|
||||||
|
imp := tryImport
|
||||||
|
if *source != "" {
|
||||||
|
imp = importers[*source]
|
||||||
|
if imp == nil {
|
||||||
|
report("source must be one of: " + importersList())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, arg := range flag.Args() {
|
||||||
|
if *verbose {
|
||||||
|
fmt.Fprintf(os.Stderr, "(processing %s)\n", arg)
|
||||||
|
}
|
||||||
|
|
||||||
|
// determine import path, object name
|
||||||
|
var path, name string
|
||||||
|
elems := strings.Split(arg, ".")
|
||||||
|
switch len(elems) {
|
||||||
|
case 2:
|
||||||
|
name = elems[1]
|
||||||
|
fallthrough
|
||||||
|
case 1:
|
||||||
|
path = elems[0]
|
||||||
|
default:
|
||||||
|
fmt.Fprintf(os.Stderr, "ignoring %q: invalid path or (qualified) identifier\n", arg)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
// import package
|
||||||
|
pkg, err := imp(packages, path)
|
||||||
|
if err != nil {
|
||||||
|
fmt.Fprintf(os.Stderr, "ignoring %q: %s\n", path, err)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
// filter objects if needed
|
||||||
|
filter := exportFilter
|
||||||
|
if name != "" {
|
||||||
|
f := filter
|
||||||
|
filter = func(obj types.Object) bool {
|
||||||
|
// TODO(gri) perhaps use regular expression matching here?
|
||||||
|
return f(obj) && obj.Name() == name
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// print contents
|
||||||
|
print(os.Stdout, pkg, filter)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// protect protects an importer imp from panics and returns the protected importer.
|
||||||
|
func protect(imp types.Importer) types.Importer {
|
||||||
|
return func(packages map[string]*types.Package, path string) (pkg *types.Package, err error) {
|
||||||
|
defer func() {
|
||||||
|
if recover() != nil {
|
||||||
|
pkg = nil
|
||||||
|
err = importFailed
|
||||||
|
}
|
||||||
|
}()
|
||||||
|
return imp(packages, path)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func tryImport(packages map[string]*types.Package, path string) (pkg *types.Package, err error) {
|
||||||
|
for source, imp := range importers {
|
||||||
|
if *verbose {
|
||||||
|
fmt.Fprintf(os.Stderr, "(trying as %s)\n", source)
|
||||||
|
}
|
||||||
|
pkg, err = imp(packages, path)
|
||||||
|
if err == nil {
|
||||||
|
break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
func register(source string, imp types.Importer) {
|
||||||
|
if _, ok := importers[source]; ok {
|
||||||
|
panic(source + " importer already registered")
|
||||||
|
}
|
||||||
|
importers[source] = imp
|
||||||
|
}
|
||||||
|
|
||||||
|
func importersList() string {
|
||||||
|
var s string
|
||||||
|
for n := range importers {
|
||||||
|
if len(s) == 0 {
|
||||||
|
s = n
|
||||||
|
} else {
|
||||||
|
s = s + ", " + n
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return s
|
||||||
|
}
|
||||||
|
|
||||||
|
func exportFilter(obj types.Object) bool {
|
||||||
|
return obj.Exported()
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,155 @@
|
||||||
|
// Copyright 2014 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 main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bytes"
|
||||||
|
"fmt"
|
||||||
|
"io"
|
||||||
|
|
||||||
|
"code.google.com/p/go.tools/go/types"
|
||||||
|
)
|
||||||
|
|
||||||
|
// TODO(gri) handle indentation
|
||||||
|
// TODO(gri) filter unexported fields of struct types?
|
||||||
|
// TODO(gri) use tabwriter for alignment?
|
||||||
|
|
||||||
|
func print(w io.Writer, pkg *types.Package, filter func(types.Object) bool) {
|
||||||
|
var p printer
|
||||||
|
p.pkg = pkg
|
||||||
|
p.printPackage(pkg, filter)
|
||||||
|
io.Copy(w, &p.buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
type printer struct {
|
||||||
|
pkg *types.Package
|
||||||
|
buf bytes.Buffer
|
||||||
|
indent int
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *printer) print(s string) {
|
||||||
|
p.buf.WriteString(s)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *printer) printf(format string, args ...interface{}) {
|
||||||
|
fmt.Fprintf(&p.buf, format, args...)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *printer) printPackage(pkg *types.Package, filter func(types.Object) bool) {
|
||||||
|
// collect objects by kind
|
||||||
|
var (
|
||||||
|
consts []*types.Const
|
||||||
|
typez []*types.TypeName // types without methods
|
||||||
|
typem []*types.TypeName // types with methods
|
||||||
|
vars []*types.Var
|
||||||
|
funcs []*types.Func
|
||||||
|
)
|
||||||
|
scope := pkg.Scope()
|
||||||
|
for _, name := range scope.Names() {
|
||||||
|
obj := scope.Lookup(name)
|
||||||
|
if !filter(obj) {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
switch obj := obj.(type) {
|
||||||
|
case *types.Const:
|
||||||
|
consts = append(consts, obj)
|
||||||
|
case *types.TypeName:
|
||||||
|
if obj.Type().(*types.Named).NumMethods() > 0 {
|
||||||
|
typem = append(typem, obj)
|
||||||
|
} else {
|
||||||
|
typez = append(typez, obj)
|
||||||
|
}
|
||||||
|
case *types.Var:
|
||||||
|
vars = append(vars, obj)
|
||||||
|
case *types.Func:
|
||||||
|
funcs = append(funcs, obj)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
p.printf("package %s\n\n", pkg.Name())
|
||||||
|
|
||||||
|
if len(consts) > 0 {
|
||||||
|
p.print("const (\n")
|
||||||
|
for _, obj := range consts {
|
||||||
|
p.printObj(obj)
|
||||||
|
p.print("\n")
|
||||||
|
}
|
||||||
|
p.print(")\n\n")
|
||||||
|
}
|
||||||
|
|
||||||
|
if len(vars) > 0 {
|
||||||
|
p.print("var (\n")
|
||||||
|
for _, obj := range vars {
|
||||||
|
p.printObj(obj)
|
||||||
|
p.print("\n")
|
||||||
|
}
|
||||||
|
p.print(")\n\n")
|
||||||
|
}
|
||||||
|
|
||||||
|
if len(typez) > 0 {
|
||||||
|
p.print("type (\n")
|
||||||
|
for _, obj := range typez {
|
||||||
|
p.printf("\t%s ", obj.Name())
|
||||||
|
types.WriteType(&p.buf, p.pkg, obj.Type().Underlying())
|
||||||
|
p.print("\n")
|
||||||
|
}
|
||||||
|
p.print(")\n\n")
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, obj := range typem {
|
||||||
|
p.printf("type %s ", obj.Name())
|
||||||
|
typ := obj.Type().(*types.Named)
|
||||||
|
types.WriteType(&p.buf, p.pkg, typ.Underlying())
|
||||||
|
p.print("\n")
|
||||||
|
for i, n := 0, typ.NumMethods(); i < n; i++ {
|
||||||
|
p.printFunc(typ.Method(i))
|
||||||
|
p.print("\n")
|
||||||
|
}
|
||||||
|
p.print("\n")
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, obj := range funcs {
|
||||||
|
p.printFunc(obj)
|
||||||
|
p.print("\n")
|
||||||
|
}
|
||||||
|
|
||||||
|
p.print("\n")
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *printer) printObj(obj types.Object) {
|
||||||
|
p.printf("\t %s", obj.Name())
|
||||||
|
// don't write untyped types (for constants)
|
||||||
|
if typ := obj.Type(); typed(typ) {
|
||||||
|
p.print(" ")
|
||||||
|
types.WriteType(&p.buf, p.pkg, typ)
|
||||||
|
}
|
||||||
|
// write constant value
|
||||||
|
if obj, ok := obj.(*types.Const); ok {
|
||||||
|
p.printf(" = %s", obj.Val())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *printer) printFunc(obj *types.Func) {
|
||||||
|
p.print("func ")
|
||||||
|
sig := obj.Type().(*types.Signature)
|
||||||
|
if recv := sig.Recv(); recv != nil {
|
||||||
|
p.print("(")
|
||||||
|
if name := recv.Name(); name != "" {
|
||||||
|
p.print(name)
|
||||||
|
p.print(" ")
|
||||||
|
}
|
||||||
|
types.WriteType(&p.buf, p.pkg, recv.Type())
|
||||||
|
p.print(") ")
|
||||||
|
}
|
||||||
|
p.print(obj.Name())
|
||||||
|
types.WriteSignature(&p.buf, p.pkg, sig)
|
||||||
|
}
|
||||||
|
|
||||||
|
func typed(typ types.Type) bool {
|
||||||
|
if t, ok := typ.Underlying().(*types.Basic); ok {
|
||||||
|
return t.Info()&types.IsUntyped == 0
|
||||||
|
}
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,19 @@
|
||||||
|
// Copyright 2014 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.
|
||||||
|
|
||||||
|
// This file implements access to export data from source.
|
||||||
|
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"code.google.com/p/go.tools/go/types"
|
||||||
|
)
|
||||||
|
|
||||||
|
func init() {
|
||||||
|
register("source", protect(sourceImporter))
|
||||||
|
}
|
||||||
|
|
||||||
|
func sourceImporter(packages map[string]*types.Package, path string) (*types.Package, error) {
|
||||||
|
panic("unimplemented")
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue