Source file src/pkg/exp/ogle/goroutine.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.

package ogle

import (
    "debug/proc"
    "exp/eval"
    "fmt"
    "os"
)

// A Goroutine represents a goroutine in a remote process.
type Goroutine struct {
    g     remoteStruct
    frame *Frame
    dead  bool
}

func (t *Goroutine) String() string {
    if t.dead {
        return "<dead thread>"
    }
    // TODO(austin) Give threads friendly ID's, possibly including
    // the name of the entry function.
    return fmt.Sprintf("thread %#x", t.g.addr().base)
}

// isG0 returns true if this thread if the internal idle thread
func (t *Goroutine) isG0() bool { return t.g.addr().base == t.g.r.p.sys.g0.addr().base }

func (t *Goroutine) resetFrame() (err os.Error) {
    // TODO(austin) Reuse any live part of the current frame stack
    // so existing references to Frame's keep working.
    t.frame, err = newFrame(t.g)
    return
}

// Out selects the caller frame of the current frame.
func (t *Goroutine) Out() os.Error {
    f, err := t.frame.Outer()
    if f != nil {
        t.frame = f
    }
    return err
}

// In selects the frame called by the current frame.
func (t *Goroutine) In() os.Error {
    f := t.frame.Inner()
    if f != nil {
        t.frame = f
    }
    return nil
}

func readylockedBP(ev Event) (EventAction, os.Error) {
    b := ev.(*Breakpoint)
    p := b.Process()

    // The new g is the only argument to this function, so the
    // stack will have the return address, then the G*.
    regs, err := b.osThread.Regs()
    if err != nil {
        return EAStop, err
    }
    sp := regs.SP()
    addr := sp + proc.Word(p.PtrSize())
    arg := remotePtr{remote{addr, p}, p.runtime.G}
    var gp eval.Value
    err = try(func(a aborter) { gp = arg.aGet(a) })
    if err != nil {
        return EAStop, err
    }
    if gp == nil {
        return EAStop, UnknownGoroutine{b.osThread, 0}
    }
    gs := gp.(remoteStruct)
    g := &Goroutine{gs, nil, false}
    p.goroutines[gs.addr().base] = g

    // Enqueue goroutine creation event
    parent := b.Goroutine()
    if parent.isG0() {
        parent = nil
    }
    p.postEvent(&GoroutineCreate{commonEvent{p, g}, parent})

    // If we don't have any thread selected, select this one
    if p.curGoroutine == nil {
        p.curGoroutine = g
    }

    return EADefault, nil
}

func goexitBP(ev Event) (EventAction, os.Error) {
    b := ev.(*Breakpoint)
    p := b.Process()

    g := b.Goroutine()
    g.dead = true

    addr := g.g.addr().base
    p.goroutines[addr] = nil, false

    // Enqueue thread exit event
    p.postEvent(&GoroutineExit{commonEvent{p, g}})

    // If we just exited our selected goroutine, selected another
    if p.curGoroutine == g {
        p.selectSomeGoroutine()
    }

    return EADefault, nil
}