libgo/runtime/go-type.h

   1 /* go-type.h -- basic information for a Go type.
   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 #ifndef LIBGO_GO_TYPE_H
   8 #define LIBGO_GO_TYPE_H
   9
  10 #include <stddef.h>
  11 #include <stdint.h>
  12
  13 #include "array.h"
  14
  15 struct String;
  16
  17 /* Many of the types in this file must match the data structures
  18    generated by the compiler, and must also match the Go types which
  19    appear in go/runtime/type.go and go/reflect/type.go.  */
  20
  21 /* Type kinds.  These are used to get the type descriptor to use for
  22    the type itself, when using unsafe.Typeof or unsafe.Reflect.  The
  23    values here must match the values generated by the compiler (the
  24    RUNTIME_TYPE_KIND_xxx values in gcc/go/types.h).  These are macros
  25    rather than an enum to make it easy to change values in the future
  26    and hard to get confused about it.
  27
  28    These correspond to the kind values used by the gc compiler.  */
  29
  30 #define GO_BOOL 1
  31 #define GO_INT 2
  32 #define GO_INT8 3
  33 #define GO_INT16 4
  34 #define GO_INT32 5
  35 #define GO_INT64 6
  36 #define GO_UINT 7
  37 #define GO_UINT8 8
  38 #define GO_UINT16 9
  39 #define GO_UINT32 10
  40 #define GO_UINT64 11
  41 #define GO_UINTPTR 12
  42 #define GO_FLOAT32 13
  43 #define GO_FLOAT64 14
  44 #define GO_COMPLEX64 15
  45 #define GO_COMPLEX128 16
  46 #define GO_ARRAY 17
  47 #define GO_CHAN 18
  48 #define GO_FUNC 19
  49 #define GO_INTERFACE 20
  50 #define GO_MAP 21
  51 #define GO_PTR 22
  52 #define GO_SLICE 23
  53 #define GO_STRING 24
  54 #define GO_STRUCT 25
  55 #define GO_UNSAFE_POINTER 26
  56
  57 #define GO_DIRECT_IFACE (1 << 5)
  58 #define GO_GC_PROG (1 << 6)
  59 #define GO_NO_POINTERS (1 << 7)
  60
  61 #define GO_CODE_MASK 0x1f
  62
  63 /* For each Go type the compiler constructs one of these structures.
  64    This is used for type reflection, interfaces, maps, and reference
  65    counting.  */
  66
  67 struct __go_type_descriptor
  68 {
  69   /* The type code for this type, one of the type kind values above.
  70      This is used by unsafe.Reflect and unsafe.Typeof to determine the
  71      type descriptor to return for this type itself.  It is also used
  72      by reflect.toType when mapping to a reflect Type structure.  */
  73   unsigned char __code;
  74
  75   /* The alignment in bytes of a variable with this type.  */
  76   unsigned char __align;
  77
  78   /* The alignment in bytes of a struct field with this type.  */
  79   unsigned char __field_align;
  80
  81   /* The size in bytes of a value of this type.  Note that all types
  82      in Go have a fixed size.  */
  83   uintptr_t __size;
  84
  85   /* The type's hash code.  */
  86   uint32_t __hash;
  87
  88   /* This function takes a pointer to a value of this type, and the
  89      size of this type, and returns a hash code.  We pass the size
  90      explicitly becaues it means that we can share a single instance
  91      of this function for various different types.  */
  92   const FuncVal *__hashfn;
  93
  94   /* This function takes two pointers to values of this type, and the
  95      size of this type, and returns whether the values are equal.  */
  96   const FuncVal *__equalfn;
  97
  98   /* The garbage collection data. */
  99   const uintptr *__gc;
 100
 101   /* A string describing this type.  This is only used for
 102      debugging.  */
 103   const struct String *__reflection;
 104
 105   /* A pointer to fields which are only used for some types.  */
 106   const struct __go_uncommon_type *__uncommon;
 107
 108   /* The descriptor for the type which is a pointer to this type.
 109      This may be NULL.  */
 110   const struct __go_type_descriptor *__pointer_to_this;
 111
 112   /* A pointer to a zero value for this type.  All types will point to
 113      the same zero value, go$zerovalue, which is a common variable so
 114      that it will be large enough.  */
 115   void *__zero;
 116 };
 117
 118 /* The information we store for each method of a type.  */
 119
 120 struct __go_method
 121 {
 122   /* The name of the method.  */
 123   const struct String *__name;
 124
 125   /* This is NULL for an exported method, or the name of the package
 126      where it lives.  */
 127   const struct String *__pkg_path;
 128
 129   /* The type of the method, without the receiver.  This will be a
 130      function type.  */
 131   const struct __go_type_descriptor *__mtype;
 132
 133   /* The type of the method, with the receiver.  This will be a
 134      function type.  */
 135   const struct __go_type_descriptor *__type;
 136
 137   /* A pointer to the code which implements the method.  This is
 138      really a function pointer.  */
 139   const void *__function;
 140 };
 141
 142 /* Additional information that we keep for named types and for types
 143    with methods.  */
 144
 145 struct __go_uncommon_type
 146 {
 147   /* The name of the type.  */
 148   const struct String *__name;
 149
 150   /* The type's package.  This is NULL for builtin types.  */
 151   const struct String *__pkg_path;
 152
 153   /* The type's methods.  This is an array of struct __go_method.  */
 154   struct __go_open_array __methods;
 155 };
 156
 157 /* The type descriptor for a fixed array type.  */
 158
 159 struct __go_array_type
 160 {
 161   /* Starts like all type descriptors.  */
 162   struct __go_type_descriptor __common;
 163
 164   /* The element type.  */
 165   struct __go_type_descriptor *__element_type;
 166
 167   /* The type of a slice of the same element type.  */
 168   struct __go_type_descriptor *__slice_type;
 169
 170   /* The length of the array.  */
 171   uintptr_t __len;
 172 };
 173
 174 /* The type descriptor for a slice.  */
 175
 176 struct __go_slice_type
 177 {
 178   /* Starts like all other type descriptors.  */
 179   struct __go_type_descriptor __common;
 180
 181   /* The element type.  */
 182   struct __go_type_descriptor *__element_type;
 183 };
 184
 185 /* The direction of a channel.  */
 186 #define CHANNEL_RECV_DIR 1
 187 #define CHANNEL_SEND_DIR 2
 188 #define CHANNEL_BOTH_DIR (CHANNEL_RECV_DIR | CHANNEL_SEND_DIR)
 189
 190 /* The type descriptor for a channel.  */
 191
 192 struct __go_channel_type
 193 {
 194   /* Starts like all other type descriptors.  */
 195   struct __go_type_descriptor __common;
 196
 197   /* The element type.  */
 198   const struct __go_type_descriptor *__element_type;
 199
 200   /* The direction.  */
 201   uintptr_t __dir;
 202 };
 203
 204 /* The type descriptor for a function.  */
 205
 206 struct __go_func_type
 207 {
 208   /* Starts like all other type descriptors.  */
 209   struct __go_type_descriptor __common;
 210
 211   /* Whether this is a varargs function.  If this is true, there will
 212      be at least one parameter.  For "..." the last parameter type is
 213      "interface{}".  For "... T" the last parameter type is "[]T".  */
 214   _Bool __dotdotdot;
 215
 216   /* The input parameter types.  This is an array of pointers to
 217      struct __go_type_descriptor.  */
 218   struct __go_open_array __in;
 219
 220   /* The output parameter types.  This is an array of pointers to
 221      struct __go_type_descriptor.  */
 222   struct __go_open_array __out;
 223 };
 224
 225 /* A method on an interface type.  */
 226
 227 struct __go_interface_method
 228 {
 229   /* The name of the method.  */
 230   const struct String *__name;
 231
 232   /* This is NULL for an exported method, or the name of the package
 233      where it lives.  */
 234   const struct String *__pkg_path;
 235
 236   /* The real type of the method.  */
 237   struct __go_type_descriptor *__type;
 238 };
 239
 240 /* An interface type.  */
 241
 242 struct __go_interface_type
 243 {
 244   /* Starts like all other type descriptors.  */
 245   struct __go_type_descriptor __common;
 246
 247   /* Array of __go_interface_method .  The methods are sorted in the
 248      same order that they appear in the definition of the
 249      interface.  */
 250   struct __go_open_array __methods;
 251 };
 252
 253 /* A map type.  */
 254
 255 struct __go_map_type
 256 {
 257   /* Starts like all other type descriptors.  */
 258   struct __go_type_descriptor __common;
 259
 260   /* The map key type.  */
 261   const struct __go_type_descriptor *__key_type;
 262
 263   /* The map value type.  */
 264   const struct __go_type_descriptor *__val_type;
 265 };
 266
 267 /* A pointer type.  */
 268
 269 struct __go_ptr_type
 270 {
 271   /* Starts like all other type descriptors.  */
 272   struct __go_type_descriptor __common;
 273
 274   /* The type to which this points.  */
 275   const struct __go_type_descriptor *__element_type;
 276 };
 277
 278 /* A field in a structure.  */
 279
 280 struct __go_struct_field
 281 {
 282   /* The name of the field--NULL for an anonymous field.  */
 283   const struct String *__name;
 284
 285   /* This is NULL for an exported method, or the name of the package
 286      where it lives.  */
 287   const struct String *__pkg_path;
 288
 289   /* The type of the field.  */
 290   const struct __go_type_descriptor *__type;
 291
 292   /* The field tag, or NULL.  */
 293   const struct String *__tag;
 294
 295   /* The offset of the field in the struct.  */
 296   uintptr_t __offset;
 297 };
 298
 299 /* A struct type.  */
 300
 301 struct __go_struct_type
 302 {
 303   /* Starts like all other type descriptors.  */
 304   struct __go_type_descriptor __common;
 305
 306   /* An array of struct __go_struct_field.  */
 307   struct __go_open_array __fields;
 308 };
 309
 310 /* Whether a type descriptor is a pointer.  */
 311
 312 static inline _Bool
 313 __go_is_pointer_type (const struct __go_type_descriptor *td)
 314 {
 315   return ((td->__code & GO_CODE_MASK) == GO_PTR
 316           || (td->__code & GO_CODE_MASK) == GO_UNSAFE_POINTER);
 317 }
 318
 319 /* Call a type hash function, given the __hashfn value.  */
 320
 321 static inline uintptr_t
 322 __go_call_hashfn (const FuncVal *hashfn, const void *p, uintptr_t size)
 323 {
 324   uintptr_t (*h) (const void *, uintptr_t) = (void *) hashfn->fn;
 325   return __builtin_call_with_static_chain (h (p, size), hashfn);
 326 }
 327
 328 /* Call a type equality function, given the __equalfn value.  */
 329
 330 static inline _Bool
 331 __go_call_equalfn (const FuncVal *equalfn, const void *p1, const void *p2,
 332                    uintptr_t size)
 333 {
 334   _Bool (*e) (const void *, const void *, uintptr_t) = (void *) equalfn->fn;
 335   return __builtin_call_with_static_chain (e (p1, p2, size), equalfn);
 336 }
 337
 338 extern _Bool
 339 __go_type_descriptors_equal(const struct __go_type_descriptor*,
 340                             const struct __go_type_descriptor*);
 341
 342 extern uintptr_t __go_type_hash_identity (const void *, uintptr_t);
 343 extern const FuncVal __go_type_hash_identity_descriptor;
 344 extern _Bool __go_type_equal_identity (const void *, const void *, uintptr_t);
 345 extern const FuncVal __go_type_equal_identity_descriptor;
 346 extern uintptr_t __go_type_hash_string (const void *, uintptr_t);
 347 extern const FuncVal __go_type_hash_string_descriptor;
 348 extern _Bool __go_type_equal_string (const void *, const void *, uintptr_t);
 349 extern const FuncVal __go_type_equal_string_descriptor;
 350 extern uintptr_t __go_type_hash_float (const void *, uintptr_t);
 351 extern const FuncVal __go_type_hash_float_descriptor;
 352 extern _Bool __go_type_equal_float (const void *, const void *, uintptr_t);
 353 extern const FuncVal __go_type_equal_float_descriptor;
 354 extern uintptr_t __go_type_hash_complex (const void *, uintptr_t);
 355 extern const FuncVal __go_type_hash_complex_descriptor;
 356 extern _Bool __go_type_equal_complex (const void *, const void *, uintptr_t);
 357 extern const FuncVal __go_type_equal_complex_descriptor;
 358 extern uintptr_t __go_type_hash_interface (const void *, uintptr_t);
 359 extern const FuncVal __go_type_hash_interface_descriptor;
 360 extern _Bool __go_type_equal_interface (const void *, const void *, uintptr_t);
 361 extern const FuncVal __go_type_equal_interface_descriptor;
 362 extern uintptr_t __go_type_hash_error (const void *, uintptr_t);
 363 extern const FuncVal __go_type_hash_error_descriptor;
 364 extern _Bool __go_type_equal_error (const void *, const void *, uintptr_t);
 365 extern const FuncVal __go_type_equal_error_descriptor;
 366
 367 #endif /* !defined(LIBGO_GO_TYPE_H) */