this is not a user-visible change.
before, all interface values were
struct Itype {
Sigt *type;
Sigi *inter;
void *method[n];
}
struct Iface {
void *addr;
Itype *itype;
}
the itype is basically a vtable, but it's unnecessary
if the static type is interface{ }.
for interface values with static type empty, the
new representation is
struct Eface {
void *addr;
Sigt *type;
}
this complicates the code somewhat, but
it reduces the number of Itypes that
have to be computed and cached,
it opens up opportunities to avoid function
calls in a few common cases,
and it will make it possible to lay out
interface{} values at compile time,
which i think i'll need for the new reflection.
R=ken
OCL=28701
CL=29121
"func sys.printint (? int64)\n"
"func sys.printstring (? string)\n"
"func sys.printpointer (? any)\n"
- "func sys.printinter (? any)\n"
+ "func sys.printiface (? any)\n"
+ "func sys.printeface (? any)\n"
"func sys.printarray (? any)\n"
"func sys.printnl ()\n"
"func sys.printsp ()\n"
"func sys.arraystring (? []uint8) (? string)\n"
"func sys.stringiter (? string, ? int) (? int)\n"
"func sys.stringiter2 (? string, ? int) (retk int, retv int)\n"
+ "func sys.ifaceI2E (iface any) (ret any)\n"
+ "func sys.ifaceE2I (sigi *uint8, iface any) (ret any)\n"
+ "func sys.ifaceT2E (sigt *uint8, elem any) (ret any)\n"
+ "func sys.ifaceE2T (sigt *uint8, elem any) (ret any)\n"
+ "func sys.ifaceE2I2 (sigi *uint8, iface any) (ret any, ok bool)\n"
+ "func sys.ifaceE2T2 (sigt *uint8, elem any) (ret any, ok bool)\n"
"func sys.ifaceT2I (sigi *uint8, sigt *uint8, elem any) (ret any)\n"
"func sys.ifaceI2T (sigt *uint8, iface any) (ret any)\n"
"func sys.ifaceI2T2 (sigt *uint8, iface any) (ret any, ok bool)\n"
"func sys.ifaceI2I (sigi *uint8, iface any) (ret any)\n"
"func sys.ifaceI2I2 (sigi *uint8, iface any) (ret any, ok bool)\n"
"func sys.ifaceeq (i1 any, i2 any) (ret bool)\n"
+ "func sys.efaceeq (i1 any, i2 any) (ret bool)\n"
"func sys.ifacethash (i1 any) (ret uint32)\n"
+ "func sys.efacethash (i1 any) (ret uint32)\n"
"func sys.newmap (keysize int, valsize int, keyalg int, valalg int, hint int) (hmap map[any] any)\n"
"func sys.mapaccess1 (hmap map[any] any, key any) (val any)\n"
"func sys.mapaccess2 (hmap map[any] any, key any) (val any, pres bool)\n"
ANOEQ,
ASTRING,
AINTER,
+ ANILINTER,
BADWIDTH = -1000000000
};
if(issimple[t->etype] || isptr[t->etype] || t->etype == TCHAN || t->etype == TFUNC)
a = AMEM; // just bytes (int, ptr, etc)
- else
- if(t->etype == TSTRING)
+ else if(t->etype == TSTRING)
a = ASTRING; // string
- else
- if(t->etype == TINTER)
+ else if(isnilinter(t))
+ a = ANILINTER; // nil interface
+ else if(t->etype == TINTER)
a = AINTER; // interface
else
a = ANOEQ; // just bytes, but no hash/eq
Node *a;
Case *c, *c0, *c1;
int ncase;
+ Type *t;
if(sw->ntest == nil)
return;
hashname = nod(OXXX, N, N);
tempname(hashname, types[TUINT32]);
- a = syslook("ifacethash", 1);
- argtype(a, sw->ntest->right->type);
+ t = sw->ntest->right->type;
+ if(isnilinter(t))
+ a = syslook("efacethash", 1);
+ else
+ a = syslook("ifacethash", 1);
+ argtype(a, t);
a = nod(OCALL, a, facename);
a = nod(OAS, hashname, a);
cas = list(cas, a);
func printint(int64);
func printstring(string);
func printpointer(any);
-func printinter(any);
+func printiface(any);
+func printeface(any);
func printarray(any);
func printnl();
func printsp();
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 ifaceI2I2(sigi *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);
+func efacethash(i1 any) (ret uint32);
func newmap(keysize int, valsize int,
keyalg int, valalg int,
I2I2,
T2I,
I2Isame,
+ E2T,
+ E2T2,
+ E2I,
+ E2I2,
+ I2E,
+ I2E2,
+ T2E,
+ E2Esame,
};
// can this code branch reach the end
cr = listcount(r);
if(cl == cr) {
+ simpleas:
walktype(r, Erv);
l = ascompatee(n->op, &n->left, &n->right);
if(l != N)
break;
et = ifaceas1(r->type, r->left->type, 1);
switch(et) {
+ case I2Isame:
+ case E2Esame:
+ n->right = nod(OLIST, r->left, nodbool(1));
+ goto simpleas;
+ case I2E:
+ n->right = nod(OLIST, n->right, nodbool(1));
+ goto simpleas;
case I2T:
et = I2T2;
break;
- case I2Isame:
case I2I:
et = I2I2;
break;
+ case E2I:
+ et = E2I2;
+ break;
+ case E2T:
+ et = E2T2;
+ break;
default:
et = Inone;
break;
walkconv(Node *n)
{
int et;
+ char *what;
Type *t;
Node *l;
defaultlit(l, T);
if(!isinter(l->type))
yyerror("type assertion requires interface on left, have %T", l->type);
- et = ifaceas(n->type, l->type, 1);
+ et = ifaceas1(t, l->type, 1);
+ if(et == I2Isame || et == E2Esame) {
+ n->op = OCONV;
+ goto nop;
+ }
if(et != Inone) {
- indir(n, ifaceop(n->type, l, et));
+ indir(n, ifaceop(t, l, et));
return;
}
goto bad;
if(l->type == T)
return;
- // nil conversion
+ // no-op conversion
if(cvttype(t, l->type)) {
+ nop:
if(l->op != ONAME) {
indir(n, l);
n->type = t;
// convert from unsafe.pointer
if(isptrto(l->type, TANY)) {
- if(isptr[n->type->etype])
+ if(isptr[t->etype])
return;
- if(n->type->etype == TUINTPTR)
+ if(t->etype == TUINTPTR)
return;
}
if(n->diag)
return;
n->diag = 1;
+ if(n->op == ODOTTYPE)
+ what = "type assertion";
+ else
+ what = "conversion";
if(l->type != T)
- yyerror("invalid conversion: %T to %T", l->type, t);
+ yyerror("invalid %s: %T to %T", what, l->type, t);
else
if(n->left->op == OLIST)
yyerror("invalid type for composite literal: %T", t);
et = l->type->etype;
if(isinter(l->type)) {
- on = syslook("printinter", 1);
+ if(isnilinter(l->type))
+ on = syslook("printeface", 1);
+ else
+ on = syslook("printiface", 1);
argtype(on, l->type); // any-1
} else if(isptr[et] || et == TCHAN || et == TMAP || et == TFUNC) {
on = syslook("printpointer", 1);
if(isinter(dst)) {
if(isinter(src)) {
+ if(isnilinter(dst)) {
+ if(isnilinter(src))
+ return E2Esame;
+ return I2E;
+ }
if(eqtype(dst, src))
return I2Isame;
- if(!isnilinter(dst))
- ifacecheck(dst, src, lineno, explicit);
+ ifacecheck(dst, src, lineno, explicit);
+ if(isnilinter(src))
+ return E2I;
return I2I;
}
if(isnilinter(dst))
- return T2I;
+ return T2E;
ifacecheck(dst, src, lineno, explicit);
return T2I;
}
if(isinter(src)) {
ifacecheck(dst, src, lineno, explicit);
+ if(isnilinter(src))
+ return E2T;
return I2T;
}
return Inone;
int et;
et = ifaceas1(dst, src, explicit);
- if(et == I2Isame)
+ if(et == I2Isame || et == E2Esame)
et = Inone;
return et;
}
[I2I] = "ifaceI2I",
[I2I2] = "ifaceI2I2",
[I2Isame] = "ifaceI2Isame",
+ [E2T] = "ifaceE2T",
+ [E2T2] = "ifaceE2T2",
+ [E2I] = "ifaceE2I",
+ [E2I2] = "ifaceE2I2",
+ [I2E] = "ifaceI2E",
+ [I2E2] = "ifaceI2E2",
+ [T2I] = "ifaceT2I",
+ [T2E] = "ifaceT2E",
+ [E2Esame] = "ifaceE2Esame",
};
Node*
on = syslook("ifaceT2I", 1);
argtype(on, tr);
argtype(on, tl);
-
break;
case I2T:
case I2T2:
case I2I:
case I2I2:
+ case E2T:
+ case E2T2:
+ case E2I:
+ case E2I2:
// iface[IT]2[IT][2](sigt *byte, iface any) (ret any[, ok bool]);
-
a = n; // interface
r = a;
- s = signame(tl); // sigi
+ s = signame(tl); // sigi or sigt
if(s == S)
fatal("ifaceop: signame %d", op);
a = s->oname;
on = syslook(ifacename[op], 1);
argtype(on, tr);
argtype(on, tl);
+ break;
+ case I2E:
+ // TODO(rsc): Should do this in back end, without a call.
+ // ifaceI2E(elem any) (ret any);
+ a = n; // interface
+ r = a;
+ on = syslook("ifaceI2E", 1);
+ argtype(on, tr);
+ argtype(on, tl);
+ break;
+
+ case T2E:
+ // TODO(rsc): Should do this in back end for pointer case, without a call.
+ // ifaceT2E(sigt *byte, elem any) (ret any);
+ a = n; // elem
+ r = a;
+
+ s = signame(tr); // sigt
+ if(s == S)
+ fatal("ifaceop: signame-1 T2E: %lT", tr);
+ a = s->oname;
+ a = nod(OADDR, a, N);
+ r = list(a, r);
+
+ on = syslook("ifaceT2E", 1);
+ argtype(on, tr);
+ argtype(on, tl);
break;
case OEQ:
a = n->left; // i1
r = list(a, r);
- on = syslook("ifaceeq", 1);
+ if(!eqtype(n->left->type, n->right->type))
+ fatal("ifaceop %O %T %T", op, n->left->type, n->right->type);
+ if(isnilinter(n->left->type))
+ on = syslook("efaceeq", 1);
+ else
+ on = syslook("ifaceeq", 1);
argtype(on, n->right->type);
argtype(on, n->left->type);
};
static Iface niliface;
+static Eface nileface;
+
static Itype* hash[1009];
static Lock ifacelock;
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)
{
byte *sname, *iname;
Itype *m;
+ if(si->size == 0)
+ throw("internal error - misuse of itype");
+
+ // easy case
+ if(st->meth[0].fname == nil) {
+ if(canfail)
+ return nil;
+ iname = si->meth[0].fname;
+ goto throw1;
+ }
+
// compiler has provided some good hash codes for us.
h = 0;
if(si)
goto throw;
}
}
- // prints("old itype\n");
if(locked)
unlock(&ifacelock);
return m;
sname = st->meth[nt].fname;
if(sname == nil) {
if(!canfail) {
+ throw1:
printf("cannot convert type %s to interface %s: missing method %s\n",
st->name, si->name, iname);
if(iface_debug) {
prints("\n");
}
throw("interface conversion");
+ return nil; // not reached
}
m->bad = 1;
m->link = hash[h];
if(locked)
unlock(&ifacelock);
- // printf("new itype %p\n", m);
return m;
}
+static void
+copyin(Sigt *st, void *src, void **dst)
+{
+ int32 wid, alg;
+ void *p;
+
+ wid = st->width;
+ alg = st->alg;
+
+ if(wid <= sizeof(*dst))
+ algarray[alg].copy(wid, dst, src);
+ else {
+ p = mal(wid);
+ algarray[alg].copy(wid, p, src);
+ *dst = p;
+ }
+}
+
+static void
+copyout(Sigt *st, void **src, void *dst)
+{
+ int32 wid, alg;
+
+ wid = st->width;
+ alg = st->alg;
+
+ if(wid <= sizeof(*src))
+ algarray[alg].copy(wid, dst, src);
+ else
+ algarray[alg].copy(wid, dst, *src);
+}
+
// ifaceT2I(sigi *byte, sigt *byte, elem any) (ret any);
+#pragma textflag 7
void
sys·ifaceT2I(Sigi *si, Sigt *st, ...)
{
byte *elem;
Iface *ret;
- int32 alg, wid;
+ int32 wid;
elem = (byte*)(&st+1);
-
- if(iface_debug) {
- prints("T2I sigi=");
- printsigi(si);
- prints(" sigt=");
- printsigt(st);
- prints(" elem=");
- sys·printpointer(*(void**)elem);
- prints("\n");
- }
-
wid = st->width;
- alg = st->alg;
ret = (Iface*)(elem + rnd(wid, sizeof(uintptr)));
+
ret->type = itype(si, st, 0);
+ copyin(st, elem, &ret->data);
+}
- if(wid <= sizeof(ret->data))
- algarray[alg].copy(wid, &ret->data, elem);
- else {
- ret->data = mal(wid);
- if(iface_debug)
- printf("T2I mal %d %p\n", wid, ret->data);
- algarray[alg].copy(wid, ret->data, elem);
- }
+// ifaceT2E(sigt *byte, elem any) (ret any);
+#pragma textflag 7
+void
+sys·ifaceT2E(Sigt *st, ...)
+{
+ byte *elem;
+ Eface *ret;
+ int32 wid;
- if(iface_debug) {
- prints("T2I ret=");
- printiface(*ret);
- prints("\n");
- }
+ elem = (byte*)(&st+1);
+ wid = st->width;
+ ret = (Eface*)(elem + rnd(wid, sizeof(uintptr)));
- FLUSH(&ret);
+ ret->type = st;
+ copyin(st, elem, &ret->data);
}
// ifaceI2T(sigt *byte, iface any) (ret any);
+#pragma textflag 7
void
sys·ifaceI2T(Sigt *st, Iface i, ...)
{
Itype *im;
byte *ret;
- int32 wid, alg;
ret = (byte*)(&i+1);
- if(iface_debug) {
- prints("I2T sigt=");
- printsigt(st);
- prints(" iface=");
- printiface(i);
- prints("\n");
- }
-
im = i.type;
if(im == nil) {
- prints("interface is nil, not ");
- prints((int8*)st->name);
- prints("\n");
+ printf("interface is nil, not %s\n", st->name);
throw("interface conversion");
}
-
if(im->sigt != st) {
- prints((int8*)im->sigi->name);
- prints(" is ");
- prints((int8*)im->sigt->name);
- prints(", not ");
- prints((int8*)st->name);
- prints("\n");
+ printf("%s is %s, not %s\n", im->sigi->name, im->sigt->name, st->name);
throw("interface conversion");
}
-
- alg = st->alg;
- wid = st->width;
- if(wid <= sizeof(i.data))
- algarray[alg].copy(wid, ret, &i.data);
- else
- algarray[alg].copy(wid, ret, i.data);
-
- if(iface_debug) {
- prints("I2T ret=");
- sys·printpointer(*(void**)ret);
- prints("\n");
- }
- FLUSH(&ret);
+ copyout(st, &i.data, ret);
}
// ifaceI2T2(sigt *byte, iface any) (ret any, ok bool);
+#pragma textflag 7
void
sys·ifaceI2T2(Sigt *st, Iface i, ...)
{
byte *ret;
bool *ok;
Itype *im;
- int32 alg, wid;
-
-
- if(iface_debug) {
- prints("I2T2 sigt=");
- printsigt(st);
- prints(" iface=");
- printiface(i);
- prints("\n");
- }
+ int32 wid;
ret = (byte*)(&i+1);
- alg = st->alg;
wid = st->width;
ok = (bool*)(ret+rnd(wid, 1));
if(im == nil || im->sigt != st) {
*ok = false;
sys·memclr(ret, wid);
- } else {
- *ok = true;
- if(wid <= sizeof(i.data))
- algarray[alg].copy(wid, ret, &i.data);
- else
- algarray[alg].copy(wid, ret, i.data);
+ return;
+ }
+
+ *ok = true;
+ copyout(st, &i.data, ret);
+}
+
+// ifaceE2T(sigt *byte, iface any) (ret any);
+#pragma textflag 7
+void
+sys·ifaceE2T(Sigt *st, 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);
+ throw("interface conversion");
}
- if(iface_debug) {
- prints("I2T2 ret=");
- sys·printpointer(*(void**)ret);
- sys·printbool(*ok);
- prints("\n");
+ copyout(st, &e.data, ret);
+}
+
+// ifaceE2T2(sigt *byte, iface any) (ret any, ok bool);
+#pragma textflag 7
+void
+sys·ifaceE2T2(Sigt *st, Eface e, ...)
+{
+ byte *ret;
+ bool *ok;
+ Sigt *t;
+ int32 wid;
+
+ ret = (byte*)(&e+1);
+ wid = st->width;
+ ok = (bool*)(ret+rnd(wid, 1));
+
+ t = e.type;
+ if(t != st) {
+ *ok = false;
+ sys·memclr(ret, wid);
+ return;
}
+
+ *ok = true;
+ copyout(st, &e.data, ret);
+}
+
+// ifaceI2E(sigi *byte, iface any) (ret any);
+// TODO(rsc): Move to back end, throw away function.
+void
+sys·ifaceI2E(Iface i, Eface ret)
+{
+ Itype *im;
+
+ ret.data = i.data;
+ im = i.type;
+ if(im == nil)
+ ret.type = nil;
+ else
+ ret.type = im->sigt;
+ FLUSH(&ret);
}
// ifaceI2I(sigi *byte, iface any) (ret any);
{
Itype *im;
- if(iface_debug) {
- prints("I2I sigi=");
- printsigi(si);
- prints(" iface=");
- printiface(i);
- prints("\n");
- }
-
im = i.type;
if(im == nil) {
+//TODO(rsc): fixme
// If incoming interface is uninitialized (zeroed)
// make the outgoing interface zeroed as well.
ret = niliface;
ret.type = itype(si, im->sigt, 0);
}
- if(iface_debug) {
- prints("I2I ret=");
- printiface(ret);
- prints("\n");
- }
-
FLUSH(&ret);
}
{
Itype *im;
- if(iface_debug) {
- prints("I2I2 sigi=");
- printsigi(si);
- prints(" iface=");
- printiface(i);
- prints("\n");
- }
-
im = i.type;
+ ok = true;
if(im == nil) {
+//TODO: fixme
// If incoming interface is uninitialized (zeroed)
// make the outgoing interface zeroed as well.
ret = niliface;
- ok = 1;
} else {
ret = i;
- ok = 1;
if(im->sigi != si) {
ret.type = itype(si, im->sigt, 1);
if(ret.type == nil) {
ret = niliface;
- ok = 0;
+ ok = false;
}
}
}
- if(iface_debug) {
- prints("I2I ret=");
- printiface(ret);
- prints("\n");
+ FLUSH(&ret);
+ FLUSH(&ok);
+}
+
+// ifaceE2I(sigi *byte, iface any) (ret any);
+void
+sys·ifaceE2I(Sigi *si, Eface e, Iface ret)
+{
+ Sigt *t;
+
+ t = e.type;
+ if(t == nil) {
+//TODO(rsc): fixme
+ ret = niliface;
+ } else {
+ ret.data = e.data;
+ ret.type = itype(si, t, 0);
}
+ FLUSH(&ret);
+}
+
+// ifaceE2I2(sigi *byte, iface any) (ret any, ok bool);
+void
+sys·ifaceE2I2(Sigi *si, Eface e, Iface ret, bool ok)
+{
+ Sigt *t;
+ t = e.type;
+ ok = true;
+ if(t == nil) {
+//TODO(rsc): fixme
+ ret = niliface;
+ } else {
+ ret.data = e.data;
+ ret.type = itype(si, t, 1);
+ if(ret.type == nil) {
+ ret = niliface;
+ ok = false;
+ }
+ }
FLUSH(&ret);
FLUSH(&ok);
}
-uint64
-ifacehash(Iface a)
+static uint64
+ifacehash1(void *data, Sigt *sigt)
{
int32 alg, wid;
- Sigt *sigt;
- if(a.type == nil)
+ if(sigt == nil)
return 0;
- sigt = a.type->sigt;
alg = sigt->alg;
wid = sigt->width;
if(algarray[alg].hash == nohash) {
throw("fake interface hash");
throw("interface hash");
}
- if(wid <= sizeof(a.data))
- return algarray[alg].hash(wid, &a.data);
- return algarray[alg].hash(wid, a.data);
+ if(wid <= sizeof(data))
+ return algarray[alg].hash(wid, &data);
+ return algarray[alg].hash(wid, data);
}
-bool
-ifaceeq(Iface i1, Iface i2)
+uint64
+ifacehash(Iface a)
{
- int32 alg, wid;
- bool ret;
-
- if(iface_debug) {
- prints("Ieq i1=");
- printiface(i1);
- prints(" i2=");
- printiface(i2);
- prints("\n");
- }
-
- ret = false;
+ if(a.type == nil)
+ return 0;
+ return ifacehash1(a.data, a.type->sigt);
+}
- // are they both nil
- if(i1.type == nil) {
- if(i2.type == nil)
- goto yes;
- goto no;
- }
- if(i2.type == nil)
- goto no;
+uint64
+efacehash(Eface a)
+{
+ return ifacehash1(a.data, a.type);
+}
- // are they the same type?
- if(i1.type->sigt != i2.type->sigt)
- goto no;
+static bool
+ifaceeq1(void *data1, void *data2, Sigt *sigt)
+{
+ int32 alg, wid;
- alg = i1.type->sigt->alg;
- wid = i1.type->sigt->width;
+ alg = sigt->alg;
+ wid = sigt->width;
if(algarray[alg].equal == noequal) {
// calling noequal will throw too,
// but we can print a better error.
- printf("comparing uncomparable type %s\n", i1.type->sigt->name);
+ printf("comparing uncomparable type %s\n", sigt->name);
if(alg == AFAKE)
throw("fake interface compare");
throw("interface compare");
}
- if(wid <= sizeof(i1.data)) {
- if(!algarray[alg].equal(wid, &i1.data, &i2.data))
- goto no;
- } else {
- if(!algarray[alg].equal(wid, i1.data, i2.data))
- goto no;
- }
+ if(wid <= sizeof(data1))
+ return algarray[alg].equal(wid, &data1, &data2);
+ return algarray[alg].equal(wid, data1, data2);
+}
-yes:
- ret = true;
-no:
- if(iface_debug) {
- prints("Ieq ret=");
- sys·printbool(ret);
- prints("\n");
- }
- return ret;
+bool
+ifaceeq(Iface i1, Iface i2)
+{
+ if(i1.type != i2.type)
+ return false;
+ if(i1.type == nil)
+ return true;
+ return ifaceeq1(i1.data, i2.data, i1.type->sigt);
+}
+
+bool
+efaceeq(Eface e1, Eface e2)
+{
+ if(e1.type != e2.type)
+ return false;
+ if(e1.type == nil)
+ return true;
+ return ifaceeq1(e1.data, e2.data, e1.type);
}
// ifaceeq(i1 any, i2 any) (ret bool);
FLUSH(&ret);
}
+// efaceeq(i1 any, i2 any) (ret bool)
+void
+sys·efaceeq(Eface e1, Eface e2, bool ret)
+{
+ ret = efaceeq(e1, e2);
+ FLUSH(&ret);
+}
+
// ifacethash(i1 any) (ret uint32);
void
sys·ifacethash(Iface i1, uint32 ret)
FLUSH(&ret);
}
+// efacethash(e1 any) (ret uint32)
+void
+sys·efacethash(Eface e1, uint32 ret)
+{
+ Sigt *st;
+
+ ret = 0;
+ st = e1.type;
+ if(st != nil)
+ ret = st->thash;
+ FLUSH(&ret);
+}
+
void
-sys·printinter(Iface i)
+sys·printiface(Iface i)
{
printiface(i);
}
void
-unsafe·Reflect(Iface i, uint64 retit, String rettype, bool retindir)
+sys·printeface(Eface e)
+{
+ printeface(e);
+}
+
+void
+unsafe·Reflect(Eface i, uint64 retit, String rettype, bool retindir)
{
int32 wid;
retindir = false;
} else {
retit = (uint64)i.data;
- rettype = gostring(i.type->sigt->name);
- wid = i.type->sigt->width;
+ rettype = gostring(i.type->name);
+ wid = i.type->width;
retindir = wid > sizeof(i.data);
}
FLUSH(&retit);
void
-unsafe·Unreflect(uint64 it, String type, bool indir, Iface ret)
+unsafe·Unreflect(uint64 it, String type, bool indir, Eface ret)
{
Sigt *sigt;
- ret = niliface;
+ ret = nileface;
if(cmpstring(type, emptystring) == 0)
goto out;
if(indir != (sigt->width > sizeof(ret.data)))
goto out;
- ret.type = itype(sigi·empty, sigt, 0);
+ ret.type = sigt;
ret.data = (void*)it;
out:
interprint(uint32 s, Iface *a)
{
USED(s);
- sys·printinter(*a);
+ sys·printiface(*a);
}
static uint32
return ifaceeq(*a, *b);
}
+static uint64
+nilinterhash(uint32 s, Eface *a)
+{
+ USED(s);
+ return efacehash(*a);
+}
+
+static void
+nilinterprint(uint32 s, Eface *a)
+{
+ USED(s);
+ sys·printeface(*a);
+}
+
+static uint32
+nilinterequal(uint32 s, Eface *a, Eface *b)
+{
+ USED(s);
+ return efaceeq(*a, *b);
+}
+
uint64
nohash(uint32 s, void *a)
{
[ANOEQ] { nohash, noequal, memprint, memcopy },
[ASTRING] { strhash, strequal, strprint, memcopy },
[AINTER] { interhash, interequal, interprint, memcopy },
+[ANILINTER] { nilinterhash, nilinterequal, nilinterprint, memcopy },
[AFAKE] { nohash, noequal, noprint, nocopy },
};
typedef struct MCache MCache;
typedef struct Iface Iface;
typedef struct Itype Itype;
+typedef struct Eface Eface;
+typedef struct Sigt Sigt;
typedef struct Defer Defer;
/*
Itype* type;
void* data;
};
+struct Eface
+{
+ Sigt* type;
+ void* data;
+};
struct Array
{ // must not move anything
ANOEQ,
ASTRING,
AINTER,
+ ANILINTER,
AFAKE,
Amax
};
MCache* allocmcache(void);
void mallocinit(void);
bool ifaceeq(Iface, Iface);
+bool efaceeq(Eface, Eface);
uint64 ifacehash(Iface);
+uint64 efacehash(Eface);
uint64 nohash(uint32, void*);
uint32 noequal(uint32, void*, void*);
void* malloc(uintptr size);
#define sys_printfloat sys·printfloat
#define sys_printhex sys·printhex
#define sys_printint sys·printint
-#define sys_printinter sys·printinter
+#define sys_printiface sys·printiface
+#define sys_printeface sys·printeface
#define sys_printpc sys·printpc
#define sys_printpointer sys·printpointer
#define sys_printstring sys·printstring
void sys_printbool(bool);
void sys_printfloat(float64);
void sys_printint(int64);
-void sys_printinter(Iface);
+void sys_printiface(Iface);
+void sys_printeface(Eface);
void sys_printstring(String);
void sys_printpc(void*);
void sys_printpointer(void*);
int
=========== fixedbugs/bug113.go
-main.I is int, not int32
+interface is int, not int32
throw: interface conversion
panic PC=xxx