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                P2(POINTER, SLICE), 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 // Complex division.
  66 DEF_GO_RUNTIME(COMPLEX64_DIV, "__go_complex64_div",
  67                P2(COMPLEX64, COMPLEX64), R1(COMPLEX64))
  68 DEF_GO_RUNTIME(COMPLEX128_DIV, "__go_complex128_div",
  69                P2(COMPLEX128, COMPLEX128), R1(COMPLEX128))
  70
  71 // Make a slice.
  72 DEF_GO_RUNTIME(MAKESLICE, "runtime.makeslice", P3(TYPE, INT, INT),
  73                R1(POINTER))
  74
  75 DEF_GO_RUNTIME(MAKESLICE64, "runtime.makeslice64", P3(TYPE, INT64, INT64),
  76                R1(POINTER))
  77
  78
  79 // Make a map with a hint and an (optional, unused) map structure.
  80 DEF_GO_RUNTIME(MAKEMAP, "runtime.makemap", P3(TYPE, INT, POINTER),
  81                 R1(MAP))
  82 DEF_GO_RUNTIME(MAKEMAP64, "runtime.makemap64", P3(TYPE, INT64, POINTER),
  83                 R1(MAP))
  84
  85 // Make a map with no hint, or a small constant hint.
  86 DEF_GO_RUNTIME(MAKEMAP_SMALL, "runtime.makemap_small", P0(), R1(MAP))
  87
  88 // Build a map from a composite literal.
  89 DEF_GO_RUNTIME(CONSTRUCT_MAP, "__go_construct_map",
  90                P5(POINTER, UINTPTR, UINTPTR, UINTPTR, POINTER),
  91                R1(MAP))
  92
  93 // Look up a key in a map.
  94 DEF_GO_RUNTIME(MAPACCESS1, "runtime.mapaccess1", P3(TYPE, MAP, POINTER),
  95                R1(POINTER))
  96
  97 // Look up a uint32 key in a map.
  98 DEF_GO_RUNTIME(MAPACCESS1_FAST32, "runtime.mapaccess1_fast32",
  99                P3(TYPE, MAP, UINT32), R1(POINTER))
 100
 101 // Look up a uint64 key in a map.
 102 DEF_GO_RUNTIME(MAPACCESS1_FAST64, "runtime.mapaccess1_fast64",
 103                P3(TYPE, MAP, UINT64), R1(POINTER))
 104
 105 // Look up a string key in a map.
 106 DEF_GO_RUNTIME(MAPACCESS1_FASTSTR, "runtime.mapaccess1_faststr",
 107                P3(TYPE, MAP, STRING), R1(POINTER))
 108
 109 // Look up a key in a map when the value is large.
 110 DEF_GO_RUNTIME(MAPACCESS1_FAT, "runtime.mapaccess1_fat",
 111                P4(TYPE, MAP, POINTER, POINTER), R1(POINTER))
 112
 113 // Look up a key in a map returning the value and whether it is
 114 // present.
 115 DEF_GO_RUNTIME(MAPACCESS2, "runtime.mapaccess2", P3(TYPE, MAP, POINTER),
 116                R2(POINTER, BOOL))
 117
 118 // Look up a uint32 key in a map returning the value and whether
 119 // it is present.
 120 DEF_GO_RUNTIME(MAPACCESS2_FAST32, "runtime.mapaccess2_fast32",
 121                P3(TYPE, MAP, UINT32), R2(POINTER, BOOL))
 122
 123 // Look up a uint64 key in a map returning the value and whether
 124 // it is present.
 125 DEF_GO_RUNTIME(MAPACCESS2_FAST64, "runtime.mapaccess2_fast64",
 126                P3(TYPE, MAP, UINT64), R2(POINTER, BOOL))
 127
 128 // Look up a string key in a map returning the value and whether
 129 // it is present.
 130 DEF_GO_RUNTIME(MAPACCESS2_FASTSTR, "runtime.mapaccess2_faststr",
 131                P3(TYPE, MAP, STRING), R2(POINTER, BOOL))
 132
 133 // Look up a key in a map, returning the value and whether it is
 134 // present, when the value is large.
 135 DEF_GO_RUNTIME(MAPACCESS2_FAT, "runtime.mapaccess2_fat",
 136                P4(TYPE, MAP, POINTER, POINTER), R2(POINTER, BOOL))
 137
 138 // Assignment to a key in a map.
 139 DEF_GO_RUNTIME(MAPASSIGN, "runtime.mapassign", P3(TYPE, MAP, POINTER),
 140                R1(POINTER))
 141
 142 // Assignment to a uint32 key in a map.
 143 DEF_GO_RUNTIME(MAPASSIGN_FAST32, "runtime.mapassign_fast32",
 144                P3(TYPE, MAP, UINT32), R1(POINTER))
 145
 146 // Assignment to a uint64 key in a map.
 147 DEF_GO_RUNTIME(MAPASSIGN_FAST64, "runtime.mapassign_fast64",
 148                P3(TYPE, MAP, UINT64), R1(POINTER))
 149
 150 // Assignment to a 32-bit pointer key in a map.
 151 DEF_GO_RUNTIME(MAPASSIGN_FAST32PTR, "runtime.mapassign_fast32ptr",
 152                P3(TYPE, MAP, POINTER), R1(POINTER))
 153
 154 // Assignment to a 64-bit pointer key in a map.
 155 DEF_GO_RUNTIME(MAPASSIGN_FAST64PTR, "runtime.mapassign_fast64ptr",
 156                P3(TYPE, MAP, POINTER), R1(POINTER))
 157
 158 // Assignment to a string key in a map.
 159 DEF_GO_RUNTIME(MAPASSIGN_FASTSTR, "runtime.mapassign_faststr",
 160                P3(TYPE, MAP, STRING), R1(POINTER))
 161
 162 // Delete a key from a map.
 163 DEF_GO_RUNTIME(MAPDELETE, "runtime.mapdelete", P3(TYPE, MAP, POINTER), R0())
 164
 165 // Delete a uint32 key from a map.
 166 DEF_GO_RUNTIME(MAPDELETE_FAST32, "runtime.mapdelete_fast32",
 167                P3(TYPE, MAP, UINT32), R0())
 168
 169 // Delete a uint64 key from a map.
 170 DEF_GO_RUNTIME(MAPDELETE_FAST64, "runtime.mapdelete_fast64",
 171                P3(TYPE, MAP, UINT64), R0())
 172
 173 // Delete a string key from a map.
 174 DEF_GO_RUNTIME(MAPDELETE_FASTSTR, "runtime.mapdelete_faststr",
 175                P3(TYPE, MAP, STRING), R0())
 176
 177 // Begin a range over a map.
 178 DEF_GO_RUNTIME(MAPITERINIT, "runtime.mapiterinit", P3(TYPE, MAP, POINTER),
 179                R0())
 180
 181 // Range over a map, moving to the next map entry.
 182 DEF_GO_RUNTIME(MAPITERNEXT, "runtime.mapiternext", P1(POINTER), R0())
 183
 184 // Clear a map.
 185 DEF_GO_RUNTIME(MAPCLEAR, "runtime.mapclear", P2(TYPE, MAP), R0())
 186
 187
 188 // Make a channel.
 189 DEF_GO_RUNTIME(MAKECHAN, "runtime.makechan", P2(TYPE, INT), R1(CHAN))
 190 DEF_GO_RUNTIME(MAKECHAN64, "runtime.makechan64", P2(TYPE, INT64), R1(CHAN))
 191
 192 // Send a value on a channel.
 193 DEF_GO_RUNTIME(CHANSEND, "runtime.chansend1", P2(CHAN, POINTER), R0())
 194
 195 // Receive a value from a channel.
 196 DEF_GO_RUNTIME(CHANRECV1, "runtime.chanrecv1", P2(CHAN, POINTER), R0())
 197
 198 // Receive a value from a channel returning whether it is closed.
 199 DEF_GO_RUNTIME(CHANRECV2, "runtime.chanrecv2", P2(CHAN, POINTER), R1(BOOL))
 200
 201
 202 // Run a select, returning the index of the selected clause and
 203 // whether that channel received a value.
 204 DEF_GO_RUNTIME(SELECTGO, "runtime.selectgo", P3(POINTER, POINTER, INT),
 205                R2(INT, BOOL))
 206
 207 // Non-blocking send a value on a channel, used for two-case select
 208 // statement with a default case.
 209 DEF_GO_RUNTIME(SELECTNBSEND, "runtime.selectnbsend", P2(CHAN, POINTER), R1(BOOL))
 210
 211 // Non-blocking receive a value from a channel, used for two-case select
 212 // statement with a default case.
 213 DEF_GO_RUNTIME(SELECTNBRECV, "runtime.selectnbrecv", P2(POINTER, CHAN), R1(BOOL))
 214
 215 // Non-blocking tuple receive from a channel, used for two-case select
 216 // statement with a default case.
 217 DEF_GO_RUNTIME(SELECTNBRECV2, "runtime.selectnbrecv2", P3(POINTER, POINTER, CHAN),
 218                R1(BOOL))
 219
 220 // Block execution.  Used for zero-case select.
 221 DEF_GO_RUNTIME(BLOCK, "runtime.block", P0(), R0())
 222
 223
 224 // Panic.
 225 DEF_GO_RUNTIME(GOPANIC, "runtime.gopanic", P1(EFACE), R0())
 226
 227 // Recover.
 228 DEF_GO_RUNTIME(GORECOVER, "runtime.gorecover", P0(), R1(EFACE))
 229
 230 // Recover when called directly from defer.
 231 DEF_GO_RUNTIME(DEFERREDRECOVER, "runtime.deferredrecover", P0(), R1(EFACE))
 232
 233 // Decide whether this function can call recover.
 234 DEF_GO_RUNTIME(CANRECOVER, "runtime.canrecover", P1(UINTPTR), R1(BOOL))
 235
 236 // Set the return address for defer in a defer thunk.
 237 DEF_GO_RUNTIME(SETDEFERRETADDR, "runtime.setdeferretaddr", P1(UINTPTR),
 238                R1(BOOL))
 239
 240 // Check for a deferred function in an exception handler.
 241 DEF_GO_RUNTIME(CHECKDEFER, "runtime.checkdefer", P1(BOOLPTR), R0())
 242
 243 // Run deferred functions.
 244 DEF_GO_RUNTIME(DEFERRETURN, "runtime.deferreturn", P1(BOOLPTR), R0())
 245
 246 // Panic with a runtime error.
 247 DEF_GO_RUNTIME(RUNTIME_ERROR, "__go_runtime_error", P1(INT32), R0())
 248
 249
 250 // Close.
 251 DEF_GO_RUNTIME(CLOSE, "runtime.closechan", P1(CHAN), R0())
 252
 253
 254 // Copy.
 255 DEF_GO_RUNTIME(SLICECOPY, "runtime.slicecopy", P3(SLICE, SLICE, UINTPTR),
 256                R1(INT))
 257
 258 // Copy from string.
 259 DEF_GO_RUNTIME(SLICESTRINGCOPY, "runtime.slicestringcopy", P2(SLICE, STRING),
 260                R1(INT))
 261
 262 // Copy of value containing pointers.
 263 DEF_GO_RUNTIME(TYPEDSLICECOPY, "runtime.typedslicecopy",
 264                P3(TYPE, SLICE, SLICE), R1(INT))
 265
 266
 267 // Grow a slice for append.
 268 DEF_GO_RUNTIME(GROWSLICE, "runtime.growslice",
 269                P5(TYPE, POINTER, INT, INT, INT), R1(SLICE))
 270
 271
 272 // Register roots (global variables) for the garbage collector.
 273 DEF_GO_RUNTIME(REGISTER_GC_ROOTS, "runtime.registerGCRoots", P1(POINTER), R0())
 274
 275 // Register type descriptors.
 276 DEF_GO_RUNTIME(REGISTER_TYPE_DESCRIPTORS, "runtime.registerTypeDescriptors",
 277                P2(INT, POINTER), R0())
 278
 279
 280 // Allocate memory.
 281 DEF_GO_RUNTIME(NEW, "runtime.newobject", P1(TYPE), R1(POINTER))
 282
 283 // Start a new goroutine.
 284 DEF_GO_RUNTIME(GO, "__go_go", P2(UINTPTR, POINTER), R1(POINTER))
 285
 286 // Defer a function.
 287 DEF_GO_RUNTIME(DEFERPROC, "runtime.deferproc", P3(BOOLPTR, UINTPTR, POINTER),
 288                R0())
 289
 290
 291 // Convert an empty interface to an empty interface, returning ok.
 292 DEF_GO_RUNTIME(IFACEE2E2, "runtime.ifaceE2E2", P1(EFACE), R2(EFACE, BOOL))
 293
 294 // Convert a non-empty interface to an empty interface, returning ok.
 295 DEF_GO_RUNTIME(IFACEI2E2, "runtime.ifaceI2E2", P1(IFACE), R2(EFACE, BOOL))
 296
 297 // Convert an empty interface to a non-empty interface, returning ok.
 298 DEF_GO_RUNTIME(IFACEE2I2, "runtime.ifaceE2I2", P2(TYPE, EFACE),
 299                R2(IFACE, BOOL))
 300
 301 // Convert a non-empty interface to a non-empty interface, returning ok.
 302 DEF_GO_RUNTIME(IFACEI2I2, "runtime.ifaceI2I2", P2(TYPE, IFACE),
 303                R2(IFACE, BOOL))
 304
 305 // Convert an empty interface to a pointer type, returning ok.
 306 DEF_GO_RUNTIME(IFACEE2T2P, "runtime.ifaceE2T2P", P2(TYPE, EFACE),
 307                R2(POINTER, BOOL))
 308
 309 // Convert a non-empty interface to a pointer type, return ok.
 310 DEF_GO_RUNTIME(IFACEI2T2P, "runtime.ifaceI2T2P", P2(TYPE, IFACE),
 311                R2(POINTER, BOOL))
 312
 313 // Convert an empty interface to a non-pointer type, returning ok.
 314 DEF_GO_RUNTIME(IFACEE2T2, "runtime.ifaceE2T2", P3(TYPE, EFACE, POINTER),
 315                R1(BOOL))
 316
 317 // Convert a non-empty interface to a non-pointer type, returning ok.
 318 DEF_GO_RUNTIME(IFACEI2T2, "runtime.ifaceI2T2", P3(TYPE, IFACE, POINTER),
 319                R1(BOOL))
 320
 321 // Return the interface method table for the second type converted to
 322 // the first type which is a (possibly empty) interface type.  Panics
 323 // if the second type is nil (indicating a nil interface value) or if
 324 // the conversion is not possible.  Used for type assertions.  This is
 325 // like REQUIREITAB, but for type assertions.
 326 DEF_GO_RUNTIME(ASSERTITAB, "runtime.assertitab", P2(TYPE, TYPE), R1(POINTER))
 327
 328 // Return the interface method table for the second type converted to
 329 // the first type, which is a non-empty interface type.  Return nil if
 330 // the second type is nil, indicating a nil interface value.  Panics
 331 // if the conversion is not possible.  Used for assignments.  This is
 332 // like ASSERTITAB, but for assignments.
 333 DEF_GO_RUNTIME(REQUIREITAB, "runtime.requireitab", P2(TYPE, TYPE),
 334                R1(POINTER))
 335
 336 // Panic when an interface type to non-interface type conversion fails.
 337 DEF_GO_RUNTIME(PANICDOTTYPE, "runtime.panicdottype", P3(TYPE, TYPE, TYPE),
 338                R0())
 339
 340 // Return whether we can convert a type to an interface type.
 341 DEF_GO_RUNTIME(IFACET2IP, "runtime.ifaceT2Ip", P2(TYPE, TYPE), R1(BOOL))
 342
 343 // Compare two empty interface values.
 344 DEF_GO_RUNTIME(EFACEEQ, "runtime.efaceeq", P2(EFACE, EFACE), R1(BOOL))
 345
 346 // Compare an empty interface value to a non-interface value.
 347 DEF_GO_RUNTIME(EFACEVALEQ, "runtime.efacevaleq", P3(EFACE, TYPE, POINTER),
 348                R1(BOOL))
 349
 350 // Compare two non-empty interface values.
 351 DEF_GO_RUNTIME(IFACEEQ, "runtime.ifaceeq", P2(IFACE, IFACE), R1(BOOL))
 352
 353 // Compare a non-empty interface value to a non-interface value.
 354 DEF_GO_RUNTIME(IFACEVALEQ, "runtime.ifacevaleq", P3(IFACE, TYPE, POINTER),
 355                R1(BOOL))
 356
 357 // Compare a non-empty interface value to an interface value.
 358 DEF_GO_RUNTIME(IFACEEFACEEQ, "runtime.ifaceefaceeq", P2(IFACE, EFACE),
 359                R1(BOOL))
 360
 361
 362 // Set *dst = src where dst is a pointer to a pointer and src is a pointer.
 363 DEF_GO_RUNTIME(GCWRITEBARRIER, "runtime.gcWriteBarrier",
 364                P2(POINTER, UINTPTR), R0())
 365
 366 // Set *dst = *src for an arbitrary type.
 367 DEF_GO_RUNTIME(TYPEDMEMMOVE, "runtime.typedmemmove",
 368                P3(TYPE, POINTER, POINTER), R0())
 369
 370 // Clear memory that contains pointer.
 371 DEF_GO_RUNTIME(MEMCLRHASPTR, "runtime.memclrHasPointers",
 372                P2(POINTER, UINTPTR), R0())
 373
 374
 375 // Lock the printer (for print/println).
 376 DEF_GO_RUNTIME(PRINTLOCK, "runtime.printlock", P0(), R0())
 377
 378 // Unlock the printer (for print/println).
 379 DEF_GO_RUNTIME(PRINTUNLOCK, "runtime.printunlock", P0(), R0())
 380
 381 // Print a string (for print/println).
 382 DEF_GO_RUNTIME(PRINTSTRING, "runtime.printstring", P1(STRING), R0())
 383
 384 // Print a uint64 (for print/println).
 385 DEF_GO_RUNTIME(PRINTUINT, "runtime.printuint", P1(UINT64), R0())
 386
 387 // Print a uint64 in hex (for print/println, used for runtime.hex type).
 388 DEF_GO_RUNTIME(PRINTHEX, "runtime.printhex", P1(UINT64), R0())
 389
 390 // Print a int64 (for print/println).
 391 DEF_GO_RUNTIME(PRINTINT, "runtime.printint", P1(INT64), R0())
 392
 393 // Print a float64 (for print/println).
 394 DEF_GO_RUNTIME(PRINTFLOAT, "runtime.printfloat", P1(FLOAT64), R0())
 395
 396 // Print a complex128 (for print/println).
 397 DEF_GO_RUNTIME(PRINTCOMPLEX, "runtime.printcomplex", P1(COMPLEX128), R0())
 398
 399 // Print a bool (for print/println).
 400 DEF_GO_RUNTIME(PRINTBOOL, "runtime.printbool", P1(BOOL), R0())
 401
 402 // Print a pointer/map/channel/function (for print/println).
 403 DEF_GO_RUNTIME(PRINTPOINTER, "runtime.printpointer", P1(POINTER), R0())
 404
 405 // Print an empty interface (for print/println).
 406 DEF_GO_RUNTIME(PRINTEFACE, "runtime.printeface", P1(EFACE), R0())
 407
 408 // Print a non-empty interface (for print/println).
 409 DEF_GO_RUNTIME(PRINTIFACE, "runtime.printiface", P1(IFACE), R0())
 410
 411 // Print a slice (for print/println).
 412 DEF_GO_RUNTIME(PRINTSLICE, "runtime.printslice", P1(SLICE), R0())
 413
 414 // Print a space (for println).
 415 DEF_GO_RUNTIME(PRINTSP, "runtime.printsp", P0(), R0())
 416
 417 // Print a newline (for println).
 418 DEF_GO_RUNTIME(PRINTNL, "runtime.printnl", P0(), R0())
 419
 420
 421 // Used for field tracking for data analysis.
 422 DEF_GO_RUNTIME(FIELDTRACK, "__go_fieldtrack", P1(POINTER), R0())
 423
 424
 425 // Unreachable code.
 426 DEF_GO_RUNTIME(UNREACHABLE, "__builtin_unreachable", P0(), R0())
 427
 428 // Memmove.
 429 DEF_GO_RUNTIME(BUILTIN_MEMMOVE, "__builtin_memmove",
 430                P3(POINTER, POINTER, UINTPTR), R0())
 431
 432 // Memset, used for zeroing memory.
 433 DEF_GO_RUNTIME(BUILTIN_MEMSET, "__builtin_memset",
 434                P3(POINTER, INT32, UINTPTR), R0())
 435
 436 // Various intrinsics.
 437
 438 // Get the caller's PC, used for runtime.getcallerpc.
 439 DEF_GO_RUNTIME(BUILTIN_RETURN_ADDRESS, "__builtin_return_address",
 440                P1(UINT32), R1(POINTER))
 441
 442 // Get the caller's SP, used for runtime.getcallersp.
 443 DEF_GO_RUNTIME(BUILTIN_DWARF_CFA, "__builtin_dwarf_cfa", P0(),
 444                R1(POINTER))
 445
 446 // Swap bytes.
 447 DEF_GO_RUNTIME(BUILTIN_BSWAP16, "__builtin_bswap16", P1(UINT16),
 448                R1(UINT16))
 449 DEF_GO_RUNTIME(BUILTIN_BSWAP32, "__builtin_bswap32", P1(UINT32),
 450                R1(UINT32))
 451 DEF_GO_RUNTIME(BUILTIN_BSWAP64, "__builtin_bswap64", P1(UINT64),
 452                R1(UINT64))
 453
 454 // Count trailing zeros.
 455 DEF_GO_RUNTIME(BUILTIN_CTZ, "__builtin_ctz", P1(UINT32), R1(INT32))
 456 DEF_GO_RUNTIME(BUILTIN_CTZLL, "__builtin_ctzll", P1(UINT64), R1(INT32))
 457
 458 // Count leading zeros.
 459 DEF_GO_RUNTIME(BUILTIN_CLZ, "__builtin_clz", P1(UINT32), R1(INT32))
 460 DEF_GO_RUNTIME(BUILTIN_CLZLL, "__builtin_clzll", P1(UINT64), R1(INT32))
 461
 462 // Count one bits.
 463 DEF_GO_RUNTIME(BUILTIN_POPCOUNT, "__builtin_popcount", P1(UINT32), R1(INT32))
 464 DEF_GO_RUNTIME(BUILTIN_POPCOUNTLL, "__builtin_popcountll", P1(UINT64), R1(INT32))
 465
 466 // Atomics.
 467 DEF_GO_RUNTIME(ATOMIC_LOAD_4, "__atomic_load_4", P2(POINTER, INT32),
 468                R1(UINT32))
 469 DEF_GO_RUNTIME(ATOMIC_LOAD_8, "__atomic_load_8", P2(POINTER, INT32),
 470                R1(UINT64))
 471 DEF_GO_RUNTIME(ATOMIC_STORE_4, "__atomic_store_4", P3(POINTER, UINT32, INT32),
 472                R0())
 473 DEF_GO_RUNTIME(ATOMIC_STORE_8, "__atomic_store_8", P3(POINTER, UINT64, INT32),
 474                R0())
 475 DEF_GO_RUNTIME(ATOMIC_EXCHANGE_4, "__atomic_exchange_4", P3(POINTER, UINT32, INT32),
 476                R1(UINT32))
 477 DEF_GO_RUNTIME(ATOMIC_EXCHANGE_8, "__atomic_exchange_8", P3(POINTER, UINT64, INT32),
 478                R1(UINT64))
 479 DEF_GO_RUNTIME(ATOMIC_COMPARE_EXCHANGE_4, "__atomic_compare_exchange_4",
 480                P6(POINTER, POINTER, UINT32, BOOL, INT32, INT32),
 481                R1(BOOL))
 482 DEF_GO_RUNTIME(ATOMIC_COMPARE_EXCHANGE_8, "__atomic_compare_exchange_8",
 483                P6(POINTER, POINTER, UINT64, BOOL, INT32, INT32),
 484                R1(BOOL))
 485 DEF_GO_RUNTIME(ATOMIC_ADD_FETCH_4, "__atomic_add_fetch_4",
 486                P3(POINTER, UINT32, INT32),
 487                R1(UINT32))
 488 DEF_GO_RUNTIME(ATOMIC_ADD_FETCH_8, "__atomic_add_fetch_8",
 489                P3(POINTER, UINT64, INT32),
 490                R1(UINT64))
 491 DEF_GO_RUNTIME(ATOMIC_AND_FETCH_1, "__atomic_and_fetch_1",
 492                P3(POINTER, UINT8, INT32),
 493                R1(UINT8))
 494 DEF_GO_RUNTIME(ATOMIC_OR_FETCH_1, "__atomic_or_fetch_1",
 495                P3(POINTER, UINT8, INT32),
 496                R1(UINT8))
 497
 498 // Remove helper macros.
 499 #undef ABFT6
 500 #undef ABFT2
 501 #undef P0
 502 #undef P1
 503 #undef P2
 504 #undef P3
 505 #undef P4
 506 #undef P5
 507 #undef P6
 508 #undef R0
 509 #undef R1
 510 #undef R2