ucount = (uintptr_t) a.__count + bcount;
count = (int) ucount;
if ((uintptr_t) count != ucount || count <= a.__count)
- __go_panic_msg ("append: slice overflow");
+ runtime_panicstring ("append: slice overflow");
if (count > a.__capacity)
{
int i;
if (channel == NULL)
- __go_panic_msg ("close of nil channel");
+ runtime_panicstring ("close of nil channel");
i = pthread_mutex_lock (&channel->lock);
__go_assert (i == 0);
{
i = pthread_mutex_unlock (&channel->lock);
__go_assert (i == 0);
- __go_panic_msg ("close of closed channel");
+ runtime_panicstring ("close of closed channel");
}
channel->is_closed = 1;
Use of this source code is governed by a BSD-style
license that can be found in the LICENSE file. */
-#include "go-panic.h"
+#include "runtime.h"
#include "interface.h"
/* Compare two interface values. Return 0 for equal, not zero for not
if (((uintptr_t) left_descriptor & reflectFlags) != 0
|| ((uintptr_t) right.__type_descriptor & reflectFlags) != 0)
- __go_panic_msg ("invalid interface value");
+ runtime_panicstring ("invalid interface value");
if (left_descriptor == NULL && right.__type_descriptor == NULL)
return 0;
Use of this source code is governed by a BSD-style
license that can be found in the LICENSE file. */
-#include "go-panic.h"
+#include "runtime.h"
#include "go-type.h"
#include "interface.h"
left_descriptor = left.__type_descriptor;
if (((uintptr_t) left_descriptor & reflectFlags) != 0)
- __go_panic_msg ("invalid interface value");
+ runtime_panicstring ("invalid interface value");
if (left_descriptor == NULL)
return 1;
if (!__go_type_descriptors_equal (left_descriptor, right_descriptor))
Use of this source code is governed by a BSD-style
license that can be found in the LICENSE file. */
-#include "go-panic.h"
+#include "runtime.h"
#include "interface.h"
/* Compare a non-empty interface value with an empty interface value.
const struct __go_type_descriptor *left_descriptor;
if (((uintptr_t) right.__type_descriptor & reflectFlags) != 0)
- __go_panic_msg ("invalid interface value");
+ runtime_panicstring ("invalid interface value");
if (left.__methods == NULL && right.__type_descriptor == NULL)
return 0;
if (left.__methods == NULL || right.__type_descriptor == NULL)
ilen = (int) len;
if (ilen < 0 || (uintptr_t) ilen != len)
- __go_panic_msg ("makeslice: len out of range");
+ runtime_panicstring ("makeslice: len out of range");
icap = (int) cap;
if (cap < len
|| (uintptr_t) icap != cap
|| (std->__element_type->__size > 0
&& cap > (uintptr_t) -1U / std->__element_type->__size))
- __go_panic_msg ("makeslice: cap out of range");
+ runtime_panicstring ("makeslice: cap out of range");
ret.__count = ilen;
ret.__capacity = icap;
#include <stddef.h>
#include <stdlib.h>
+#include "runtime.h"
#include "go-alloc.h"
#include "go-assert.h"
-#include "go-panic.h"
#include "map.h"
/* Delete the entry matching KEY from MAP. */
void **pentry;
if (map == NULL)
- __go_panic_msg ("deletion of entry in nil map");
+ runtime_panicstring ("deletion of entry in nil map");
descriptor = map->__descriptor;
#include <stddef.h>
#include <stdlib.h>
+#include "runtime.h"
#include "go-alloc.h"
#include "go-assert.h"
-#include "go-panic.h"
#include "map.h"
/* Rehash MAP to a larger size. */
if (map == NULL)
{
if (insert)
- __go_panic_msg ("assignment to entry in nil map");
+ runtime_panicstring ("assignment to entry in nil map");
return NULL;
}
#include <stddef.h>
#include <stdint.h>
+#include "runtime.h"
#include "go-alloc.h"
#include "go-assert.h"
-#include "go-panic.h"
#include "channel.h"
struct __go_channel*
if (ientries < 0
|| (uintptr_t) ientries != entries
|| (element_size > 0 && entries > (uintptr_t) -1 / element_size))
- __go_panic_msg ("chan size out of range");
+ runtime_panicstring ("chan size out of range");
alloc_size = (element_size + sizeof (uint64_t) - 1) / sizeof (uint64_t);
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-alloc.h"
-#include "go-panic.h"
#include "map.h"
/* List of prime numbers, copied from libstdc++/src/hashtable.c. */
ientries = (int) entries;
if (ientries < 0 || (uintptr_t) ientries != entries)
- __go_panic_msg ("map size out of range");
+ runtime_panicstring ("map size out of range");
if (entries == 0)
entries = 5;
__printpanics (g->panic);
runtime_dopanic (0);
}
-
-/* This is used by the runtime library. */
-
-void
-__go_panic_msg (const char* msg)
-{
- size_t len;
- unsigned char *sdata;
- struct __go_string s;
- struct __go_empty_interface arg;
-
- len = __builtin_strlen (msg);
- sdata = runtime_mallocgc (len, FlagNoPointers, 0, 0);
- __builtin_memcpy (sdata, msg, len);
- s.__data = sdata;
- s.__length = len;
- newErrorString(s, &arg);
- __go_panic (arg);
-}
extern void __go_panic (struct __go_empty_interface)
__attribute__ ((noreturn));
-extern void __go_panic_msg (const char* msg)
- __attribute__ ((noreturn));
-
extern void __go_print_string (struct __go_string);
extern struct __go_empty_interface __go_recover (void);
struct __go_empty_interface *ret)
__asm__ ("libgo_runtime.runtime.NewTypeAssertionError");
-extern void newErrorString(struct __go_string, struct __go_empty_interface *)
+extern void runtime_newErrorString(struct __go_string,
+ struct __go_empty_interface *)
__asm__ ("libgo_runtime.runtime.NewErrorString");
extern void printany(struct __go_empty_interface)
#include <stdlib.h>
#include <stdint.h>
+#include "runtime.h"
#include "go-alloc.h"
#include "go-assert.h"
-#include "go-panic.h"
#include "go-type.h"
#include "map.h"
__go_assert (mt->__common.__code == GO_MAP);
if (map == NULL)
- __go_panic_msg ("assignment to entry in nil map");
+ runtime_panicstring ("assignment to entry in nil map");
key_descriptor = mt->__key_type;
if (__go_is_pointer_type (key_descriptor))
#include <stdlib.h>
#include <stdint.h>
+#include "runtime.h"
#include "interface.h"
#include "go-alloc.h"
-#include "go-panic.h"
#include "go-string.h"
#include "go-type.h"
struct reflect_ret ret;
if (((uintptr_t) e.__type_descriptor & reflectFlags) != 0)
- __go_panic_msg ("invalid interface value");
+ runtime_panicstring ("invalid interface value");
if (e.__type_descriptor == NULL)
{
struct __go_empty_interface ret;
if (((uintptr_t) e.__type_descriptor & reflectFlags) != 0)
- __go_panic_msg ("invalid interface value");
+ runtime_panicstring ("invalid interface value");
if (e.__type_descriptor == NULL)
{
Use of this source code is governed by a BSD-style
license that can be found in the LICENSE file. */
-#include "go-panic.h"
+#include "runtime.h"
/* The compiler generates calls to this function. This enum values
are known to the compiler and used by compiled code. Any change
case SLICE_INDEX_OUT_OF_BOUNDS:
case ARRAY_INDEX_OUT_OF_BOUNDS:
case STRING_INDEX_OUT_OF_BOUNDS:
- __go_panic_msg ("index out of range");
+ runtime_panicstring ("index out of range");
case SLICE_SLICE_OUT_OF_BOUNDS:
case ARRAY_SLICE_OUT_OF_BOUNDS:
case STRING_SLICE_OUT_OF_BOUNDS:
- __go_panic_msg ("slice bounds out of range");
+ runtime_panicstring ("slice bounds out of range");
case NIL_DEREFERENCE:
- __go_panic_msg ("nil pointer dereference");
+ runtime_panicstring ("nil pointer dereference");
case MAKE_SLICE_OUT_OF_BOUNDS:
- __go_panic_msg ("make slice len or cap out of range");
+ runtime_panicstring ("make slice len or cap out of range");
case MAKE_MAP_OUT_OF_BOUNDS:
- __go_panic_msg ("make map len out of range");
+ runtime_panicstring ("make map len out of range");
case MAKE_CHAN_OUT_OF_BOUNDS:
- __go_panic_msg ("make chan len out of range");
+ runtime_panicstring ("make chan len out of range");
default:
- __go_panic_msg ("unknown runtime error");
+ runtime_panicstring ("unknown runtime error");
}
}
{
i = pthread_mutex_unlock (&channel->lock);
__go_assert (i == 0);
- __go_panic_msg ("send on closed channel");
+ runtime_panicstring ("send on closed channel");
}
if (channel->num_entries > 0)
channel->selected_for_send = 0;
i = pthread_mutex_unlock (&channel->lock);
__go_assert (i == 0);
- __go_panic_msg ("send on closed channel");
+ runtime_panicstring ("send on closed channel");
}
/* If somebody else has the channel locked for sending, we have
i = sigprocmask (SIG_UNBLOCK, &clear, NULL);
__go_assert (i == 0);
- __go_panic_msg (msg);
+ runtime_panicstring (msg);
}
for (i = 0; signals[i].sig != -1; ++i)
if (end == -1)
end = len;
if (start > len || end < start || end > len)
- __go_panic_msg ("string index out of bounds");
+ runtime_panicstring ("string index out of bounds");
ret.__data = s.__data + start;
ret.__length = end - start;
return ret;
Use of this source code is governed by a BSD-style
license that can be found in the LICENSE file. */
+#include "runtime.h"
#include "interface.h"
-#include "go-panic.h"
#include "go-type.h"
/* A hash function for an empty interface. */
v2_descriptor = v2->__type_descriptor;
if (((uintptr_t) v1_descriptor & reflectFlags) != 0
|| ((uintptr_t) v2_descriptor & reflectFlags) != 0)
- __go_panic_msg ("invalid interface value");
+ runtime_panicstring ("invalid interface value");
if (v1_descriptor == NULL || v2_descriptor == NULL)
return v1_descriptor == v2_descriptor;
if (!__go_type_descriptors_equal (v1_descriptor, v2_descriptor))
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-type.h"
-#include "go-panic.h"
/* A hash function used for a type which does not support hash
functions. */
__go_type_hash_error (const void *val __attribute__ ((unused)),
size_t key_size __attribute__ ((unused)))
{
- __go_panic_msg ("hash of unhashable type");
+ runtime_panicstring ("hash of unhashable type");
}
/* An equality function for an interface. */
const void *v2 __attribute__ ((unused)),
size_t key_size __attribute__ ((unused)))
{
- __go_panic_msg ("comparing uncomparable types");
+ runtime_panicstring ("comparing uncomparable types");
}
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-alloc.h"
-#include "go-panic.h"
#include "go-type.h"
#include "interface.h"
struct __go_empty_interface ret;
if (((uintptr_t) type.__type_descriptor & reflectFlags) != 0)
- __go_panic_msg ("invalid interface value");
+ runtime_panicstring ("invalid interface value");
/* FIXME: We should check __type_descriptor to verify that this is
really a type descriptor. */
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-alloc.h"
-#include "go-panic.h"
#include "go-type.h"
#include "interface.h"
const struct __go_type_descriptor *descriptor;
if (((uintptr_t) type.__type_descriptor & reflectFlags) != 0)
- __go_panic_msg ("invalid interface value");
+ runtime_panicstring ("invalid interface value");
/* FIXME: We should check __type_descriptor to verify that this is
really a type descriptor. */
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-alloc.h"
-#include "go-panic.h"
#include "go-type.h"
#include "interface.h"
const struct __go_type_descriptor *descriptor;
if (((uintptr_t) type.__type_descriptor & reflectFlags) != 0)
- __go_panic_msg ("invalid interface value");
+ runtime_panicstring ("invalid interface value");
/* FIXME: We should check __type_descriptor to verify that this is
really a type descriptor. */
// license that can be found in the LICENSE file.
package runtime
-#include "go-panic.h"
+#include "runtime.h"
#include "go-type.h"
#include "interface.h"
-#define nil NULL
-typedef _Bool bool;
typedef struct __go_type_descriptor descriptor;
typedef const struct __go_type_descriptor const_descriptor;
typedef struct __go_interface interface;
// Convert an empty interface to an empty interface.
func ifaceE2E2(e empty_interface) (ret empty_interface, ok bool) {
if(((uintptr_t)e.__type_descriptor&reflectFlags) != 0)
- __go_panic_msg("invalid interface value");
+ runtime_panicstring("invalid interface value");
ret = e;
ok = ret.__type_descriptor != nil;
}
// Convert an empty interface to a non-empty interface.
func ifaceE2I2(inter *descriptor, e empty_interface) (ret interface, ok bool) {
if(((uintptr_t)e.__type_descriptor&reflectFlags) != 0)
- __go_panic_msg("invalid interface value");
+ runtime_panicstring("invalid interface value");
if (e.__type_descriptor == nil) {
ret.__methods = nil;
ret.__object = nil;
// Convert an empty interface to a pointer type.
func ifaceE2T2P(inter *descriptor, e empty_interface) (ret *void, ok bool) {
if(((uintptr_t)e.__type_descriptor&reflectFlags) != 0)
- __go_panic_msg("invalid interface value");
+ runtime_panicstring("invalid interface value");
if (!__go_type_descriptors_equal(inter, e.__type_descriptor)) {
ret = nil;
ok = 0;
// Convert an empty interface to a non-pointer type.
func ifaceE2T2(inter *descriptor, e empty_interface, ret *void) (ok bool) {
if(((uintptr_t)e.__type_descriptor&reflectFlags) != 0)
- __go_panic_msg("invalid interface value");
+ runtime_panicstring("invalid interface value");
if (!__go_type_descriptors_equal(inter, e.__type_descriptor)) {
__builtin_memset(ret, 0, inter->__size);
ok = 0;
#include "go-string.h"
#include "interface.h"
#include "go-type.h"
-typedef struct __go_empty_interface Eface;
-typedef struct __go_type_descriptor Type;
-typedef struct __go_func_type FuncType;
MHeap runtime_mheap;
extern MStats mstats; // defined in extern.go
// license that can be found in the LICENSE file.
package runtime
+#include "runtime.h"
#include "map.h"
-#define nil NULL
-typedef unsigned char byte;
-typedef _Bool bool;
-
-typedef struct __go_map_type MapType;
typedef struct __go_map Hmap;
typedef struct __go_hash_iter hiter;
#include "runtime.h"
#include "go-panic.h"
-typedef struct __go_type_descriptor Type;
-typedef struct __go_interface Iface;
-typedef struct __go_empty_interface Eface;
-
func ifaceE2I(inter *Type, e Eface, ret *Iface) {
const Type *t;
Eface err;
runtime_exit(1); // even more not reached
}
+void
+runtime_panicstring(const char *s)
+{
+ Eface err;
+
+ if(runtime_m()->gcing) {
+ runtime_printf("panic: %s\n", s);
+ runtime_throw("panic during gc");
+ }
+ runtime_newErrorString(runtime_gostringnocopy((const byte*)s), &err);
+ runtime_panic(err);
+}
+
static int32 argc;
static byte** argv;
s = runtime_malloc(argc*sizeof s[0]);
for(i=0; i<argc; i++)
- s[i] = runtime_gostringnocopy((byte*)argv[i]);
+ s[i] = runtime_gostringnocopy((const byte*)argv[i]);
os_Args.__values = (void*)s;
os_Args.__count = argc;
os_Args.__capacity = argc;
typedef struct FixAlloc FixAlloc;
typedef struct __go_defer_stack Defer;
+typedef struct __go_interface Iface;
+typedef struct __go_empty_interface Eface;
+typedef struct __go_type_descriptor Type;
typedef struct __go_panic_stack Panic;
typedef struct __go_open_array Slice;
typedef struct __go_string String;
+typedef struct __go_func_type FuncType;
+typedef struct __go_map_type MapType;
+
/*
* per-cpu declaration.
*/
void runtime_goargs(void);
void runtime_goenvs(void);
void runtime_throw(const char*);
+void runtime_panicstring(const char*) __attribute__ ((noreturn));
void* runtime_mal(uintptr);
void runtime_schedinit(void);
void runtime_initsig(int32);
-String runtime_gostringnocopy(byte*);
+String runtime_gostringnocopy(const byte*);
void* runtime_mstart(void*);
G* runtime_malg(int32, byte**, size_t*);
void runtime_minit(void);
void runtime_futexsleep(uint32*, uint32, int64);
void runtime_futexwakeup(uint32*, uint32);
+/*
+ * runtime go-called
+ */
+void runtime_panic(Eface);
/* Functions. */
+#define runtime_panic __go_panic
#define runtime_printf printf
#define runtime_malloc(s) __go_alloc(s)
#define runtime_free(p) __go_free(p)
}
String
-runtime_gostringnocopy(byte *str)
+runtime_gostringnocopy(const byte *str)
{
String s;
projects / gcc.git / commitdiff