Skip to content

G
go
Commit 5624e344 authored by Rob Pike's avatar Rob Pike
Browse files
Options

rearrange tree to reflect design based on $GOROOT $GOOS $GOARCH 

SVN=121291
parent f4ccabde
Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 702 deletions
src/lib/runtime/runtime.c deleted 100644 → 0
View file @ f4ccabde
// 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 "runtime.h"
int32 debug = 0;
void
sys_printbool(bool v)
{
if(v) {
sys_write(1, (byte*)"true", 4);
return;
}
sys_write(1, (byte*)"false", 5);
}
void
sys_printfloat(float64 v)
{
sys_write(1, "printfloat", 10);
}
void
sys_printint(int64 v)
{
byte buf[100];
int32 i, s;
s = 0;
if(v < 0) {
v = -v;
s = 1;
if(v < 0) {
sys_write(1, (byte*)"-oo", 3);
return;
}
}
for(i=nelem(buf)-1; i>0; i--) {
buf[i] = v%10 + '0';
if(v < 10)
break;
v = v/10;
}
if(s) {
i--;
buf[i] = '-';
}
sys_write(1, buf+i, nelem(buf)-i);
}
void
sys_printpointer(void *p)
{
uint64 v;
byte buf[100];
int32 i;
v = (int64)p;
for(i=nelem(buf)-1; i>0; i--) {
buf[i] = v%16 + '0';
if(buf[i] > '9')
buf[i] += 'a'-'0'-10;
if(v < 16)
break;
v = v/16;
}
sys_write(1, buf+i, nelem(buf)-i);
}
void
sys_panicl(int32 lno)
{
prints("\npanic on line ");
sys_printint(lno);
prints("\n");
*(int32*)0 = 0;
}
void
sys_printstring(string v)
{
sys_write(1, v->str, v->len);
}
int32
strlen(int8 *s)
{
int32 l;
for(l=0; s[l]!=0; l++)
;
return l;
}
void
prints(int8 *s)
{
sys_write(1, s, strlen(s));
}
dump(byte *p, int32 n)
{
uint32 v;
int32 i;
for(i=0; i<n; i++) {
sys_printpointer((byte*)(p[i]>>4));
sys_printpointer((byte*)(p[i]&0xf));
if((i&15) == 15)
prints("\n");
else
prints(" ");
}
if(n & 15)
prints("\n");
}
static uint8* hunk;
static uint32 nhunk;
static uint64 nmmap;
static uint64 nmal;
enum
{
NHUNK = 20<<20,
PROT_NONE = 0x00,
PROT_READ = 0x01,
PROT_WRITE = 0x02,
PROT_EXEC = 0x04,
MAP_FILE = 0x0000,
MAP_SHARED = 0x0001,
MAP_PRIVATE = 0x0002,
MAP_FIXED = 0x0010,
MAP_ANON = 0x1000,
};
static void
throw(int8 *s)
{
prints("throw: ");
prints(s);
prints("\n");
sys_exit(1);
}
static void
mcpy(byte *t, byte *f, uint32 n)
{
while(n > 0) {
*t = *f;
t++;
f++;
n--;
}
}
static byte*
brk(uint32 n)
{
byte* v;
v = sys_mmap(nil, NHUNK, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, 0, 0);
sys_memclr(v, n);
nmmap += n;
return v;
}
static void*
mal(uint32 n)
{
byte* v;
// round to keep everything 64-bit alligned
while(n & 7)
n++;
nmal += n;
// do we have enough in contiguous hunk
if(n > nhunk) {
// if it is big allocate it separately
if(n > NHUNK)
return brk(n);
// allocate a new contiguous hunk
hunk = brk(NHUNK);
nhunk = NHUNK;
}
// allocate from the contiguous hunk
v = hunk;
hunk += n;
nhunk -= n;
return v;
}
void
sys_mal(uint32 n, uint8 *ret)
{
ret = mal(n);
FLUSH(&ret);
}
void
sys_catstring(string s1, string s2, string s3)
{
uint32 l;
if(s1->len == 0) {
s3 = s2;
goto out;
}
if(s2->len == 0) {
s3 = s1;
goto out;
}
l = s1->len + s2->len;
s3 = mal(sizeof(s3->len)+l);
s3->len = l;
mcpy(s3->str, s1->str, s1->len);
mcpy(s3->str+s1->len, s2->str, s2->len);
out:
FLUSH(&s3);
}
void
sys_cmpstring(string s1, string s2, int32 v)
{
uint32 i, l;
byte c1, c2;
l = s1->len;
if(s2->len < l)
l = s2->len;
for(i=0; i<l; i++) {
c1 = s1->str[i];
c2 = s2->str[i];
if(c1 < c2) {
v = -1;
goto out;
}
if(c1 > c2) {
v = +1;
goto out;
}
}
if(s1->len < s2->len) {
v = -1;
goto out;
}
if(s1->len > s2->len) {
v = +1;
goto out;
}
v = 0;
out:
FLUSH(&v);
}
static int32
strcmp(byte *s1, byte *s2)
{
uint32 i;
byte c1, c2;
for(i=0;; i++) {
c1 = s1[i];
c2 = s2[i];
if(c1 < c2)
return -1;
if(c1 > c2)
return +1;
if(c1 == 0)
return 0;
}
}
static void
prbounds(int8* s, int32 a, int32 b, int32 c)
{
int32 i;
prints(s);
prints(" ");
sys_printint(a);
prints("<");
sys_printint(b);
prints(">");
sys_printint(c);
prints("\n");
throw("bounds");
}
void
sys_slicestring(string si, int32 lindex, int32 hindex, string so)
{
string s, str;
int32 l;
if(lindex < 0 || lindex > si->len ||
hindex < lindex || hindex > si->len)
prbounds("slice", lindex, si->len, hindex);
l = hindex-lindex;
so = mal(sizeof(so->len)+l);
so->len = l;
mcpy(so->str, si->str+lindex, l);
FLUSH(&so);
}
void
sys_indexstring(string s, int32 i, byte b)
{
if(i < 0 || i >= s->len)
prbounds("index", 0, i, s->len);
b = s->str[i];
FLUSH(&b);
}
/*
* this is the plan9 runetochar
* extended for 36 bits in 7 bytes
* note that it truncates to 32 bits
* through the argument passing.
*/
static int32
runetochar(byte *str, uint32 c)
{
int32 i, n;
uint32 mask, mark;
/*
* one character in 7 bits
*/
if(c <= 0x07FUL) {
str[0] = c;
return 1;
}
/*
* every new character picks up 5 bits
* one less in the first byte and
* six more in an extension byte
*/
mask = 0x7ffUL;
mark = 0xC0UL;
for(n=1;; n++) {
if(c <= mask)
break;
mask = (mask<<5) | 0x1fUL;
mark = (mark>>1) | 0x80UL;
}
/*
* lay down the bytes backwards
* n is the number of extension bytes
* mask is the max codepoint
* mark is the zeroth byte indicator
*/
for(i=n; i>0; i--) {
str[i] = 0x80UL | (c&0x3fUL);
c >>= 6;
}
str[0] = mark|c;
return n+1;
}
void
sys_intstring(int64 v, string s)
{
int32 l;
s = mal(sizeof(s->len)+8);
s->len = runetochar(s->str, v);
FLUSH(&s);
}
void
sys_byteastring(byte *a, int32 l, string s)
{
s = mal(sizeof(s->len)+l);
s->len = l;
mcpy(s->str, a, l);
FLUSH(&s);
}
static Map* hash[1009];
static Map*
hashmap(Sigi *si, Sigs *ss)
{
int32 ns, ni;
uint32 ihash, h;
byte *sname, *iname;
Map *m;
h = ((uint32)si + (uint32)ss) % nelem(hash);
for(m=hash[h]; m!=nil; m=m->link) {
if(m->si == si && m->ss == ss) {
if(m->bad) {
throw("bad hashmap");
m = nil;
}
// prints("old hashmap\n");
return m;
}
}
ni = si[0].offset; // first word has size
m = mal(sizeof(*m) + ni*sizeof(m->fun[0]));
m->si = si;
m->ss = ss;
ni = 1; // skip first word
ns = 0;
loop1:
// pick up next name from
// interface signature
iname = si[ni].name;
if(iname == nil) {
m->link = hash[h];
hash[h] = m;
// prints("new hashmap\n");
return m;
}
ihash = si[ni].hash;
loop2:
// pick up and comapre next name
// from structure signature
sname = ss[ns].name;
if(sname == nil) {
prints((int8*)iname);
prints(": ");
throw("hashmap: failed to find method");
m->bad = 1;
m->link = hash[h];
hash[h] = m;
return nil;
}
if(ihash != ss[ns].hash ||
strcmp(sname, iname) != 0) {
ns++;
goto loop2;
}
m->fun[si[ni].offset] = ss[ns].fun;
ni++;
goto loop1;
}
void
sys_ifaces2i(Sigi *si, Sigs *ss, Map *m, void *s)
{
if(debug) {
prints("s2i sigi=");
sys_printpointer(si);
prints(" sigs=");
sys_printpointer(ss);
prints(" s=");
sys_printpointer(s);
}
if(s == nil) {
throw("ifaces2i: nil pointer");
m = nil;
FLUSH(&m);
return;
}
m = hashmap(si, ss);
if(debug) {
prints(" returning m=");
sys_printpointer(m);
prints(" s=");
sys_printpointer(s);
prints("\n");
dump((byte*)m, 64);
}
FLUSH(&m);
}
void
sys_ifacei2i(Sigi *si, Map *m, void *s)
{
if(debug) {
prints("i2i sigi=");
sys_printpointer(si);
prints(" m=");
sys_printpointer(m);
prints(" s=");
sys_printpointer(s);
}
if(m == nil) {
throw("ifacei2i: nil map");
s = nil;
FLUSH(&s);
return;
}
if(m->si == nil) {
throw("ifacei2i: nil pointer");
return;
}
if(m->si != si) {
m = hashmap(si, m->ss);
FLUSH(&m);
}
if(debug) {
prints(" returning m=");
sys_printpointer(m);
prints(" s=");
sys_printpointer(s);
prints("\n");
dump((byte*)m, 64);
}
}
void
sys_ifacei2s(Sigs *ss, Map *m, void *s)
{
if(debug) {
prints("i2s m=");
sys_printpointer(m);
prints(" s=");
sys_printpointer(s);
prints("\n");
}
if(m == nil) {
throw("ifacei2s: nil map");
s = nil;
FLUSH(&s);
return;
}
if(m->ss != ss) {
dump((byte*)m, 64);
throw("ifacei2s: wrong pointer");
s = nil;
FLUSH(&s);
return;
}
}
void
check(void)
{
int8 a;
uint8 b;
int16 c;
uint16 d;
int32 e;
uint32 f;
int64 g;
uint64 h;
float32 i;
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) != 8) throw("bad k");
if(sizeof(l) != 8) throw("bad l");
// prints(1"check ok\n");
}
src/lib/runtime/runtime.h deleted 100644 → 0
View file @ f4ccabde
// 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.
/*
* basic types
*/
typedef signed char int8;
typedef unsigned char uint8;
typedef signed short int16;
typedef unsigned short uint16;
typedef signed int int32;
typedef unsigned int uint32;
typedef signed long long int int64;
typedef unsigned long long int uint64;
typedef float float32;
typedef double float64;
/*
* get rid of C types
*/
#define unsigned XXunsigned
#define signed XXsigned
#define char XXchar
#define short XXshort
#define int XXint
#define long XXlong
#define float XXfloat
#define double XXdouble
/*
* defined types
*/
typedef uint8 bool;
typedef uint8 byte;
typedef struct
{
int32 len;
byte str[1];
} *string;
typedef struct
{
byte* name;
uint32 hash;
void (*fun)(void);
} Sigs;
typedef struct
{
byte* name;
uint32 hash;
uint32 offset;
} Sigi;
typedef struct Map Map;
struct Map
{
Sigi* si;
Sigs* ss;
Map* link;
int32 bad;
int32 unused;
void (*fun[])(void);
};
/*
* defined constants
*/
enum
{
true = 1,
false = 0,
};
/*
* defined macros
* you need super-goru privilege
* to add this list.
*/
#define nelem(x) (sizeof(x)/sizeof((x)[0]))
#define nil ((void*)0)
/*
* very low level
*/
void FLUSH(void*);
void prints(int8*);
void sys_exit(int32);
void sys_write(int32, void*, int32);
void sys_breakpoint(void);
uint8* sys_mmap(byte*, uint32, int32, int32, int32, uint32);
void sys_memclr(byte*, uint32);
/*
* runtime
*/
void sys_printbool(bool);
void sys_printfloat(float64);
void sys_printint(int64);
void sys_printstring(string);
void sys_catstring(string, string, string);
void sys_cmpstring(string, string, int32);
void sys_slicestring(string, int32, int32, string);
void sys_indexstring(string, int32, byte);
void sys_intstring(int64, string);
void sys_ifaces2i(Sigi*, Sigs*, Map*, void*);
void sys_ifacei2i(Sigi*, Map*, void*);
void sys_ifacei2s(Sigs*, Map*, void*);
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7