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 // Decode a non-ASCII rune from a string.
  35 DEF_GO_RUNTIME(DECODERUNE, "runtime.decoderune", P2(STRING, INT),
  36                R2(RUNE, INT))
  37
  38 // Concatenate strings.
  39 DEF_GO_RUNTIME(CONCATSTRINGS, "runtime.concatstrings", P2(POINTER, SLICE),
  40                R1(STRING))
  41 DEF_GO_RUNTIME(CONCATSTRING2, "runtime.concatstring2",
  42                P2(POINTER, ARRAY2STRING), R1(STRING))
  43 DEF_GO_RUNTIME(CONCATSTRING3, "runtime.concatstring3",
  44                P2(POINTER, ARRAY3STRING), R1(STRING))
  45 DEF_GO_RUNTIME(CONCATSTRING4, "runtime.concatstring4",
  46                P2(POINTER, ARRAY4STRING), R1(STRING))
  47 DEF_GO_RUNTIME(CONCATSTRING5, "runtime.concatstring5",
  48                P2(POINTER, ARRAY5STRING), R1(STRING))
  49
  50 // Compare two strings for equality.
  51 DEF_GO_RUNTIME(EQSTRING, "runtime.eqstring", P2(STRING, STRING), R1(BOOL))
  52
  53 // Compare two strings.
  54 DEF_GO_RUNTIME(CMPSTRING, "runtime.cmpstring", P2(STRING, STRING), R1(INT))
  55
  56 // Take a slice of a string.
  57 DEF_GO_RUNTIME(STRING_SLICE, "__go_string_slice", P3(STRING, INT, INT),
  58                R1(STRING))
  59
  60 // Convert an integer to a string.
  61 DEF_GO_RUNTIME(INTSTRING, "runtime.intstring", P2(POINTER, INT64), R1(STRING))
  62
  63 // Convert a []byte to a string.
  64 DEF_GO_RUNTIME(SLICEBYTETOSTRING, "runtime.slicebytetostring",
  65                P2(POINTER, SLICE), R1(STRING))
  66
  67 // Convert a []rune to a string.
  68 DEF_GO_RUNTIME(SLICERUNETOSTRING, "runtime.slicerunetostring",
  69                P2(POINTER, SLICE), R1(STRING))
  70
  71 // Convert a string to a []byte.
  72 DEF_GO_RUNTIME(STRINGTOSLICEBYTE, "runtime.stringtoslicebyte",
  73                P2(POINTER, STRING), R1(SLICE))
  74
  75 // Convert a string to a []rune.
  76 DEF_GO_RUNTIME(STRINGTOSLICERUNE, "runtime.stringtoslicerune",
  77                P2(POINTER, STRING), R1(SLICE))
  78
  79
  80 // Complex division.
  81 DEF_GO_RUNTIME(COMPLEX64_DIV, "__go_complex64_div",
  82                P2(COMPLEX64, COMPLEX64), R1(COMPLEX64))
  83 DEF_GO_RUNTIME(COMPLEX128_DIV, "__go_complex128_div",
  84                P2(COMPLEX128, COMPLEX128), R1(COMPLEX128))
  85
  86 // Make a slice.
  87 DEF_GO_RUNTIME(MAKESLICE, "runtime.makeslice", P3(TYPE, INT, INT),
  88                R1(SLICE))
  89
  90 DEF_GO_RUNTIME(MAKESLICE64, "runtime.makeslice64", P3(TYPE, INT64, INT64),
  91                R1(SLICE))
  92
  93
  94 // Make a map with a hint and an (optional, unused) map structure.
  95 DEF_GO_RUNTIME(MAKEMAP, "runtime.makemap", P3(TYPE, INT, POINTER),
  96                 R1(MAP))
  97 DEF_GO_RUNTIME(MAKEMAP64, "runtime.makemap64", P3(TYPE, INT64, POINTER),
  98                 R1(MAP))
  99
 100 // Make a map with no hint, or a small constant hint.
 101 DEF_GO_RUNTIME(MAKEMAP_SMALL, "runtime.makemap_small", P0(), R1(MAP))
 102
 103 // Build a map from a composite literal.
 104 DEF_GO_RUNTIME(CONSTRUCT_MAP, "__go_construct_map",
 105                P5(POINTER, UINTPTR, UINTPTR, UINTPTR, POINTER),
 106                R1(MAP))
 107
 108 // Look up a key in a map.
 109 DEF_GO_RUNTIME(MAPACCESS1, "runtime.mapaccess1", P3(TYPE, MAP, POINTER),
 110                R1(POINTER))
 111
 112 // Look up a key in a map when the value is large.
 113 DEF_GO_RUNTIME(MAPACCESS1_FAT, "runtime.mapaccess1_fat",
 114                P4(TYPE, MAP, POINTER, POINTER), R1(POINTER))
 115
 116 // Look up a key in a map returning the value and whether it is
 117 // present.
 118 DEF_GO_RUNTIME(MAPACCESS2, "runtime.mapaccess2", P3(TYPE, MAP, POINTER),
 119                R2(POINTER, BOOL))
 120
 121 // Look up a key in a map, returning the value and whether it is
 122 // present, when the value is large.
 123 DEF_GO_RUNTIME(MAPACCESS2_FAT, "runtime.mapaccess2_fat",
 124                P4(TYPE, MAP, POINTER, POINTER), R2(POINTER, BOOL))
 125
 126 // Assignment to a key in a map.
 127 DEF_GO_RUNTIME(MAPASSIGN, "runtime.mapassign", P3(TYPE, MAP, POINTER),
 128                R1(POINTER))
 129
 130 // Delete a key from a map.
 131 DEF_GO_RUNTIME(MAPDELETE, "runtime.mapdelete", P3(TYPE, MAP, POINTER), R0())
 132
 133 // Begin a range over a map.
 134 DEF_GO_RUNTIME(MAPITERINIT, "runtime.mapiterinit", P3(TYPE, MAP, POINTER),
 135                R0())
 136
 137 // Range over a map, moving to the next map entry.
 138 DEF_GO_RUNTIME(MAPITERNEXT, "runtime.mapiternext", P1(POINTER), R0())
 139
 140
 141 // Make a channel.
 142 DEF_GO_RUNTIME(MAKECHAN, "runtime.makechan", P2(TYPE, INT), R1(CHAN))
 143 DEF_GO_RUNTIME(MAKECHAN64, "runtime.makechan64", P2(TYPE, INT64), R1(CHAN))
 144
 145 // Send a value on a channel.
 146 DEF_GO_RUNTIME(CHANSEND, "runtime.chansend1", P2(CHAN, POINTER), R0())
 147
 148 // Receive a value from a channel.
 149 DEF_GO_RUNTIME(CHANRECV1, "runtime.chanrecv1", P2(CHAN, POINTER), R0())
 150
 151 // Receive a value from a channel returning whether it is closed.
 152 DEF_GO_RUNTIME(CHANRECV2, "runtime.chanrecv2", P2(CHAN, POINTER), R1(BOOL))
 153
 154
 155 // Start building a select statement.
 156 DEF_GO_RUNTIME(NEWSELECT, "runtime.newselect", P3(POINTER, INT64, INT32), R0())
 157
 158 // Add a default clause to a select statement.
 159 DEF_GO_RUNTIME(SELECTDEFAULT, "runtime.selectdefault", P1(POINTER), R0())
 160
 161 // Add a send clause to a select statement.
 162 DEF_GO_RUNTIME(SELECTSEND, "runtime.selectsend", P3(POINTER, CHAN, POINTER),
 163                R0())
 164
 165 // Add a receive clause to a select statement.
 166 DEF_GO_RUNTIME(SELECTRECV, "runtime.selectrecv",
 167                P4(POINTER, CHAN, POINTER, BOOLPTR), R0())
 168
 169 // Run a select, returning the index of the selected clause.
 170 DEF_GO_RUNTIME(SELECTGO, "runtime.selectgo", P1(POINTER), R1(INT))
 171
 172
 173 // Panic.
 174 DEF_GO_RUNTIME(GOPANIC, "runtime.gopanic", P1(EFACE), R0())
 175
 176 // Recover.
 177 DEF_GO_RUNTIME(GORECOVER, "runtime.gorecover", P0(), R1(EFACE))
 178
 179 // Recover when called directly from defer.
 180 DEF_GO_RUNTIME(DEFERREDRECOVER, "runtime.deferredrecover", P0(), R1(EFACE))
 181
 182 // Decide whether this function can call recover.
 183 DEF_GO_RUNTIME(CANRECOVER, "runtime.canrecover", P1(POINTER), R1(BOOL))
 184
 185 // Set the return address for defer in a defer thunk.
 186 DEF_GO_RUNTIME(SETDEFERRETADDR, "runtime.setdeferretaddr", P1(POINTER),
 187                R1(BOOL))
 188
 189 // Check for a deferred function in an exception handler.
 190 DEF_GO_RUNTIME(CHECKDEFER, "runtime.checkdefer", P1(BOOLPTR), R0())
 191
 192 // Run deferred functions.
 193 DEF_GO_RUNTIME(DEFERRETURN, "runtime.deferreturn", P1(BOOLPTR), R0())
 194
 195 // Panic with a runtime error.
 196 DEF_GO_RUNTIME(RUNTIME_ERROR, "__go_runtime_error", P1(INT32), R0())
 197
 198
 199 // Close.
 200 DEF_GO_RUNTIME(CLOSE, "runtime.closechan", P1(CHAN), R0())
 201
 202
 203 // Copy.
 204 DEF_GO_RUNTIME(SLICECOPY, "runtime.slicecopy", P3(SLICE, SLICE, UINTPTR),
 205                R1(INT))
 206
 207 // Copy from string.
 208 DEF_GO_RUNTIME(SLICESTRINGCOPY, "runtime.slicestringcopy", P2(SLICE, STRING),
 209                R1(INT))
 210
 211 // Copy of value containing pointers.
 212 DEF_GO_RUNTIME(TYPEDSLICECOPY, "runtime.typedslicecopy",
 213                P3(TYPE, SLICE, SLICE), R1(INT))
 214
 215
 216 // Grow a slice for append.
 217 DEF_GO_RUNTIME(GROWSLICE, "runtime.growslice", P3(TYPE, SLICE, INT), R1(SLICE))
 218
 219
 220 // Register roots (global variables) for the garbage collector.
 221 DEF_GO_RUNTIME(REGISTER_GC_ROOTS, "runtime.registerGCRoots", P1(POINTER), R0())
 222
 223
 224 // Allocate memory.
 225 DEF_GO_RUNTIME(NEW, "runtime.newobject", P1(TYPE), R1(POINTER))
 226
 227 // Start a new goroutine.
 228 DEF_GO_RUNTIME(GO, "__go_go", P2(FUNC_PTR, POINTER), R0())
 229
 230 // Defer a function.
 231 DEF_GO_RUNTIME(DEFERPROC, "runtime.deferproc", P3(BOOLPTR, FUNC_PTR, POINTER),
 232                R0())
 233
 234
 235 // Convert an empty interface to an empty interface, returning ok.
 236 DEF_GO_RUNTIME(IFACEE2E2, "runtime.ifaceE2E2", P1(EFACE), R2(EFACE, BOOL))
 237
 238 // Convert a non-empty interface to an empty interface, returning ok.
 239 DEF_GO_RUNTIME(IFACEI2E2, "runtime.ifaceI2E2", P1(IFACE), R2(EFACE, BOOL))
 240
 241 // Convert an empty interface to a non-empty interface, returning ok.
 242 DEF_GO_RUNTIME(IFACEE2I2, "runtime.ifaceE2I2", P2(TYPE, EFACE),
 243                R2(IFACE, BOOL))
 244
 245 // Convert a non-empty interface to a non-empty interface, returning ok.
 246 DEF_GO_RUNTIME(IFACEI2I2, "runtime.ifaceI2I2", P2(TYPE, IFACE),
 247                R2(IFACE, BOOL))
 248
 249 // Convert an empty interface to a pointer type, returning ok.
 250 DEF_GO_RUNTIME(IFACEE2T2P, "runtime.ifaceE2T2P", P2(TYPE, EFACE),
 251                R2(POINTER, BOOL))
 252
 253 // Convert a non-empty interface to a pointer type, return ok.
 254 DEF_GO_RUNTIME(IFACEI2T2P, "runtime.ifaceI2T2P", P2(TYPE, IFACE),
 255                R2(POINTER, BOOL))
 256
 257 // Convert an empty interface to a non-pointer type, returning ok.
 258 DEF_GO_RUNTIME(IFACEE2T2, "runtime.ifaceE2T2", P3(TYPE, EFACE, POINTER),
 259                R1(BOOL))
 260
 261 // Convert a non-empty interface to a non-pointer type, returning ok.
 262 DEF_GO_RUNTIME(IFACEI2T2, "runtime.ifaceI2T2", P3(TYPE, IFACE, POINTER),
 263                R1(BOOL))
 264
 265 // Return the interface method table for the second type converted to
 266 // the first type which is a (possibly empty) interface type.  Panics
 267 // if the second type is nil (indicating a nil interface value) or if
 268 // the conversion is not possible.  Used for type assertions.  This is
 269 // like REQUIREITAB, but for type assertions.
 270 DEF_GO_RUNTIME(ASSERTITAB, "runtime.assertitab", P2(TYPE, TYPE), R1(POINTER))
 271
 272 // Return the interface method table for the second type converted to
 273 // the first type, which is a non-empty interface type.  Return nil if
 274 // the second type is nil, indicating a nil interface value.  Panics
 275 // if the conversion is not possible.  Used for assignments.  This is
 276 // like ASSERTITAB, but for assignments.
 277 DEF_GO_RUNTIME(REQUIREITAB, "runtime.requireitab", P2(TYPE, TYPE),
 278                R1(POINTER))
 279
 280 // Check whether an interface type may be converted to a
 281 // non-interface type.
 282 DEF_GO_RUNTIME(ASSERTI2T, "runtime.assertI2T", P3(TYPE, TYPE, TYPE), R0())
 283
 284 // Return whether we can convert a type to an interface type.
 285 DEF_GO_RUNTIME(IFACET2IP, "runtime.ifaceT2Ip", 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(EFACEEQ, "runtime.efaceeq", P2(EFACE, EFACE), R1(BOOL))
 299
 300 // Compare an empty interface value to a non-interface value.
 301 DEF_GO_RUNTIME(EFACEVALEQ, "runtime.efacevaleq", P3(EFACE, TYPE, POINTER),
 302                R1(BOOL))
 303
 304 // Compare two non-empty interface values.
 305 DEF_GO_RUNTIME(IFACEEQ, "runtime.ifaceeq", P2(IFACE, IFACE), R1(BOOL))
 306
 307 // Compare a non-empty interface value to a non-interface value.
 308 DEF_GO_RUNTIME(IFACEVALEQ, "runtime.ifacevaleq", P3(IFACE, TYPE, POINTER),
 309                R1(BOOL))
 310
 311 // Compare a non-empty interface value to an interface value.
 312 DEF_GO_RUNTIME(IFACEEFACEEQ, "runtime.ifaceefaceeq", P2(IFACE, EFACE),
 313                R1(BOOL))
 314
 315
 316 // Set *dst = src where dst is a pointer to a pointer and src is a pointer.
 317 DEF_GO_RUNTIME(WRITEBARRIERPTR, "runtime.writebarrierptr",
 318                P2(POINTER, POINTER), R0())
 319
 320 // Set *dst = *src for an arbitrary type.
 321 DEF_GO_RUNTIME(TYPEDMEMMOVE, "runtime.typedmemmove",
 322                P3(TYPE, POINTER, POINTER), R0())
 323
 324
 325 // Lock the printer (for print/println).
 326 DEF_GO_RUNTIME(PRINTLOCK, "runtime.printlock", P0(), R0())
 327
 328 // Unlock the printer (for print/println).
 329 DEF_GO_RUNTIME(PRINTUNLOCK, "runtime.printunlock", P0(), R0())
 330
 331 // Print a string (for print/println).
 332 DEF_GO_RUNTIME(PRINTSTRING, "runtime.printstring", P1(STRING), R0())
 333
 334 // Print a uint64 (for print/println).
 335 DEF_GO_RUNTIME(PRINTUINT, "runtime.printuint", P1(UINT64), R0())
 336
 337 // Print a int64 (for print/println).
 338 DEF_GO_RUNTIME(PRINTINT, "runtime.printint", P1(INT64), R0())
 339
 340 // Print a float64 (for print/println).
 341 DEF_GO_RUNTIME(PRINTFLOAT, "runtime.printfloat", P1(FLOAT64), R0())
 342
 343 // Print a complex128 (for print/println).
 344 DEF_GO_RUNTIME(PRINTCOMPLEX, "runtime.printcomplex", P1(COMPLEX128), R0())
 345
 346 // Print a bool (for print/println).
 347 DEF_GO_RUNTIME(PRINTBOOL, "runtime.printbool", P1(BOOL), R0())
 348
 349 // Print a pointer/map/channel/function (for print/println).
 350 DEF_GO_RUNTIME(PRINTPOINTER, "runtime.printpointer", P1(POINTER), R0())
 351
 352 // Print an empty interface (for print/println).
 353 DEF_GO_RUNTIME(PRINTEFACE, "runtime.printeface", P1(EFACE), R0())
 354
 355 // Print a non-empty interface (for print/println).
 356 DEF_GO_RUNTIME(PRINTIFACE, "runtime.printiface", P1(IFACE), R0())
 357
 358 // Print a slice (for print/println).
 359 DEF_GO_RUNTIME(PRINTSLICE, "runtime.printslice", P1(SLICE), R0())
 360
 361 // Print a space (for println).
 362 DEF_GO_RUNTIME(PRINTSP, "runtime.printsp", P0(), R0())
 363
 364 // Print a newline (for println).
 365 DEF_GO_RUNTIME(PRINTNL, "runtime.printnl", P0(), R0())
 366
 367
 368 // Used for field tracking for data analysis.
 369 DEF_GO_RUNTIME(FIELDTRACK, "__go_fieldtrack", P1(POINTER), R0())
 370
 371
 372 // Unreachable code.
 373 DEF_GO_RUNTIME(UNREACHABLE, "__builtin_unreachable", P0(), R0())
 374
 375 // Remove helper macros.
 376 #undef ABFT6
 377 #undef ABFT2
 378 #undef P0
 379 #undef P1
 380 #undef P2
 381 #undef P3
 382 #undef P4
 383 #undef P5
 384 #undef P6
 385 #undef R0
 386 #undef R1
 387 #undef R2