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, "__builtin_memcmp", P3(POINTER, POINTER, UINTPTR), R1(INT32))
  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",
  40                P3(POINTER, POINTER, INT), R1(STRING))
  41
  42 // Compare two strings.
  43 DEF_GO_RUNTIME(CMPSTRING, "runtime.cmpstring", P2(STRING, STRING), R1(INT))
  44
  45 // Convert an integer to a string.
  46 DEF_GO_RUNTIME(INTSTRING, "runtime.intstring", P2(POINTER, INT64), R1(STRING))
  47
  48 // Convert a []byte to a string.
  49 DEF_GO_RUNTIME(SLICEBYTETOSTRING, "runtime.slicebytetostring",
  50                P3(POINTER, POINTER, INT), R1(STRING))
  51
  52 // Convert a []rune to a string.
  53 DEF_GO_RUNTIME(SLICERUNETOSTRING, "runtime.slicerunetostring",
  54                P2(POINTER, SLICE), R1(STRING))
  55
  56 // Convert a string to a []byte.
  57 DEF_GO_RUNTIME(STRINGTOSLICEBYTE, "runtime.stringtoslicebyte",
  58                P2(POINTER, STRING), R1(SLICE))
  59
  60 // Convert a string to a []rune.
  61 DEF_GO_RUNTIME(STRINGTOSLICERUNE, "runtime.stringtoslicerune",
  62                P2(POINTER, STRING), R1(SLICE))
  63
  64
  65 // Make a slice.
  66 DEF_GO_RUNTIME(MAKESLICE, "runtime.makeslice", P3(TYPE, INT, INT),
  67                R1(POINTER))
  68
  69 DEF_GO_RUNTIME(MAKESLICE64, "runtime.makeslice64", P3(TYPE, INT64, INT64),
  70                R1(POINTER))
  71
  72
  73 // Make a map with a hint and an (optional, unused) map structure.
  74 DEF_GO_RUNTIME(MAKEMAP, "runtime.makemap", P3(TYPE, INT, POINTER),
  75                 R1(MAP))
  76 DEF_GO_RUNTIME(MAKEMAP64, "runtime.makemap64", P3(TYPE, INT64, POINTER),
  77                 R1(MAP))
  78
  79 // Make a map with no hint, or a small constant hint.
  80 DEF_GO_RUNTIME(MAKEMAP_SMALL, "runtime.makemap__small", P0(), R1(MAP))
  81
  82 // Build a map from a composite literal.
  83 DEF_GO_RUNTIME(CONSTRUCT_MAP, "__go_construct_map",
  84                P5(POINTER, UINTPTR, UINTPTR, UINTPTR, POINTER),
  85                R1(MAP))
  86
  87 // Look up a key in a map.
  88 DEF_GO_RUNTIME(MAPACCESS1, "runtime.mapaccess1", P3(TYPE, MAP, POINTER),
  89                R1(POINTER))
  90
  91 // Look up a uint32 key in a map.
  92 DEF_GO_RUNTIME(MAPACCESS1_FAST32, "runtime.mapaccess1__fast32",
  93                P3(TYPE, MAP, UINT32), R1(POINTER))
  94
  95 // Look up a uint64 key in a map.
  96 DEF_GO_RUNTIME(MAPACCESS1_FAST64, "runtime.mapaccess1__fast64",
  97                P3(TYPE, MAP, UINT64), R1(POINTER))
  98
  99 // Look up a string key in a map.
 100 DEF_GO_RUNTIME(MAPACCESS1_FASTSTR, "runtime.mapaccess1__faststr",
 101                P3(TYPE, MAP, STRING), R1(POINTER))
 102
 103 // Look up a key in a map when the value is large.
 104 DEF_GO_RUNTIME(MAPACCESS1_FAT, "runtime.mapaccess1__fat",
 105                P4(TYPE, MAP, POINTER, POINTER), R1(POINTER))
 106
 107 // Look up a key in a map returning the value and whether it is
 108 // present.
 109 DEF_GO_RUNTIME(MAPACCESS2, "runtime.mapaccess2", P3(TYPE, MAP, POINTER),
 110                R2(POINTER, BOOL))
 111
 112 // Look up a uint32 key in a map returning the value and whether
 113 // it is present.
 114 DEF_GO_RUNTIME(MAPACCESS2_FAST32, "runtime.mapaccess2__fast32",
 115                P3(TYPE, MAP, UINT32), R2(POINTER, BOOL))
 116
 117 // Look up a uint64 key in a map returning the value and whether
 118 // it is present.
 119 DEF_GO_RUNTIME(MAPACCESS2_FAST64, "runtime.mapaccess2__fast64",
 120                P3(TYPE, MAP, UINT64), R2(POINTER, BOOL))
 121
 122 // Look up a string key in a map returning the value and whether
 123 // it is present.
 124 DEF_GO_RUNTIME(MAPACCESS2_FASTSTR, "runtime.mapaccess2__faststr",
 125                P3(TYPE, MAP, STRING), R2(POINTER, BOOL))
 126
 127 // Look up a key in a map, returning the value and whether it is
 128 // present, when the value is large.
 129 DEF_GO_RUNTIME(MAPACCESS2_FAT, "runtime.mapaccess2__fat",
 130                P4(TYPE, MAP, POINTER, POINTER), R2(POINTER, BOOL))
 131
 132 // Assignment to a key in a map.
 133 DEF_GO_RUNTIME(MAPASSIGN, "runtime.mapassign", P3(TYPE, MAP, POINTER),
 134                R1(POINTER))
 135
 136 // Assignment to a uint32 key in a map.
 137 DEF_GO_RUNTIME(MAPASSIGN_FAST32, "runtime.mapassign__fast32",
 138                P3(TYPE, MAP, UINT32), R1(POINTER))
 139
 140 // Assignment to a uint64 key in a map.
 141 DEF_GO_RUNTIME(MAPASSIGN_FAST64, "runtime.mapassign__fast64",
 142                P3(TYPE, MAP, UINT64), R1(POINTER))
 143
 144 // Assignment to a 32-bit pointer key in a map.
 145 DEF_GO_RUNTIME(MAPASSIGN_FAST32PTR, "runtime.mapassign__fast32ptr",
 146                P3(TYPE, MAP, POINTER), R1(POINTER))
 147
 148 // Assignment to a 64-bit pointer key in a map.
 149 DEF_GO_RUNTIME(MAPASSIGN_FAST64PTR, "runtime.mapassign__fast64ptr",
 150                P3(TYPE, MAP, POINTER), R1(POINTER))
 151
 152 // Assignment to a string key in a map.
 153 DEF_GO_RUNTIME(MAPASSIGN_FASTSTR, "runtime.mapassign__faststr",
 154                P3(TYPE, MAP, STRING), R1(POINTER))
 155
 156 // Delete a key from a map.
 157 DEF_GO_RUNTIME(MAPDELETE, "runtime.mapdelete", P3(TYPE, MAP, POINTER), R0())
 158
 159 // Delete a uint32 key from a map.
 160 DEF_GO_RUNTIME(MAPDELETE_FAST32, "runtime.mapdelete__fast32",
 161                P3(TYPE, MAP, UINT32), R0())
 162
 163 // Delete a uint64 key from a map.
 164 DEF_GO_RUNTIME(MAPDELETE_FAST64, "runtime.mapdelete__fast64",
 165                P3(TYPE, MAP, UINT64), R0())
 166
 167 // Delete a string key from a map.
 168 DEF_GO_RUNTIME(MAPDELETE_FASTSTR, "runtime.mapdelete__faststr",
 169                P3(TYPE, MAP, STRING), R0())
 170
 171 // Begin a range over a map.
 172 DEF_GO_RUNTIME(MAPITERINIT, "runtime.mapiterinit", P3(TYPE, MAP, POINTER),
 173                R0())
 174
 175 // Range over a map, moving to the next map entry.
 176 DEF_GO_RUNTIME(MAPITERNEXT, "runtime.mapiternext", P1(POINTER), R0())
 177
 178 // Clear a map.
 179 DEF_GO_RUNTIME(MAPCLEAR, "runtime.mapclear", P2(TYPE, MAP), R0())
 180
 181
 182 // Make a channel.
 183 DEF_GO_RUNTIME(MAKECHAN, "runtime.makechan", P2(TYPE, INT), R1(CHAN))
 184 DEF_GO_RUNTIME(MAKECHAN64, "runtime.makechan64", P2(TYPE, INT64), R1(CHAN))
 185
 186 // Send a value on a channel.
 187 DEF_GO_RUNTIME(CHANSEND, "runtime.chansend1", P2(CHAN, POINTER), R0())
 188
 189 // Receive a value from a channel.
 190 DEF_GO_RUNTIME(CHANRECV1, "runtime.chanrecv1", P2(CHAN, POINTER), R0())
 191
 192 // Receive a value from a channel returning whether it is closed.
 193 DEF_GO_RUNTIME(CHANRECV2, "runtime.chanrecv2", P2(CHAN, POINTER), R1(BOOL))
 194
 195
 196 // Run a select, returning the index of the selected clause and
 197 // whether that channel received a value.
 198 DEF_GO_RUNTIME(SELECTGO, "runtime.selectgo",
 199                P5(POINTER, POINTER, INT, INT, BOOL), R2(INT, BOOL))
 200
 201 // Non-blocking send a value on a channel, used for two-case select
 202 // statement with a default case.
 203 DEF_GO_RUNTIME(SELECTNBSEND, "runtime.selectnbsend", P2(CHAN, POINTER), R1(BOOL))
 204
 205 // Non-blocking receive a value from a channel, used for two-case select
 206 // statement with a default case.
 207 DEF_GO_RUNTIME(SELECTNBRECV, "runtime.selectnbrecv", P2(POINTER, CHAN), R1(BOOL))
 208
 209 // Non-blocking tuple receive from a channel, used for two-case select
 210 // statement with a default case.
 211 DEF_GO_RUNTIME(SELECTNBRECV2, "runtime.selectnbrecv2", P3(POINTER, POINTER, CHAN),
 212                R1(BOOL))
 213
 214 // Block execution.  Used for zero-case select.
 215 DEF_GO_RUNTIME(BLOCK, "runtime.block", P0(), R0())
 216
 217
 218 // Panic.
 219 DEF_GO_RUNTIME(GOPANIC, "runtime.gopanic", P1(EFACE), R0())
 220
 221 // Recover.
 222 DEF_GO_RUNTIME(GORECOVER, "runtime.gorecover", P0(), R1(EFACE))
 223
 224 // Recover when called directly from defer.
 225 DEF_GO_RUNTIME(DEFERREDRECOVER, "runtime.deferredrecover", P0(), R1(EFACE))
 226
 227 // Decide whether this function can call recover.
 228 DEF_GO_RUNTIME(CANRECOVER, "runtime.canrecover", P1(UINTPTR), R1(BOOL))
 229
 230 // Set the return address for defer in a defer thunk.
 231 DEF_GO_RUNTIME(SETDEFERRETADDR, "runtime.setdeferretaddr", P1(UINTPTR),
 232                R1(BOOL))
 233
 234 // Check for a deferred function in an exception handler.
 235 DEF_GO_RUNTIME(CHECKDEFER, "runtime.checkdefer", P1(BOOLPTR), R0())
 236
 237 // Run deferred functions.
 238 DEF_GO_RUNTIME(DEFERRETURN, "runtime.deferreturn", P1(BOOLPTR), R0())
 239
 240
 241 // Close.
 242 DEF_GO_RUNTIME(CLOSE, "runtime.closechan", P1(CHAN), R0())
 243
 244
 245 // Copy.
 246 DEF_GO_RUNTIME(SLICECOPY, "runtime.slicecopy",
 247                P5(POINTER, INT, POINTER, INT, UINTPTR), R1(INT))
 248
 249 // Copy from string.
 250 DEF_GO_RUNTIME(SLICESTRINGCOPY, "runtime.slicestringcopy",
 251                P3(POINTER, INT, STRING), R1(INT))
 252
 253 // Copy of value containing pointers.
 254 DEF_GO_RUNTIME(TYPEDSLICECOPY, "runtime.typedslicecopy",
 255                P5(TYPE, POINTER, INT, POINTER, INT), R1(INT))
 256
 257 // Grow a slice for append.
 258 DEF_GO_RUNTIME(GROWSLICE, "runtime.growslice",
 259                P5(TYPE, POINTER, INT, INT, INT), R1(SLICE))
 260
 261
 262 // Check the length and cap passed to make, without making a slice.
 263 // This is used for apend(s, make([]T, len)...).
 264 DEF_GO_RUNTIME(CHECK_MAKE_SLICE, "runtime.checkMakeSlice", P3(TYPE, INT, INT),
 265                R1(UINTPTR))
 266
 267 // Register roots (global variables) for the garbage collector.
 268 DEF_GO_RUNTIME(REGISTER_GC_ROOTS, "runtime.registerGCRoots", P1(POINTER), R0())
 269
 270 // Register type descriptors.
 271 DEF_GO_RUNTIME(REGISTER_TYPE_DESCRIPTORS, "runtime.registerTypeDescriptors",
 272                P2(INT, POINTER), R0())
 273
 274
 275 // Allocate memory.
 276 DEF_GO_RUNTIME(NEW, "runtime.newobject", P1(TYPE), R1(POINTER))
 277
 278 // Start a new goroutine.
 279 DEF_GO_RUNTIME(GO, "__go_go", P2(UINTPTR, POINTER), R1(POINTER))
 280
 281 // Defer a function.
 282 DEF_GO_RUNTIME(DEFERPROC, "runtime.deferproc", P3(BOOLPTR, UINTPTR, POINTER),
 283                R0())
 284
 285 // Defer a function, with stack-allocated defer structure.
 286 DEF_GO_RUNTIME(DEFERPROCSTACK, "runtime.deferprocStack",
 287                P4(POINTER, BOOLPTR, UINTPTR, POINTER), R0())
 288
 289
 290 // Convert an empty interface to an empty interface, returning ok.
 291 DEF_GO_RUNTIME(IFACEE2E2, "runtime.ifaceE2E2", P1(EFACE), R2(EFACE, BOOL))
 292
 293 // Convert a non-empty interface to an empty interface, returning ok.
 294 DEF_GO_RUNTIME(IFACEI2E2, "runtime.ifaceI2E2", P1(IFACE), R2(EFACE, BOOL))
 295
 296 // Convert an empty interface to a non-empty interface, returning ok.
 297 DEF_GO_RUNTIME(IFACEE2I2, "runtime.ifaceE2I2", P2(TYPE, EFACE),
 298                R2(IFACE, BOOL))
 299
 300 // Convert a non-empty interface to a non-empty interface, returning ok.
 301 DEF_GO_RUNTIME(IFACEI2I2, "runtime.ifaceI2I2", P2(TYPE, IFACE),
 302                R2(IFACE, BOOL))
 303
 304 // Convert an empty interface to a pointer type, returning ok.
 305 DEF_GO_RUNTIME(IFACEE2T2P, "runtime.ifaceE2T2P", P2(TYPE, EFACE),
 306                R2(POINTER, BOOL))
 307
 308 // Convert a non-empty interface to a pointer type, return ok.
 309 DEF_GO_RUNTIME(IFACEI2T2P, "runtime.ifaceI2T2P", P2(TYPE, IFACE),
 310                R2(POINTER, BOOL))
 311
 312 // Convert an empty interface to a non-pointer type, returning ok.
 313 DEF_GO_RUNTIME(IFACEE2T2, "runtime.ifaceE2T2", P3(TYPE, EFACE, POINTER),
 314                R1(BOOL))
 315
 316 // Convert a non-empty interface to a non-pointer type, returning ok.
 317 DEF_GO_RUNTIME(IFACEI2T2, "runtime.ifaceI2T2", P3(TYPE, IFACE, POINTER),
 318                R1(BOOL))
 319
 320 // Return the interface method table for the second type converted to
 321 // the first type which is a (possibly empty) interface type.  Panics
 322 // if the second type is nil (indicating a nil interface value) or if
 323 // the conversion is not possible.  Used for type assertions.  This is
 324 // like REQUIREITAB, but for type assertions.
 325 DEF_GO_RUNTIME(ASSERTITAB, "runtime.assertitab", P2(TYPE, TYPE), R1(POINTER))
 326
 327 // Return the interface method table for the second type converted to
 328 // the first type, which is a non-empty interface type.  Return nil if
 329 // the second type is nil, indicating a nil interface value.  Panics
 330 // if the conversion is not possible.  Used for assignments.  This is
 331 // like ASSERTITAB, but for assignments.
 332 DEF_GO_RUNTIME(REQUIREITAB, "runtime.requireitab", P2(TYPE, TYPE),
 333                R1(POINTER))
 334
 335 // Panic when an interface type to non-interface type conversion fails.
 336 DEF_GO_RUNTIME(PANICDOTTYPE, "runtime.panicdottype", P3(TYPE, TYPE, TYPE),
 337                R0())
 338
 339 // Return whether we can convert a type to an interface type.
 340 DEF_GO_RUNTIME(IFACET2IP, "runtime.ifaceT2Ip", P2(TYPE, TYPE), R1(BOOL))
 341
 342 // Compare two type descriptors for equality.
 343 DEF_GO_RUNTIME(EQTYPE, "runtime.eqtype", P2(TYPE, TYPE), R1(BOOL))
 344
 345 // Compare two empty interface values.
 346 DEF_GO_RUNTIME(EFACEEQ, "runtime.efaceeq", P2(EFACE, EFACE), R1(BOOL))
 347
 348 // Compare an empty interface value to a non-interface value.
 349 DEF_GO_RUNTIME(EFACEVALEQ, "runtime.efacevaleq", P3(EFACE, TYPE, POINTER),
 350                R1(BOOL))
 351
 352 // Compare two non-empty interface values.
 353 DEF_GO_RUNTIME(IFACEEQ, "runtime.ifaceeq", P2(IFACE, IFACE), R1(BOOL))
 354
 355 // Compare a non-empty interface value to a non-interface value.
 356 DEF_GO_RUNTIME(IFACEVALEQ, "runtime.ifacevaleq", P3(IFACE, TYPE, POINTER),
 357                R1(BOOL))
 358
 359 // Compare a non-empty interface value to an interface value.
 360 DEF_GO_RUNTIME(IFACEEFACEEQ, "runtime.ifaceefaceeq", P2(IFACE, EFACE),
 361                R1(BOOL))
 362
 363
 364 // Set *dst = src where dst is a pointer to a pointer and src is a pointer.
 365 DEF_GO_RUNTIME(GCWRITEBARRIER, "runtime.gcWriteBarrier",
 366                P2(POINTER, UINTPTR), R0())
 367
 368 // Set *dst = *src for an arbitrary type.
 369 DEF_GO_RUNTIME(TYPEDMEMMOVE, "runtime.typedmemmove",
 370                P3(TYPE, POINTER, POINTER), R0())
 371
 372 // Clear memory that contains pointer.
 373 DEF_GO_RUNTIME(MEMCLRHASPTR, "runtime.memclrHasPointers",
 374                P2(POINTER, UINTPTR), R0())
 375
 376
 377 // Lock the printer (for print/println).
 378 DEF_GO_RUNTIME(PRINTLOCK, "runtime.printlock", P0(), R0())
 379
 380 // Unlock the printer (for print/println).
 381 DEF_GO_RUNTIME(PRINTUNLOCK, "runtime.printunlock", P0(), R0())
 382
 383 // Print a string (for print/println).
 384 DEF_GO_RUNTIME(PRINTSTRING, "runtime.printstring", P1(STRING), R0())
 385
 386 // Print a uint64 (for print/println).
 387 DEF_GO_RUNTIME(PRINTUINT, "runtime.printuint", P1(UINT64), R0())
 388
 389 // Print a uint64 in hex (for print/println, used for runtime.hex type).
 390 DEF_GO_RUNTIME(PRINTHEX, "runtime.printhex", P1(UINT64), R0())
 391
 392 // Print a int64 (for print/println).
 393 DEF_GO_RUNTIME(PRINTINT, "runtime.printint", P1(INT64), R0())
 394
 395 // Print a float64 (for print/println).
 396 DEF_GO_RUNTIME(PRINTFLOAT, "runtime.printfloat", P1(FLOAT64), R0())
 397
 398 // Print a complex128 (for print/println).
 399 DEF_GO_RUNTIME(PRINTCOMPLEX, "runtime.printcomplex", P1(COMPLEX128), R0())
 400
 401 // Print a bool (for print/println).
 402 DEF_GO_RUNTIME(PRINTBOOL, "runtime.printbool", P1(BOOL), R0())
 403
 404 // Print a pointer/map/channel/function (for print/println).
 405 DEF_GO_RUNTIME(PRINTPOINTER, "runtime.printpointer", P1(POINTER), R0())
 406
 407 // Print an empty interface (for print/println).
 408 DEF_GO_RUNTIME(PRINTEFACE, "runtime.printeface", P1(EFACE), R0())
 409
 410 // Print a non-empty interface (for print/println).
 411 DEF_GO_RUNTIME(PRINTIFACE, "runtime.printiface", P1(IFACE), R0())
 412
 413 // Print a slice (for print/println).
 414 DEF_GO_RUNTIME(PRINTSLICE, "runtime.printslice", P1(SLICE), R0())
 415
 416 // Print a space (for println).
 417 DEF_GO_RUNTIME(PRINTSP, "runtime.printsp", P0(), R0())
 418
 419 // Print a newline (for println).
 420 DEF_GO_RUNTIME(PRINTNL, "runtime.printnl", P0(), R0())
 421
 422
 423 // Used for field tracking for data analysis.
 424 DEF_GO_RUNTIME(FIELDTRACK, "__go_fieldtrack", P1(POINTER), R0())
 425
 426
 427 // Unreachable code.
 428 DEF_GO_RUNTIME(UNREACHABLE, "__builtin_unreachable", P0(), R0())
 429
 430 // Memmove.
 431 DEF_GO_RUNTIME(BUILTIN_MEMMOVE, "__builtin_memmove",
 432                P3(POINTER, POINTER, UINTPTR), R0())
 433
 434 // Memset, used for zeroing memory.
 435 DEF_GO_RUNTIME(BUILTIN_MEMSET, "__builtin_memset",
 436                P3(POINTER, INT32, UINTPTR), R0())
 437
 438 // Various intrinsics.
 439
 440 // Get the caller's PC, used for runtime.getcallerpc.
 441 DEF_GO_RUNTIME(BUILTIN_RETURN_ADDRESS, "__builtin_return_address",
 442                P1(UINT32), R1(POINTER))
 443
 444 // Get the caller's SP, used for runtime.getcallersp.
 445 DEF_GO_RUNTIME(BUILTIN_DWARF_CFA, "__builtin_dwarf_cfa", P0(),
 446                R1(POINTER))
 447
 448 // Swap bytes.
 449 DEF_GO_RUNTIME(BUILTIN_BSWAP16, "__builtin_bswap16", P1(UINT16),
 450                R1(UINT16))
 451 DEF_GO_RUNTIME(BUILTIN_BSWAP32, "__builtin_bswap32", P1(UINT32),
 452                R1(UINT32))
 453 DEF_GO_RUNTIME(BUILTIN_BSWAP64, "__builtin_bswap64", P1(UINT64),
 454                R1(UINT64))
 455
 456 // Count trailing zeros.
 457 DEF_GO_RUNTIME(BUILTIN_CTZ, "__builtin_ctz", P1(UINT32), R1(INT32))
 458 DEF_GO_RUNTIME(BUILTIN_CTZLL, "__builtin_ctzll", P1(UINT64), R1(INT32))
 459
 460 // Count leading zeros.
 461 DEF_GO_RUNTIME(BUILTIN_CLZ, "__builtin_clz", P1(UINT32), R1(INT32))
 462 DEF_GO_RUNTIME(BUILTIN_CLZLL, "__builtin_clzll", P1(UINT64), R1(INT32))
 463
 464 // Count one bits.
 465 DEF_GO_RUNTIME(BUILTIN_POPCOUNT, "__builtin_popcount", P1(UINT32), R1(INT32))
 466 DEF_GO_RUNTIME(BUILTIN_POPCOUNTLL, "__builtin_popcountll", P1(UINT64), R1(INT32))
 467
 468 // Atomics.
 469 DEF_GO_RUNTIME(ATOMIC_LOAD_4, "__atomic_load_4", P2(POINTER, INT32),
 470                R1(UINT32))
 471 DEF_GO_RUNTIME(ATOMIC_LOAD_8, "__atomic_load_8", P2(POINTER, INT32),
 472                R1(UINT64))
 473 DEF_GO_RUNTIME(ATOMIC_STORE_4, "__atomic_store_4", P3(POINTER, UINT32, INT32),
 474                R0())
 475 DEF_GO_RUNTIME(ATOMIC_STORE_8, "__atomic_store_8", P3(POINTER, UINT64, INT32),
 476                R0())
 477 DEF_GO_RUNTIME(ATOMIC_EXCHANGE_4, "__atomic_exchange_4", P3(POINTER, UINT32, INT32),
 478                R1(UINT32))
 479 DEF_GO_RUNTIME(ATOMIC_EXCHANGE_8, "__atomic_exchange_8", P3(POINTER, UINT64, INT32),
 480                R1(UINT64))
 481 DEF_GO_RUNTIME(ATOMIC_COMPARE_EXCHANGE_4, "__atomic_compare_exchange_4",
 482                P6(POINTER, POINTER, UINT32, BOOL, INT32, INT32),
 483                R1(BOOL))
 484 DEF_GO_RUNTIME(ATOMIC_COMPARE_EXCHANGE_8, "__atomic_compare_exchange_8",
 485                P6(POINTER, POINTER, UINT64, BOOL, INT32, INT32),
 486                R1(BOOL))
 487 DEF_GO_RUNTIME(ATOMIC_ADD_FETCH_4, "__atomic_add_fetch_4",
 488                P3(POINTER, UINT32, INT32),
 489                R1(UINT32))
 490 DEF_GO_RUNTIME(ATOMIC_ADD_FETCH_8, "__atomic_add_fetch_8",
 491                P3(POINTER, UINT64, INT32),
 492                R1(UINT64))
 493 DEF_GO_RUNTIME(ATOMIC_AND_FETCH_1, "__atomic_and_fetch_1",
 494                P3(POINTER, UINT8, INT32),
 495                R1(UINT8))
 496 DEF_GO_RUNTIME(ATOMIC_OR_FETCH_1, "__atomic_or_fetch_1",
 497                P3(POINTER, UINT8, INT32),
 498                R1(UINT8))
 499
 500 // Panic reporting a division by zero.
 501 DEF_GO_RUNTIME(PANIC_DIVIDE, "runtime.panicdivide", P0(), R0())
 502
 503 // Panic reporting a shift by negative count.
 504 DEF_GO_RUNTIME(PANIC_SHIFT, "runtime.panicshift", P0(), R0())
 505
 506 // Panic reporting a nil dereference.
 507 DEF_GO_RUNTIME(PANIC_MEM, "runtime.panicmem", P0(), R0())
 508
 509 // Panic reporting that make's slice len argument is out of range.
 510 DEF_GO_RUNTIME(PANIC_MAKE_SLICE_LEN, "runtime.panicmakeslicelen", P0(), R0())
 511
 512 // Panic reporting that make's slice cap argument is out of range.
 513 DEF_GO_RUNTIME(PANIC_MAKE_SLICE_CAP, "runtime.panicmakeslicecap", P0(), R0())
 514
 515 // Panic reporting using go with a nil function.
 516 DEF_GO_RUNTIME(PANIC_GO_NIL, "runtime.panicgonil", P0(), R0())
 517
 518 // Panics reporting an index or slice out of bounds error.
 519 DEF_GO_RUNTIME(PANIC_INDEX, "runtime.goPanicIndex",
 520                P2(INT, INT), R0())
 521 DEF_GO_RUNTIME(PANIC_INDEX_U, "runtime.goPanicIndexU",
 522                P2(UINT, INT), R0())
 523 DEF_GO_RUNTIME(PANIC_SLICE_ALEN, "runtime.goPanicSliceAlen",
 524                P2(INT, INT), R0())
 525 DEF_GO_RUNTIME(PANIC_SLICE_ALEN_U, "runtime.goPanicSliceAlenU",
 526                P2(UINT, INT), R0())
 527 DEF_GO_RUNTIME(PANIC_SLICE_ACAP, "runtime.goPanicSliceAcap",
 528                P2(INT, INT), R0())
 529 DEF_GO_RUNTIME(PANIC_SLICE_ACAP_U, "runtime.goPanicSliceAcapU",
 530                P2(UINT, INT), R0())
 531 DEF_GO_RUNTIME(PANIC_SLICE_B, "runtime.goPanicSliceB",
 532                P2(INT, INT), R0())
 533 DEF_GO_RUNTIME(PANIC_SLICE_B_U, "runtime.goPanicSliceBU",
 534                P2(UINT, INT), R0())
 535 DEF_GO_RUNTIME(PANIC_SLICE3_ALEN, "runtime.goPanicSlice3Alen",
 536                P2(INT, INT), R0())
 537 DEF_GO_RUNTIME(PANIC_SLICE3_ALEN_U, "runtime.goPanicSlice3AlenU",
 538                P2(UINT, INT), R0())
 539 DEF_GO_RUNTIME(PANIC_SLICE3_ACAP, "runtime.goPanicSlice3Acap",
 540                P2(INT, INT), R0())
 541 DEF_GO_RUNTIME(PANIC_SLICE3_ACAP_U, "runtime.goPanicSlice3AcapU",
 542                P2(UINT, INT), R0())
 543 DEF_GO_RUNTIME(PANIC_SLICE3_B, "runtime.goPanicSlice3B",
 544                P2(INT, INT), R0())
 545 DEF_GO_RUNTIME(PANIC_SLICE3_B_U, "runtime.goPanicSlice3BU",
 546                P2(UINT, INT), R0())
 547 DEF_GO_RUNTIME(PANIC_SLICE3_C, "runtime.goPanicSlice3C",
 548                P2(INT, INT), R0())
 549 DEF_GO_RUNTIME(PANIC_SLICE3_C_U, "runtime.goPanicSlice3CU",
 550                P2(UINT, INT), R0())
 551
 552 // Panics reporting an index or slice out of bounds error with a
 553 // 64-bit index type.  These are only used by 32-bit targets.
 554 DEF_GO_RUNTIME(PANIC_EXTEND_INDEX, "runtime.goPanicExtendIndex",
 555                P2(INT64, INT), R0())
 556 DEF_GO_RUNTIME(PANIC_EXTEND_INDEX_U, "runtime.goPanicExtendIndexU",
 557                P2(UINT64, INT), R0())
 558 DEF_GO_RUNTIME(PANIC_EXTEND_SLICE_ALEN, "runtime.goPanicExtendSliceAlen",
 559                P2(INT64, INT), R0())
 560 DEF_GO_RUNTIME(PANIC_EXTEND_SLICE_ALEN_U, "runtime.goPanicExtendSliceAlenU",
 561                P2(UINT64, INT), R0())
 562 DEF_GO_RUNTIME(PANIC_EXTEND_SLICE_ACAP, "runtime.goPanicExtendSliceAcap",
 563                P2(INT64, INT), R0())
 564 DEF_GO_RUNTIME(PANIC_EXTEND_SLICE_ACAP_U, "runtime.goPanicExtendSliceAcapU",
 565                P2(UINT64, INT), R0())
 566 DEF_GO_RUNTIME(PANIC_EXTEND_SLICE_B, "runtime.goPanicExtendSliceB",
 567                P2(INT64, INT), R0())
 568 DEF_GO_RUNTIME(PANIC_EXTEND_SLICE_B_U, "runtime.goPanicExtendSliceBU",
 569                P2(UINT64, INT), R0())
 570 DEF_GO_RUNTIME(PANIC_EXTEND_SLICE3_ALEN, "runtime.goPanicExtendSlice3Alen",
 571                P2(INT64, INT), R0())
 572 DEF_GO_RUNTIME(PANIC_EXTEND_SLICE3_ALEN_U, "runtime.goPanicExtendSlice3AlenU",
 573                P2(UINT64, INT), R0())
 574 DEF_GO_RUNTIME(PANIC_EXTEND_SLICE3_ACAP, "runtime.goPanicExtendSlice3Acap",
 575                P2(INT64, INT), R0())
 576 DEF_GO_RUNTIME(PANIC_EXTEND_SLICE3_ACAP_U, "runtime.goPanicExtendSlice3AcapU",
 577                P2(UINT64, INT), R0())
 578 DEF_GO_RUNTIME(PANIC_EXTEND_SLICE3_B, "runtime.goPanicExtendSlice3B",
 579                P2(INT64, INT), R0())
 580 DEF_GO_RUNTIME(PANIC_EXTEND_SLICE3_B_U, "runtime.goPanicExtendSlice3BU",
 581                P2(UINT64, INT), R0())
 582 DEF_GO_RUNTIME(PANIC_EXTEND_SLICE3_C, "runtime.goPanicExtendSlice3C",
 583                P2(INT64, INT), R0())
 584 DEF_GO_RUNTIME(PANIC_EXTEND_SLICE3_C_U, "runtime.goPanicExtendSlice3CU",
 585                P2(UINT64, INT), R0())
 586
 587 // Remove helper macros.
 588 #undef ABFT6
 589 #undef ABFT2
 590 #undef P0
 591 #undef P1
 592 #undef P2
 593 #undef P3
 594 #undef P4
 595 #undef P5
 596 #undef P6
 597 #undef R0
 598 #undef R1
 599 #undef R2