libgo/runtime/go-cgo.c

   1 /* go-cgo.c -- SWIG support routines for libgo.
   2
   3    Copyright 2011 The Go Authors. All rights reserved.
   4    Use of this source code is governed by a BSD-style
   5    license that can be found in the LICENSE file.  */
   6
   7 #include "runtime.h"
   8 #include "go-alloc.h"
   9 #include "interface.h"
  10 #include "go-panic.h"
  11 #include "go-type.h"
  12
  13 extern void __go_receive (ChanType *, Hchan *, byte *);
  14
  15 /* Prepare to call from code written in Go to code written in C or
  16    C++.  This takes the current goroutine out of the Go scheduler, as
  17    though it were making a system call.  Otherwise the program can
  18    lock up if the C code goes to sleep on a mutex or for some other
  19    reason.  This idea is to call this function, then immediately call
  20    the C/C++ function.  After the C/C++ function returns, call
  21    syscall_cgocalldone.  The usual Go code would look like
  22
  23        syscall.Cgocall()
  24        defer syscall.Cgocalldone()
  25        cfunction()
  26
  27    */
  28
  29 /* We let Go code call these via the syscall package.  */
  30 void syscall_cgocall(void) __asm__ (GOSYM_PREFIX "syscall.Cgocall");
  31 void syscall_cgocalldone(void) __asm__ (GOSYM_PREFIX "syscall.CgocallDone");
  32 void syscall_cgocallback(void) __asm__ (GOSYM_PREFIX "syscall.CgocallBack");
  33 void syscall_cgocallbackdone(void) __asm__ (GOSYM_PREFIX "syscall.CgocallBackDone");
  34
  35 void
  36 syscall_cgocall ()
  37 {
  38   M* m;
  39   G* g;
  40
  41   if (runtime_needextram && runtime_cas (&runtime_needextram, 1, 0))
  42     runtime_newextram ();
  43
  44   runtime_lockOSThread();
  45
  46   m = runtime_m ();
  47   ++m->ncgocall;
  48   g = runtime_g ();
  49   ++g->ncgo;
  50   runtime_entersyscall ();
  51 }
  52
  53 /* Prepare to return to Go code from C/C++ code.  */
  54
  55 void
  56 syscall_cgocalldone ()
  57 {
  58   G* g;
  59
  60   g = runtime_g ();
  61   __go_assert (g != NULL);
  62   --g->ncgo;
  63   if (g->ncgo == 0)
  64     {
  65       /* We are going back to Go, and we are not in a recursive call.
  66          Let the garbage collector clean up any unreferenced
  67          memory.  */
  68       g->cgomal = NULL;
  69     }
  70
  71   /* If we are invoked because the C function called _cgo_panic, then
  72      _cgo_panic will already have exited syscall mode.  */
  73   if (g->status == Gsyscall)
  74     runtime_exitsyscall ();
  75
  76   runtime_unlockOSThread();
  77 }
  78
  79 /* Call back from C/C++ code to Go code.  */
  80
  81 void
  82 syscall_cgocallback ()
  83 {
  84   M *mp;
  85
  86   mp = runtime_m ();
  87   if (mp == NULL)
  88     {
  89       runtime_needm ();
  90       mp = runtime_m ();
  91       mp->dropextram = true;
  92     }
  93
  94   runtime_exitsyscall ();
  95
  96   if (runtime_g ()->ncgo == 0)
  97     {
  98       /* The C call to Go came from a thread not currently running any
  99          Go.  In the case of -buildmode=c-archive or c-shared, this
 100          call may be coming in before package initialization is
 101          complete.  Wait until it is.  */
 102       __go_receive (NULL, runtime_main_init_done, NULL);
 103     }
 104
 105   mp = runtime_m ();
 106   if (mp->needextram)
 107     {
 108       mp->needextram = 0;
 109       runtime_newextram ();
 110     }
 111 }
 112
 113 /* Prepare to return to C/C++ code from a callback to Go code.  */
 114
 115 void
 116 syscall_cgocallbackdone ()
 117 {
 118   M *mp;
 119
 120   runtime_entersyscall ();
 121   mp = runtime_m ();
 122   if (mp->dropextram && runtime_g ()->ncgo == 0)
 123     {
 124       mp->dropextram = false;
 125       runtime_dropm ();
 126     }
 127 }
 128
 129 /* Allocate memory and save it in a list visible to the Go garbage
 130    collector.  */
 131
 132 void *
 133 alloc_saved (size_t n)
 134 {
 135   void *ret;
 136   G *g;
 137   CgoMal *c;
 138
 139   ret = __go_alloc (n);
 140
 141   g = runtime_g ();
 142   c = (CgoMal *) __go_alloc (sizeof (CgoMal));
 143   c->next = g->cgomal;
 144   c->alloc = ret;
 145   g->cgomal = c;
 146
 147   return ret;
 148 }
 149
 150 /* These are routines used by SWIG.  The gc runtime library provides
 151    the same routines under the same name, though in that case the code
 152    is required to import runtime/cgo.  */
 153
 154 void *
 155 _cgo_allocate (size_t n)
 156 {
 157   void *ret;
 158
 159   runtime_exitsyscall ();
 160   ret = alloc_saved (n);
 161   runtime_entersyscall ();
 162   return ret;
 163 }
 164
 165 extern const struct __go_type_descriptor string_type_descriptor
 166   __asm__ (GOSYM_PREFIX "__go_tdn_string");
 167
 168 void
 169 _cgo_panic (const char *p)
 170 {
 171   intgo len;
 172   unsigned char *data;
 173   String *ps;
 174   struct __go_empty_interface e;
 175
 176   runtime_exitsyscall ();
 177   len = __builtin_strlen (p);
 178   data = alloc_saved (len);
 179   __builtin_memcpy (data, p, len);
 180   ps = alloc_saved (sizeof *ps);
 181   ps->str = data;
 182   ps->len = len;
 183   e.__type_descriptor = &string_type_descriptor;
 184   e.__object = ps;
 185
 186   /* We don't call runtime_entersyscall here, because normally what
 187      will happen is that we will walk up the stack to a Go deferred
 188      function that calls recover.  However, this will do the wrong
 189      thing if this panic is recovered and the stack unwinding is
 190      caught by a C++ exception handler.  It might be possible to
 191      handle this by calling runtime_entersyscall in the personality
 192      function in go-unwind.c.  FIXME.  */
 193
 194   __go_panic (e);
 195 }
 196
 197 /* Used for _cgo_wait_runtime_init_done.  This is based on code in
 198    runtime/cgo/gcc_libinit.c in the master library.  */
 199
 200 static pthread_cond_t runtime_init_cond = PTHREAD_COND_INITIALIZER;
 201 static pthread_mutex_t runtime_init_mu = PTHREAD_MUTEX_INITIALIZER;
 202 static _Bool runtime_init_done;
 203
 204 /* This is called by exported cgo functions to ensure that the runtime
 205    has been initialized before we enter the function.  This is needed
 206    when building with -buildmode=c-archive or similar.  */
 207
 208 void
 209 _cgo_wait_runtime_init_done (void)
 210 {
 211   int err;
 212
 213   if (__atomic_load_n (&runtime_init_done, __ATOMIC_ACQUIRE))
 214     return;
 215
 216   err = pthread_mutex_lock (&runtime_init_mu);
 217   if (err != 0)
 218     abort ();
 219   while (!__atomic_load_n (&runtime_init_done, __ATOMIC_ACQUIRE))
 220     {
 221       err = pthread_cond_wait (&runtime_init_cond, &runtime_init_mu);
 222       if (err != 0)
 223         abort ();
 224     }
 225   err = pthread_mutex_unlock (&runtime_init_mu);
 226   if (err != 0)
 227     abort ();
 228 }
 229
 230 /* This is called by runtime_main after the Go runtime is
 231    initialized.  */
 232
 233 void
 234 _cgo_notify_runtime_init_done (void)
 235 {
 236   int err;
 237
 238   err = pthread_mutex_lock (&runtime_init_mu);
 239   if (err != 0)
 240     abort ();
 241   __atomic_store_n (&runtime_init_done, 1, __ATOMIC_RELEASE);
 242   err = pthread_cond_broadcast (&runtime_init_cond);
 243   if (err != 0)
 244     abort ();
 245   err = pthread_mutex_unlock (&runtime_init_mu);
 246   if (err != 0)
 247     abort ();
 248 }
 249
 250 // runtime_iscgo is set to true if some cgo code is linked in.
 251 // This is done by a constructor in the cgo generated code.
 252 _Bool runtime_iscgo;
 253
 254 // runtime_cgoHasExtraM is set on startup when an extra M is created
 255 // for cgo.  The extra M must be created before any C/C++ code calls
 256 // cgocallback.
 257 _Bool runtime_cgoHasExtraM;