runtime: rewrite panic/defer code from C to Go

    
    The actual stack unwind code is still in C, but the rest of the code,
    notably all the memory allocation, is now in Go.  The names are changed
    to the names used in the Go 1.7 runtime, but the code is necessarily
    somewhat different.
    
    The __go_makefunc_can_recover function is dropped, as the uses of it
    were removed in https://golang.org/cl/198770044.
    
    Reviewed-on: https://go-review.googlesource.com/33414

From-SVN: r242715

14 files changed, 89 insertions, 949 deletions

diff --git a/libgo/runtime/go-cgo.c b/libgo/runtime/go-cgo.c
index 88b3f1e..75c1806 100644
--- a/libgo/runtime/go-cgo.c
+++ b/libgo/runtime/go-cgo.c
@@ -6,7 +6,6 @@
 
 #include "runtime.h"
 #include "go-alloc.h"
-#include "go-panic.h"
 #include "go-type.h"
 
 extern void chanrecv1 (ChanType *, Hchan *, void *)
@@ -191,7 +190,7 @@ _cgo_panic (const char *p)
      handle this by calling runtime_entersyscall in the personality
      function in go-unwind.c.  FIXME.  */
 
-  __go_panic (e);
+  runtime_panic (e);
 }
 
 /* Used for _cgo_wait_runtime_init_done.  This is based on code in
diff --git a/libgo/runtime/go-defer.c b/libgo/runtime/go-defer.c
deleted file mode 100644
index f3e14bd..0000000
--- a/libgo/runtime/go-defer.c
+++ /dev/null
@@ -1,84 +0,0 @@
-/* go-defer.c -- manage the defer stack.
-
-   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.  */
-
-#include <stddef.h>
-
-#include "runtime.h"
-#include "go-alloc.h"
-#include "go-panic.h"
-
-/* This function is called each time we need to defer a call.  */
-
-void
-__go_defer (_Bool *frame, void (*pfn) (void *), void *arg)
-{
-  G *g;
-  Defer *n;
-
-  g = runtime_g ();
-  n = runtime_newdefer ();
-  n->next = g->_defer;
-  n->frame = frame;
-  n->_panic = g->_panic;
-  n->pfn = (uintptr) pfn;
-  n->arg = arg;
-  n->retaddr = 0;
-  n->makefunccanrecover = 0;
-  n->special = 0;
-  g->_defer = n;
-}
-
-/* This function is called when we want to undefer the stack.  */
-
-void
-__go_undefer (_Bool *frame)
-{
-  G *g;
-
-  g = runtime_g ();
-  while (g->_defer != NULL && g->_defer->frame == frame)
-    {
-      Defer *d;
-      void (*pfn) (void *);
-
-      d = g->_defer;
-      pfn = (void (*) (void *)) d->pfn;
-      d->pfn = 0;
-
-      if (pfn != NULL)
-	(*pfn) (d->arg);
-
-      g->_defer = d->next;
-
-      /* This may be called by a cgo callback routine to defer the
-	 call to syscall.CgocallBackDone, in which case we will not
-	 have a memory context.  Don't try to free anything in that
-	 case--the GC will release it later.  */
-      if (runtime_m () != NULL)
-	runtime_freedefer (d);
-
-      /* Since we are executing a defer function here, we know we are
-	 returning from the calling function.  If the calling
-	 function, or one of its callees, paniced, then the defer
-	 functions would be executed by __go_panic.  */
-      *frame = 1;
-    }
-}
-
-/* This function is called to record the address to which the deferred
-   function returns.  This may in turn be checked by __go_can_recover.
-   The frontend relies on this function returning false.  */
-
-_Bool
-__go_set_defer_retaddr (void *retaddr)
-{
-  G *g;
-
-  g = runtime_g ();
-  if (g->_defer != NULL)
-    g->_defer->retaddr = (uintptr) __builtin_extract_return_addr (retaddr);
-  return 0;
-}
diff --git a/libgo/runtime/go-deferred-recover.c b/libgo/runtime/go-deferred-recover.c
deleted file mode 100644
index c89c1fb..0000000
--- a/libgo/runtime/go-deferred-recover.c
+++ /dev/null
@@ -1,93 +0,0 @@
-/* go-deferred-recover.c -- support for a deferred recover function.
-
-   Copyright 2010 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.  */
-
-#include <stddef.h>
-
-#include "runtime.h"
-#include "go-panic.h"
-
-/* This is called when a call to recover is deferred.  That is,
-   something like
-     defer recover()
-
-   We need to handle this specially.  In 6g/8g, the recover function
-   looks up the stack frame.  In particular, that means that a
-   deferred recover will not recover a panic thrown in the same
-   function that defers the recover.  It will only recover a panic
-   thrown in a function that defers the deferred call to recover.
-
-   In other words:
-
-   func f1() {
-	defer recover()	// does not stop panic
-	panic(0)
-   }
-
-   func f2() {
-	defer func() {
-		defer recover()	// stops panic(0)
-	}()
-	panic(0)
-   }
-
-   func f3() {
-	defer func() {
-		defer recover()	// does not stop panic
-		panic(0)
-	}()
-	panic(1)
-   }
-
-   func f4() {
-	defer func() {
-		defer func() {
-			defer recover()	// stops panic(0)
-		}()
-		panic(0)
-	}()
-	panic(1)
-   }
-
-   The interesting case here is f3.  As can be seen from f2, the
-   deferred recover could pick up panic(1).  However, this does not
-   happen because it is blocked by the panic(0).
-
-   When a function calls recover, then when we invoke it we pass a
-   hidden parameter indicating whether it should recover something.
-   This parameter is set based on whether the function is being
-   invoked directly from defer.  The parameter winds up determining
-   whether __go_recover or __go_deferred_recover is called at all.
-
-   In the case of a deferred recover, the hidden parameter which
-   controls the call is actually the one set up for the function which
-   runs the defer recover() statement.  That is the right thing in all
-   the cases above except for f3.  In f3 the function is permitted to
-   call recover, but the deferred recover call is not.  We address
-   that here by checking for that specific case before calling
-   recover.  If this function was deferred when there is already a
-   panic on the panic stack, then we can only recover that panic, not
-   any other.
-
-   Note that we can get away with using a special function here
-   because you are not permitted to take the address of a predeclared
-   function like recover.  */
-
-Eface
-__go_deferred_recover ()
-{
-  G *g;
-
-  g = runtime_g ();
-  if (g->_defer == NULL || g->_defer->_panic != g->_panic)
-    {
-      Eface ret;
-
-      ret._type = NULL;
-      ret.data = NULL;
-      return ret;
-    }
-  return __go_recover ();
-}
diff --git a/libgo/runtime/go-panic.c b/libgo/runtime/go-panic.c
deleted file mode 100644
index 2fb65aa..0000000
--- a/libgo/runtime/go-panic.c
+++ /dev/null
@@ -1,110 +0,0 @@
-/* go-panic.c -- support for the go panic function.
-
-   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.  */
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "runtime.h"
-#include "arch.h"
-#include "malloc.h"
-#include "go-alloc.h"
-#include "go-panic.h"
-
-/* Print the panic stack.  This is used when there is no recover.  */
-
-static void
-__printpanics (Panic *p)
-{
-  if (p->next != NULL)
-    {
-      __printpanics (p->next);
-      runtime_printf ("\t");
-    }
-  runtime_printf ("panic: ");
-  runtime_printany (p->arg);
-  if (p->recovered)
-    runtime_printf (" [recovered]");
-  runtime_printf ("\n");
-}
-
-/* This implements __go_panic which is used for the panic
-   function.  */
-
-void
-__go_panic (Eface arg)
-{
-  G *g;
-  Panic *n;
-
-  g = runtime_g ();
-
-  n = (Panic *) __go_alloc (sizeof (Panic));
-  n->arg = arg;
-  n->next = g->_panic;
-  g->_panic = n;
-
-  /* Run all the defer functions.  */
-
-  while (1)
-    {
-      Defer *d;
-      void (*pfn) (void *);
-
-      d = g->_defer;
-      if (d == NULL)
-	break;
-
-      pfn = (void (*) (void *)) d->pfn;
-      d->pfn = 0;
-
-      if (pfn != NULL)
-	{
-	  (*pfn) (d->arg);
-
-	  if (n->recovered)
-	    {
-	      /* Some defer function called recover.  That means that
-		 we should stop running this panic.  */
-
-	      g->_panic = n->next;
-	      __go_free (n);
-
-	      /* Now unwind the stack by throwing an exception.  The
-		 compiler has arranged to create exception handlers in
-		 each function which uses a defer statement.  These
-		 exception handlers will check whether the entry on
-		 the top of the defer stack is from the current
-		 function.  If it is, we have unwound the stack far
-		 enough.  */
-	      __go_unwind_stack ();
-
-	      /* __go_unwind_stack should not return.  */
-	      abort ();
-	    }
-
-	  /* Because we executed that defer function by a panic, and
-	     it did not call recover, we know that we are not
-	     returning from the calling function--we are panicing
-	     through it.  */
-	  *d->frame = 0;
-	}
-
-      g->_defer = d->next;
-
-      /* This may be called by a cgo callback routine to defer the
-	 call to syscall.CgocallBackDone, in which case we will not
-	 have a memory context.  Don't try to free anything in that
-	 case--the GC will release it later.  */
-      if (runtime_m () != NULL)
-	runtime_freedefer (d);
-    }
-
-  /* The panic was not recovered.  */
-
-  runtime_startpanic ();
-  __printpanics (g->_panic);
-  runtime_dopanic (0);
-}
diff --git a/libgo/runtime/go-panic.h b/libgo/runtime/go-panic.h
deleted file mode 100644
index 83b5292..0000000
--- a/libgo/runtime/go-panic.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/* go-panic.h -- declare the go panic functions.
-
-   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.  */
-
-#ifndef LIBGO_GO_PANIC_H
-#define LIBGO_GO_PANIC_H
-
-extern void __go_panic (Eface)
-  __attribute__ ((noreturn));
-
-extern void __go_print_string (String);
-
-extern Eface __go_recover (void);
-
-extern _Bool __go_can_recover (void *);
-
-extern void __go_makefunc_can_recover (void *retaddr);
-
-extern void __go_makefunc_ffi_can_recover (Location*, int);
-
-extern void __go_makefunc_returning (void);
-
-extern void __go_unwind_stack (void);
-
-#endif /* !defined(LIBGO_GO_PANIC_H) */
diff --git a/libgo/runtime/go-recover.c b/libgo/runtime/go-recover.c
deleted file mode 100644
index 97efdcd..0000000
--- a/libgo/runtime/go-recover.c
+++ /dev/null
@@ -1,273 +0,0 @@
-/* go-recover.c -- support for the go recover function.
-
-   Copyright 2010 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.  */
-
-#include "runtime.h"
-#include "go-panic.h"
-
-/* If the top of the defer stack can be recovered, then return it.
-   Otherwise return NULL.  */
-
-static Defer *
-current_defer ()
-{
-  G *g;
-  Defer *d;
-
-  g = runtime_g ();
-
-  d = g->_defer;
-  if (d == NULL)
-    return NULL;
-
-  /* The panic which would be recovered is the one on the top of the
-     panic stack.  We do not want to recover it if that panic was on
-     the top of the panic stack when this function was deferred.  */
-  if (d->_panic == g->_panic)
-    return NULL;
-
-  /* The deferred thunk will call _go_set_defer_retaddr.  If this has
-     not happened, then we have not been called via defer, and we can
-     not recover.  */
-  if (d->retaddr == 0)
-    return NULL;
-
-  return d;
-}
-
-/* This is called by a thunk to see if the real function should be
-   permitted to recover a panic value.  Recovering a value is
-   permitted if the thunk was called directly by defer.  RETADDR is
-   the return address of the function which is calling
-   __go_can_recover--this is, the thunk.  */
-
-_Bool
-__go_can_recover (void *retaddr)
-{
-  Defer *d;
-  const char* ret;
-  const char* dret;
-  Location locs[16];
-  const byte *name;
-  intgo len;
-  int n;
-  int i;
-  _Bool found_ffi_callback;
-
-  d = current_defer ();
-  if (d == NULL)
-    return 0;
-
-  ret = (const char *) __builtin_extract_return_addr (retaddr);
-
-  dret = (const char *) (uintptr) d->retaddr;
-  if (ret <= dret && ret + 16 >= dret)
-    return 1;
-
-  /* On some systems, in some cases, the return address does not work
-     reliably.  See http://gcc.gnu.org/PR60406.  If we are permitted
-     to call recover, the call stack will look like this:
-       __go_panic, __go_undefer, etc.
-       thunk to call deferred function (calls __go_set_defer_retaddr)
-       function that calls __go_can_recover (passing return address)
-       __go_can_recover
-     Calling runtime_callers will skip the thunks.  So if our caller's
-     caller starts with __go, then we are permitted to call
-     recover.  */
-
-  if (runtime_callers (1, &locs[0], 2, false) < 2)
-    return 0;
-
-  name = locs[1].function.str;
-  len = locs[1].function.len;
-
-  /* Although locs[1].function is a Go string, we know it is
-     NUL-terminated.  */
-  if (len > 4
-      && __builtin_strchr ((const char *) name, '.') == NULL
-      && __builtin_strncmp ((const char *) name, "__go_", 4) == 0)
-    return 1;
-
-  /* If we are called from __go_makefunc_can_recover, then we need to
-     look one level higher.  */
-  if (locs[0].function.len > 0
-      && __builtin_strcmp ((const char *) locs[0].function.str,
-			   "__go_makefunc_can_recover") == 0)
-    {
-      if (runtime_callers (3, &locs[0], 1, false) < 1)
-	return 0;
-      name = locs[0].function.str;
-      len = locs[0].function.len;
-      if (len > 4
-	  && __builtin_strchr ((const char *) name, '.') == NULL
-	  && __builtin_strncmp ((const char *) name, "__go_", 4) == 0)
-	return 1;
-    }
-
-  /* If the function calling recover was created by reflect.MakeFunc,
-     then __go_makefunc_can_recover or __go_makefunc_ffi_can_recover
-     will have set the __makefunc_can_recover field.  */
-  if (!d->makefunccanrecover)
-    return 0;
-
-  /* We look up the stack, ignoring libffi functions and functions in
-     the reflect package, until we find reflect.makeFuncStub or
-     reflect.ffi_callback called by FFI functions.  Then we check the
-     caller of that function.  */
-
-  n = runtime_callers (2, &locs[0], sizeof locs / sizeof locs[0], false);
-  found_ffi_callback = 0;
-  for (i = 0; i < n; i++)
-    {
-      const byte *name;
-
-      if (locs[i].function.len == 0)
-	{
-	  /* No function name means this caller isn't Go code.  Assume
-	     that this is libffi.  */
-	  continue;
-	}
-
-      /* Ignore functions in libffi.  */
-      name = locs[i].function.str;
-      if (__builtin_strncmp ((const char *) name, "ffi_", 4) == 0)
-	continue;
-
-      if (found_ffi_callback)
-	break;
-
-      if (__builtin_strcmp ((const char *) name, "reflect.ffi_callback") == 0)
-	{
-	  found_ffi_callback = 1;
-	  continue;
-	}
-
-      if (__builtin_strcmp ((const char *) name, "reflect.makeFuncStub") == 0)
-	{
-	  i++;
-	  break;
-	}
-
-      /* Ignore other functions in the reflect package.  */
-      if (__builtin_strncmp ((const char *) name, "reflect.", 8) == 0)
-	continue;
-
-      /* We should now be looking at the real caller.  */
-      break;
-    }
-
-  if (i < n && locs[i].function.len > 0)
-    {
-      name = locs[i].function.str;
-      if (__builtin_strncmp ((const char *) name, "__go_", 4) == 0)
-	return 1;
-    }
-
-  return 0;
-}
-
-/* This function is called when code is about to enter a function
-   created by reflect.MakeFunc.  It is called by the function stub
-   used by MakeFunc.  If the stub is permitted to call recover, then a
-   real MakeFunc function is permitted to call recover.  */
-
-void
-__go_makefunc_can_recover (void *retaddr)
-{
-  Defer *d;
-
-  d = current_defer ();
-  if (d == NULL)
-    return;
-
-  /* If we are already in a call stack of MakeFunc functions, there is
-     nothing we can usefully check here.  */
-  if (d->makefunccanrecover)
-    return;
-
-  if (__go_can_recover (retaddr))
-    d->makefunccanrecover = 1;
-}
-
-/* This function is called when code is about to enter a function
-   created by the libffi version of reflect.MakeFunc.  This function
-   is passed the names of the callers of the libffi code that called
-   the stub.  It uses to decide whether it is permitted to call
-   recover, and sets d->makefunccanrecover so that __go_recover can
-   make the same decision.  */
-
-void
-__go_makefunc_ffi_can_recover (Location *loc, int n)
-{
-  Defer *d;
-  const byte *name;
-  intgo len;
-
-  d = current_defer ();
-  if (d == NULL)
-    return;
-
-  /* If we are already in a call stack of MakeFunc functions, there is
-     nothing we can usefully check here.  */
-  if (d->makefunccanrecover)
-    return;
-
-  /* LOC points to the caller of our caller.  That will be a thunk.
-     If its caller was a runtime function, then it was called directly
-     by defer.  */
-
-  if (n < 2)
-    return;
-
-  name = (loc + 1)->function.str;
-  len = (loc + 1)->function.len;
-  if (len > 4
-      && __builtin_strchr ((const char *) name, '.') == NULL
-      && __builtin_strncmp ((const char *) name, "__go_", 4) == 0)
-    d->makefunccanrecover = 1;
-}
-
-/* This function is called when code is about to exit a function
-   created by reflect.MakeFunc.  It is called by the function stub
-   used by MakeFunc.  It clears the makefunccanrecover field.  It's OK
-   to always clear this field, because __go_can_recover will only be
-   called by a stub created for a function that calls recover.  That
-   stub will not call a function created by reflect.MakeFunc, so by
-   the time we get here any caller higher up on the call stack no
-   longer needs the information.  */
-
-void
-__go_makefunc_returning (void)
-{
-  Defer *d;
-
-  d = runtime_g ()->_defer;
-  if (d != NULL)
-    d->makefunccanrecover = 0;
-}
-
-/* This is only called when it is valid for the caller to recover the
-   value on top of the panic stack, if there is one.  */
-
-Eface
-__go_recover ()
-{
-  G *g;
-  Panic *p;
-
-  g = runtime_g ();
-
-  if (g->_panic == NULL || g->_panic->recovered)
-    {
-      Eface ret;
-
-      ret._type = NULL;
-      ret.data = NULL;
-      return ret;
-    }
-  p = g->_panic;
-  p->recovered = 1;
-  return p->arg;
-}
diff --git a/libgo/runtime/go-signal.c b/libgo/runtime/go-signal.c
index b844dc5..c1f1a52 100644
--- a/libgo/runtime/go-signal.c
+++ b/libgo/runtime/go-signal.c
@@ -11,8 +11,6 @@
 #include <ucontext.h>
 
 #include "runtime.h"
