恐慌与恢复

// A _panic holds information about an active panic.
//
// A _panic value must only ever live on the stack.
//
// The argp and link fields are stack pointers, but don't need special
// handling during stack growth: because they are pointer-typed and
// _panic values only live on the stack, regular stack pointer
// adjustment takes care of them.
type _panic struct {
  argp      unsafe.Pointer // pointer to arguments of deferred call run during panic; cannot move - known to liblink
  arg       any            // argument to panic
  link      *_panic        // link to earlier panic
  pc        uintptr        // where to return to in runtime if this panic is bypassed
  sp        unsafe.Pointer // where to return to in runtime if this panic is bypassed
  recovered bool           // whether this panic is over
  aborted   bool           // the panic was aborted
  goexit    bool
}

func addOneOpenDeferFrame(gp *g, pc uintptr, sp unsafe.Pointer) {
  var prevDefer *_defer
  if sp == nil {
    prevDefer = gp._defer
    pc = prevDefer.framepc
    sp = unsafe.Pointer(prevDefer.sp)
  }
  systemstack(func() {
    gentraceback(pc, uintptr(sp), 0, gp, 0, nil, 0x7fffffff,
      func(frame *stkframe, unused unsafe.Pointer) bool {
        if prevDefer != nil && prevDefer.sp == frame.sp {
          // Skip the frame for the previous defer that
          // we just finished (and was used to set
          // where we restarted the stack scan)
          return true
        }
        f := frame.fn
        fd := funcdata(f, _FUNCDATA_OpenCodedDeferInfo)
        if fd == nil {
          return true
        }
        // Insert the open defer record in the
        // chain, in order sorted by sp.
        d := gp._defer
        var prev *_defer
        for d != nil {
          dsp := d.sp
          if frame.sp < dsp {
            break
          }
          if frame.sp == dsp {
            if !d.openDefer {
              throw("duplicated defer entry")
            }
            // Don't add any record past an
            // in-progress defer entry. We don't
            // need it, and more importantly, we
            // want to keep the invariant that
            // there is no open defer entry
            // passed an in-progress entry (see
            // header comment).
            if d.started {
              return false
            }
            return true
          }
          prev = d
          d = d.link
        }
        if frame.fn.deferreturn == 0 {
          throw("missing deferreturn")
        }

        d1 := newdefer()
        d1.openDefer = true
        d1._panic = nil
        // These are the pc/sp to set after we've
        // run a defer in this frame that did a
        // recover. We return to a special
        // deferreturn that runs any remaining
        // defers and then returns from the
        // function.
        d1.pc = frame.fn.entry() + uintptr(frame.fn.deferreturn)
        d1.varp = frame.varp
        d1.fd = fd
        // Save the SP/PC associated with current frame,
        // so we can continue stack trace later if needed.
        d1.framepc = frame.pc
        d1.sp = frame.sp
        d1.link = d
        if prev == nil {
          gp._defer = d1
        } else {
          prev.link = d1
        }
        // Stop stack scanning after adding one open defer record
        return false
      },
      nil, 0)
  })
}