gcc/go/gofrontend/runtime.def

   1 // runtime.def -- runtime functions called by generated code.  -*- C++ -*-
   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 // Definitions for the Go runtime functions.
   8
   9 // Parameter type helper macros.
  10 #define ABFT6(T1, T2, T3, T4, T5, T6) \
  11   { RFT_ ## T1, RFT_ ## T2, RFT_ ## T3, RFT_ ## T4, RFT_ ## T5, RFT_ ## T6 }
  12 #define P0()                    ABFT6(VOID, VOID, VOID, VOID, VOID, VOID)
  13 #define P1(T)                   ABFT6(T, VOID, VOID, VOID, VOID, VOID)
  14 #define P2(T1, T2)              ABFT6(T1, T2, VOID, VOID, VOID, VOID)
  15 #define P3(T1, T2, T3)          ABFT6(T1, T2, T3, VOID, VOID, VOID)
  16 #define P4(T1, T2, T3, T4)      ABFT6(T1, T2, T3, T4, VOID, VOID)
  17 #define P5(T1, T2, T3, T4, T5)  ABFT6(T1, T2, T3, T4, T5, VOID)
  18 #define P6(T1,T2,T3,T4,T5,T6)   ABFT6(T1, T2, T3, T4, T5, T6)
  19
  20 // Result type helper macros.
  21 #define ABFT2(T1, T2) { RFT_ ## T1, RFT_ ## T2 }
  22 #define R0()                    ABFT2(VOID, VOID)
  23 #define R1(T)                   ABFT2(T, VOID)
  24 #define R2(T1, T2)              ABFT2(T1, T2)
  25
  26 // Define all the Go runtime functions.  The first parameter is the
  27 // enum code used to refer to the function.  The second parameter is
  28 // the name.  The third is the parameter types and the fourth is the
  29 // result types.
  30
  31 // The standard C memcmp function, used for struct comparisons.
  32 DEF_GO_RUNTIME(MEMCMP, "__go_memcmp", P3(POINTER, POINTER, UINTPTR), R1(INT))
  33
  34 // Range over a string, returning the next index.
  35 DEF_GO_RUNTIME(STRINGITER, "runtime.stringiter", P2(STRING, INT), R1(INT))
  36
  37 // Range over a string, returning the next index and character.
  38 DEF_GO_RUNTIME(STRINGITER2, "runtime.stringiter2", P2(STRING, INT),
  39                R2(INT, RUNE))
  40
  41 // Concatenate two strings.
  42 DEF_GO_RUNTIME(STRING_PLUS, "__go_string_plus", P2(STRING, STRING), R1(STRING))
  43
  44 // Compare two strings.
  45 DEF_GO_RUNTIME(STRCMP, "__go_strcmp", P2(STRING, STRING), R1(INT))
  46
  47 // Take a slice of a string.
  48 DEF_GO_RUNTIME(STRING_SLICE, "__go_string_slice", P3(STRING, INT, INT),
  49                R1(STRING))
  50
  51 // Convert an integer to a string.
  52 DEF_GO_RUNTIME(INT_TO_STRING, "__go_int_to_string", P1(INT), R1(STRING))
  53
  54 // Convert a byte array to a string.
  55 DEF_GO_RUNTIME(BYTE_ARRAY_TO_STRING, "__go_byte_array_to_string",
  56                P2(POINTER, INT), R1(STRING))
  57
  58 // Convert an int array to a string.
  59 DEF_GO_RUNTIME(INT_ARRAY_TO_STRING, "__go_int_array_to_string",
  60                P2(POINTER, INT), R1(STRING))
  61
  62 // Convert a string to a byte slice.
  63 DEF_GO_RUNTIME(STRING_TO_BYTE_ARRAY, "__go_string_to_byte_array",
  64                P1(STRING), R1(SLICE))
  65
  66 // Convert a string to an int slice.
  67 DEF_GO_RUNTIME(STRING_TO_INT_ARRAY, "__go_string_to_int_array",
  68                P1(STRING), R1(SLICE))
  69
  70
  71 // Make a slice.
  72 DEF_GO_RUNTIME(MAKESLICE1, "__go_make_slice1", P2(TYPE, UINTPTR), R1(SLICE))
  73 DEF_GO_RUNTIME(MAKESLICE2, "__go_make_slice2", P3(TYPE, UINTPTR, UINTPTR),
  74                R1(SLICE))
  75 DEF_GO_RUNTIME(MAKESLICE1BIG, "__go_make_slice1_big", P2(TYPE, UINT64),
  76                R1(SLICE))
  77 DEF_GO_RUNTIME(MAKESLICE2BIG, "__go_make_slice2_big", P3(TYPE, UINT64, UINT64),
  78                R1(SLICE))
  79
  80
  81 // Make a map.
  82 DEF_GO_RUNTIME(MAKEMAP, "__go_new_map", P2(MAPDESCRIPTOR, UINTPTR), R1(MAP))
  83 DEF_GO_RUNTIME(MAKEMAPBIG, "__go_new_map_big", P2(MAPDESCRIPTOR, UINT64),
  84                R1(MAP))
  85
  86 // Build a map from a composite literal.
  87 DEF_GO_RUNTIME(CONSTRUCT_MAP, "__go_construct_map",
  88                P6(POINTER, UINTPTR, UINTPTR, UINTPTR, UINTPTR, POINTER),
  89                R1(MAP))
  90
  91 // Get the length of a map (the number of entries).
  92 DEF_GO_RUNTIME(MAP_LEN, "__go_map_len", P1(MAP), R1(INT))
  93
  94 // Look up a key in a map.
  95 DEF_GO_RUNTIME(MAP_INDEX, "__go_map_index", P3(MAP, POINTER, BOOL),
  96                R1(POINTER))
  97
  98 // Look up a key in a map returning whether it is present.
  99 DEF_GO_RUNTIME(MAPACCESS2, "runtime.mapaccess2",
 100                P4(TYPE, MAP, POINTER, POINTER), R1(BOOL))
 101
 102 // Tuple assignment to a map element.
 103 DEF_GO_RUNTIME(MAPASSIGN2, "runtime.mapassign2",
 104                P4(MAP, POINTER, POINTER, BOOL), R0())
 105
 106 // Delete a key from a map.
 107 DEF_GO_RUNTIME(MAPDELETE, "runtime.mapdelete", P2(MAP, POINTER), R0())
 108
 109 // Begin a range over a map.
 110 DEF_GO_RUNTIME(MAPITERINIT, "runtime.mapiterinit", P2(MAP, MAPITER), R0())
 111
 112 // Range over a map, returning the next key.
 113 DEF_GO_RUNTIME(MAPITER1, "runtime.mapiter1", P2(MAPITER, POINTER), R0())
 114
 115 // Range over a map, returning the next key and value.
 116 DEF_GO_RUNTIME(MAPITER2, "runtime.mapiter2", P3(MAPITER, POINTER, POINTER),
 117                R0())
 118
 119 // Range over a map, moving to the next map entry.
 120 DEF_GO_RUNTIME(MAPITERNEXT, "runtime.mapiternext", P1(MAPITER), R0())
 121
 122
 123 // Make a channel.
 124 DEF_GO_RUNTIME(MAKECHAN, "__go_new_channel", P2(TYPE, UINTPTR), R1(CHAN))
 125 DEF_GO_RUNTIME(MAKECHANBIG, "__go_new_channel_big", P2(TYPE, UINT64), R1(CHAN))
 126
 127 // Get the length of a channel (the number of unread values).
 128 DEF_GO_RUNTIME(CHAN_LEN, "__go_chan_len", P1(CHAN), R1(INT))
 129
 130 // Get the capacity of a channel (the size of the buffer).
 131 DEF_GO_RUNTIME(CHAN_CAP, "__go_chan_cap", P1(CHAN), R1(INT))
 132
 133 // Send a small value on a channel.
 134 DEF_GO_RUNTIME(SEND_SMALL, "__go_send_small", P3(TYPE, CHAN, UINT64), R0())
 135
 136 // Send a big value on a channel.
 137 DEF_GO_RUNTIME(SEND_BIG, "__go_send_big", P3(TYPE, CHAN, POINTER), R0())
 138
 139 // Receive a small value from a channel.
 140 DEF_GO_RUNTIME(RECEIVE_SMALL, "__go_receive_small", P2(TYPE, CHAN), R1(UINT64))
 141
 142 // Receive a big value from a channel.
 143 DEF_GO_RUNTIME(RECEIVE_BIG, "__go_receive_big", P3(TYPE, CHAN, POINTER), R0())
 144
 145 // Receive a value from a channel returning whether it is closed.
 146 DEF_GO_RUNTIME(CHANRECV2, "runtime.chanrecv2", P3(TYPE, CHAN, POINTER),
 147                R1(BOOL))
 148
 149
 150 // Start building a select statement.
 151 DEF_GO_RUNTIME(NEWSELECT, "runtime.newselect", P1(INT32), R1(POINTER))
 152
 153 // Add a default clause to a select statement.
 154 DEF_GO_RUNTIME(SELECTDEFAULT, "runtime.selectdefault",
 155                P2(POINTER, INT32), R0())
 156
 157 // Add a send clause to a select statement.
 158 DEF_GO_RUNTIME(SELECTSEND, "runtime.selectsend",
 159                P4(POINTER, CHAN, POINTER, INT32), R0())
 160
 161 // Add a receive clause to a select statement, for a clause which does
 162 // not check whether the channel is closed.
 163 DEF_GO_RUNTIME(SELECTRECV, "runtime.selectrecv",
 164                P4(POINTER, CHAN, POINTER, INT32), R0())
 165
 166 // Add a receive clause to a select statement, for a clause which does
 167 // check whether the channel is closed.
 168 DEF_GO_RUNTIME(SELECTRECV2, "runtime.selectrecv2",
 169                P5(POINTER, CHAN, POINTER, BOOLPTR, INT32), R0())
 170
 171 // Run a select, returning the index of the selected clause.
 172 DEF_GO_RUNTIME(SELECTGO, "runtime.selectgo", P1(POINTER), R1(INT32))
 173
 174
 175 // Panic.
 176 DEF_GO_RUNTIME(PANIC, "__go_panic", P1(EFACE), R0())
 177
 178 // Recover.
 179 DEF_GO_RUNTIME(RECOVER, "__go_recover", P0(), R1(EFACE))
 180
 181 // Recover when called directly from defer.
 182 DEF_GO_RUNTIME(DEFERRED_RECOVER, "__go_deferred_recover", P0(), R1(EFACE))
 183
 184 // Decide whether this function can call recover.
 185 DEF_GO_RUNTIME(CAN_RECOVER, "__go_can_recover", P1(POINTER), R1(BOOL))
 186
 187 // Get the return address of the function.
 188 DEF_GO_RUNTIME(RETURN_ADDRESS, "__go_return_address", P1(INT), R1(POINTER))
 189
 190 // Set the return address for defer in a defer thunk.
 191 DEF_GO_RUNTIME(SET_DEFER_RETADDR, "__go_set_defer_retaddr", P1(POINTER),
 192                R1(BOOL))
 193
 194 // Check for a deferred function in an exception handler.
 195 DEF_GO_RUNTIME(CHECK_DEFER, "__go_check_defer", P1(BOOLPTR), R0())
 196
 197 // Run deferred functions.
 198 DEF_GO_RUNTIME(UNDEFER, "__go_undefer", P1(BOOLPTR), R0())
 199
 200 // Panic with a runtime error.
 201 DEF_GO_RUNTIME(RUNTIME_ERROR, "__go_runtime_error", P1(INT32), R0())
 202
 203
 204 // Close.
 205 DEF_GO_RUNTIME(CLOSE, "__go_close", P1(CHAN), R0())
 206
 207
 208 // Copy.
 209 DEF_GO_RUNTIME(COPY, "__go_copy", P3(POINTER, POINTER, UINTPTR), R0())
 210
 211 // Append.
 212 DEF_GO_RUNTIME(APPEND, "__go_append", P4(SLICE, POINTER, UINTPTR, UINTPTR),
 213                R1(SLICE))
 214
 215
 216 // Register roots (global variables) for the garbage collector.
 217 DEF_GO_RUNTIME(REGISTER_GC_ROOTS, "__go_register_gc_roots", P1(POINTER), R0())
 218
 219
 220 // Allocate memory.
 221 DEF_GO_RUNTIME(NEW, "__go_new", P1(UINTPTR), R1(POINTER))
 222
 223 // Allocate memory which can not contain pointers.
 224 DEF_GO_RUNTIME(NEW_NOPOINTERS, "__go_new_nopointers", P1(UINTPTR), R1(POINTER))
 225
 226
 227 // Allocate a trampoline for a function literal.
 228 DEF_GO_RUNTIME(ALLOCATE_GO_TRAMPOLINE, "__go_allocate_trampoline",
 229                P2(UINTPTR, POINTER), R1(POINTER))
 230
 231
 232 // Start a new goroutine.
 233 DEF_GO_RUNTIME(GO, "__go_go", P2(FUNC_PTR, POINTER), R0())
 234
 235
 236 // Defer a function.
 237 DEF_GO_RUNTIME(DEFER, "__go_defer", P3(BOOLPTR, FUNC_PTR, POINTER), R0())
 238
 239
 240 // Convert an empty interface to an empty interface, returning ok.
 241 DEF_GO_RUNTIME(IFACEE2E2, "runtime.ifaceE2E2", P1(EFACE), R2(EFACE, BOOL))
 242
 243 // Convert a non-empty interface to an empty interface, returning ok.
 244 DEF_GO_RUNTIME(IFACEI2E2, "runtime.ifaceI2E2", P1(IFACE), R2(EFACE, BOOL))
 245
 246 // Convert an empty interface to a non-empty interface, returning ok.
 247 DEF_GO_RUNTIME(IFACEE2I2, "runtime.ifaceE2I2", P2(TYPE, EFACE),
 248                R2(IFACE, BOOL))
 249
 250 // Convert a non-empty interface to a non-empty interface, returning ok.
 251 DEF_GO_RUNTIME(IFACEI2I2, "runtime.ifaceI2I2", P2(TYPE, IFACE),
 252                R2(IFACE, BOOL))
 253
 254 // Convert an empty interface to a pointer type, returning ok.
 255 DEF_GO_RUNTIME(IFACEE2T2P, "runtime.ifaceE2T2P", P2(TYPE, EFACE),
 256                R2(POINTER, BOOL))
 257
 258 // Convert a non-empty interface to a pointer type, return ok.
 259 DEF_GO_RUNTIME(IFACEI2T2P, "runtime.ifaceI2T2P", P2(TYPE, IFACE),
 260                R2(POINTER, BOOL))
 261
 262 // Convert an empty interface to a non-pointer type, returning ok.
 263 DEF_GO_RUNTIME(IFACEE2T2, "runtime.ifaceE2T2", P3(TYPE, EFACE, POINTER),
 264                R1(BOOL))
 265
 266 // Convert a non-empty interface to a non-pointer type, returning ok.
 267 DEF_GO_RUNTIME(IFACEI2T2, "runtime.ifaceI2T2", P3(TYPE, IFACE, POINTER),
 268                R1(BOOL))
 269
 270 // A type assertion from one interface type to another.  This is
 271 // used for a type assertion.
 272 DEF_GO_RUNTIME(ASSERT_INTERFACE, "__go_assert_interface", P2(TYPE, TYPE), R0())
 273
 274 // Convert one interface type to another.  This is used for an
 275 // assignment.
 276 DEF_GO_RUNTIME(CONVERT_INTERFACE, "__go_convert_interface", P2(TYPE, TYPE),
 277                R1(POINTER))
 278
 279 // Check whether an interface type may be converted to a
 280 // non-interface type.
 281 DEF_GO_RUNTIME(CHECK_INTERFACE_TYPE, "__go_check_interface_type",
 282                P3(TYPE, TYPE, TYPE), R0())
 283
 284 // Return whether we can convert an interface type to a type.
 285 DEF_GO_RUNTIME(IFACEI2TP, "runtime.ifaceI2Tp", P2(TYPE, TYPE), R1(BOOL))
 286
 287 // Get the type descriptor of an empty interface.
 288 DEF_GO_RUNTIME(EFACETYPE, "runtime.efacetype", P1(EFACE), R1(TYPE))
 289
 290 // Get the type descriptor of a non-empty interface.
 291 DEF_GO_RUNTIME(IFACETYPE, "runtime.ifacetype", P1(IFACE), R1(TYPE))
 292
 293
 294 // Compare two type descriptors for equality.
 295 DEF_GO_RUNTIME(IFACETYPEEQ, "runtime.ifacetypeeq", P2(TYPE, TYPE), R1(BOOL))
 296
 297 // Compare two empty interface values.
 298 DEF_GO_RUNTIME(EMPTY_INTERFACE_COMPARE, "__go_empty_interface_compare",
 299                P2(EFACE, EFACE), R1(INT))
 300
 301 // Compare an empty interface value to a non-interface value.
 302 DEF_GO_RUNTIME(EMPTY_INTERFACE_VALUE_COMPARE,
 303                "__go_empty_interface_value_compare",
 304                P3(EFACE, TYPE, POINTER), R1(INT))
 305
 306 // Compare two non-empty interface values.
 307 DEF_GO_RUNTIME(INTERFACE_COMPARE, "__go_interface_compare",
 308                P2(IFACE, IFACE), R1(INT))
 309
 310 // Compare a non-empty interface value to a non-interface value.
 311 DEF_GO_RUNTIME(INTERFACE_VALUE_COMPARE, "__go_interface_value_compare",
 312                P3(IFACE, TYPE, POINTER), R1(INT))
 313
 314 // Compare a non-empty interface value to an interface value.
 315 DEF_GO_RUNTIME(INTERFACE_EMPTY_COMPARE, "__go_interface_empty_compare",
 316                P2(IFACE, EFACE), R1(INT))
 317
 318
 319 // Print a string (for print/println).
 320 DEF_GO_RUNTIME(PRINT_STRING, "__go_print_string", P1(STRING), R0())
 321
 322 // Print a uint64 (for print/println).
 323 DEF_GO_RUNTIME(PRINT_UINT64, "__go_print_uint64", P1(UINT64), R0())
 324
 325 // Print a int64 (for print/println).
 326 DEF_GO_RUNTIME(PRINT_INT64, "__go_print_int64", P1(INT64), R0())
 327
 328 // Print a float64 (for print/println).
 329 DEF_GO_RUNTIME(PRINT_DOUBLE, "__go_print_double", P1(FLOAT64), R0())
 330
 331 // Print a complex128 (for print/println).
 332 DEF_GO_RUNTIME(PRINT_COMPLEX, "__go_print_complex", P1(COMPLEX128), R0())
 333
 334 // Print a bool (for print/println).
 335 DEF_GO_RUNTIME(PRINT_BOOL, "__go_print_bool", P1(BOOL), R0())
 336
 337 // Print a pointer/map/channel/function (for print/println).
 338 DEF_GO_RUNTIME(PRINT_POINTER, "__go_print_pointer", P1(POINTER), R0())
 339
 340 // Print an empty interface (for print/println).
 341 DEF_GO_RUNTIME(PRINT_EMPTY_INTERFACE, "__go_print_empty_interface",
 342                P1(EFACE), R0())
 343
 344 // Print a non-empty interface (for print/println).
 345 DEF_GO_RUNTIME(PRINT_INTERFACE, "__go_print_interface", P1(IFACE), R0())
 346
 347 // Print a slice (for print/println).
 348 DEF_GO_RUNTIME(PRINT_SLICE, "__go_print_slice", P1(SLICE), R0())
 349
 350 // Print a space (for println).
 351 DEF_GO_RUNTIME(PRINT_SPACE, "__go_print_space", P0(), R0())
 352
 353 // Print a newline (for println).
 354 DEF_GO_RUNTIME(PRINT_NL, "__go_print_nl", P0(), R0())
 355
 356
 357 // Remove helper macros.
 358 #undef ABFT6
 359 #undef ABFT2
 360 #undef P0
 361 #undef P1
 362 #undef P2
 363 #undef P3
 364 #undef P4
 365 #undef P5
 366 #undef P6
 367 #undef R0
 368 #undef R1
 369 #undef R2