-#include "go-assert.h"
-#include "go-panic.h"
 
 #ifndef SA_RESTART
   #define SA_RESTART 0
diff --git a/libgo/runtime/go-strslice.c b/libgo/runtime/go-strslice.c
index ce20f29..c9f196b 100644
--- a/libgo/runtime/go-strslice.c
+++ b/libgo/runtime/go-strslice.c
@@ -5,9 +5,6 @@
    license that can be found in the LICENSE file.  */
 
 #include "runtime.h"
-#include "go-panic.h"
-#include "arch.h"
-#include "malloc.h"
 
 String
 __go_string_slice (String s, intgo start, intgo end)
diff --git a/libgo/runtime/go-unwind.c b/libgo/runtime/go-unwind.c
index fb59115..9e85b4b 100644
--- a/libgo/runtime/go-unwind.c
+++ b/libgo/runtime/go-unwind.c
@@ -15,7 +15,6 @@
 
 #include "runtime.h"
 #include "go-alloc.h"
-#include "go-panic.h"
 
 /* The code for a Go exception.  */
 
@@ -34,110 +33,16 @@ static const _Unwind_Exception_Class __go_exception_class =
    << 8 | (_Unwind_Exception_Class) '\0');
 #endif
 
+/* Rethrow an exception.  */
 
