Skip to content

G
go
Commit c7513eac authored by Russ Cox's avatar Russ Cox
Browse files
Options

runtime: use new reflect data structures (CL 31107) 

in place of sigi, sigt.

R=ken
OCL=31118
CL=31277
parent ce2e450c
Hide whitespace changes
Inline Side-by-side
Showing with 247 additions and 531 deletions
src/cmd/gc/sys.go
View file @ c7513eac
......@@ -36,17 +36,17 @@ func stringiter(string, int) int;
func stringiter2(string, int) (retk int, retv int);
func ifaceI2E(iface any) (ret any);
func ifaceE2I(sigi *byte, iface any) (ret any);
func ifaceT2E(sigt *byte, elem any) (ret any);
func ifaceE2T(sigt *byte, elem any) (ret any);
func ifaceE2I2(sigi *byte, iface any) (ret any, ok bool);
func ifaceE2T2(sigt *byte, elem any) (ret any, ok bool);
func ifaceT2I(sigi *byte, sigt *byte, elem any) (ret any);
func ifaceI2T(sigt *byte, iface any) (ret any);
func ifaceI2T2(sigt *byte, iface any) (ret any, ok bool);
func ifaceI2I(sigi *byte, iface any) (ret any);
func ifaceI2Ix(sigi *byte, iface any) (ret any);
func ifaceI2I2(sigi *byte, iface any) (ret any, ok bool);
func ifaceE2I(typ *byte, iface any) (ret any);
func ifaceT2E(typ *byte, elem any) (ret any);
func ifaceE2T(typ *byte, elem any) (ret any);
func ifaceE2I2(typ *byte, iface any) (ret any, ok bool);
func ifaceE2T2(typ *byte, elem any) (ret any, ok bool);
func ifaceT2I(typ1 *byte, typ2 *byte, elem any) (ret any);
func ifaceI2T(typ *byte, iface any) (ret any);
func ifaceI2T2(typ *byte, iface any) (ret any, ok bool);
func ifaceI2I(typ *byte, iface any) (ret any);
func ifaceI2Ix(typ *byte, iface any) (ret any);
func ifaceI2I2(typ *byte, iface any) (ret any, ok bool);
func ifaceeq(i1 any, i2 any) (ret bool);
func efaceeq(i1 any, i2 any) (ret bool);
func ifacethash(i1 any) (ret uint32);
......
src/pkg/runtime/Makefile
View file @ c7513eac
......@@ -70,6 +70,7 @@ OFILES=\
sys.$O\
thread.$O\
traceback.$O\
type.$O\
$(OFILES_$(GOARCH))\
HFILES=\
......
src/pkg/runtime/iface.c
View file @ c7513eac
......@@ -3,173 +3,64 @@
// license that can be found in the LICENSE file.
#include "runtime.h"
#include "type.h"
int32 iface_debug = 0;
static void
printiface(Iface i)
{
printf("(%p,%p)", i.tab, i.data);
}
typedef struct Sigt Sigt;
typedef struct Sigi Sigi;
typedef struct Itype Itype;
static void
printeface(Eface e)
{
printf("(%p,%p)", e.type, e.data);
}
/*
* the layout of Iface, Sigt and Sigi are known to the compiler
* layout of Itab known to compilers
*/
struct Sigt
{
byte* name; // name of basic type
Sigt* link; // for linking into hash tables
uint32 thash; // hash of type
uint32 mhash; // hash of methods
uint16 width; // width of base type in bytes
uint16 alg; // algorithm
// note: on amd64 there is a 32-bit pad here.
struct {
byte* fname;
uint32 fhash; // hash of type
uint32 offset; // offset of substruct
void (*fun)(void);
} meth[1]; // one or more - last name is nil
};
struct Sigi
{
byte* name;
uint32 hash;
uint32 size; // number of methods
struct {
byte* fname;
uint32 fhash;
uint32 perm; // location of fun in Sigt
} meth[1]; // [size+1] - last name is nil
};
struct Itype
struct Itab
{
Sigi* sigi;
Sigt* sigt;
Itype* link;
InterfaceType* inter;
Type* type;
Itab* link;
int32 bad;
int32 unused;
void (*fun[])(void);
};
static Iface niliface;
static Eface nileface;
static Itype* hash[1009];
static Itab* hash[1009];
static Lock ifacelock;
Sigi sigi·empty[2] = { (byte*)"interface { }" };
static void
printsigi(Sigi *si)
{
int32 i;
byte *name;
sys·printpointer(si);
prints("{");
prints((int8*)si->name);
prints(":");
for(i=0;; i++) {
name = si->meth[i].fname;
if(name == nil)
break;
prints("[");
sys·printint(i);
prints("]\"");
prints((int8*)name);
prints("\"");
sys·printint(si->meth[i].fhash%999);
prints("/");
sys·printint(si->meth[i].perm);
}
prints("}");
}
static void
printsigt(Sigt *st)
{
int32 i;
byte *name;
sys·printpointer(st);
prints("{");
prints((int8*)st->name);
prints(":");
sys·printint(st->thash%999); // type hash
prints(",");
sys·printint(st->mhash%999); // method hash
prints(",");
sys·printint(st->width); // width
prints(",");
sys·printint(st->alg); // algorithm
for(i=0;; i++) {
name = st->meth[i].fname;
if(name == nil)
break;
prints("[");
sys·printint(i);
prints("]\"");
prints((int8*)name);
prints("\"");
sys·printint(st->meth[i].fhash%999);
prints("/");
sys·printint(st->meth[i].offset);
prints("/");
sys·printpointer(st->meth[i].fun);
}
prints("}");
}
static void
printiface(Iface i)
{
prints("(");
sys·printpointer(i.type);
prints(",");
sys·printpointer(i.data);
prints(")");
}
static void
printeface(Eface e)
{
prints("(");
sys·printpointer(e.type);
prints(",");
sys·printpointer(e.data);
prints(")");
}
static Itype*
itype(Sigi *si, Sigt *st, int32 canfail)
static Itab*
itab(InterfaceType *inter, Type *type, int32 canfail)
{
int32 locked;
int32 nt, ni;
int32 ni;
Method *t, *et;
IMethod *i, *ei;
uint32 ihash, h;
byte *sname, *iname;
Itype *m;
String *iname;
Itab *m;
UncommonType *x;
if(si->size == 0)
throw("internal error - misuse of itype");
if(inter->mhdr.nel == 0)
throw("internal error - misuse of itab");
// easy case
if(st->meth[0].fname == nil) {
x = type->x;
if(x == nil) {
if(canfail)
return nil;
iname = si->meth[0].fname;
goto throw1;
iname = inter->m[0].name;
goto throw;
}
// compiler has provided some good hash codes for us.
h = 0;
if(si)
h += si->hash;
if(st) {
h += st->thash;
h += st->mhash;
}
h = inter->hash;
h += 17 * type->hash;
// TODO(rsc): h += 23 * x->mhash ?
h %= nelem(hash);
// look twice - once without lock, once with.
......@@ -178,7 +69,7 @@ itype(Sigi *si, Sigt *st, int32 canfail)
if(locked)
lock(&ifacelock);
for(m=hash[h]; m!=nil; m=m->link) {
if(m->sigi == si && m->sigt == st) {
if(m->inter == inter && m->type == type) {
if(m->bad) {
m = nil;
if(!canfail) {
......@@ -188,8 +79,8 @@ itype(Sigi *si, Sigt *st, int32 canfail)
// the cached result doesn't record which
// interface function was missing, so jump
// down to the interface check, which will
// give a better error.
goto throw;
// do more work but give a better error.
goto search;
}
}
if(locked)
......@@ -199,69 +90,60 @@ itype(Sigi *si, Sigt *st, int32 canfail)
}
}
ni = si->size;
m = malloc(sizeof(*m) + ni*sizeof(m->fun[0]));
m->sigi = si;
m->sigt = st;
throw:
nt = 0;
for(ni=0;; ni++) {
iname = si->meth[ni].fname;
if(iname == nil)
break;
// pick up next name from
// interface signature
ihash = si->meth[ni].fhash;
for(;; nt++) {
// pick up and compare next name
// from structure signature
sname = st->meth[nt].fname;
if(sname == nil) {
ni = inter->mhdr.nel;
m = malloc(sizeof(*m) + ni*sizeof m->fun[0]);
m->inter = inter;
m->type = type;
search:
// both inter and type have method sorted by hash,
// so can iterate over both in lock step;
// the loop is O(ni+nt) not O(ni*nt).
i = inter->m;
ei = i + inter->mhdr.nel;
t = x->m;
et = t + x->mhdr.nel;
for(; i < ei; i++) {
ihash = i->hash;
iname = i->name;
for(;; t++) {
if(t >= et) {
if(!canfail) {
throw1:
printf("cannot convert type %s to interface %s: missing method %s\n",
st->name, si->name, iname);
if(iface_debug) {
prints("interface");
printsigi(si);
prints("\ntype");
printsigt(st);
prints("\n");
}
throw:
// didn't find method
printf("%S is not %S: missing method %S\n",
*type->string, *inter->string, *iname);
throw("interface conversion");
return nil; // not reached
}
m->bad = 1;
m->link = hash[h];
hash[h] = m;
if(locked)
unlock(&ifacelock);
return nil;
goto out;
}
if(ihash == st->meth[nt].fhash && strcmp(sname, iname) == 0)
if(t->hash == ihash && t->name == iname)
break;
}
m->fun[si->meth[ni].perm] = st->meth[nt].fun;
if(m)
m->fun[i->perm] = t->ifn;
}
out:
m->link = hash[h];
hash[h] = m;
if(locked)
unlock(&ifacelock);
if(m->bad)
return nil;
return m;
}
static void
copyin(Sigt *st, void *src, void **dst)
copyin(Type *t, void *src, void **dst)
{
int32 wid, alg;
void *p;
wid = st->width;
alg = st->alg;
wid = t->size;
alg = t->alg;
if(wid <= sizeof(*dst))
algarray[alg].copy(wid, dst, src);
......@@ -273,12 +155,12 @@ copyin(Sigt *st, void *src, void **dst)
}
static void
copyout(Sigt *st, void **src, void *dst)
copyout(Type *t, void **src, void *dst)
{
int32 wid, alg;
wid = st->width;
alg = st->alg;
wid = t->size;
alg = t->alg;
if(wid <= sizeof(*src))
algarray[alg].copy(wid, dst, src);
......@@ -286,132 +168,123 @@ copyout(Sigt *st, void **src, void *dst)
algarray[alg].copy(wid, dst, *src);
}
// ifaceT2I(sigi *byte, sigt *byte, elem any) (ret any);
// ifaceT2I(sigi *byte, sigt *byte, elem any) (ret Iface);
#pragma textflag 7
void
sys·ifaceT2I(Sigi *si, Sigt *st, ...)
sys·ifaceT2I(InterfaceType *inter, Type *t, ...)
{
byte *elem;
Iface *ret;
int32 wid;
elem = (byte*)(&st+1);
wid = st->width;
ret = (Iface*)(elem + rnd(wid, sizeof(uintptr)));
ret->type = itype(si, st, 0);
copyin(st, elem, &ret->data);
elem = (byte*)(&t+1);
wid = t->size;
ret = (Iface*)(elem + rnd(wid, Structrnd));
ret->tab = itab(inter, t, 0);
copyin(t, elem, &ret->data);
}
// ifaceT2E(sigt *byte, elem any) (ret any);
// ifaceT2E(sigt *byte, elem any) (ret Eface);
#pragma textflag 7
void
sys·ifaceT2E(Sigt *st, ...)
sys·ifaceT2E(Type *t, ...)
{
byte *elem;
Eface *ret;
int32 wid;
elem = (byte*)(&st+1);
wid = st->width;
ret = (Eface*)(elem + rnd(wid, sizeof(uintptr)));
elem = (byte*)(&t+1);
wid = t->size;
ret = (Eface*)(elem + rnd(wid, Structrnd));
ret->type = st;
copyin(st, elem, &ret->data);
ret->type = t;
copyin(t, elem, &ret->data);
}
// ifaceI2T(sigt *byte, iface any) (ret any);
#pragma textflag 7
void
sys·ifaceI2T(Sigt *st, Iface i, ...)
sys·ifaceI2T(Type *t, Iface i, ...)
{
Itype *im;
Itab *tab;
byte *ret;
ret = (byte*)(&i+1);
im = i.type;
if(im == nil) {
printf("interface is nil, not %s\n", st->name);
tab = i.tab;
if(tab == nil) {
printf("interface is nil, not %S\n", *t->string);
throw("interface conversion");
}
if(im->sigt != st) {
printf("%s is %s, not %s\n", im->sigi->name, im->sigt->name, st->name);
if(tab->type != t) {
printf("%S is %S, not %S\n", *tab->inter->string, *tab->type->string, *t->string);
throw("interface conversion");
}
copyout(st, &i.data, ret);
copyout(t, &i.data, ret);
}
// ifaceI2T2(sigt *byte, iface any) (ret any, ok bool);
// ifaceI2T2(sigt *byte, i Iface) (ret any, ok bool);
#pragma textflag 7
void
sys·ifaceI2T2(Sigt *st, Iface i, ...)
sys·ifaceI2T2(Type *t, Iface i, ...)
{
byte *ret;
bool *ok;
Itype *im;
int32 wid;
ret = (byte*)(&i+1);
wid = st->width;
wid = t->size;
ok = (bool*)(ret+rnd(wid, 1));
im = i.type;
if(im == nil || im->sigt != st) {
if(i.tab == nil || i.tab->type != t) {
*ok = false;
sys·memclr(ret, wid);
return;
}
*ok = true;
copyout(st, &i.data, ret);
copyout(t, &i.data, ret);
}
// ifaceE2T(sigt *byte, iface any) (ret any);
// ifaceE2T(sigt *byte, e Eface) (ret any);
#pragma textflag 7
void
sys·ifaceE2T(Sigt *st, Eface e, ...)
sys·ifaceE2T(Type *t, Eface e, ...)
{
Sigt *t;
byte *ret;
ret = (byte*)(&e+1);
t = e.type;
if(t == nil) {
printf("interface is nil, not %s\n", st->name);
throw("interface conversion");
}
if(t != st) {
printf("interface is %s, not %s\n", t->name, st->name);
if(e.type != t) {
if(e.type == nil)
printf("interface is nil, not %S\n", *t->string);
else
printf("interface is %S, not %S\n", *e.type->string, *t->string);
throw("interface conversion");
}
copyout(st, &e.data, ret);
copyout(t, &e.data, ret);
}
// ifaceE2T2(sigt *byte, iface any) (ret any, ok bool);
#pragma textflag 7
void
sys·ifaceE2T2(Sigt *st, Eface e, ...)
sys·ifaceE2T2(Type *t, Eface e, ...)
{
byte *ret;
bool *ok;
Sigt *t;
int32 wid;
ret = (byte*)(&e+1);
wid = st->width;
wid = t->size;
ok = (bool*)(ret+rnd(wid, 1));
t = e.type;
if(t != st) {
if(t != e.type) {
*ok = false;
sys·memclr(ret, wid);
return;
}
*ok = true;
copyout(st, &e.data, ret);
copyout(t, &e.data, ret);
}
// ifaceI2E(sigi *byte, iface any) (ret any);
......@@ -419,33 +292,35 @@ sys·ifaceE2T2(Sigt *st, Eface e, ...)
void
sys·ifaceI2E(Iface i, Eface ret)
{
Itype *im;
Itab *tab;
ret.data = i.data;
im = i.type;
if(im == nil)
tab = i.tab;
if(tab == nil)
ret.type = nil;
else
ret.type = im->sigt;
ret.type = tab->type;
FLUSH(&ret);
}
// ifaceI2I(sigi *byte, iface any) (ret any);
// called only for implicit (no type assertion) conversions
// called only for implicit (no type assertion) conversions.
// converting nil is okay.
void
sys·ifaceI2I(Sigi *si, Iface i, Iface ret)
sys·ifaceI2I(InterfaceType *inter, Iface i, Iface ret)
{
Itype *im;
Itab *tab;
im = i.type;
if(im == nil) {
tab = i.tab;
if(tab == nil) {
// If incoming interface is uninitialized (zeroed)
// make the outgoing interface zeroed as well.
ret = niliface;
ret.tab = nil;
ret.data = nil;
} else {
ret = i;
if(im->sigi != si)
ret.type = itype(si, im->sigt, 0);
if(tab->inter != inter)
ret.tab = itab(inter, tab->type, 0);
}
FLUSH(&ret);
......@@ -453,20 +328,21 @@ sys·ifaceI2I(Sigi *si, Iface i, Iface ret)
// ifaceI2Ix(sigi *byte, iface any) (ret any);
// called only for explicit conversions (with type assertion).
// converting nil is not okay.
void
sys·ifaceI2Ix(Sigi *si, Iface i, Iface ret)
sys·ifaceI2Ix(InterfaceType *inter, Iface i, Iface ret)
{
Itype *im;
Itab *tab;
im = i.type;
if(im == nil) {
tab = i.tab;
if(tab == nil) {
// explicit conversions require non-nil interface value.
printf("interface is nil, not %s\n", si->name);
printf("interface is nil, not %S\n", *inter->string);
throw("interface conversion");
} else {
ret = i;
if(im->sigi != si)
ret.type = itype(si, im->sigt, 0);
if(tab->inter != inter)
ret.tab = itab(inter, tab->type, 0);
}
FLUSH(&ret);
......@@ -474,22 +350,23 @@ sys·ifaceI2Ix(Sigi *si, Iface i, Iface ret)
// ifaceI2I2(sigi *byte, iface any) (ret any, ok bool);
void
sys·ifaceI2I2(Sigi *si, Iface i, Iface ret, bool ok)
sys·ifaceI2I2(InterfaceType *inter, Iface i, Iface ret, bool ok)
{
Itype *im;
Itab *tab;
im = i.type;
if(im == nil) {
tab = i.tab;
if(tab == nil) {
// If incoming interface is nil, the conversion fails.
ret = niliface;
ret.tab = nil;
ret.data = nil;
ok = false;
} else {
ret = i;
ok = true;
if(im->sigi != si) {
ret.type = itype(si, im->sigt, 1);
if(ret.type == nil) {
ret = niliface;
if(tab->inter != inter) {
ret.tab = itab(inter, tab->type, 1);
if(ret.tab == nil) {
ret.data = nil;
ok = false;
}
}
......@@ -502,39 +379,40 @@ sys·ifaceI2I2(Sigi *si, Iface i, Iface ret, bool ok)
// ifaceE2I(sigi *byte, iface any) (ret any);
// Called only for explicit conversions (with type assertion).
void
sys·ifaceE2I(Sigi *si, Eface e, Iface ret)
sys·ifaceE2I(InterfaceType *inter, Eface e, Iface ret)
{
Sigt *t;
Type *t;
t = e.type;
if(t == nil) {
// explicit conversions require non-nil interface value.
printf("interface is nil, not %s\n", si->name);
printf("interface is nil, not %S\n", *inter->string);
throw("interface conversion");
} else {
ret.data = e.data;
ret.type = itype(si, t, 0);
ret.tab = itab(inter, t, 0);
}
FLUSH(&ret);
}
// ifaceE2I2(sigi *byte, iface any) (ret any, ok bool);
void
sys·ifaceE2I2(Sigi *si, Eface e, Iface ret, bool ok)
sys·ifaceE2I2(InterfaceType *inter, Eface e, Iface ret, bool ok)
{
Sigt *t;
Type *t;
t = e.type;
ok = true;
if(t == nil) {
// If incoming interface is nil, the conversion fails.
ret = niliface;
ret.data = nil;
ret.tab = nil;
ok = false;
} else {
ret.data = e.data;
ret.type = itype(si, t, 1);
if(ret.type == nil) {
ret = niliface;
ret.tab = itab(inter, t, 1);
if(ret.tab == nil) {
ret.data = nil;
ok = false;
}
}
......@@ -543,19 +421,19 @@ sys·ifaceE2I2(Sigi *si, Eface e, Iface ret, bool ok)
}
static uintptr
ifacehash1(void *data, Sigt *sigt)
ifacehash1(void *data, Type *t)
{
int32 alg, wid;
if(sigt == nil)
if(t == nil)
return 0;
alg = sigt->alg;
wid = sigt->width;
alg = t->alg;
wid = t->size;
if(algarray[alg].hash == nohash) {
// calling nohash will throw too,
// but we can print a better error.
printf("hash of unhashable type %s\n", sigt->name);
printf("hash of unhashable type %S\n", *t->string);
if(alg == AFAKE)
throw("fake interface hash");
throw("interface hash");
......@@ -568,9 +446,9 @@ ifacehash1(void *data, Sigt *sigt)
uintptr
ifacehash(Iface a)
{
if(a.type == nil)
if(a.tab == nil)
return 0;
return ifacehash1(a.data, a.type->sigt);
return ifacehash1(a.data, a.tab->type);
}
uintptr
......@@ -580,17 +458,17 @@ efacehash(Eface a)
}
static bool
ifaceeq1(void *data1, void *data2, Sigt *sigt)
ifaceeq1(void *data1, void *data2, Type *t)
{
int32 alg, wid;
alg = sigt->alg;
wid = sigt->width;
alg = t->alg;
wid = t->size;
if(algarray[alg].equal == noequal) {
// calling noequal will throw too,
// but we can print a better error.
printf("comparing uncomparable type %s\n", sigt->name);
printf("comparing uncomparable type %S\n", *t->string);
if(alg == AFAKE)
throw("fake interface compare");
throw("interface compare");
......@@ -604,11 +482,11 @@ ifaceeq1(void *data1, void *data2, Sigt *sigt)
bool
ifaceeq(Iface i1, Iface i2)
{
if(i1.type != i2.type)
if(i1.tab != i2.tab)
return false;
if(i1.type == nil)
if(i1.tab == nil)
return true;
return ifaceeq1(i1.data, i2.data, i1.type->sigt);
return ifaceeq1(i1.data, i2.data, i1.tab->type);
}
bool
......@@ -641,16 +519,12 @@ sys·efaceeq(Eface e1, Eface e2, bool ret)
void
sys·ifacethash(Iface i1, uint32 ret)
{
Itype *im;
Sigt *st;
Itab *tab;
ret = 0;
im = i1.type;
if(im != nil) {
st = im->sigt;
if(st != nil)
ret = st->thash;
}
tab = i1.tab;
if(tab != nil)
ret = tab->type->hash;
FLUSH(&ret);
}
......@@ -658,12 +532,12 @@ sys·ifacethash(Iface i1, uint32 ret)
void
sys·efacethash(Eface e1, uint32 ret)
{
Sigt *st;
Type *t;
ret = 0;
st = e1.type;
if(st != nil)
ret = st->thash;
t = e1.type;
if(t != nil)
ret = t->hash;
FLUSH(&ret);
}
......@@ -680,227 +554,68 @@ sys·printeface(Eface e)
}
void
unsafe·Reflect(Eface i, uint64 retit, String rettype, bool retindir)
{
int32 wid;
if(i.type == nil) {
retit = 0;
rettype = emptystring;
retindir = false;
} else {
retit = (uint64)i.data;
rettype = gostring(i.type->name);
wid = i.type->width;
retindir = wid > sizeof(i.data);
}
FLUSH(&retit);
FLUSH(&rettype);
FLUSH(&retindir);
}
extern Sigt *gotypesigs[];
extern int32 ngotypesigs;
// The reflection library can ask to unreflect on a type
// that has never been used, so we don't have a signature for it.
// For concreteness, suppose a program does
//
// type T struct{ x []int }
// var t T;
// v := reflect.NewValue(v);
// vv := v.Field(0);
// if s, ok := vv.Interface().(string) {
// print("first field is string");
// }
//
// vv.Interface() returns the result of sys.Unreflect with
// a typestring of "[]int". If []int is not used with interfaces
// in the rest of the program, there will be no signature in gotypesigs
// for "[]int", so we have to invent one. The requirements
// on the fake signature are:
//
// (1) any interface conversion using the signature will fail
// (2) calling unsafe.Reflect() returns the args to unreflect
// (3) the right algorithm type is used, for == and map insertion
//
// (1) is ensured by the fact that we allocate a new Sigt,
// so it will necessarily be != any Sigt in gotypesigs.
// (2) is ensured by storing the type string in the signature
// and setting the width to force the correct value of the bool indir.
// (3) is ensured by sniffing the type string.
//
// Note that (1) is correct behavior: if the program had tested
// for .([]int) instead of .(string) above, then there would be a
// signature with type string "[]int" in gotypesigs, and unreflect
// wouldn't call fakesigt.
static Sigt* fake[1009];
static int32 nfake;
enum
{
SizeofInt = 4,
SizeofFloat = 4,
};
// Table of prefixes of names of comparable types.
static struct {
int8 *s;
int8 n;
int8 alg;
int8 w;
} cmp[] =
{
// basic types
"int", 3+1, AMEM, SizeofInt, // +1 is NUL
"uint", 4+1, AMEM, SizeofInt,
"int8", 4+1, AMEM, 1,
"uint8", 5+1, AMEM, 1,
"int16", 5+1, AMEM, 2,
"uint16", 6+1, AMEM, 2,
"int32", 5+1, AMEM, 4,
"uint32", 6+1, AMEM, 4,
"int64", 5+1, AMEM, 8,
"uint64", 6+1, AMEM, 8,
"uintptr", 7+1, AMEM, sizeof(uintptr),
"float", 5+1, AMEM, SizeofFloat,
"float32", 7+1, AMEM, 4,
"float64", 7+1, AMEM, 8,
"bool", 4+1, AMEM, sizeof(bool),
// string compare is special
"string", 6+1, ASTRING, sizeof(String),
// generic types, identified by prefix
"*", 1, AMEM, sizeof(uintptr),
"chan ", 5, AMEM, sizeof(uintptr),
"func(", 5, AMEM, sizeof(uintptr),
"map[", 4, AMEM, sizeof(uintptr),
};
static Sigt*
fakesigt(String type, bool indir)
{
Sigt *sigt;
uint32 h;
int32 i, locked;
h = 0;
for(i=0; i<type.len; i++)
h = h*37 + type.str[i];
h += indir;
h %= nelem(fake);
for(locked=0; locked<2; locked++) {
if(locked)
lock(&ifacelock);
for(sigt = fake[h]; sigt != nil; sigt = sigt->link) {
// don't need to compare indir.
// same type string but different indir will have
// different hashes.
if(mcmp(sigt->name, type.str, type.len) == 0)
if(sigt->name[type.len] == '\0') {
if(locked)
unlock(&ifacelock);
return sigt;
}
}
}
sigt = malloc(sizeof(*sigt));
sigt->name = malloc(type.len + 1);
mcpy(sigt->name, type.str, type.len);
sigt->alg = AFAKE;
sigt->width = 1; // small width
if(indir)
sigt->width = 2*sizeof(niliface.data); // big width
// AFAKE is like ANOEQ; check whether the type
// should have a more capable algorithm.
for(i=0; i<nelem(cmp); i++) {
if(mcmp((byte*)sigt->name, (byte*)cmp[i].s, cmp[i].n) == 0) {
sigt->alg = cmp[i].alg;
sigt->width = cmp[i].w;
break;
}
}
sigt->link = fake[h];
fake[h] = sigt;
unlock(&ifacelock);
return sigt;
}
static int32
cmpstringchars(String a, uint8 *b)
unsafe·Typeof(Eface e, Eface ret)
{
int32 i;
byte c1, c2;
for(i=0;; i++) {
c1 = 0;
if(i < a.len)
c1 = a.str[i];
c2 = b[i];
if(c1 < c2)
return -1;
if(c1 > c2)
return +1;
if(c1 == 0)
return 0;
}
if(e.type == nil) {
ret.type = nil;
ret.data = nil;
} else
ret = *(Eface*)e.type;
FLUSH(&ret);
}
static Sigt*
findtype(String type, bool indir)
void
unsafe·Reflect(Eface e, Eface rettype, void *retaddr)
{
int32 i, lo, hi, m;
uintptr *p;
uintptr x;
lo = 0;
hi = ngotypesigs;
while(lo < hi) {
m = lo + (hi - lo)/2;
i = cmpstringchars(type, gotypesigs[m]->name);
if(i == 0)
return gotypesigs[m];
if(i < 0)
hi = m;
else
lo = m+1;
if(e.type == nil) {
rettype.type = nil;
rettype.data = nil;
retaddr = 0;
} else {
rettype = *(Eface*)e.type;
if(e.type->size <= sizeof(uintptr)) {
// Copy data into x ...
x = 0;
algarray[e.type->alg].copy(e.type->size, &x, &e.data);
// but then build pointer to x so that Reflect
// always returns pointer to data.
p = mallocgc(sizeof(uintptr));
*p = x;
} else {
// Already a pointer, but still make a copy,
// to preserve value semantics for interface data.
p = mallocgc(e.type->size);
algarray[e.type->alg].copy(e.type->size, p, e.data);
}
retaddr = p;
}
return fakesigt(type, indir);
FLUSH(&rettype);
FLUSH(&retaddr);
}
void
unsafe·Unreflect(uint64 it, String type, bool indir, Eface ret)
{
Sigt *sigt;
ret = nileface;
if(cmpstring(type, emptystring) == 0)
goto out;
if(type.len > 10 && mcmp(type.str, (byte*)"interface ", 10) == 0) {
printf("unsafe.Unreflect: cannot put %S in interface\n", type);
throw("unsafe.Unreflect");
unsafe·Unreflect(Iface typ, void *addr, Eface e)
{
// Reflect library has reinterpreted typ
// as its own kind of type structure.
// We know that the pointer to the original
// type structure sits before the data pointer.
e.type = (Type*)((Eface*)typ.data-1);
// Interface holds either pointer to data
// or copy of original data.
if(e.type->size <= sizeof(uintptr))
algarray[e.type->alg].copy(e.type->size, &e.data, addr);
else {
// Easier: already a pointer to data.
// TODO(rsc): Should this make a copy?
e.data = addr;
}
// if we think the type should be indirect
// and caller does not, play it safe, return nil.
sigt = findtype(type, indir);
if(indir != (sigt->width > sizeof(ret.data)))
goto out;
ret.type = sigt;
ret.data = (void*)it;
out:
FLUSH(&ret);
FLUSH(&e);
}
src/pkg/runtime/print.c
View file @ c7513eac
......@@ -76,10 +76,10 @@ printf(int8 *s, ...)
sys·printint(*(int64*)arg);
break;
case 'x':
sys·printhex(*(int32*)arg);
sys·printhex(*(uint32*)arg);
break;
case 'X':
sys·printhex(*(int64*)arg);
sys·printhex(*(uint64*)arg);
break;
case 'p':
sys·printpointer(*(void**)arg);
......
src/pkg/runtime/runtime.h
View file @ c7513eac
......@@ -56,9 +56,9 @@ typedef struct Usema Usema;
typedef struct SigTab SigTab;
typedef struct MCache MCache;
typedef struct Iface Iface;
typedef struct Itype Itype;
typedef struct Itab Itab;
typedef struct Eface Eface;
typedef struct Sigt Sigt;
typedef struct Type Type;
typedef struct Defer Defer;
/*
......@@ -117,12 +117,12 @@ struct String
};
struct Iface
{
Itype* type;
Itab* tab;
void* data;
};
struct Eface
{
Sigt* type;
Type* type;
void* data;
};
......
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