Rebase.
[official-gcc.git] / gcc / go / gofrontend / runtime.def
blob8c6e82b226768469b78f09f39372d6027ec18a89
1 // runtime.def -- runtime functions called by generated code. -*- C++ -*-
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.
7 // Definitions for the Go runtime functions.
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)
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)
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.
31 // The standard C memcmp function, used for struct comparisons.
32 DEF_GO_RUNTIME(MEMCMP, "__go_memcmp", P3(POINTER, POINTER, UINTPTR), R1(INT))
34 // Range over a string, returning the next index.
35 DEF_GO_RUNTIME(STRINGITER, "runtime.stringiter", P2(STRING, INT), R1(INT))
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))
41 // Concatenate two strings.
42 DEF_GO_RUNTIME(STRING_PLUS, "__go_string_plus", P2(STRING, STRING), R1(STRING))
44 // Compare two strings.
45 DEF_GO_RUNTIME(STRCMP, "__go_strcmp", P2(STRING, STRING), R1(INT))
47 // Take a slice of a string.
48 DEF_GO_RUNTIME(STRING_SLICE, "__go_string_slice", P3(STRING, INT, INT),
49 R1(STRING))
51 // Convert an integer to a string.
52 DEF_GO_RUNTIME(INT_TO_STRING, "__go_int_to_string", P1(INT), R1(STRING))
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))
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))
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))
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))
71 // Complex division.
72 DEF_GO_RUNTIME(COMPLEX64_DIV, "__go_complex64_div",
73 P2(COMPLEX64, COMPLEX64), R1(COMPLEX64))
74 DEF_GO_RUNTIME(COMPLEX128_DIV, "__go_complex128_div",
75 P2(COMPLEX128, COMPLEX128), R1(COMPLEX128))
77 // Make a slice.
78 DEF_GO_RUNTIME(MAKESLICE1, "__go_make_slice1", P2(TYPE, UINTPTR), R1(SLICE))
79 DEF_GO_RUNTIME(MAKESLICE2, "__go_make_slice2", P3(TYPE, UINTPTR, UINTPTR),
80 R1(SLICE))
81 DEF_GO_RUNTIME(MAKESLICE1BIG, "__go_make_slice1_big", P2(TYPE, UINT64),
82 R1(SLICE))
83 DEF_GO_RUNTIME(MAKESLICE2BIG, "__go_make_slice2_big", P3(TYPE, UINT64, UINT64),
84 R1(SLICE))
87 // Make a map.
88 DEF_GO_RUNTIME(MAKEMAP, "__go_new_map", P2(MAPDESCRIPTOR, UINTPTR), R1(MAP))
89 DEF_GO_RUNTIME(MAKEMAPBIG, "__go_new_map_big", P2(MAPDESCRIPTOR, UINT64),
90 R1(MAP))
92 // Build a map from a composite literal.
93 DEF_GO_RUNTIME(CONSTRUCT_MAP, "__go_construct_map",
94 P6(POINTER, UINTPTR, UINTPTR, UINTPTR, UINTPTR, POINTER),
95 R1(MAP))
97 // Get the length of a map (the number of entries).
98 DEF_GO_RUNTIME(MAP_LEN, "__go_map_len", P1(MAP), R1(INT))
100 // Look up a key in a map.
101 DEF_GO_RUNTIME(MAP_INDEX, "__go_map_index", P3(MAP, POINTER, BOOL),
102 R1(POINTER))
104 // Look up a key in a map returning whether it is present.
105 DEF_GO_RUNTIME(MAPACCESS2, "runtime.mapaccess2",
106 P4(TYPE, MAP, POINTER, POINTER), R1(BOOL))
108 // Tuple assignment to a map element.
109 DEF_GO_RUNTIME(MAPASSIGN2, "runtime.mapassign2",
110 P4(MAP, POINTER, POINTER, BOOL), R0())
112 // Delete a key from a map.
113 DEF_GO_RUNTIME(MAPDELETE, "runtime.mapdelete", P2(MAP, POINTER), R0())
115 // Begin a range over a map.
116 DEF_GO_RUNTIME(MAPITERINIT, "runtime.mapiterinit", P2(MAP, MAPITER), R0())
118 // Range over a map, returning the next key.
119 DEF_GO_RUNTIME(MAPITER1, "runtime.mapiter1", P2(MAPITER, POINTER), R0())
121 // Range over a map, returning the next key and value.
122 DEF_GO_RUNTIME(MAPITER2, "runtime.mapiter2", P3(MAPITER, POINTER, POINTER),
123 R0())
125 // Range over a map, moving to the next map entry.
126 DEF_GO_RUNTIME(MAPITERNEXT, "runtime.mapiternext", P1(MAPITER), R0())
129 // Make a channel.
130 DEF_GO_RUNTIME(MAKECHAN, "__go_new_channel", P2(TYPE, UINTPTR), R1(CHAN))
131 DEF_GO_RUNTIME(MAKECHANBIG, "__go_new_channel_big", P2(TYPE, UINT64), R1(CHAN))
133 // Get the length of a channel (the number of unread values).
134 DEF_GO_RUNTIME(CHAN_LEN, "__go_chan_len", P1(CHAN), R1(INT))
136 // Get the capacity of a channel (the size of the buffer).
137 DEF_GO_RUNTIME(CHAN_CAP, "__go_chan_cap", P1(CHAN), R1(INT))
139 // Send a small value on a channel.
140 DEF_GO_RUNTIME(SEND_SMALL, "__go_send_small", P3(TYPE, CHAN, UINT64), R0())
142 // Send a big value on a channel.
143 DEF_GO_RUNTIME(SEND_BIG, "__go_send_big", P3(TYPE, CHAN, POINTER), R0())
145 // Receive a value from a channel.
146 DEF_GO_RUNTIME(RECEIVE, "__go_receive", P3(TYPE, CHAN, POINTER), R0())
148 // Receive a value from a channel returning whether it is closed.
149 DEF_GO_RUNTIME(CHANRECV2, "runtime.chanrecv2", P3(TYPE, CHAN, POINTER),
150 R1(BOOL))
153 // Start building a select statement.
154 DEF_GO_RUNTIME(NEWSELECT, "runtime.newselect", P1(INT32), R1(POINTER))
156 // Add a default clause to a select statement.
157 DEF_GO_RUNTIME(SELECTDEFAULT, "runtime.selectdefault",
158 P2(POINTER, INT32), R0())
160 // Add a send clause to a select statement.
161 DEF_GO_RUNTIME(SELECTSEND, "runtime.selectsend",
162 P4(POINTER, CHAN, POINTER, INT32), R0())
164 // Add a receive clause to a select statement, for a clause which does
165 // not check whether the channel is closed.
166 DEF_GO_RUNTIME(SELECTRECV, "runtime.selectrecv",
167 P4(POINTER, CHAN, POINTER, INT32), R0())
169 // Add a receive clause to a select statement, for a clause which does
170 // check whether the channel is closed.
171 DEF_GO_RUNTIME(SELECTRECV2, "runtime.selectrecv2",
172 P5(POINTER, CHAN, POINTER, BOOLPTR, INT32), R0())
174 // Run a select, returning the index of the selected clause.
175 DEF_GO_RUNTIME(SELECTGO, "runtime.selectgo", P1(POINTER), R1(INT32))
178 // Panic.
179 DEF_GO_RUNTIME(PANIC, "__go_panic", P1(EFACE), R0())
181 // Recover.
182 DEF_GO_RUNTIME(RECOVER, "__go_recover", P0(), R1(EFACE))
184 // Recover when called directly from defer.
185 DEF_GO_RUNTIME(DEFERRED_RECOVER, "__go_deferred_recover", P0(), R1(EFACE))
187 // Decide whether this function can call recover.
188 DEF_GO_RUNTIME(CAN_RECOVER, "__go_can_recover", P1(POINTER), R1(BOOL))
190 // Get the return address of the function.
191 DEF_GO_RUNTIME(RETURN_ADDRESS, "__go_return_address", P1(INT), R1(POINTER))
193 // Set the return address for defer in a defer thunk.
194 DEF_GO_RUNTIME(SET_DEFER_RETADDR, "__go_set_defer_retaddr", P1(POINTER),
195 R1(BOOL))
197 // Check for a deferred function in an exception handler.
198 DEF_GO_RUNTIME(CHECK_DEFER, "__go_check_defer", P1(BOOLPTR), R0())
200 // Run deferred functions.
201 DEF_GO_RUNTIME(UNDEFER, "__go_undefer", P1(BOOLPTR), R0())
203 // Panic with a runtime error.
204 DEF_GO_RUNTIME(RUNTIME_ERROR, "__go_runtime_error", P1(INT32), R0())
207 // Close.
208 DEF_GO_RUNTIME(CLOSE, "__go_builtin_close", P1(CHAN), R0())
211 // Copy.
212 DEF_GO_RUNTIME(COPY, "__go_copy", P3(POINTER, POINTER, UINTPTR), R0())
214 // Append.
215 DEF_GO_RUNTIME(APPEND, "__go_append", P4(SLICE, POINTER, UINTPTR, UINTPTR),
216 R1(SLICE))
219 // Register roots (global variables) for the garbage collector.
220 DEF_GO_RUNTIME(REGISTER_GC_ROOTS, "__go_register_gc_roots", P1(POINTER), R0())
223 // Allocate memory.
224 DEF_GO_RUNTIME(NEW, "__go_new", P1(UINTPTR), R1(POINTER))
226 // Allocate memory which can not contain pointers.
227 DEF_GO_RUNTIME(NEW_NOPOINTERS, "__go_new_nopointers", P1(UINTPTR), R1(POINTER))
230 // Start a new goroutine.
231 DEF_GO_RUNTIME(GO, "__go_go", P2(FUNC_PTR, POINTER), R0())
233 // Get the function closure.
234 DEF_GO_RUNTIME(GET_CLOSURE, "__go_get_closure", P0(), R1(POINTER))
236 // Set the function closure.
237 DEF_GO_RUNTIME(SET_CLOSURE, "__go_set_closure", P1(POINTER), R0())
239 // Defer a function.
240 DEF_GO_RUNTIME(DEFER, "__go_defer", P3(BOOLPTR, FUNC_PTR, POINTER), R0())
243 // Convert an empty interface to an empty interface, returning ok.
244 DEF_GO_RUNTIME(IFACEE2E2, "runtime.ifaceE2E2", P1(EFACE), R2(EFACE, BOOL))
246 // Convert a non-empty interface to an empty interface, returning ok.
247 DEF_GO_RUNTIME(IFACEI2E2, "runtime.ifaceI2E2", P1(IFACE), R2(EFACE, BOOL))
249 // Convert an empty interface to a non-empty interface, returning ok.
250 DEF_GO_RUNTIME(IFACEE2I2, "runtime.ifaceE2I2", P2(TYPE, EFACE),
251 R2(IFACE, BOOL))
253 // Convert a non-empty interface to a non-empty interface, returning ok.
254 DEF_GO_RUNTIME(IFACEI2I2, "runtime.ifaceI2I2", P2(TYPE, IFACE),
255 R2(IFACE, BOOL))
257 // Convert an empty interface to a pointer type, returning ok.
258 DEF_GO_RUNTIME(IFACEE2T2P, "runtime.ifaceE2T2P", P2(TYPE, EFACE),
259 R2(POINTER, BOOL))
261 // Convert a non-empty interface to a pointer type, return ok.
262 DEF_GO_RUNTIME(IFACEI2T2P, "runtime.ifaceI2T2P", P2(TYPE, IFACE),
263 R2(POINTER, BOOL))
265 // Convert an empty interface to a non-pointer type, returning ok.
266 DEF_GO_RUNTIME(IFACEE2T2, "runtime.ifaceE2T2", P3(TYPE, EFACE, POINTER),
267 R1(BOOL))
269 // Convert a non-empty interface to a non-pointer type, returning ok.
270 DEF_GO_RUNTIME(IFACEI2T2, "runtime.ifaceI2T2", P3(TYPE, IFACE, POINTER),
271 R1(BOOL))
273 // A type assertion from one interface type to another. This is
274 // used for a type assertion.
275 DEF_GO_RUNTIME(ASSERT_INTERFACE, "__go_assert_interface", P2(TYPE, TYPE), R1(POINTER))
277 // Convert one interface type to another. This is used for an
278 // assignment.
279 DEF_GO_RUNTIME(CONVERT_INTERFACE, "__go_convert_interface", P2(TYPE, TYPE),
280 R1(POINTER))
282 // Check whether an interface type may be converted to a
283 // non-interface type.
284 DEF_GO_RUNTIME(CHECK_INTERFACE_TYPE, "__go_check_interface_type",
285 P3(TYPE, TYPE, TYPE), R0())
287 // Return whether we can convert an interface type to a type.
288 DEF_GO_RUNTIME(IFACEI2TP, "runtime.ifaceI2Tp", P2(TYPE, TYPE), R1(BOOL))
290 // Get the type descriptor of an empty interface.
291 DEF_GO_RUNTIME(EFACETYPE, "runtime.efacetype", P1(EFACE), R1(TYPE))
293 // Get the type descriptor of a non-empty interface.
294 DEF_GO_RUNTIME(IFACETYPE, "runtime.ifacetype", P1(IFACE), R1(TYPE))
297 // Compare two type descriptors for equality.
298 DEF_GO_RUNTIME(IFACETYPEEQ, "runtime.ifacetypeeq", P2(TYPE, TYPE), R1(BOOL))
300 // Compare two empty interface values.
301 DEF_GO_RUNTIME(EMPTY_INTERFACE_COMPARE, "__go_empty_interface_compare",
302 P2(EFACE, EFACE), R1(INT))
304 // Compare an empty interface value to a non-interface value.
305 DEF_GO_RUNTIME(EMPTY_INTERFACE_VALUE_COMPARE,
306 "__go_empty_interface_value_compare",
307 P3(EFACE, TYPE, POINTER), R1(INT))
309 // Compare two non-empty interface values.
310 DEF_GO_RUNTIME(INTERFACE_COMPARE, "__go_interface_compare",
311 P2(IFACE, IFACE), R1(INT))
313 // Compare a non-empty interface value to a non-interface value.
314 DEF_GO_RUNTIME(INTERFACE_VALUE_COMPARE, "__go_interface_value_compare",
315 P3(IFACE, TYPE, POINTER), R1(INT))
317 // Compare a non-empty interface value to an interface value.
318 DEF_GO_RUNTIME(INTERFACE_EMPTY_COMPARE, "__go_interface_empty_compare",
319 P2(IFACE, EFACE), R1(INT))
322 // Print a string (for print/println).
323 DEF_GO_RUNTIME(PRINT_STRING, "__go_print_string", P1(STRING), R0())
325 // Print a uint64 (for print/println).
326 DEF_GO_RUNTIME(PRINT_UINT64, "__go_print_uint64", P1(UINT64), R0())
328 // Print a int64 (for print/println).
329 DEF_GO_RUNTIME(PRINT_INT64, "__go_print_int64", P1(INT64), R0())
331 // Print a float64 (for print/println).
332 DEF_GO_RUNTIME(PRINT_DOUBLE, "__go_print_double", P1(FLOAT64), R0())
334 // Print a complex128 (for print/println).
335 DEF_GO_RUNTIME(PRINT_COMPLEX, "__go_print_complex", P1(COMPLEX128), R0())
337 // Print a bool (for print/println).
338 DEF_GO_RUNTIME(PRINT_BOOL, "__go_print_bool", P1(BOOL), R0())
340 // Print a pointer/map/channel/function (for print/println).
341 DEF_GO_RUNTIME(PRINT_POINTER, "__go_print_pointer", P1(POINTER), R0())
343 // Print an empty interface (for print/println).
344 DEF_GO_RUNTIME(PRINT_EMPTY_INTERFACE, "__go_print_empty_interface",
345 P1(EFACE), R0())
347 // Print a non-empty interface (for print/println).
348 DEF_GO_RUNTIME(PRINT_INTERFACE, "__go_print_interface", P1(IFACE), R0())
350 // Print a slice (for print/println).
351 DEF_GO_RUNTIME(PRINT_SLICE, "__go_print_slice", P1(SLICE), R0())
353 // Print a space (for println).
354 DEF_GO_RUNTIME(PRINT_SPACE, "__go_print_space", P0(), R0())
356 // Print a newline (for println).
357 DEF_GO_RUNTIME(PRINT_NL, "__go_print_nl", P0(), R0())
360 // Used for field tracking for data analysis.
361 DEF_GO_RUNTIME(FIELDTRACK, "__go_fieldtrack", P1(POINTER), R0())
364 // Remove helper macros.
365 #undef ABFT6
366 #undef ABFT2
367 #undef P0
368 #undef P1
369 #undef P2
370 #undef P3
371 #undef P4
372 #undef P5
373 #undef P6
374 #undef R0
375 #undef R1
376 #undef R2