-/* This function is called by exception handlers used when unwinding
-   the stack after a recovered panic.  The exception handler looks
-   like this:
-     __go_check_defer (frame);
-     return;
-   If we have not yet reached the frame we are looking for, we
-   continue unwinding.  */
+void rethrowException (void) __asm__(GOSYM_PREFIX "runtime.rethrowException");
 
 void
-__go_check_defer (_Bool *frame)
+rethrowException ()
 {
-  G *g;
   struct _Unwind_Exception *hdr;
 
-  g = runtime_g ();
-
-  if (g == NULL)
-    {
-      /* Some other language has thrown an exception.  We know there
-	 are no defer handlers, so there is nothing to do.  */
-    }
-  else if (g->isforeign)
-    {
-      Panic *n;
-      _Bool recovered;
-
-      /* Some other language has thrown an exception.  We need to run
-	 the local defer handlers.  If they call recover, we stop
-	 unwinding the stack here.  */
-
-      n = (Panic *) __go_alloc (sizeof (Panic));
-
-      n->arg._type = NULL;
-      n->arg.data = NULL;
-      n->recovered = 0;
-      n->isforeign = 1;
-      n->next = g->_panic;
-      g->_panic = n;
-
-      while (1)
-	{
-	  Defer *d;
-	  void (*pfn) (void *);
-
-	  d = g->_defer;
-	  if (d == NULL || d->frame != frame || d->pfn == 0)
-	    break;
-
-	  pfn = (void (*) (void *)) d->pfn;
-	  g->_defer = d->next;
-
-	  (*pfn) (d->arg);
-
-	  if (runtime_m () != NULL)
-	    runtime_freedefer (d);
-
-	  if (n->recovered)
-	    {
-	      /* The recover function caught the panic thrown by some
-		 other language.  */
-	      break;
-	    }
-	}
-
-      recovered = n->recovered;
-      g->_panic = n->next;
-      __go_free (n);
-
-      if (recovered)
-	{
-	  /* Just return and continue executing Go code.  */
-	  *frame = 1;
-	  return;
-	}
-
-      /* We are panicing through this function.  */
-      *frame = 0;
-    }
-  else if (g->_defer != NULL
-	   && g->_defer->pfn == 0
-	   && g->_defer->frame == frame)
-    {
-      Defer *d;
-
-      /* This is the defer function which called recover.  Simply
-	 return to stop the stack unwind, and let the Go code continue
-	 to execute.  */
-      d = g->_defer;
-      g->_defer = d->next;
-
-      if (runtime_m () != NULL)
-	runtime_freedefer (d);
-
-      /* We are returning from this function.  */
-      *frame = 1;
-
-      return;
-    }
-
-  /* This is some other defer function.  It was already run by the
-     call to panic, or just above.  Rethrow the exception.  */
-
-  hdr = (struct _Unwind_Exception *) g->exception;
+  hdr = (struct _Unwind_Exception *) runtime_g()->exception;
 
 #ifdef __USING_SJLJ_EXCEPTIONS__
   _Unwind_SjLj_Resume_or_Rethrow (hdr);
@@ -153,23 +58,48 @@ __go_check_defer (_Bool *frame)
   abort();
 }
 
