libgo/go/exp/ogle/goroutine.go

   1 // Copyright 2009 The Go Authors.  All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package ogle
   6
   7 import (
   8         "debug/proc"
   9         "exp/eval"
  10         "fmt"
  11         "os"
  12 )
  13
  14 // A Goroutine represents a goroutine in a remote process.
  15 type Goroutine struct {
  16         g     remoteStruct
  17         frame *Frame
  18         dead  bool
  19 }
  20
  21 func (t *Goroutine) String() string {
  22         if t.dead {
  23                 return "<dead thread>"
  24         }
  25         // TODO(austin) Give threads friendly ID's, possibly including
  26         // the name of the entry function.
  27         return fmt.Sprintf("thread %#x", t.g.addr().base)
  28 }
  29
  30 // isG0 returns true if this thread if the internal idle thread
  31 func (t *Goroutine) isG0() bool { return t.g.addr().base == t.g.r.p.sys.g0.addr().base }
  32
  33 func (t *Goroutine) resetFrame() (err os.Error) {
  34         // TODO(austin) Reuse any live part of the current frame stack
  35         // so existing references to Frame's keep working.
  36         t.frame, err = newFrame(t.g)
  37         return
  38 }
  39
  40 // Out selects the caller frame of the current frame.
  41 func (t *Goroutine) Out() os.Error {
  42         f, err := t.frame.Outer()
  43         if f != nil {
  44                 t.frame = f
  45         }
  46         return err
  47 }
  48
  49 // In selects the frame called by the current frame.
  50 func (t *Goroutine) In() os.Error {
  51         f := t.frame.Inner()
  52         if f != nil {
  53                 t.frame = f
  54         }
  55         return nil
  56 }
  57
  58 func readylockedBP(ev Event) (EventAction, os.Error) {
  59         b := ev.(*Breakpoint)
  60         p := b.Process()
  61
  62         // The new g is the only argument to this function, so the
  63         // stack will have the return address, then the G*.
  64         regs, err := b.osThread.Regs()
  65         if err != nil {
  66                 return EAStop, err
  67         }
  68         sp := regs.SP()
  69         addr := sp + proc.Word(p.PtrSize())
  70         arg := remotePtr{remote{addr, p}, p.runtime.G}
  71         var gp eval.Value
  72         err = try(func(a aborter) { gp = arg.aGet(a) })
  73         if err != nil {
  74                 return EAStop, err
  75         }
  76         if gp == nil {
  77                 return EAStop, UnknownGoroutine{b.osThread, 0}
  78         }
  79         gs := gp.(remoteStruct)
  80         g := &Goroutine{gs, nil, false}
  81         p.goroutines[gs.addr().base] = g
  82
  83         // Enqueue goroutine creation event
  84         parent := b.Goroutine()
  85         if parent.isG0() {
  86                 parent = nil
  87         }
  88         p.postEvent(&GoroutineCreate{commonEvent{p, g}, parent})
  89
  90         // If we don't have any thread selected, select this one
  91         if p.curGoroutine == nil {
  92                 p.curGoroutine = g
  93         }
  94
  95         return EADefault, nil
  96 }
  97
  98 func goexitBP(ev Event) (EventAction, os.Error) {
  99         b := ev.(*Breakpoint)
 100         p := b.Process()
 101
 102         g := b.Goroutine()
 103         g.dead = true
 104
 105         addr := g.g.addr().base
 106         p.goroutines[addr] = nil, false
 107
 108         // Enqueue thread exit event
 109         p.postEvent(&GoroutineExit{commonEvent{p, g}})
 110
 111         // If we just exited our selected goroutine, selected another
 112         if p.curGoroutine == g {
 113                 p.selectSomeGoroutine()
 114         }
 115
 116         return EADefault, nil
 117 }