[GCC 4.8] Initial check-in of GCC 4.8.0

Change-Id: I0719d8a6d0f69b367a6ab6f10eb75622dbf12771

1 files changed, 106 insertions, 0 deletions

diff --git a/gcc-4.8/libgo/runtime/go-panic.c b/gcc-4.8/libgo/runtime/go-panic.c
new file mode 100644
index 000000000..530629ca3
--- /dev/null
+++ b/gcc-4.8/libgo/runtime/go-panic.c
@@ -0,0 +1,106 @@
+/* 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-defer.h"
+#include "go-panic.h"
+#include "interface.h"
+
+/* Print the panic stack.  This is used when there is no recover.  */
+
+static void
+__printpanics (struct __go_panic_stack *p)
+{
+  if (p->__next != NULL)
+    {
+      __printpanics (p->__next);
+      runtime_printf ("\t");
+    }
+  runtime_printf ("panic: ");
+  runtime_printany (p->__arg);
+  if (p->__was_recovered)
+    runtime_printf (" [recovered]");
+  runtime_printf ("\n");
+}
+
+/* This implements __go_panic which is used for the panic
+   function.  */
+
+void
+__go_panic (struct __go_empty_interface arg)
+{
+  G *g;
+  struct __go_panic_stack *n;
+
+  g = runtime_g ();
+
+  n = (struct __go_panic_stack *) __go_alloc (sizeof (struct __go_panic_stack));
+  n->__arg = arg;
+  n->__next = g->panic;
+  g->panic = n;
+
+  /* Run all the defer functions.  */
+
+  while (1)
+    {
+      struct __go_defer_stack *d;
+      void (*pfn) (void *);
+
+      d = g->defer;
+      if (d == NULL)
+	break;
+
+      pfn = d->__pfn;
+      d->__pfn = NULL;
+
+      if (pfn != NULL)
+	{
+	  (*pfn) (d->__arg);
+
+	  if (n->__was_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;
+      __go_free (d);
+    }
+
+  /* The panic was not recovered.  */
+
+  runtime_startpanic ();
+  __printpanics (g->panic);
+  runtime_dopanic (0);
+}