-/* Unwind function calls until we reach the one which used a defer
-   function which called recover.  Each function which uses a defer
-   statement will have an exception handler, as shown above.  */
+/* Return the size of the type that holds an exception header, so that
+   it can be allocated by Go code.  */
+
+uintptr unwindExceptionSize(void)
+  __asm__ (GOSYM_PREFIX "runtime.unwindExceptionSize");
+
+uintptr
+unwindExceptionSize ()
+{
+  uintptr ret, align;
+
+  ret = sizeof (struct _Unwind_Exception);
+  /* Adjust the size fo make sure that we can get an aligned value.  */
+  align = __alignof__ (struct _Unwind_Exception);
+  if (align > __alignof__ (uintptr))
+    ret += align - __alignof__ (uintptr);
+  return ret;
+}
+
+/* Throw an exception.  This is called with g->exception pointing to
+   an uninitialized _Unwind_Exception instance.  */
+
+void throwException (void) __asm__(GOSYM_PREFIX "runtime.throwException");
 
 void
-__go_unwind_stack ()
+throwException ()
 {
   struct _Unwind_Exception *hdr;
+  uintptr align;
+
+  hdr = (struct _Unwind_Exception *)runtime_g ()->exception;
 
+  /* Make sure the value is correctly aligned.  It will be large
+     enough, because of unwindExceptionSize.  */
+  align = __alignof__ (struct _Unwind_Exception);
   hdr = ((struct _Unwind_Exception *)
-	 __go_alloc (sizeof (struct _Unwind_Exception)));
+	 (((uintptr) hdr + align - 1) &~ (align - 1)));
+
   __builtin_memcpy (&hdr->exception_class, &__go_exception_class,
 		    sizeof hdr->exception_class);
   hdr->exception_cleanup = NULL;
 
