libgo/runtime/go-reflect-chan.c

   1 /* go-reflect-chan.c -- channel reflection support for Go.
   2
   3    Copyright 2009 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 <stdlib.h>
   8 #include <stdint.h>
   9
  10 #include "config.h"
  11 #include "go-type.h"
  12 #include "channel.h"
  13
  14 /* This file implements support for reflection on channels.  These
  15    functions are called from reflect/value.go.  */
  16
  17 extern unsigned char *makechan (const struct __go_type_descriptor *, uint32_t)
  18   asm ("libgo_reflect.reflect.makechan");
  19
  20 unsigned char *
  21 makechan (const struct __go_type_descriptor *typ, uint32_t size)
  22 {
  23   return (unsigned char *) __go_new_channel (typ->__size, size);
  24 }
  25
  26 extern void chansend (unsigned char *, unsigned char *, _Bool *)
  27   asm ("libgo_reflect.reflect.chansend");
  28
  29 void
  30 chansend (unsigned char *ch, unsigned char *val, _Bool *pres)
  31 {
  32   struct __go_channel *channel = (struct __go_channel *) ch;
  33
  34   if (channel->element_size <= sizeof (uint64_t))
  35     {
  36       union
  37       {
  38         char b[sizeof (uint64_t)];
  39         uint64_t v;
  40       } u;
  41
  42       __builtin_memset (u.b, 0, sizeof (uint64_t));
  43 #ifndef WORDS_BIGENDIAN
  44       __builtin_memcpy (u.b, val, channel->element_size);
  45 #else
  46       __builtin_memcpy (u.b + sizeof (uint64_t) - channel->element_size, val,
  47                         channel->element_size);
  48 #endif
  49       if (pres == NULL)
  50         __go_send_small (channel, u.v, 0);
  51       else
  52         *pres = __go_send_nonblocking_small (channel, u.v);
  53     }
  54   else
  55     {
  56       if (pres == NULL)
  57         __go_send_big (channel, val, 0);
  58       else
  59         *pres = __go_send_nonblocking_big (channel, val);
  60     }
  61 }
  62
  63 extern void chanrecv (unsigned char *, unsigned char *, _Bool *)
  64   asm ("libgo_reflect.reflect.chanrecv");
  65
  66 void
  67 chanrecv (unsigned char *ch, unsigned char *val, _Bool *pres)
  68 {
  69   struct __go_channel *channel = (struct __go_channel *) ch;
  70
  71   if (channel->element_size <= sizeof (uint64_t))
  72     {
  73       union
  74       {
  75         char b[sizeof (uint64_t)];
  76         uint64_t v;
  77       } u;
  78
  79       if (pres == NULL)
  80         u.v = __go_receive_small (channel, 0);
  81       else
  82         {
  83           struct __go_receive_nonblocking_small s;
  84
  85           s = __go_receive_nonblocking_small (channel);
  86           *pres = s.__success;
  87           if (!s.__success)
  88             return;
  89           u.v = s.__val;
  90         }
  91
  92 #ifndef WORDS_BIGENDIAN
  93       __builtin_memcpy (val, u.b, channel->element_size);
  94 #else
  95       __builtin_memcpy (val, u.b + sizeof (uint64_t) - channel->element_size,
  96                         channel->element_size);
  97 #endif
  98     }
  99   else
 100     {
 101       if (pres == NULL)
 102         __go_receive_big (channel, val, 0);
 103       else
 104         *pres = __go_receive_nonblocking_big (channel, val);
 105     }
 106 }
 107
 108 extern _Bool chanclosed (unsigned char *)
 109   asm ("libgo_reflect.reflect.chanclosed");
 110
 111 _Bool
 112 chanclosed (unsigned char *ch)
 113 {
 114   struct __go_channel *channel = (struct __go_channel *) ch;
 115
 116   return __go_builtin_closed (channel);
 117 }
 118
 119 extern void chanclose (unsigned char *)
 120   asm ("libgo_reflect.reflect.chanclose");
 121
 122 void
 123 chanclose (unsigned char *ch)
 124 {
 125   struct __go_channel *channel = (struct __go_channel *) ch;
 126
 127   __go_builtin_close (channel);
 128 }
 129
 130 extern int32_t chanlen (unsigned char *) asm ("libgo_reflect.reflect.chanlen");
 131
 132 int32_t
 133 chanlen (unsigned char *ch)
 134 {
 135   struct __go_channel *channel = (struct __go_channel *) ch;
 136
 137   return (int32_t) __go_chan_len (channel);
 138 }
 139
 140 extern int32_t chancap (unsigned char *) asm ("libgo_reflect.reflect.chancap");
 141
 142 int32_t
 143 chancap (unsigned char *ch)
 144 {
 145   struct __go_channel *channel = (struct __go_channel *) ch;
 146
 147   return (int32_t) __go_chan_cap (channel);
 148 }