Merge from mainline (167278:168000).

[official-gcc/graphite-test-results.git] / libgo / go / exp / ogle / cmd.go

// 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)
        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{
        {"load", cmdLoad},
        {"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):]
                }
        }
        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:])
                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, " ", -1)
                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)
}