-  runtime_g ()->exception = hdr;
-
 #ifdef __USING_SJLJ_EXCEPTIONS__
   _Unwind_SjLj_RaiseException (hdr);
 #else
diff --git a/libgo/runtime/heapdump.c b/libgo/runtime/heapdump.c
index 3a5bc1b..80d2b7b 100644
--- a/libgo/runtime/heapdump.c
+++ b/libgo/runtime/heapdump.c
@@ -14,7 +14,6 @@
 #include "malloc.h"
 #include "mgc0.h"
 #include "go-type.h"
-#include "go-panic.h"
 
 #define hash __hash
 #define KindNoPointers GO_NO_POINTERS
@@ -284,7 +283,7 @@ dumpgoroutine(G *gp)
 	// runtime_gentraceback(pc, sp, lr, gp, 0, nil, 0x7fffffff, dumpframe, &child, false);
 
 	// dump defer & panic records
-	for(d = gp->_defer; d != nil; d = d->next) {
+	for(d = gp->_defer; d != nil; d = d->link) {
 		dumpint(TagDefer);
 		dumpint((uintptr)d);
 		dumpint((uintptr)gp);
@@ -292,16 +291,16 @@ dumpgoroutine(G *gp)
 		dumpint((uintptr)d->frame);
 		dumpint((uintptr)d->pfn);
 		dumpint((uintptr)0);
-		dumpint((uintptr)d->next);
+		dumpint((uintptr)d->link);
 	}
-	for (p = gp->_panic; p != nil; p = p->next) {
+	for (p = gp->_panic; p != nil; p = p->link) {
 		dumpint(TagPanic);
 		dumpint((uintptr)p);
 		dumpint((uintptr)gp);
 		dumpint((uintptr)p->arg._type);
 		dumpint((uintptr)p->arg.data);
 		dumpint((uintptr)0);
-		dumpint((uintptr)p->next);
+		dumpint((uintptr)p->link);
 	}
 }
 
diff --git a/libgo/runtime/mgc0.c b/libgo/runtime/mgc0.c
index e5a9dfb..7efad5e 100644
--- a/libgo/runtime/mgc0.c
+++ b/libgo/runtime/mgc0.c
@@ -124,6 +124,7 @@ clearpools(void)
 {
 	P *p, **pp;
 	MCache *c;
+	Defer *d, *dlink;
 
 	// clear sync.Pool's
 	if(poolcleanup != nil) {
@@ -138,9 +139,17 @@ clearpools(void)
 			c->tiny = nil;
 			c->tinysize = 0;
 		}
-		// clear defer pools
-		p->deferpool = nil;
 	}
+
+	// Clear central defer pools.
+	// Leave per-P pools alone, they have strictly bounded size.
+	runtime_lock(&runtime_sched->deferlock);
+	for(d = runtime_sched->deferpool; d != nil; d = dlink) {
+		dlink = d->link;
+		d->link = nil;
+	}
+	runtime_sched->deferpool = nil;
+	runtime_unlock(&runtime_sched->deferlock);
 }
 
 typedef struct Workbuf Workbuf;
