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 size in bytes of a value of this type.  Note that all types
  70      in Go have a fixed size.  */
  71   uintptr_t __size;
  72
  73   /* The size of the memory prefix of a value of this type that holds
  74      all pointers.  */
  75   uintptr_t __ptrdata;
  76
  77   /* The type's hash code.  */
  78   uint32_t __hash;
  79
  80   /* The type code for this type, one of the type kind values above.
  81      This is used by unsafe.Reflect and unsafe.Typeof to determine the
  82      type descriptor to return for this type itself.  It is also used
  83      by reflect.toType when mapping to a reflect Type structure.  */
  84   unsigned char __code;
  85
  86   /* The alignment in bytes of a variable with this type.  */
  87   unsigned char __align;
  88
  89   /* The alignment in bytes of a struct field with this type.  */
  90   unsigned char __field_align;
  91
  92   /* This function takes a pointer to a value of this type, and the
  93      size of this type, and returns a hash code.  We pass the size
  94      explicitly becaues it means that we can share a single instance
  95      of this function for various different types.  */
  96   const FuncVal *__hashfn;
  97
  98   /* This function takes two pointers to values of this type, and the
  99      size of this type, and returns whether the values are equal.  */
 100   const FuncVal *__equalfn;
 101
 102   /* The garbage collection data. */
 103   const byte *__gcdata;
 104
 105   /* A string describing this type.  This is only used for
 106      debugging.  */
 107   const struct String *__reflection;
 108
 109   /* A pointer to fields which are only used for some types.  */
 110   const struct __go_uncommon_type *__uncommon;
 111
 112   /* The descriptor for the type which is a pointer to this type.
 113      This may be NULL.  */
 114   const struct __go_type_descriptor *__pointer_to_this;
 115 };
 116
 117 /* The information we store for each method of a type.  */
 118
 119 struct __go_method
 120 {
 121   /* The name of the method.  */
 122   const struct String *__name;
 123
 124   /* This is NULL for an exported method, or the name of the package
 125      where it lives.  */
 126   const struct String *__pkg_path;
 127
 128   /* The type of the method, without the receiver.  This will be a
 129      function type.  */
 130   const struct __go_type_descriptor *__mtype;
 131
 132   /* The type of the method, with the receiver.  This will be a
 133      function type.  */
 134   const struct __go_type_descriptor *__type;
 135
 136   /* A pointer to the code which implements the method.  This is
 137      really a function pointer.  */
 138   const void *__function;
 139 };
 140
 141 /* Additional information that we keep for named types and for types
 142    with methods.  */
 143
 144 struct __go_uncommon_type
 145 {
 146   /* The name of the type.  */
 147   const struct String *__name;
 148
 149   /* The type's package.  This is NULL for builtin types.  */
 150   const struct String *__pkg_path;
 151
 152   /* The type's methods.  This is an array of struct __go_method.  */
 153   struct __go_open_array __methods;
 154 };
 155
 156 /* The type descriptor for a fixed array type.  */
 157
 158 struct __go_array_type
 159 {
 160   /* Starts like all type descriptors.  */
 161   struct __go_type_descriptor __common;
 162
 163   /* The element type.  */
 164   struct __go_type_descriptor *__element_type;
 165
 166   /* The type of a slice of the same element type.  */
 167   struct __go_type_descriptor *__slice_type;
 168
 169   /* The length of the array.  */
 170   uintptr_t __len;
 171 };
 172
 173 /* The type descriptor for a slice.  */
 174
 175 struct __go_slice_type
 176 {
 177   /* Starts like all other type descriptors.  */
 178   struct __go_type_descriptor __common;
 179
 180   /* The element type.  */
 181   struct __go_type_descriptor *__element_type;
 182 };
 183
 184 /* The direction of a channel.  */
 185 #define CHANNEL_RECV_DIR 1
 186 #define CHANNEL_SEND_DIR 2
 187 #define CHANNEL_BOTH_DIR (CHANNEL_RECV_DIR | CHANNEL_SEND_DIR)
 188
 189 /* The type descriptor for a channel.  */
 190
 191 struct __go_channel_type
 192 {
 193   /* Starts like all other type descriptors.  */
 194   struct __go_type_descriptor __common;
 195
 196   /* The element type.  */
 197   const struct __go_type_descriptor *__element_type;
 198
 199   /* The direction.  */
 200   uintptr_t __dir;
 201 };
 202
 203 /* The type descriptor for a function.  */
 204
 205 struct __go_func_type
 206 {
 207   /* Starts like all other type descriptors.  */
 208   struct __go_type_descriptor __common;
 209
 210   /* Whether this is a varargs function.  If this is true, there will
 211      be at least one parameter.  For "..." the last parameter type is
 212      "interface{}".  For "... T" the last parameter type is "[]T".  */
 213   _Bool __dotdotdot;
 214
 215   /* The input parameter types.  This is an array of pointers to
 216      struct __go_type_descriptor.  */
 217   struct __go_open_array __in;
 218
 219   /* The output parameter types.  This is an array of pointers to
 220      struct __go_type_descriptor.  */
 221   struct __go_open_array __out;
 222 };
 223
 224 /* A method on an interface type.  */
 225
 226 struct __go_interface_method
 227 {
 228   /* The name of the method.  */
 229   const struct String *__name;
 230
 231   /* This is NULL for an exported method, or the name of the package
 232      where it lives.  */
 233   const struct String *__pkg_path;
 234
 235   /* The real type of the method.  */
 236   struct __go_type_descriptor *__type;
 237 };
 238
 239 /* An interface type.  */
 240
 241 struct __go_interface_type
 242 {
 243   /* Starts like all other type descriptors.  */
 244   struct __go_type_descriptor __common;
 245
 246   /* Array of __go_interface_method .  The methods are sorted in the
 247      same order that they appear in the definition of the
 248      interface.  */
 249   struct __go_open_array __methods;
 250 };
 251
 252 /* A map type.  */
 253
 254 struct __go_map_type
 255 {
 256   /* Starts like all other type descriptors.  */
 257   struct __go_type_descriptor __common;
 258
 259   /* The map key type.  */
 260   const struct __go_type_descriptor *__key_type;
 261
 262   /* The map value type.  */
 263   const struct __go_type_descriptor *__val_type;
 264
 265   /* The map bucket type.  */
 266   const struct __go_type_descriptor *__bucket_type;
 267
 268   /* The map header type.  */
 269   const struct __go_type_descriptor *__hmap_type;
 270
 271   /* The size of the key slot.  */
 272   uint8_t __key_size;
 273
 274   /* Whether to store a pointer to key rather than the key itself.  */
 275   uint8_t __indirect_key;
 276
 277   /* The size of the value slot.  */
 278   uint8_t __value_size;
 279
 280   /* Whether to store a pointer to value rather than the value itself.  */
 281   uint8_t __indirect_value;
 282
 283   /* The size of a bucket.  */
 284   uint16_t __bucket_size;
 285
 286   /* Whether the key type is reflexive--whether k==k for all keys.  */
 287   _Bool __reflexive_key;
 288
 289   /* Whether we should update the key when overwriting an entry.  */
 290   _Bool __need_key_update;
 291 };
 292
 293 /* A pointer type.  */
 294
 295 struct __go_ptr_type
 296 {
 297   /* Starts like all other type descriptors.  */
 298   struct __go_type_descriptor __common;
 299
 300   /* The type to which this points.  */
 301   const struct __go_type_descriptor *__element_type;
 302 };
 303
 304 /* A field in a structure.  */
 305
 306 struct __go_struct_field
 307 {
 308   /* The name of the field--NULL for an anonymous field.  */
 309   const struct String *__name;
 310
 311   /* This is NULL for an exported method, or the name of the package
 312      where it lives.  */
 313   const struct String *__pkg_path;
 314
 315   /* The type of the field.  */
 316   const struct __go_type_descriptor *__type;
 317
 318   /* The field tag, or NULL.  */
 319   const struct String *__tag;
 320
 321   /* The offset of the field in the struct.  */
 322   uintptr_t __offset;
 323 };
 324
 325 /* A struct type.  */
 326
 327 struct __go_struct_type
 328 {
 329   /* Starts like all other type descriptors.  */
 330   struct __go_type_descriptor __common;
 331
 332   /* An array of struct __go_struct_field.  */
 333   struct __go_open_array __fields;
 334 };
 335
 336 /* Whether a type descriptor is a pointer.  */
 337
 338 static inline _Bool
 339 __go_is_pointer_type (const struct __go_type_descriptor *td)
 340 {
 341   return ((td->__code & GO_CODE_MASK) == GO_PTR
 342           || (td->__code & GO_CODE_MASK) == GO_UNSAFE_POINTER);
 343 }
 344
 345 /* Call a type hash function, given the __hashfn value.  */
 346
 347 static inline uintptr_t
 348 __go_call_hashfn (const FuncVal *hashfn, const void *p, uintptr_t seed,
 349                   uintptr_t size)
 350 {
 351   uintptr_t (*h) (const void *, uintptr_t, uintptr_t) = (void *) hashfn->fn;
 352   return __builtin_call_with_static_chain (h (p, seed, size), hashfn);
 353 }
 354
 355 /* Call a type equality function, given the __equalfn value.  */
 356
 357 static inline _Bool
 358 __go_call_equalfn (const FuncVal *equalfn, const void *p1, const void *p2,
 359                    uintptr_t size)
 360 {
 361   _Bool (*e) (const void *, const void *, uintptr_t) = (void *) equalfn->fn;
 362   return __builtin_call_with_static_chain (e (p1, p2, size), equalfn);
 363 }
 364
 365 extern _Bool
 366 __go_type_descriptors_equal(const struct __go_type_descriptor*,
 367                             const struct __go_type_descriptor*);
 368
 369 #endif /* !defined(LIBGO_GO_TYPE_H) */