src/pkg/exp/ogle/cmd.go - go - Git at Google

 // Copyright 2009 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.

 // Ogle is the beginning of a debugger for Go.
 package ogle

 import (
 	"bufio";
 	"debug/elf";
 	"debug/proc";
 	"exp/eval";
 	"fmt";
 	"go/scanner";
 	"go/token";
 	"os";
 	"strconv";
 	"strings";
 )

 var world *eval.World
 var curProc *Process

 func Main() {
 	world = eval.NewWorld();
 	defineFuncs();
 	r := bufio.NewReader(os.Stdin);
 	for {
 		print("; ");
 		line, err := r.ReadSlice('\n');
 		if err != nil {
 			break
 		}

 		// Try line as a command
 		cmd, rest := getCmd(line);
 		if cmd != nil {
 			err := cmd.handler(rest);
 			if err != nil {
 				scanner.PrintError(os.Stderr, err)
 			}
 			continue;
 		}

 		// Try line as code
 		code, err := world.Compile(string(line));
 		if err != nil {
 			scanner.PrintError(os.Stderr, err);
 			continue;
 		}
 		v, err := code.Run();
 		if err != nil {
 			fmt.Fprintf(os.Stderr, err.String());
 			continue;
 		}
 		if v != nil {
 			println(v.String())
 		}
 	}
 }

 // newScanner creates a new scanner that scans that given input bytes.
 func newScanner(input []byte) (*scanner.Scanner, *scanner.ErrorVector) {
 	sc := new(scanner.Scanner);
 	ev := new(scanner.ErrorVector);
 	ev.Init();
 	sc.Init("input", input, ev, 0);

 	return sc, ev;
 }

 /*
  * Commands
  */

 // A UsageError occurs when a command is called with illegal arguments.
 type UsageError string

 func (e UsageError) String() string	{ return string(e) }

 // A cmd represents a single command with a handler.
 type cmd struct {
 	cmd	string;
 	handler	func([]byte) os.Error;
 }

 var cmds = []cmd{
 	cmd{"load", cmdLoad},
 	cmd{"bt", cmdBt},
 }

 // getCmd attempts to parse an input line as a registered command.  If
 // successful, it returns the command and the bytes remaining after
 // the command, which should be passed to the command.
 func getCmd(line []byte) (*cmd, []byte) {
 	sc, _ := newScanner(line);
 	pos, tok, lit := sc.Scan();
 	if sc.ErrorCount != 0 || tok != token.IDENT {
 		return nil, nil
 	}

 	slit := string(lit);
 	for i := range cmds {
 		if cmds[i].cmd == slit {
 			return &cmds[i], line[pos.Offset+len(lit) : len(line)]
 		}
 	}
 	return nil, nil;
 }

 // cmdLoad starts or attaches to a process.  Its form is similar to
 // import:
 //
 //  load [sym] "path" [;]
 //
 // sym specifies the name to give to the process.  If not given, the
 // name is derived from the path of the process.  If ".", then the
 // packages from the remote process are defined into the current
 // namespace.  If given, this symbol is defined as a package
 // containing the process' packages.
 //
 // path gives the path of the process to start or attach to.  If it is
 // "pid:<num>", then attach to the given PID.  Otherwise, treat it as
 // a file path and space-separated arguments and start a new process.
 //
 // load always sets the current process to the loaded process.
 func cmdLoad(args []byte) os.Error {
 	ident, path, err := parseLoad(args);
 	if err != nil {
 		return err
 	}
 	if curProc != nil {
 		return UsageError("multiple processes not implemented")
 	}
 	if ident != "." {
 		return UsageError("process identifiers not implemented")
 	}

 	// Parse argument and start or attach to process
 	var fname string;
 	var tproc proc.Process;
 	if len(path) >= 4 && path[0:4] == "pid:" {
 		pid, err := strconv.Atoi(path[4:len(path)]);
 		if err != nil {
 			return err
 		}
 		fname, err = os.Readlink(fmt.Sprintf("/proc/%d/exe", pid));
 		if err != nil {
 			return err
 		}
 		tproc, err = proc.Attach(pid);
 		if err != nil {
 			return err
 		}
 		println("Attached to", pid);
 	} else {
 		parts := strings.Split(path, " ", 0);
 		if len(parts) == 0 {
 			fname = ""
 		} else {
 			fname = parts[0]
 		}
 		tproc, err = proc.ForkExec(fname, parts, os.Environ(), "", []*os.File{os.Stdin, os.Stdout, os.Stderr});
 		if err != nil {
 			return err
 		}
 		println("Started", path);
 		// TODO(austin) If we fail after this point, kill tproc
 		// before detaching.
 	}

 	// Get symbols
 	f, err := os.Open(fname, os.O_RDONLY, 0);
 	if err != nil {
 		tproc.Detach();
 		return err;
 	}
 	defer f.Close();
 	elf, err := elf.NewFile(f);
 	if err != nil {
 		tproc.Detach();
 		return err;
 	}
 	curProc, err = NewProcessElf(tproc, elf);
 	if err != nil {
 		tproc.Detach();
 		return err;
 	}

 	// Prepare new process
 	curProc.OnGoroutineCreate().AddHandler(EventPrint);
 	curProc.OnGoroutineExit().AddHandler(EventPrint);

 	err = curProc.populateWorld(world);
 	if err != nil {
 		tproc.Detach();
 		return err;
 	}

 	return nil;
 }

 func parseLoad(args []byte) (ident string, path string, err os.Error) {
 	err = UsageError("Usage: load [sym] \"path\"");
 	sc, ev := newScanner(args);

 	var toks [4]token.Token;
 	var lits [4][]byte;
 	for i := range toks {
 		_, toks[i], lits[i] = sc.Scan()
 	}
 	if sc.ErrorCount != 0 {
 		err = ev.GetError(scanner.NoMultiples);
 		return;
 	}

 	i := 0;
 	switch toks[i] {
 	case token.PERIOD, token.IDENT:
 		ident = string(lits[i]);
 		i++;
 	}

 	if toks[i] != token.STRING {
 		return
 	}
 	path, uerr := strconv.Unquote(string(lits[i]));
 	if uerr != nil {
 		err = uerr;
 		return;
 	}
 	i++;

 	if toks[i] == token.SEMICOLON {
 		i++
 	}
 	if toks[i] != token.EOF {
 		return
 	}

 	return ident, path, nil;
 }

 // cmdBt prints a backtrace for the current goroutine.  It takes no
 // arguments.
 func cmdBt(args []byte) os.Error {
 	err := parseNoArgs(args, "Usage: bt");
 	if err != nil {
 		return err
 	}

 	if curProc == nil || curProc.curGoroutine == nil {
 		return NoCurrentGoroutine{}
 	}

 	f := curProc.curGoroutine.frame;
 	if f == nil {
 		fmt.Println("No frames on stack");
 		return nil;
 	}

 	for f.Inner() != nil {
 		f = f.Inner()
 	}

 	for i := 0; i < 100; i++ {
 		if f == curProc.curGoroutine.frame {
 			fmt.Printf("=> ")
 		} else {
 			fmt.Printf("   ")
 		}
 		fmt.Printf("%8x %v\n", f.pc, f);
 		f, err = f.Outer();
 		if err != nil {
 			return err
 		}
 		if f == nil {
 			return nil
 		}
 	}

 	fmt.Println("...");
 	return nil;
 }

 func parseNoArgs(args []byte, usage string) os.Error {
 	sc, ev := newScanner(args);
 	_, tok, _ := sc.Scan();
 	if sc.ErrorCount != 0 {
 		return ev.GetError(scanner.NoMultiples)
 	}
 	if tok != token.EOF {
 		return UsageError(usage)
 	}
 	return nil;
 }

 /*
  * Functions
  */

 // defineFuncs populates world with the built-in functions.
 func defineFuncs() {
 	t, v := eval.FuncFromNativeTyped(fnOut, fnOutSig);
 	world.DefineConst("Out", t, v);
 	t, v = eval.FuncFromNativeTyped(fnContWait, fnContWaitSig);
 	world.DefineConst("ContWait", t, v);
 	t, v = eval.FuncFromNativeTyped(fnBpSet, fnBpSetSig);
 	world.DefineConst("BpSet", t, v);
 }

 // printCurFrame prints the current stack frame, as it would appear in
 // a backtrace.
 func printCurFrame() {
 	if curProc == nil || curProc.curGoroutine == nil {
 		return
 	}
 	f := curProc.curGoroutine.frame;
 	if f == nil {
 		return
 	}
 	fmt.Printf("=> %8x %v\n", f.pc, f);
 }

 // fnOut moves the current frame to the caller of the current frame.
 func fnOutSig()	{}
 func fnOut(t *eval.Thread, args []eval.Value, res []eval.Value) {
 	if curProc == nil {
 		t.Abort(NoCurrentGoroutine{})
 	}
 	err := curProc.Out();
 	if err != nil {
 		t.Abort(err)
 	}
 	// TODO(austin) Only in the command form
 	printCurFrame();
 }

 // fnContWait continues the current process and waits for a stopping event.
 func fnContWaitSig()	{}
 func fnContWait(t *eval.Thread, args []eval.Value, res []eval.Value) {
 	if curProc == nil {
 		t.Abort(NoCurrentGoroutine{})
 	}
 	err := curProc.ContWait();
 	if err != nil {
 		t.Abort(err)
 	}
 	// TODO(austin) Only in the command form
 	ev := curProc.Event();
 	if ev != nil {
 		fmt.Printf("%v\n", ev)
 	}
 	printCurFrame();
 }

 // fnBpSet sets a breakpoint at the entry to the named function.
 func fnBpSetSig(string)	{}
 func fnBpSet(t *eval.Thread, args []eval.Value, res []eval.Value) {
 	// TODO(austin) This probably shouldn't take a symbol name.
 	// Perhaps it should take an interface that provides PC's.
 	// Functions and instructions can implement that interface and
 	// we can have something to translate file:line pairs.
 	if curProc == nil {
 		t.Abort(NoCurrentGoroutine{})
 	}
 	name := args[0].(eval.StringValue).Get(t);
 	fn := curProc.syms.LookupFunc(name);
 	if fn == nil {
 		t.Abort(UsageError("no such function " + name))
 	}
 	curProc.OnBreakpoint(proc.Word(fn.Entry)).AddHandler(EventStop);
 }
	// Copyright 2009 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.

	// Ogle is the beginning of a debugger for Go.
	package ogle

	import (
	"bufio";
	"debug/elf";
	"debug/proc";
	"exp/eval";
	"fmt";
	"go/scanner";
	"go/token";
	"os";
	"strconv";
	"strings";
	)

	var world *eval.World
	var curProc *Process

	func Main() {
	world = eval.NewWorld();
	defineFuncs();
	r := bufio.NewReader(os.Stdin);
	for {
	print("; ");
	line, err := r.ReadSlice('\n');
	if err != nil {
	break
	}

	// Try line as a command
	cmd, rest := getCmd(line);
	if cmd != nil {
	err := cmd.handler(rest);
	if err != nil {
	scanner.PrintError(os.Stderr, err)
	}
	continue;
	}

	// Try line as code
	code, err := world.Compile(string(line));
	if err != nil {
	scanner.PrintError(os.Stderr, err);
	continue;
	}
	v, err := code.Run();
	if err != nil {
	fmt.Fprintf(os.Stderr, err.String());
	continue;
	}
	if v != nil {
	println(v.String())
	}
	}
	}

	// newScanner creates a new scanner that scans that given input bytes.
	func newScanner(input []byte) (scanner.Scanner, scanner.ErrorVector) {
	sc := new(scanner.Scanner);
	ev := new(scanner.ErrorVector);
	ev.Init();
	sc.Init("input", input, ev, 0);

	return sc, ev;
	}

	/*
	* Commands
	*/

	// A UsageError occurs when a command is called with illegal arguments.
	type UsageError string

	func (e UsageError) String() string { return string(e) }

	// A cmd represents a single command with a handler.
	type cmd struct {
	cmd string;
	handler func([]byte) os.Error;
	}

	var cmds = []cmd{
	cmd{"load", cmdLoad},
	cmd{"bt", cmdBt},
	}

	// getCmd attempts to parse an input line as a registered command. If
	// successful, it returns the command and the bytes remaining after
	// the command, which should be passed to the command.
	func getCmd(line []byte) (*cmd, []byte) {
	sc, _ := newScanner(line);
	pos, tok, lit := sc.Scan();
	if sc.ErrorCount != 0 \|\| tok != token.IDENT {
	return nil, nil
	}

	slit := string(lit);
	for i := range cmds {
	if cmds[i].cmd == slit {
	return &cmds[i], line[pos.Offset+len(lit) : len(line)]
	}
	}
	return nil, nil;
	}

	// cmdLoad starts or attaches to a process. Its form is similar to
	// import:
	//
	// load [sym] "path" [;]
	//
	// sym specifies the name to give to the process. If not given, the
	// name is derived from the path of the process. If ".", then the
	// packages from the remote process are defined into the current
	// namespace. If given, this symbol is defined as a package
	// containing the process' packages.
	//
	// path gives the path of the process to start or attach to. If it is
	// "pid:<num>", then attach to the given PID. Otherwise, treat it as
	// a file path and space-separated arguments and start a new process.
	//
	// load always sets the current process to the loaded process.
	func cmdLoad(args []byte) os.Error {
	ident, path, err := parseLoad(args);
	if err != nil {
	return err
	}
	if curProc != nil {
	return UsageError("multiple processes not implemented")
	}
	if ident != "." {
	return UsageError("process identifiers not implemented")
	}

	// Parse argument and start or attach to process
	var fname string;
	var tproc proc.Process;
	if len(path) >= 4 && path[0:4] == "pid:" {
	pid, err := strconv.Atoi(path[4:len(path)]);
	if err != nil {
	return err
	}
	fname, err = os.Readlink(fmt.Sprintf("/proc/%d/exe", pid));
	if err != nil {
	return err
	}
	tproc, err = proc.Attach(pid);
	if err != nil {
	return err
	}
	println("Attached to", pid);
	} else {
	parts := strings.Split(path, " ", 0);
	if len(parts) == 0 {
	fname = ""
	} else {
	fname = parts[0]
	}
	tproc, err = proc.ForkExec(fname, parts, os.Environ(), "", []*os.File{os.Stdin, os.Stdout, os.Stderr});
	if err != nil {
	return err
	}
	println("Started", path);
	// TODO(austin) If we fail after this point, kill tproc
	// before detaching.
	}

	// Get symbols
	f, err := os.Open(fname, os.O_RDONLY, 0);
	if err != nil {
	tproc.Detach();
	return err;
	}
	defer f.Close();
	elf, err := elf.NewFile(f);
	if err != nil {
	tproc.Detach();
	return err;
	}
	curProc, err = NewProcessElf(tproc, elf);
	if err != nil {
	tproc.Detach();
	return err;
	}

	// Prepare new process
	curProc.OnGoroutineCreate().AddHandler(EventPrint);
	curProc.OnGoroutineExit().AddHandler(EventPrint);

	err = curProc.populateWorld(world);
	if err != nil {
	tproc.Detach();
	return err;
	}

	return nil;
	}

	func parseLoad(args []byte) (ident string, path string, err os.Error) {
	err = UsageError("Usage: load [sym] \"path\"");
	sc, ev := newScanner(args);

	var toks [4]token.Token;
	var lits [4][]byte;
	for i := range toks {
	_, toks[i], lits[i] = sc.Scan()
	}
	if sc.ErrorCount != 0 {
	err = ev.GetError(scanner.NoMultiples);
	return;
	}

	i := 0;
	switch toks[i] {
	case token.PERIOD, token.IDENT:
	ident = string(lits[i]);
	i++;
	}

	if toks[i] != token.STRING {
	return
	}
	path, uerr := strconv.Unquote(string(lits[i]));
	if uerr != nil {
	err = uerr;
	return;
	}
	i++;

	if toks[i] == token.SEMICOLON {
	i++
	}
	if toks[i] != token.EOF {
	return
	}

	return ident, path, nil;
	}

	// cmdBt prints a backtrace for the current goroutine. It takes no
	// arguments.
	func cmdBt(args []byte) os.Error {
	err := parseNoArgs(args, "Usage: bt");
	if err != nil {
	return err
	}

	if curProc == nil \|\| curProc.curGoroutine == nil {
	return NoCurrentGoroutine{}
	}

	f := curProc.curGoroutine.frame;
	if f == nil {
	fmt.Println("No frames on stack");
	return nil;
	}

	for f.Inner() != nil {
	f = f.Inner()
	}

	for i := 0; i < 100; i++ {
	if f == curProc.curGoroutine.frame {
	fmt.Printf("=> ")
	} else {
	fmt.Printf(" ")
	}
	fmt.Printf("%8x %v\n", f.pc, f);
	f, err = f.Outer();
	if err != nil {
	return err
	}
	if f == nil {
	return nil
	}
	}

	fmt.Println("...");
	return nil;
	}

	func parseNoArgs(args []byte, usage string) os.Error {
	sc, ev := newScanner(args);
	_, tok, _ := sc.Scan();
	if sc.ErrorCount != 0 {
	return ev.GetError(scanner.NoMultiples)
	}
	if tok != token.EOF {
	return UsageError(usage)
	}
	return nil;
	}

	/*
	* Functions
	*/

	// defineFuncs populates world with the built-in functions.
	func defineFuncs() {
	t, v := eval.FuncFromNativeTyped(fnOut, fnOutSig);
	world.DefineConst("Out", t, v);
	t, v = eval.FuncFromNativeTyped(fnContWait, fnContWaitSig);
	world.DefineConst("ContWait", t, v);
	t, v = eval.FuncFromNativeTyped(fnBpSet, fnBpSetSig);
	world.DefineConst("BpSet", t, v);
	}

	// printCurFrame prints the current stack frame, as it would appear in
	// a backtrace.
	func printCurFrame() {
	if curProc == nil \|\| curProc.curGoroutine == nil {
	return
	}
	f := curProc.curGoroutine.frame;
	if f == nil {
	return
	}
	fmt.Printf("=> %8x %v\n", f.pc, f);
	}

	// fnOut moves the current frame to the caller of the current frame.
	func fnOutSig() {}
	func fnOut(t *eval.Thread, args []eval.Value, res []eval.Value) {
	if curProc == nil {
	t.Abort(NoCurrentGoroutine{})
	}
	err := curProc.Out();
	if err != nil {
	t.Abort(err)
	}
	// TODO(austin) Only in the command form
	printCurFrame();
	}

	// fnContWait continues the current process and waits for a stopping event.
	func fnContWaitSig() {}
	func fnContWait(t *eval.Thread, args []eval.Value, res []eval.Value) {
	if curProc == nil {
	t.Abort(NoCurrentGoroutine{})
	}
	err := curProc.ContWait();
	if err != nil {
	t.Abort(err)
	}
	// TODO(austin) Only in the command form
	ev := curProc.Event();
	if ev != nil {
	fmt.Printf("%v\n", ev)
	}
	printCurFrame();
	}

	// fnBpSet sets a breakpoint at the entry to the named function.
	func fnBpSetSig(string) {}
	func fnBpSet(t *eval.Thread, args []eval.Value, res []eval.Value) {
	// TODO(austin) This probably shouldn't take a symbol name.
	// Perhaps it should take an interface that provides PC's.
	// Functions and instructions can implement that interface and
	// we can have something to translate file:line pairs.
	if curProc == nil {
	t.Abort(NoCurrentGoroutine{})
	}
	name := args[0].(eval.StringValue).Get(t);
	fn := curProc.syms.LookupFunc(name);
	if fn == nil {
	t.Abort(UsageError("no such function " + name))
	}
	curProc.OnBreakpoint(proc.Word(fn.Entry)).AddHandler(EventStop);
	}