@@ -2125,7 +2134,7 @@ runtime_gc(int32 force)
 	// without a lock will do the gc instead.
 	m = runtime_m();
 	pmstats = mstats();
-	if(!pmstats->enablegc || runtime_g() == m->g0 || m->locks > 0 || runtime_panicking || m->preemptoff.len > 0)
+	if(!pmstats->enablegc || runtime_g() == m->g0 || m->locks > 0 || runtime_panicking() || m->preemptoff.len > 0)
 		return;
 
 	if(gcpercent == GcpercentUnknown) {	// first time through
diff --git a/libgo/runtime/panic.c b/libgo/runtime/panic.c
index 78c8f5d..493fde8 100644
--- a/libgo/runtime/panic.c
+++ b/libgo/runtime/panic.c
@@ -3,218 +3,14 @@
 // license that can be found in the LICENSE file.
 
 #include "runtime.h"
-#include "malloc.h"
-#include "go-panic.h"
 
-// Code related to defer, panic and recover.
-
-uint32 runtime_panicking;
-static Lock paniclk;
-
-// Allocate a Defer, usually using per-P pool.
-// Each defer must be released with freedefer.
-Defer*
-runtime_newdefer()
-{
-	Defer *d;
-	P *p;
-
-	d = nil;
-	p = (P*)runtime_m()->p;
-	d = p->deferpool;
-	if(d)
-		p->deferpool = d->next;
-	if(d == nil) {
-		// deferpool is empty
-		d = runtime_malloc(sizeof(Defer));
-	}
-	return d;
-}
-
-// Free the given defer.
-// The defer cannot be used after this call.
-void
-runtime_freedefer(Defer *d)
-{
-	P *p;
-
-	if(d->special)
-		return;
-	p = (P*)runtime_m()->p;
-	d->next = p->deferpool;
-	p->deferpool = d;
-	// No need to wipe out pointers in argp/pc/fn/args,
-	// because we empty the pool before GC.
-}
-
-// Run all deferred functions for the current goroutine.
-// This is noinline for go_can_recover.
-static void __go_rundefer (void) __attribute__ ((noinline));
-static void
-__go_rundefer(void)
-{
-	G *g;
-	Defer *d;
-
-	g = runtime_g();
-	while((d = g->_defer) != nil) {
-		void (*pfn)(void*);
-
-		g->_defer = d->next;
-		pfn = (void (*) (void *))d->pfn;
-		d->pfn = 0;
-		if (pfn != nil)
-			(*pfn)(d->arg);
-		runtime_freedefer(d);
-	}
-}
-
-void
-runtime_startpanic(void)
-{
-	G *g;
-	M *m;
-
-	g = runtime_g();
-	m = g->m;
-	if(runtime_mheap.cachealloc.size == 0) { // very early
-		runtime_printf("runtime: panic before malloc heap initialized\n");
-		m->mallocing = 1; // tell rest of panic not to try to malloc
-	} else if(m->mcache == nil) // can happen if called from signal handler or throw
-		m->mcache = runtime_allocmcache();
-	switch(m->dying) {
-	case 0:
-		m->dying = 1;
-		g->writebuf.__values = nil;
-		g->writebuf.__count = 0;
-		g->writebuf.__capacity = 0;
-		runtime_xadd(&runtime_panicking, 1);
-		runtime_lock(&paniclk);
-		if(runtime_debug.schedtrace > 0 || runtime_debug.scheddetail > 0)
-			runtime_schedtrace(true);
-		runtime_freezetheworld();
-		return;
-	case 1:
-		// Something failed while panicing, probably the print of the
-		// argument to panic().  Just print a stack trace and exit.
-		m->dying = 2;
-		runtime_printf("panic during panic\n");
-		runtime_dopanic(0);
-		runtime_exit(3);
-	case 2:
-		// This is a genuine bug in the runtime, we couldn't even
-		// print the stack trace successfully.
-		m->dying = 3;
-		runtime_printf("stack trace unavailable\n");
-		runtime_exit(4);
-	default:
-		// Can't even print!  Just exit.
-		runtime_exit(5);
-	}
-}
-
-void
-runtime_dopanic(int32 unused __attribute__ ((unused)))
-{
-	G *g;
-	static bool didothers;
-	bool crash;
-	int32 t;
-
-	g = runtime_g();
-	if(g->sig != 0) {
-		runtime_printf("[signal %x code=%p addr=%p",
-			       g->sig, (void*)g->sigcode0, (void*)g->sigcode1);
-		if (g->sigpc != 0)
-			runtime_printf(" pc=%p", g->sigpc);
-		runtime_printf("]\n");
-	}
-
-	if((t = runtime_gotraceback(&crash)) > 0){
-		if(g != runtime_m()->g0) {
-			runtime_printf("\n");
-			runtime_goroutineheader(g);
-			runtime_traceback(0);
-			runtime_printcreatedby(g);
-		} else if(t >= 2 || runtime_m()->throwing > 0) {
-			runtime_printf("\nruntime stack:\n");
-			runtime_traceback(0);
-		}
-		if(!didothers) {
-			didothers = true;
-			runtime_tracebackothers(g);
-		}
-	}
-	runtime_unlock(&paniclk);
-	if(runtime_xadd(&runtime_panicking, -1) != 0) {
-		// Some other m is panicking too.
-		// Let it print what it needs to print.
-		// Wait forever without chewing up cpu.
-		// It will exit when it's done.
-		static Lock deadlock;
-		runtime_lock(&deadlock);
-		runtime_lock(&deadlock);
-	}
-	
-	if(crash)
-		runtime_crash();
-
-	runtime_exit(2);
-}
-
-bool
-runtime_canpanic(G *gp)
-{
-	M *m = runtime_m();
-	byte g;
-
-	USED(&g);  // don't use global g, it points to gsignal
-
-	// Is it okay for gp to panic instead of crashing the program?
-	// Yes, as long as it is running Go code, not runtime code,
-	// and not stuck in a system call.
-	if(gp == nil || gp != m->curg)
-		return false;
-	if(m->locks-m->softfloat != 0 || m->mallocing != 0 || m->throwing != 0 || m->gcing != 0 || m->dying != 0)
-		return false;
-	if(gp->atomicstatus != _Grunning)
-		return false;
-#ifdef GOOS_windows
-	if(m->libcallsp != 0)
-		return false;
-#endif
-	return true;
-}
+extern void gothrow(String) __attribute__((noreturn));
+extern void gothrow(String) __asm__(GOSYM_PREFIX "runtime.throw");
 
 void
 runtime_throw(const char *s)
 {
-	M *mp;
-
-	mp = runtime_m();
-	if(mp->throwing == 0)
-		mp->throwing = 1;
-	runtime_startpanic();
-	runtime_printf("fatal error: %s\n", s);
-	runtime_dopanic(0);
-	*(int32*)0 = 0;	// not reached
-	runtime_exit(1);	// even more not reached
-}
-
-void throw(String) __asm__ (GOSYM_PREFIX "runtime.throw");
-void
-throw(String s)
-{
-	M *mp;
-
-	mp = runtime_m();
-	if(mp->throwing == 0)
-		mp->throwing = 1;
-	runtime_startpanic();
-	runtime_printf("fatal error: %S\n", s);
-	runtime_dopanic(0);
-	*(int32*)0 = 0;	// not reached
-	runtime_exit(1);	// even more not reached
+	gothrow(runtime_gostringnocopy((const byte *)s));
 }
 
 void
@@ -237,18 +33,3 @@ runtime_panicstring(const char *s)
 	runtime_newErrorCString(s, &err);
 	runtime_panic(err);
 }
