summaryrefslogtreecommitdiff
path: root/src/pkg/runtime/runtime.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/runtime/runtime.c')
-rw-r--r--src/pkg/runtime/runtime.c286
1 files changed, 164 insertions, 122 deletions
diff --git a/src/pkg/runtime/runtime.c b/src/pkg/runtime/runtime.c
index 25a6f26bd..9d3efe966 100644
--- a/src/pkg/runtime/runtime.c
+++ b/src/pkg/runtime/runtime.c
@@ -4,87 +4,87 @@
#include "runtime.h"
-int32 panicking = 0;
-int32 maxround = sizeof(uintptr);
-int32 fd = 1;
+enum {
+ maxround = sizeof(uintptr),
+};
+
+int32 runtime·panicking = 0;
int32
-gotraceback(void)
+runtime·gotraceback(void)
{
byte *p;
- p = getenv("GOTRACEBACK");
+ p = runtime·getenv("GOTRACEBACK");
if(p == nil || p[0] == '\0')
return 1; // default is on
- return atoi(p);
+ return runtime·atoi(p);
}
void
-panic(int32 unused)
+runtime·dopanic(int32 unused)
{
- fd = 2;
- if(panicking) {
- printf("double panic\n");
- exit(3);
+ if(runtime·panicking) {
+ runtime·printf("double panic\n");
+ runtime·exit(3);
}
- panicking++;
+ runtime·panicking++;
- printf("\npanic PC=%X\n", (uint64)(uintptr)&unused);
- if(gotraceback()){
- traceback(·getcallerpc(&unused), getcallersp(&unused), 0, g);
- tracebackothers(g);
+ runtime·printf("\npanic PC=%X\n", (uint64)(uintptr)&unused);
+ if(runtime·gotraceback()){
+ runtime·traceback(runtime·getcallerpc(&unused), runtime·getcallersp(&unused), 0, g);
+ runtime·tracebackothers(g);
}
- breakpoint(); // so we can grab it in a debugger
- exit(2);
+ runtime·breakpoint(); // so we can grab it in a debugger
+ runtime·exit(2);
}
void
-·panicindex(void)
+runtime·panicindex(void)
{
- panicstring("index out of range");
+ runtime·panicstring("index out of range");
}
void
-·panicslice(void)
+runtime·panicslice(void)
{
- panicstring("slice bounds out of range");
+ runtime·panicstring("slice bounds out of range");
}
void
-·throwreturn(void)
+runtime·throwreturn(void)
{
// can only happen if compiler is broken
- throw("no return at end of a typed function - compiler is broken");
+ runtime·throw("no return at end of a typed function - compiler is broken");
}
void
-·throwinit(void)
+runtime·throwinit(void)
{
// can only happen with linker skew
- throw("recursive call during initialization - linker skew");
+ runtime·throw("recursive call during initialization - linker skew");
}
void
-throw(int8 *s)
+runtime·throw(int8 *s)
{
- fd = 2;
- printf("throw: %s\n", s);
- panic(-1);
+ runtime·printf("throw: %s\n", s);
+ runtime·dopanic(0);
*(int32*)0 = 0; // not reached
- exit(1); // even more not reached
+ runtime·exit(1); // even more not reached
}
void
-panicstring(int8 *s)
+runtime·panicstring(int8 *s)
{
Eface err;
- ·newErrorString(gostringnocopy((byte*)s), &err);
- ·panic(err);
+ runtime·newErrorString(runtime·gostringnocopy((byte*)s), &err);
+ runtime·panic(err);
}
void
-mcpy(byte *t, byte *f, uint32 n)
+runtime·mcpy(byte *t, byte *f, uint32 n)
{
while(n > 0) {
*t = *f;
@@ -95,7 +95,7 @@ mcpy(byte *t, byte *f, uint32 n)
}
int32
-mcmp(byte *s1, byte *s2, uint32 n)
+runtime·mcmp(byte *s1, byte *s2, uint32 n)
{
uint32 i;
byte c1, c2;
@@ -113,7 +113,7 @@ mcmp(byte *s1, byte *s2, uint32 n)
byte*
-mchr(byte *p, byte c, byte *ep)
+runtime·mchr(byte *p, byte c, byte *ep)
{
for(; p < ep; p++)
if(*p == c)
@@ -122,7 +122,7 @@ mchr(byte *p, byte c, byte *ep)
}
uint32
-rnd(uint32 n, uint32 m)
+runtime·rnd(uint32 n, uint32 m)
{
uint32 r;
@@ -141,54 +141,65 @@ Slice os·Args;
Slice os·Envs;
void
-args(int32 c, uint8 **v)
+runtime·args(int32 c, uint8 **v)
{
argc = c;
argv = v;
}
+int32 runtime·isplan9;
+
void
-goargs(void)
+runtime·goargs(void)
{
- String *gargv;
- String *genvv;
- int32 i, envc;
-
- for(envc=0; argv[argc+1+envc] != 0; envc++)
- ;
-
- gargv = malloc(argc*sizeof gargv[0]);
- genvv = malloc(envc*sizeof genvv[0]);
+ String *s;
+ int32 i;
+
+ // for windows implementation see "os" package
+ if(Windows)
+ return;
+ s = runtime·malloc(argc*sizeof s[0]);
for(i=0; i<argc; i++)
- gargv[i] = gostringnocopy(argv[i]);
- os·Args.array = (byte*)gargv;
+ s[i] = runtime·gostringnocopy(argv[i]);
+ os·Args.array = (byte*)s;
os·Args.len = argc;
os·Args.cap = argc;
+}
- for(i=0; i<envc; i++)
- genvv[i] = gostringnocopy(argv[argc+1+i]);
- os·Envs.array = (byte*)genvv;
- os·Envs.len = envc;
- os·Envs.cap = envc;
+void
+runtime·goenvs_unix(void)
+{
+ String *s;
+ int32 i, n;
+
+ for(n=0; argv[argc+1+n] != 0; n++)
+ ;
+
+ s = runtime·malloc(n*sizeof s[0]);
+ for(i=0; i<n; i++)
+ s[i] = runtime·gostringnocopy(argv[argc+1+i]);
+ os·Envs.array = (byte*)s;
+ os·Envs.len = n;
+ os·Envs.cap = n;
}
// Atomic add and return new value.
uint32
-xadd(uint32 volatile *val, int32 delta)
+runtime·xadd(uint32 volatile *val, int32 delta)
{
uint32 oval, nval;
for(;;){
oval = *val;
nval = oval + delta;
- if(cas(val, oval, nval))
+ if(runtime·cas(val, oval, nval))
return nval;
}
}
byte*
-getenv(int8 *s)
+runtime·getenv(int8 *s)
{
int32 i, j, len;
byte *v, *bs;
@@ -196,7 +207,7 @@ getenv(int8 *s)
int32 envc;
bs = (byte*)s;
- len = findnull(bs);
+ len = runtime·findnull(bs);
envv = (String*)os·Envs.array;
envc = os·Envs.len;
for(i=0; i<envc; i++){
@@ -215,17 +226,17 @@ getenv(int8 *s)
}
void
-·getgoroot(String out)
+runtime·getgoroot(String out)
{
byte *p;
- p = getenv("GOROOT");
- out = gostringnocopy(p);
+ p = runtime·getenv("GOROOT");
+ out = runtime·gostringnocopy(p);
FLUSH(&out);
}
int32
-atoi(byte *p)
+runtime·atoi(byte *p)
{
int32 n;
@@ -236,7 +247,7 @@ atoi(byte *p)
}
void
-check(void)
+runtime·check(void)
{
int8 a;
uint8 b;
@@ -250,35 +261,44 @@ check(void)
float64 j;
void* k;
uint16* l;
-
- if(sizeof(a) != 1) throw("bad a");
- if(sizeof(b) != 1) throw("bad b");
- if(sizeof(c) != 2) throw("bad c");
- if(sizeof(d) != 2) throw("bad d");
- if(sizeof(e) != 4) throw("bad e");
- if(sizeof(f) != 4) throw("bad f");
- if(sizeof(g) != 8) throw("bad g");
- if(sizeof(h) != 8) throw("bad h");
- if(sizeof(i) != 4) throw("bad i");
- if(sizeof(j) != 8) throw("bad j");
- if(sizeof(k) != sizeof(uintptr)) throw("bad k");
- if(sizeof(l) != sizeof(uintptr)) throw("bad l");
-// prints(1"check ok\n");
+ struct x1 {
+ byte x;
+ };
+ struct y1 {
+ struct x1 x1;
+ byte y;
+ };
+
+ if(sizeof(a) != 1) runtime·throw("bad a");
+ if(sizeof(b) != 1) runtime·throw("bad b");
+ if(sizeof(c) != 2) runtime·throw("bad c");
+ if(sizeof(d) != 2) runtime·throw("bad d");
+ if(sizeof(e) != 4) runtime·throw("bad e");
+ if(sizeof(f) != 4) runtime·throw("bad f");
+ if(sizeof(g) != 8) runtime·throw("bad g");
+ if(sizeof(h) != 8) runtime·throw("bad h");
+ if(sizeof(i) != 4) runtime·throw("bad i");
+ if(sizeof(j) != 8) runtime·throw("bad j");
+ if(sizeof(k) != sizeof(uintptr)) runtime·throw("bad k");
+ if(sizeof(l) != sizeof(uintptr)) runtime·throw("bad l");
+ if(sizeof(struct x1) != 1) runtime·throw("bad sizeof x1");
+ if(offsetof(struct y1, y) != 1) runtime·throw("bad offsetof y1.y");
+ if(sizeof(struct y1) != 2) runtime·throw("bad sizeof y1");
uint32 z;
z = 1;
- if(!cas(&z, 1, 2))
- throw("cas1");
+ if(!runtime·cas(&z, 1, 2))
+ runtime·throw("cas1");
if(z != 2)
- throw("cas2");
+ runtime·throw("cas2");
z = 4;
- if(cas(&z, 5, 6))
- throw("cas3");
+ if(runtime·cas(&z, 5, 6))
+ runtime·throw("cas3");
if(z != 4)
- throw("cas4");
+ runtime·throw("cas4");
- initsig(0);
+ runtime·initsig(0);
}
/*
@@ -310,14 +330,19 @@ memhash(uint32 s, void *a)
static uint32
memequal(uint32 s, void *a, void *b)
{
- byte *ba, *bb;
- uint32 i;
+ byte *ba, *bb, *aend;
+ if(a == b)
+ return 1;
ba = a;
bb = b;
- for(i=0; i<s; i++)
- if(ba[i] != bb[i])
+ aend = ba+s;
+ while(ba != aend) {
+ if(*ba != *bb)
return 0;
+ ba++;
+ bb++;
+ }
return 1;
}
@@ -341,7 +366,7 @@ memprint(uint32 s, void *a)
v = *(uint64*)a;
break;
}
- ·printint(v);
+ runtime·printint(v);
}
static void
@@ -361,6 +386,24 @@ memcopy(uint32 s, void *a, void *b)
ba[i] = bb[i];
}
+static uint32
+memwordequal(uint32 s, void *a, void *b)
+{
+ USED(s);
+ return *(uintptr*)(a) == *(uintptr*)(b);
+}
+
+static void
+memwordcopy(uint32 s, void *a, void *b)
+{
+ USED(s);
+ if (b == nil) {
+ *(uintptr*)(a) = 0;
+ return;
+ }
+ *(uintptr*)(a) = *(uintptr*)(b);
+}
+
static uintptr
strhash(uint32 s, String *a)
{
@@ -371,119 +414,118 @@ strhash(uint32 s, String *a)
static uint32
strequal(uint32 s, String *a, String *b)
{
+ int32 alen;
+
USED(s);
- return cmpstring(*a, *b) == 0;
+ alen = a->len;
+ if(alen != b->len)
+ return false;
+ return memequal(alen, a->str, b->str);
}
static void
strprint(uint32 s, String *a)
{
USED(s);
- ·printstring(*a);
+ runtime·printstring(*a);
}
static uintptr
interhash(uint32 s, Iface *a)
{
USED(s);
- return ifacehash(*a);
+ return runtime·ifacehash(*a);
}
static void
interprint(uint32 s, Iface *a)
{
USED(s);
- ·printiface(*a);
+ runtime·printiface(*a);
}
static uint32
interequal(uint32 s, Iface *a, Iface *b)
{
USED(s);
- return ifaceeq(*a, *b);
+ return runtime·ifaceeq_c(*a, *b);
}
static uintptr
nilinterhash(uint32 s, Eface *a)
{
USED(s);
- return efacehash(*a);
+ return runtime·efacehash(*a);
}
static void
nilinterprint(uint32 s, Eface *a)
{
USED(s);
- ·printeface(*a);
+ runtime·printeface(*a);
}
static uint32
nilinterequal(uint32 s, Eface *a, Eface *b)
{
USED(s);
- return efaceeq(*a, *b);
+ return runtime·efaceeq_c(*a, *b);
}
uintptr
-nohash(uint32 s, void *a)
+runtime·nohash(uint32 s, void *a)
{
USED(s);
USED(a);
- panicstring("hash of unhashable type");
+ runtime·panicstring("hash of unhashable type");
return 0;
}
uint32
-noequal(uint32 s, void *a, void *b)
+runtime·noequal(uint32 s, void *a, void *b)
{
USED(s);
USED(a);
USED(b);
- panicstring("comparing uncomparable types");
+ runtime·panicstring("comparing uncomparable types");
return 0;
}
Alg
-algarray[] =
+runtime·algarray[] =
{
[AMEM] { memhash, memequal, memprint, memcopy },
-[ANOEQ] { nohash, noequal, memprint, memcopy },
+[ANOEQ] { runtime·nohash, runtime·noequal, memprint, memcopy },
[ASTRING] { strhash, strequal, strprint, memcopy },
[AINTER] { interhash, interequal, interprint, memcopy },
[ANILINTER] { nilinterhash, nilinterequal, nilinterprint, memcopy },
+[AMEMWORD] { memhash, memwordequal, memprint, memwordcopy },
};
-#pragma textflag 7
-void
-FLUSH(void *v)
-{
- USED(v);
-}
-
int64
-nanotime(void)
+runtime·nanotime(void)
{
int64 sec;
int32 usec;
sec = 0;
usec = 0;
- gettime(&sec, &usec);
+ runtime·gettime(&sec, &usec);
return sec*1000000000 + (int64)usec*1000;
}
void
-·Caller(int32 skip, uintptr retpc, String retfile, int32 retline, bool retbool)
+runtime·Caller(int32 skip, uintptr retpc, String retfile, int32 retline, bool retbool)
{
Func *f;
- if(callers(1+skip, &retpc, 1) == 0 || (f = findfunc(retpc-1)) == nil) {
- retfile = emptystring;
+ if(runtime·callers(1+skip, &retpc, 1) == 0 || (f = runtime·findfunc(retpc-1)) == nil) {
+ retfile = runtime·emptystring;
retline = 0;
retbool = false;
} else {
retfile = f->src;
- retline = funcline(f, retpc-1);
+ retline = runtime·funcline(f, retpc-1);
retbool = true;
}
FLUSH(&retfile);
@@ -492,15 +534,15 @@ void
}
void
-·Callers(int32 skip, Slice pc, int32 retn)
+runtime·Callers(int32 skip, Slice pc, int32 retn)
{
- retn = callers(skip, (uintptr*)pc.array, pc.len);
+ retn = runtime·callers(skip, (uintptr*)pc.array, pc.len);
FLUSH(&retn);
}
void
-·FuncForPC(uintptr pc, void *retf)
+runtime·FuncForPC(uintptr pc, void *retf)
{
- retf = findfunc(pc);
+ retf = runtime·findfunc(pc);
FLUSH(&retf);
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-13 10:19:14 +0000