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_NO_POINTERS (1 << 7)
  58
  59 #define GO_CODE_MASK 0x7f
  60
  61 /* For each Go type the compiler constructs one of these structures.
  62    This is used for type reflectin, interfaces, maps, and reference
  63    counting.  */
  64
  65 struct __go_type_descriptor
  66 {
  67   /* The type code for this type, one of the type kind values above.
  68      This is used by unsafe.Reflect and unsafe.Typeof to determine the
  69      type descriptor to return for this type itself.  It is also used
  70      by reflect.toType when mapping to a reflect Type structure.  */
  71   unsigned char __code;
  72
  73   /* The alignment in bytes of a variable with this type.  */
  74   unsigned char __align;
  75
  76   /* The alignment in bytes of a struct field with this type.  */
  77   unsigned char __field_align;
  78
  79   /* The size in bytes of a value of this type.  Note that all types
  80      in Go have a fixed size.  */
  81   uintptr_t __size;
  82
  83   /* The type's hash code.  */
  84   uint32_t __hash;
  85
  86   /* This function takes a pointer to a value of this type, and the
  87      size of this type, and returns a hash code.  We pass the size
  88      explicitly becaues it means that we can share a single instance
  89      of this function for various different types.  */
  90   uintptr_t (*__hashfn) (const void *, uintptr_t);
  91
  92   /* This function takes two pointers to values of this type, and the
  93      size of this type, and returns whether the values are equal.  */
  94   _Bool (*__equalfn) (const void *, const void *, uintptr_t);
  95
  96   /* A string describing this type.  This is only used for
  97      debugging.  */
  98   const struct String *__reflection;
  99
 100   /* A pointer to fields which are only used for some types.  */
 101   const struct __go_uncommon_type *__uncommon;
 102
 103   /* The descriptor for the type which is a pointer to this type.
 104      This may be NULL.  */
 105   const struct __go_type_descriptor *__pointer_to_this;
 106 };
 107
 108 /* The information we store for each method of a type.  */
 109
 110 struct __go_method
 111 {
 112   /* The name of the method.  */
 113   const struct String *__name;
 114
 115   /* This is NULL for an exported method, or the name of the package
 116      where it lives.  */
 117   const struct String *__pkg_path;
 118
 119   /* The type of the method, without the receiver.  This will be a
 120      function type.  */
 121   const struct __go_type_descriptor *__mtype;
 122
 123   /* The type of the method, with the receiver.  This will be a
 124      function type.  */
 125   const struct __go_type_descriptor *__type;
 126
 127   /* A pointer to the code which implements the method.  This is
 128      really a function pointer.  */
 129   const void *__function;
 130 };
 131
 132 /* Additional information that we keep for named types and for types
 133    with methods.  */
 134
 135 struct __go_uncommon_type
 136 {
 137   /* The name of the type.  */
 138   const struct String *__name;
 139
 140   /* The type's package.  This is NULL for builtin types.  */
 141   const struct String *__pkg_path;
 142
 143   /* The type's methods.  This is an array of struct __go_method.  */
 144   struct __go_open_array __methods;
 145 };
 146
 147 /* The type descriptor for a fixed array type.  */
 148
 149 struct __go_array_type
 150 {
 151   /* Starts like all type descriptors.  */
 152   struct __go_type_descriptor __common;
 153
 154   /* The element type.  */
 155   struct __go_type_descriptor *__element_type;
 156
 157   /* The type of a slice of the same element type.  */
 158   struct __go_type_descriptor *__slice_type;
 159
 160   /* The length of the array.  */
 161   uintptr_t __len;
 162 };
 163
 164 /* The type descriptor for a slice.  */
 165
 166 struct __go_slice_type
 167 {
 168   /* Starts like all other type descriptors.  */
 169   struct __go_type_descriptor __common;
 170
 171   /* The element type.  */
 172   struct __go_type_descriptor *__element_type;
 173 };
 174
 175 /* The direction of a channel.  */
 176 #define CHANNEL_RECV_DIR 1
 177 #define CHANNEL_SEND_DIR 2
 178 #define CHANNEL_BOTH_DIR (CHANNEL_RECV_DIR | CHANNEL_SEND_DIR)
 179
 180 /* The type descriptor for a channel.  */
 181
 182 struct __go_channel_type
 183 {
 184   /* Starts like all other type descriptors.  */
 185   struct __go_type_descriptor __common;
 186
 187   /* The element type.  */
 188   const struct __go_type_descriptor *__element_type;
 189
 190   /* The direction.  */
 191   uintptr_t __dir;
 192 };
 193
 194 /* The type descriptor for a function.  */
 195
 196 struct __go_func_type
 197 {
 198   /* Starts like all other type descriptors.  */
 199   struct __go_type_descriptor __common;
 200
 201   /* Whether this is a varargs function.  If this is true, there will
 202      be at least one parameter.  For "..." the last parameter type is
 203      "interface{}".  For "... T" the last parameter type is "[]T".  */
 204   _Bool __dotdotdot;
 205
 206   /* The input parameter types.  This is an array of pointers to
 207      struct __go_type_descriptor.  */
 208   struct __go_open_array __in;
 209
 210   /* The output parameter types.  This is an array of pointers to
 211      struct __go_type_descriptor.  */
 212   struct __go_open_array __out;
 213 };
 214
 215 /* A method on an interface type.  */
 216
 217 struct __go_interface_method
 218 {
 219   /* The name of the method.  */
 220   const struct String *__name;
 221
 222   /* This is NULL for an exported method, or the name of the package
 223      where it lives.  */
 224   const struct String *__pkg_path;
 225
 226   /* The real type of the method.  */
 227   struct __go_type_descriptor *__type;
 228 };
 229
 230 /* An interface type.  */
 231
 232 struct __go_interface_type
 233 {
 234   /* Starts like all other type descriptors.  */
 235   struct __go_type_descriptor __common;
 236
 237   /* Array of __go_interface_method .  The methods are sorted in the
 238      same order that they appear in the definition of the
 239      interface.  */
 240   struct __go_open_array __methods;
 241 };
 242
 243 /* A map type.  */
 244
 245 struct __go_map_type
 246 {
 247   /* Starts like all other type descriptors.  */
 248   struct __go_type_descriptor __common;
 249
 250   /* The map key type.  */
 251   const struct __go_type_descriptor *__key_type;
 252
 253   /* The map value type.  */
 254   const struct __go_type_descriptor *__val_type;
 255 };
 256
 257 /* A pointer type.  */
 258
 259 struct __go_ptr_type
 260 {
 261   /* Starts like all other type descriptors.  */
 262   struct __go_type_descriptor __common;
 263
 264   /* The type to which this points.  */
 265   const struct __go_type_descriptor *__element_type;
 266 };
 267
 268 /* A field in a structure.  */
 269
 270 struct __go_struct_field
 271 {
 272   /* The name of the field--NULL for an anonymous field.  */
 273   const struct String *__name;
 274
 275   /* This is NULL for an exported method, or the name of the package
 276      where it lives.  */
 277   const struct String *__pkg_path;
 278
 279   /* The type of the field.  */
 280   const struct __go_type_descriptor *__type;
 281
 282   /* The field tag, or NULL.  */
 283   const struct String *__tag;
 284
 285   /* The offset of the field in the struct.  */
 286   uintptr_t __offset;
 287 };
 288
 289 /* A struct type.  */
 290
 291 struct __go_struct_type
 292 {
 293   /* Starts like all other type descriptors.  */
 294   struct __go_type_descriptor __common;
 295
 296   /* An array of struct __go_struct_field.  */
 297   struct __go_open_array __fields;
 298 };
 299
 300 /* If an empty interface has these bits set in its type pointer, it
 301    was copied from a reflect.Value and is not a valid empty
 302    interface.  */
 303
 304 enum
 305 {
 306   reflectFlags = 3,
 307 };
 308
 309 /* Whether a type descriptor is a pointer.  */
 310
 311 static inline _Bool
 312 __go_is_pointer_type (const struct __go_type_descriptor *td)
 313 {
 314   return td->__code == GO_PTR || td->__code == GO_UNSAFE_POINTER;
 315 }
 316
 317 extern _Bool
 318 __go_type_descriptors_equal(const struct __go_type_descriptor*,
 319                             const struct __go_type_descriptor*);
 320
 321 extern uintptr_t __go_type_hash_identity (const void *, uintptr_t);
 322 extern _Bool __go_type_equal_identity (const void *, const void *, uintptr_t);
 323 extern uintptr_t __go_type_hash_string (const void *, uintptr_t);
 324 extern _Bool __go_type_equal_string (const void *, const void *, uintptr_t);
 325 extern uintptr_t __go_type_hash_float (const void *, uintptr_t);
 326 extern _Bool __go_type_equal_float (const void *, const void *, uintptr_t);
 327 extern uintptr_t __go_type_hash_complex (const void *, uintptr_t);
 328 extern _Bool __go_type_equal_complex (const void *, const void *, uintptr_t);
 329 extern uintptr_t __go_type_hash_interface (const void *, uintptr_t);
 330 extern _Bool __go_type_equal_interface (const void *, const void *, uintptr_t);
 331 extern uintptr_t __go_type_hash_error (const void *, uintptr_t);
 332 extern _Bool __go_type_equal_error (const void *, const void *, uintptr_t);
 333
 334 #endif /* !defined(LIBGO_GO_TYPE_H) */