-
-void runtime_Goexit (void) __asm__ (GOSYM_PREFIX "runtime.Goexit");
-
-void
-runtime_Goexit(void)
-{
-	__go_rundefer();
-	runtime_goexit();
-}
-
-void
-runtime_panicdivide(void)
-{
-	runtime_panicstring("integer divide by zero");
-}
diff --git a/libgo/runtime/proc.c b/libgo/runtime/proc.c
index d8834ad..dd5562b 100644
--- a/libgo/runtime/proc.c
+++ b/libgo/runtime/proc.c
@@ -255,7 +255,7 @@ kickoff(void)
 	param = g->param;
 	g->param = nil;
 	fn(param);
-	runtime_goexit();
+	runtime_goexit1();
 }
 
 // Switch context to a different goroutine.  This is like longjmp.
@@ -351,8 +351,6 @@ runtime_mcall(void (*pfn)(G*))
 //
 // Design doc at http://golang.org/s/go11sched.
 
-typedef struct schedt Sched;
-
 enum
 {
 	// Number of goroutine ids to grab from runtime_sched->goidgen to local per-P cache at once.
@@ -362,7 +360,7 @@ enum
 
 extern Sched* runtime_getsched() __asm__ (GOSYM_PREFIX "runtime.getsched");
 
-static Sched*	runtime_sched;
+Sched*	runtime_sched;
 int32	runtime_gomaxprocs;
 uint32	runtime_needextram = 1;
 M	runtime_m0;
@@ -581,7 +579,7 @@ runtime_main(void* dummy __attribute__((unused)))
 	
 	// Defer unlock so that runtime.Goexit during init does the unlock too.
 	d.pfn = (uintptr)(void*)initDone;
-	d.next = g->_defer;
+	d.link = g->_defer;
 	d.arg = (void*)-1;
 	d._panic = g->_panic;
 	d.retaddr = 0;
@@ -604,7 +602,7 @@ runtime_main(void* dummy __attribute__((unused)))
 
 	if(g->_defer != &d || (void*)d.pfn != initDone)
 		runtime_throw("runtime: bad defer entry after init");
-	g->_defer = d.next;
+	g->_defer = d.link;
 	runtime_unlockOSThread();
 
 	// For gccgo we have to wait until after main is initialized
@@ -626,7 +624,7 @@ runtime_main(void* dummy __attribute__((unused)))
 	// another goroutine at the same time as main returns,
 	// let the other goroutine finish printing the panic trace.
 	// Once it does, it will exit. See issue 3934.
-	if(runtime_panicking)
+	if(runtime_panicking())
 		runtime_park(nil, nil, "panicwait");
 
 	runtime_exit(0);
@@ -1945,16 +1943,16 @@ runtime_gosched0(G *gp)
 // Need to mark it as nosplit, because it runs with sp > stackbase (as runtime_lessstack).
 // Since it does not return it does not matter.  But if it is preempted
 // at the split stack check, GC will complain about inconsistent sp.
-void runtime_goexit(void) __attribute__ ((noinline));
+void runtime_goexit1(void) __attribute__ ((noinline));
 void
-runtime_goexit(void)
+runtime_goexit1(void)
 {
 	if(g->atomicstatus != _Grunning)
 		runtime_throw("bad g status");
 	runtime_mcall(goexit0);
 }
 
-// runtime_goexit continuation on g0.
+// runtime_goexit1 continuation on g0.
 static void
 goexit0(G *gp)
 {
@@ -2744,6 +2742,7 @@ procresize(int32 new)
 	bool pempty;
 	G *gp;
 	P *p;
+	intgo j;
 
 	old = runtime_gomaxprocs;
 	if(old < 0 || old > _MaxGomaxprocs || new <= 0 || new >_MaxGomaxprocs)
@@ -2755,6 +2754,9 @@ procresize(int32 new)
 			p = (P*)runtime_mallocgc(sizeof(*p), 0, FlagNoInvokeGC);
 			p->id = i;
 			p->status = _Pgcstop;
+			p->deferpool.__values = &p->deferpoolbuf[0];
+			p->deferpool.__count = 0;
+			p->deferpool.__capacity = nelem(p->deferpoolbuf);
 			runtime_atomicstorep(&runtime_allp[i], p);
 		}
 		if(p->mcache == nil) {
@@ -2803,6 +2805,10 @@ procresize(int32 new)
 	// free unused P's
 	for(i = new; i < old; i++) {
 		p = runtime_allp[i];
+		for(j = 0; j < p->deferpool.__count; j++) {
+			((struct _defer**)p->deferpool.__values)[j] = nil;
+		}
+		p->deferpool.__count = 0;
 		runtime_freemcache(p->mcache);
 		p->mcache = nil;
 		gfpurge(p);
@@ -2902,7 +2908,7 @@ checkdead(void)
 	// freezetheworld will cause all running threads to block.
 	// And runtime will essentially enter into deadlock state,
 	// except that there is a thread that will call runtime_exit soon.
-	if(runtime_panicking > 0)
+	if(runtime_panicking() > 0)
 		return;
 	if(run < 0) {
 		runtime_printf("runtime: checkdead: nmidle=%d nmidlelocked=%d mcount=%d\n",
diff --git a/libgo/runtime/runtime.h b/libgo/runtime/runtime.h
index 50143fe..34b5b44 100644
--- a/libgo/runtime/runtime.h
+++ b/libgo/runtime/runtime.h
@@ -73,6 +73,7 @@ typedef	struct	ParForThread	ParForThread;
 typedef	struct	cgoMal		CgoMal;
 typedef	struct	PollDesc	PollDesc;
 typedef	struct	sudog		SudoG;
+typedef struct	schedt		Sched;
 
 typedef	struct	__go_open_array		Slice;
 typedef	struct	iface			Iface;
@@ -241,9 +242,11 @@ extern	uintptr runtime_allglen;
 extern	G*	runtime_lastg;
 extern	M*	runtime_allm;
 extern	P**	runtime_allp;
+extern	Sched*  runtime_sched;
 extern	int32	runtime_gomaxprocs;
 extern	uint32	runtime_needextram;
-extern	uint32	runtime_panicking;
+extern	uint32	runtime_panicking(void)
+  __asm__ (GOSYM_PREFIX "runtime.getPanicking");
 extern	int8*	runtime_goos;
 extern	int32	runtime_ncpu;
 extern 	void	(*runtime_sysargs)(int32, uint8**);
@@ -306,7 +309,8 @@ void	runtime_needm(void)
 void	runtime_dropm(void)
   __asm__ (GOSYM_PREFIX "runtime.dropm");
 void	runtime_signalstack(byte*, int32);
-MCache*	runtime_allocmcache(void);
+MCache*	runtime_allocmcache(void)
+  __asm__ (GOSYM_PREFIX "runtime.allocmcache");
 void	runtime_freemcache(MCache*);
 void	runtime_mallocinit(void);
 void	runtime_mprofinit(void);
@@ -348,12 +352,14 @@ void runtime_newextram(void);
 #define runtime_breakpoint() __builtin_trap()
 void	runtime_gosched(void);
 void	runtime_gosched0(G*);
-void	runtime_schedtrace(bool);
+void	runtime_schedtrace(bool)
+  __asm__ (GOSYM_PREFIX "runtime.schedtrace");
 void	runtime_park(bool(*)(G*, void*), void*, const char*);
 void	runtime_parkunlock(Lock*, const char*);
 void	runtime_tsleep(int64, const char*);
 M*	runtime_newm(void);
-void	runtime_goexit(void);
+void	runtime_goexit1(void)
+  __asm__ (GOSYM_PREFIX "runtime.goexit1");
 void	runtime_entersyscall(int32)
   __asm__ (GOSYM_PREFIX "runtime.entersyscall");
 void	runtime_entersyscallblock(int32)
@@ -369,7 +375,8 @@ int64	runtime_unixnanotime(void) // real time, can skip
 void	runtime_dopanic(int32) __attribute__ ((noreturn));
 void	runtime_startpanic(void)
   __asm__ (GOSYM_PREFIX "runtime.startpanic");
-void	runtime_freezetheworld(void);
+void	runtime_freezetheworld(void)
+  __asm__ (GOSYM_PREFIX "runtime.freezetheworld");
 void	runtime_unwindstack(G*, byte*);
 void	runtime_sigprof()
   __asm__ (GOSYM_PREFIX "runtime.sigprof");
@@ -494,13 +501,14 @@ void __wrap_rtems_task_variable_add(void **);
 void reflect_call(const struct __go_func_type *, FuncVal *, _Bool, _Bool,
 		  void **, void **)
   __asm__ (GOSYM_PREFIX "reflect.call");
-#define runtime_panic __go_panic
+void runtime_panic(Eface)
+  __asm__ (GOSYM_PREFIX "runtime.gopanic");
+void runtime_panic(Eface)
+  __attribute__ ((noreturn));
 
 /*
  * runtime c-called (but written in Go)
  */
-void	runtime_printany(Eface)
-     __asm__ (GOSYM_PREFIX "runtime.Printany");
 void	runtime_newTypeAssertionError(const String*, const String*, const String*, const String*, Eface*)
      __asm__ (GOSYM_PREFIX "runtime.NewTypeAssertionError");
 void	runtime_newErrorCString(const char*, Eface*)