code review 5453043: runtime: prep for type-specific algorithms

src/pkg/runtime/iface.c

 // 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"
 #include "arch.h"
 #include "type.h"
 #include "malloc.h"
 
 enum·
@@ skipping 141 matching lines @@
         runtime·atomicstorep(&hash[h], m);
         runtime·unlock(&ifacelock);
         if(m->bad)
                 return nil;
         return m;
 }
 
 static void
 copyin(Type *t, void *src, void **dst)
 {
-        int32 wid, alg;
+        uintptr size;
         void *p;
-
-        wid = t->size;
+        Alg *alg;
+
+        size = t->size;
         alg = t->alg;
 
-        if(wid <= sizeof(*dst))
-                runtime·algarray[alg].copy(wid, dst, src);
+        if(size <= sizeof(*dst))
+                alg->copy(size, dst, src);
         else {
-                p = runtime·mal(wid);
-                runtime·algarray[alg].copy(wid, p, src);
+                p = runtime·mal(size);
+                alg->copy(size, p, src);
                 *dst = p;
         }
 }
 
 static void
 copyout(Type *t, void **src, void *dst)
 {
-        int32 wid, alg;
-
-        wid = t->size;
+        uintptr size;
+        Alg *alg;
+
+        size = t->size;
         alg = t->alg;
 
-        if(wid <= sizeof(*src))
-                runtime·algarray[alg].copy(wid, dst, src);
+        if(size <= sizeof(*src))
+                alg->copy(size, dst, src);
         else
-                runtime·algarray[alg].copy(wid, dst, *src);
+                alg->copy(size, dst, *src);
 }
 
 // func convT2I(typ *byte, typ2 *byte, elem any) (ret any)
 #pragma textflag 7
 void
 runtime·convT2I(Type *t, InterfaceType *inter, ...)
 {
         byte *elem;
         Iface *ret;
         int32 wid;
@@ skipping 342 matching lines @@
         USED(inter);
         ret = e;
         ok = e.type != nil;
         FLUSH(&ret);
         FLUSH(&ok);
 }
 
 static uintptr
 ifacehash1(void *data, Type *t)
 {
-        int32 alg, wid;
+        Alg *alg;
+        uintptr size, h;
         Eface err;
 
         if(t == nil)
                 return 0;
 
         alg = t->alg;
-        wid = t->size;
-        if(runtime·algarray[alg].hash == runtime·nohash) {
+        size = t->size;
+        if(alg->hash == runtime·nohash) {
                 // calling nohash will panic too,
                 // but we can print a better error.
                 runtime·newErrorString(runtime·catstring(runtime·gostringnocopy((byte*)"hash of unhashable type "), *t->string), &err);
                 runtime·panic(err);
         }
-        if(wid <= sizeof(data))
-                return runtime·algarray[alg].hash(wid, &data);
-        return runtime·algarray[alg].hash(wid, data);
+        h = 0;
+        if(size <= sizeof(data))
+                alg->hash(&h, size, &data);
+        else
+                alg->hash(&h, size, data);
+        return h;
 }
 
 uintptr
 runtime·ifacehash(Iface a)
 {
         if(a.tab == nil)
                 return 0;
         return ifacehash1(a.data, a.tab->type);
 }
 
 uintptr
 runtime·efacehash(Eface a)
 {
         return ifacehash1(a.data, a.type);
 }
 
 static bool
 ifaceeq1(void *data1, void *data2, Type *t)
 {
-        int32 alg, wid;
+        uintptr size;
+        Alg *alg;
         Eface err;
+        bool eq;
 
         alg = t->alg;
-        wid = t->size;
-
-        if(runtime·algarray[alg].equal == runtime·noequal) {
+        size = t->size;
+
+        if(alg->equal == runtime·noequal) {
                 // calling noequal will panic too,
                 // but we can print a better error.
                 runtime·newErrorString(runtime·catstring(runtime·gostringnocopy((byte*)"comparing uncomparable type "), *t->string), &err);
                 runtime·panic(err);
         }
 
-        if(wid <= sizeof(data1))
-                return runtime·algarray[alg].equal(wid, &data1, &data2);
-        return runtime·algarray[alg].equal(wid, data1, data2);
+        eq = 0;
+        if(size <= sizeof(data1))
+                alg->equal(&eq, size, &data1, &data2);
+        else
+                alg->equal(&eq, size, data1, data2);
+        return eq;
 }
 
 bool
 runtime·ifaceeq_c(Iface i1, Iface i2)
 {
         if(i1.tab != i2.tab)
                 return false;
         if(i1.tab == nil)
                 return true;
         return ifaceeq1(i1.data, i2.data, i1.tab->type);
@@ skipping 81 matching lines @@
                 runtime·throw("invalid interface value");
         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;
-                        runtime·algarray[e.type->alg].copy(e.type->size, &x, &e.data);
+                        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 = runtime·mal(sizeof(uintptr));
                         *p = x;
                 } else {
                         // Already a pointer, but still make a copy,
                         // to preserve value semantics for interface data.
                         p = runtime·mal(e.type->size);
-                        runtime·algarray[e.type->alg].copy(e.type->size, p, e.data);
+                        e.type->alg->copy(e.type->size, p, e.data);
                 }
                 retaddr = p;
         }
         FLUSH(&rettype);
         FLUSH(&retaddr);
 }
 
 void
 unsafe·Unreflect(Eface typ, void *addr, Eface e)
 {
         if(((uintptr)typ.type&reflectFlags) != 0)
                 runtime·throw("invalid interface value");
 
         // 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))
-                runtime·algarray[e.type->alg].copy(e.type->size, &e.data, addr);
+                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;
         }
 
         FLUSH(&e);
 }
 
 void
@@ skipping 32 matching lines @@
         // type structure sits before the data pointer.
         t = (Type*)((Eface*)typ.data-1);
 ········
         size = n*t->size;
         if(t->kind&KindNoPointers)
                 ret = runtime·mallocgc(size, FlagNoPointers, 1, 1);
         else
                 ret = runtime·mal(size);
         FLUSH(&ret);
 }