Avoid always splitting the stack when calling append and copy.

From-SVN: r167970

2 files changed, 45 insertions, 19 deletions

diff --git a/libgo/runtime/go-append.c b/libgo/runtime/go-append.c
index aa8f4a1..91493b1 100644
--- a/libgo/runtime/go-append.c
+++ b/libgo/runtime/go-append.c
@@ -4,37 +4,43 @@
    Use of this source code is governed by a BSD-style
    license that can be found in the LICENSE file.  */
 
-#include "go-assert.h"
 #include "go-type.h"
+#include "go-panic.h"
 #include "array.h"
 #include "runtime.h"
 #include "malloc.h"
 
+/* We should be OK if we don't split the stack here, since the only
+   libc functions we call are memcpy and memmove.  If we don't do
+   this, we will always split the stack, because of memcpy and
+   memmove.  */
+extern struct __go_open_array
+__go_append (struct __go_open_array, void *, size_t, size_t)
+  __attribute__ ((no_split_stack));
+
 struct __go_open_array
-__go_append (const struct __go_slice_type *type,
-	     struct __go_open_array a, struct __go_open_array b)
+__go_append (struct __go_open_array a, void *bvalues, size_t bcount,
+	     size_t element_size)
 {
-  size_t element_size;
-  unsigned int ucount;
+  size_t ucount;
   int count;
 
-  if (b.__values == NULL || b.__count == 0)
+  if (bvalues == NULL || bcount == 0)
     return a;
 
-  __go_assert (type->__common.__code == GO_SLICE);
-  element_size = type->__element_type->__size;
-
-  ucount = (unsigned int) a.__count + (unsigned int) b.__count;
+  ucount = (size_t) a.__count + bcount;
   count = (int) ucount;
-  __go_assert (ucount == (unsigned int) count && count >= a.__count);
+  if ((size_t) count != ucount || count <= a.__count)
+    __go_panic_msg ("append: slice overflow");
+
   if (count > a.__capacity)
     {
       int m;
-      struct __go_open_array n;
+      void *n;
 
       m = a.__capacity;
       if (m == 0)
-	m = b.__count;
+	m = (int) bcount;
       else
 	{
 	  do
@@ -47,16 +53,15 @@ __go_append (const struct __go_slice_type *type,
 	  while (m < count);
 	}
 
-      n.__values = __go_alloc (m * element_size);
-      n.__count = a.__count;
-      n.__capacity = m;
-      __builtin_memcpy (n.__values, a.__values, n.__count * element_size);
+      n = __go_alloc (m * element_size);
+      __builtin_memcpy (n, a.__values, a.__count * element_size);
 
-      a = n;
+      a.__values = n;
+      a.__capacity = m;
     }
 
   __builtin_memmove ((char *) a.__values + a.__count * element_size,
-		     b.__values, b.__count * element_size);
+		     bvalues, bcount * element_size);
   a.__count = count;
   return a;
 }
diff --git a/libgo/runtime/go-copy.c b/libgo/runtime/go-copy.c
new file mode 100644
index 0000000..998aeb9
--- /dev/null
+++ b/libgo/runtime/go-copy.c
@@ -0,0 +1,21 @@
+/* go-append.c -- the go builtin copy 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>
+
+/* We should be OK if we don't split the stack here, since we are just
+   calling memmove which shouldn't need much stack.  If we don't do
+   this we will always split the stack, because of memmove.  */
+
+extern void
+__go_copy (void *, void *, size_t)
+  __attribute__ ((no_split_stack));
+
+void
+__go_copy (void *a, void *b, size_t len)
+{
+  __builtin_memmove (a, b, len);
+}