code review 834045: Library support for cgo export.

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 44 matching lines @@
 typedef struct  Stktop          Stktop;
 typedef struct  String          String;
 typedef struct  Usema           Usema;
 typedef struct  SigTab          SigTab;
 typedef struct  MCache          MCache;
 typedef struct  Iface           Iface;
 typedef struct  Itab            Itab;
 typedef struct  Eface           Eface;
 typedef struct  Type            Type;
 typedef struct  Defer           Defer;
+typedef struct  Panic           Panic;
 typedef struct  hash            Hmap;
 typedef struct  Hchan           Hchan;
 typedef struct  Complex64       Complex64;
 typedef struct  Complex128      Complex128;
 
 /*
  * per-cpu declaration.
  * "extern register" is a special storage class implemented by 6c, 8c, etc.
  * on machines with lots of registers, it allocates a register that will not be
  * used in generated code.  on the x86, it allocates a slot indexed by a
  * segment register.
  *
  * amd64: allocated downwards from R15
  * x86: allocated upwards from 0(FS)
  * arm: allocated downwards from R10
  *
  * every C file linked into a Go program must include runtime.h
  * so that the C compiler knows to avoid other uses of these registers.
  * the Go compilers know to avoid them.
  */
 extern  register        G*      g;
 extern  register        M*      m;
 
 /*
  * defined constants
  */
 enum
 {
         // G status
+        //
+        // If you add to this list, add to the list
+        // of "okay during garbage collection" status
+        // in mgc0.c too.
         Gidle,
         Grunnable,
         Grunning,
         Gsyscall,
         Gwaiting,
         Gmoribund,
         Gdead,
+        Grecovery,
 };
 enum
 {
         true    = 1,
         false   = 0,
 };
 
 /*
  * structures
  */
