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

src/pkg/runtime/runtime.h

 // 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;
@@ skipping 25 matching lines @@
 #define int                     XXint / / /
 #define long                    XXlong / / /
 #define float                   XXfloat / / /
 #define double                  XXdouble / / /
 
 /*
  * defined types
  */
 typedef uint8                   bool;
 typedef uint8                   byte;
-typedef struct  Alg             Alg;
 typedef struct  Func            Func;
 typedef struct  G               G;
 typedef struct  Gobuf           Gobuf;
 typedef union   Lock            Lock;
 typedef struct  M               M;
 typedef struct  Mem             Mem;
 typedef union   Note            Note;
 typedef struct  Slice           Slice;
 typedef struct  Stktop          Stktop;
 typedef struct  String          String;
@@ skipping 196 matching lines @@
         // The offsets of these fields are known to (hard-coded in) libmach.
         uint8*  stackguard;
         uint8*  stackbase;
         Gobuf   gobuf;
         uint32  argsize;
 
         uint8*  argp;   // pointer to arguments in old frame
         uintptr free;   // if free>0, call stackfree using free as size
         bool    panic;  // is this frame the top of a panic?
 };
-struct  Alg
-{
-        uintptr (*hash)(uint32, void*);
-        uint32  (*equal)(uint32, void*, void*);
-        void    (*print)(uint32, void*);
-        void    (*copy)(uint32, void*, void*);
-};
 struct  SigTab
 {
         int32   flags;
         int8    *name;
 };
 enum
 {
         SigCatch = 1<<0,
         SigIgnore = 1<<1,
         SigRestart = 1<<2,
@@ skipping 69 matching lines @@
  *    you need super-gopher-guru privilege
  *    to add this list.
  */
 #define nelem(x)        (sizeof(x)/sizeof((x)[0]))
 #define nil             ((void*)0)
 #define offsetof(s,m)   (uint32)(&(((s*)0)->m))
 
 /*
  * known to compiler
  */
+enum {
+        Structrnd = sizeof(uintptr)
+};
+
+/*
+ * type algorithms - known to compiler
+ */
 enum
 {
         AMEM,
         ANOEQ,
         ASTRING,
         AINTER,
         ANILINTER,
         ASLICE,
         AMEM8,
         AMEM16,
         AMEM32,
         AMEM64,
         AMEM128,
         ANOEQ8,
         ANOEQ16,
         ANOEQ32,
         ANOEQ64,
         ANOEQ128,
         Amax
 };
+typedef struct  Alg             Alg;
+struct  Alg
+{
+        void    (*hash)(uintptr*, uintptr, void*);
+        void    (*equal)(bool*, uintptr, void*, void*);
+        void    (*print)(uintptr, void*);
+        void    (*copy)(uintptr, void*, void*);
+};
 
+extern  Alg     runtime·algarray[Amax];
 
-enum {
-        Structrnd = sizeof(uintptr)
-};
+void    runtime·memhash(uintptr*, uintptr, void*);
+void    runtime·nohash(uintptr*, uintptr, void*);
+void    runtime·strhash(uintptr*, uintptr, void*);
+void    runtime·interhash(uintptr*, uintptr, void*);
+void    runtime·nilinterhash(uintptr*, uintptr, void*);
+
+void    runtime·memequal(bool*, uintptr, void*, void*);
+void    runtime·noequal(bool*, uintptr, void*, void*);
+void    runtime·strequal(bool*, uintptr, void*, void*);
+void    runtime·interequal(bool*, uintptr, void*, void*);
+void    runtime·nilinterequal(bool*, uintptr, void*, void*);
+
+void    runtime·memprint(uintptr, void*);
+void    runtime·strprint(uintptr, void*);
+void    runtime·interprint(uintptr, void*);
+void    runtime·nilinterprint(uintptr, void*);
+
+void    runtime·memcopy(uintptr, void*, void*);
+void    runtime·memcopy8(uintptr, void*, void*);
+void    runtime·memcopy16(uintptr, void*, void*);
+void    runtime·memcopy32(uintptr, void*, void*);
+void    runtime·memcopy64(uintptr, void*, void*);
+void    runtime·memcopy128(uintptr, void*, void*);
+void    runtime·memcopy(uintptr, void*, void*);
+void    runtime·strcopy(uintptr, void*, void*);
+void    runtime·algslicecopy(uintptr, void*, void*);
+void    runtime·intercopy(uintptr, void*, void*);
+void    runtime·nilintercopy(uintptr, void*, void*);
 
 /*
  * deferred subroutine calls
  */
 struct Defer
 {
         int32   siz;
         bool    nofree;
         byte*   argp;  // where args were copied from
         byte*   pc;
         byte*   fn;
         Defer*  link;
         byte    args[8];        // padded to actual size
 };
 
 /*
  * panics
  */
 struct Panic
 {
         Eface   arg;            // argument to panic
         byte*   stackbase;      // g->stackbase in panic
         Panic*  link;           // link to earlier panic
         bool    recovered;      // whether this panic is over
 };
 
 /*
  * external data
  */
-extern  Alg     runtime·algarray[Amax];
 extern  String  runtime·emptystring;
 G*      runtime·allg;
 G*      runtime·lastg;
 M*      runtime·allm;
 extern  int32   runtime·gomaxprocs;
 extern  bool    runtime·singleproc;
 extern  uint32  runtime·panicking;
 extern  int32   runtime·gcwaiting;              // gc is waiting to run
 int8*   runtime·goos;
 int32   runtime·ncpu;
@@ skipping 67 matching lines @@
 Func*   runtime·findfunc(uintptr);
 int32   runtime·funcline(Func*, uintptr);
 void*   runtime·stackalloc(uint32);
 void    runtime·stackfree(void*, uintptr);
 MCache* runtime·allocmcache(void);
 void    runtime·mallocinit(void);
 bool    runtime·ifaceeq_c(Iface, Iface);
 bool    runtime·efaceeq_c(Eface, Eface);
 uintptr runtime·ifacehash(Iface);
 uintptr runtime·efacehash(Eface);
-uintptr runtime·nohash(uint32, void*);
-uint32  runtime·noequal(uint32, void*, void*);
 void*   runtime·malloc(uintptr size);
 void    runtime·free(void *v);
 bool    runtime·addfinalizer(void*, void(*fn)(void*), int32);
 void    runtime·runpanic(Panic*);
 void*   runtime·getcallersp(void*);
 int32   runtime·mcount(void);
 void    runtime·mcall(void(*)(G*));
 uint32  runtime·fastrand1(void);
 
 void    runtime·exit(int32);
@@ skipping 167 matching lines @@
 
 Hchan*  runtime·makechan_c(ChanType*, int64);
 void    runtime·chansend(ChanType*, Hchan*, byte*, bool*);
 void    runtime·chanrecv(ChanType*, Hchan*, byte*, bool*, bool*);
 int32   runtime·chanlen(Hchan*);
 int32   runtime·chancap(Hchan*);
 bool    runtime·showframe(Func*);
 
 void    runtime·ifaceE2I(struct InterfaceType*, Eface, Iface*);