@@ skipping 58 matching lines @@
         // The offsets of these fields are known to (hard-coded in) libmach.
         byte*   sp;
         byte*   pc;
         G*      g;
 };
 struct  G
 {
         byte*   stackguard;     // cannot move - also known to linker, libmach, libcgo
         byte*   stackbase;      // cannot move - also known to libmach, libcgo
         Defer*  defer;
-        Gobuf   sched;          // cannot move - also known to libmach
+        Panic*  panic;
+        Gobuf   sched;
         byte*   stack0;
         byte*   entry;          // initial function
         G*      alllink;        // on allg
         void*   param;          // passed parameter on wakeup
         int16   status;
         int32   goid;
         uint32  selgen;         // valid sudog pointer
         G*      schedlink;
         bool    readyonstop;
+        bool    ispanic;
         M*      m;              // for debuggers, but offset not hard-coded
         M*      lockedm;
+        int32   sig;
+        uintptr sigcode0;
+        uintptr sigcode1;
 };
 struct  M
 {
         // The offsets of these fields are known to (hard-coded in) libmach.
         G*      g0;             // goroutine with scheduling stack
         void    (*morepc)(void);
         void*   morefp; // frame pointer for more stack
         Gobuf   morebuf;        // gobuf arg to morestack
 
         // Fields not known to debuggers.
@@ skipping 29 matching lines @@
         // The offsets of these fields are known to (hard-coded in) libmach.
         uint8*  stackguard;
         uint8*  stackbase;
         Gobuf   gobuf;
         uint32  args;
 
         // Frame pointer: where args start in old frame.
         // fp == gobuf.sp except in the case of a reflected
         // function call, which uses an off-stack argument frame.
         uint8*  fp;
+        bool    free;   // call stackfree for this frame?
+        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,
         SigQueue = 1<<3,
+        SigPanic = 1<<4,
 };
 
 // NOTE(rsc): keep in sync with extern.go:/type.Func.
 // Eventually, the loaded symbol table should be closer to this form.
 struct  Func
 {
         String  name;
         String  type;   // go type string
         String  src;    // src file name
         Slice   pcln;   // pc/ln tab for this func
@@ skipping 16 matching lines @@
 /*
  * known to compiler
  */
 enum
 {
         AMEM,
         ANOEQ,
         ASTRING,
         AINTER,
         ANILINTER,
-        AFAKE,
         Amax
 };
 
 
 enum {
         Structrnd = sizeof(uintptr)
 };
 
 /*
  * deferred subroutine calls
  */
 struct Defer
 {
         int32   siz;
         byte*   sp;
+        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     algarray[Amax];
 extern  String  emptystring;
 G*      allg;
 M*      allm;
 int32   goidgen;
@@ skipping 18 matching lines @@
  * very low level c-called
  */
 void    gogo(Gobuf*, uintptr);
 void    gogocall(Gobuf*, void(*)(void));
 uintptr gosave(Gobuf*);
 void    ·lessstack(void);
 void    goargs(void);
 void    FLUSH(void*);
 void*   getu(void);
 void    throw(int8*);
+void    panicstring(int8*);
 uint32  rnd(uint32, uint32);
 void    prints(int8*);
 void    printf(int8*, ...);
 byte*   mchr(byte*, byte, byte*);
 void    mcpy(byte*, byte*, uint32);
 int32   mcmp(byte*, byte*, uint32);
 void    memmove(void*, void*, uint32);
 void*   mal(uintptr);
 void*   malx(uintptr size, int32 skip_delta);
 uint32  cmpstring(String, String);
+String  catstring(String, String);
 String  gostring(byte*);
 String  gostringw(uint16*);
 void    initsig(void);
 int32   gotraceback(void);
-void    traceback(uint8 *pc, uint8 *sp, G* gp);
+void    traceback(uint8 *pc, uint8 *sp, uint8 *lr, G* gp);
 void    tracebackothers(G*);
 int32   open(byte*, int32, ...);
 int32   write(int32, void*, int32);
 bool    cas(uint32*, uint32, uint32);
 bool    casp(void**, void*, void*);
 uint32  xadd(uint32 volatile*, int32);
 void    jmpdefer(byte*, void*);
 void    exit1(int32);
 void    ready(G*);
 byte*   getenv(int8*);
@@ skipping 11 matching lines @@
 bool    ifaceeq(Iface, Iface);
 bool    efaceeq(Eface, Eface);
 uintptr ifacehash(Iface);
 uintptr efacehash(Eface);
 uintptr nohash(uint32, void*);
 uint32  noequal(uint32, void*, void*);
 void*   malloc(uintptr size);
 void    free(void *v);
 void    addfinalizer(void*, void(*fn)(void*), int32);
 void    walkfintab(void (*fn)(void*));
+void    runpanic(Panic*);
+void*   getcallersp(void*);
 
 void    exit(int32);
 void    breakpoint(void);
 void    gosched(void);
 void    goexit(void);
 void    runcgo(void (*fn)(void*), void*);
-void    runcgocallback(void*, void (*fn)());
+void    runcgocallback(G*, void*, void (*fn)());
 void    ·entersyscall(void);
 void    ·exitsyscall(void);
-void    startcgocallback(void);
-void    endcgocallback(void);
+void    startcgocallback(G*);
+void    endcgocallback(G*);
 G*      newproc1(byte*, byte*, int32, int32);
 void    siginit(void);
 bool    sigsend(int32 sig);
 void    gettime(int64*, int32*);
 int32   callers(int32, uintptr*, int32);
 int64   nanotime(void);
+void    panic(int32);
 
 #pragma varargck        argpos  printf  1
 
 #pragma varargck        type    "d"     int32
 #pragma varargck        type    "d"     uint32
 #pragma varargck        type    "D"     int64
 #pragma varargck        type    "D"     uint64
 #pragma varargck        type    "x"     int32
 #pragma varargck        type    "x"     uint32
 #pragma varargck        type    "X"     int64
@@ skipping 58 matching lines @@
 /*
  * This is consistent across Linux and BSD.
  * If a new OS is added that is different, move this to
  * $GOOS/$GOARCH/defs.h.
  */
 #define EACCES          13
 
 /*
  * low level go-called
  */
-uint8*  runtime_mmap(byte*, uint32, int32, int32, int32, uint32);
+uint8*  runtime_mmap(byte*, uintptr, int32, int32, int32, uint32);
 void    runtime_memclr(byte*, uint32);
 void    runtime_setcallerpc(void*, void*);
 void*   runtime_getcallerpc(void*);
 
 /*
  * runtime go-called
  */
 void    runtime_printbool(bool);
 void    runtime_printfloat(float64);
 void    runtime_printint(int64);
 void    runtime_printiface(Iface);
 void    runtime_printeface(Eface);
 void    runtime_printstring(String);
 void    runtime_printpc(void*);
 void    runtime_printpointer(void*);
 void    runtime_printuint(uint64);
 void    runtime_printhex(uint64);
 void    runtime_printslice(Slice);
 void    runtime_printcomplex(Complex128);
-void    ·panicl(int32);
 void    reflect·call(byte*, byte*, uint32);
+void    ·panic(Eface);
+void    ·panicindex(void);
+void    ·panicslice(void);
+/*
+ * runtime c-called (but written in Go)
+ */
+void ·newError(String, Eface*);
+void    ·printany(Eface);
+void    ·newTypeAssertionError(Type*, Type*, Type*, String*, String*, String*, String*, Eface*);
+void    ·newErrorString(String, Eface*);
 
 /*
  * wrapped for go users
  */
 float64 Inf(int32 sign);
 float64 NaN(void);
 float32 float32frombits(uint32 i);
 uint32  float32tobits(float32 f);
 float64 float64frombits(uint64 i);
 uint64  float64tobits(float64 f);
@@ skipping 17 matching lines @@
 
 Hchan*  makechan(Type*, uint32);
 void    chansend(Hchan*, void*, bool*);
 void    chanrecv(Hchan*, void*, bool*);
 void    chanclose(Hchan*);
 bool    chanclosed(Hchan*);
 int32   chanlen(Hchan*);
 int32   chancap(Hchan*);
 
 void    ifaceE2I(struct InterfaceType*, Eface, Iface*);