|
111
|
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
|
|
131
|
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))
|
|
111
|
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.
|
|
131
|
142 DEF_GO_RUNTIME(MAKECHAN, "runtime.makechan", P2(TYPE, INT), R1(CHAN))
|
|
|
143 DEF_GO_RUNTIME(MAKECHAN64, "runtime.makechan64", P2(TYPE, INT64), R1(CHAN))
|
|
111
|
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
|
|
131
|
155 // Run a select, returning the index of the selected clause and
|
|
|
156 // whether that channel received a value.
|
|
|
157 DEF_GO_RUNTIME(SELECTGO, "runtime.selectgo", P3(POINTER, POINTER, INT),
|
|
|
158 R2(INT, BOOL))
|
|
111
|
159
|
|
|
160
|
|
|
161 // Panic.
|
|
|
162 DEF_GO_RUNTIME(GOPANIC, "runtime.gopanic", P1(EFACE), R0())
|
|
|
163
|
|
|
164 // Recover.
|
|
|
165 DEF_GO_RUNTIME(GORECOVER, "runtime.gorecover", P0(), R1(EFACE))
|
|
|
166
|
|
|
167 // Recover when called directly from defer.
|
|
|
168 DEF_GO_RUNTIME(DEFERREDRECOVER, "runtime.deferredrecover", P0(), R1(EFACE))
|
|
|
169
|
|
|
170 // Decide whether this function can call recover.
|
|
|
171 DEF_GO_RUNTIME(CANRECOVER, "runtime.canrecover", P1(POINTER), R1(BOOL))
|
|
|
172
|
|
|
173 // Set the return address for defer in a defer thunk.
|
|
|
174 DEF_GO_RUNTIME(SETDEFERRETADDR, "runtime.setdeferretaddr", P1(POINTER),
|
|
|
175 R1(BOOL))
|
|
|
176
|
|
|
177 // Check for a deferred function in an exception handler.
|
|
|
178 DEF_GO_RUNTIME(CHECKDEFER, "runtime.checkdefer", P1(BOOLPTR), R0())
|
|
|
179
|
|
|
180 // Run deferred functions.
|
|
|
181 DEF_GO_RUNTIME(DEFERRETURN, "runtime.deferreturn", P1(BOOLPTR), R0())
|
|
|
182
|
|
|
183 // Panic with a runtime error.
|
|
|
184 DEF_GO_RUNTIME(RUNTIME_ERROR, "__go_runtime_error", P1(INT32), R0())
|
|
|
185
|
|
|
186
|
|
|
187 // Close.
|
|
|
188 DEF_GO_RUNTIME(CLOSE, "runtime.closechan", P1(CHAN), R0())
|
|
|
189
|
|
|
190
|
|
|
191 // Copy.
|
|
|
192 DEF_GO_RUNTIME(SLICECOPY, "runtime.slicecopy", P3(SLICE, SLICE, UINTPTR),
|
|
|
193 R1(INT))
|
|
|
194
|
|
|
195 // Copy from string.
|
|
|
196 DEF_GO_RUNTIME(SLICESTRINGCOPY, "runtime.slicestringcopy", P2(SLICE, STRING),
|
|
|
197 R1(INT))
|
|
|
198
|
|
|
199 // Copy of value containing pointers.
|
|
|
200 DEF_GO_RUNTIME(TYPEDSLICECOPY, "runtime.typedslicecopy",
|
|
|
201 P3(TYPE, SLICE, SLICE), R1(INT))
|
|
|
202
|
|
|
203
|
|
|
204 // Grow a slice for append.
|
|
|
205 DEF_GO_RUNTIME(GROWSLICE, "runtime.growslice", P3(TYPE, SLICE, INT), R1(SLICE))
|
|
|
206
|
|
|
207
|
|
|
208 // Register roots (global variables) for the garbage collector.
|
|
|
209 DEF_GO_RUNTIME(REGISTER_GC_ROOTS, "runtime.registerGCRoots", P1(POINTER), R0())
|
|
|
210
|
|
|
211
|
|
|
212 // Allocate memory.
|
|
|
213 DEF_GO_RUNTIME(NEW, "runtime.newobject", P1(TYPE), R1(POINTER))
|
|
|
214
|
|
|
215 // Start a new goroutine.
|
|
|
216 DEF_GO_RUNTIME(GO, "__go_go", P2(FUNC_PTR, POINTER), R0())
|
|
|
217
|
|
|
218 // Defer a function.
|
|
|
219 DEF_GO_RUNTIME(DEFERPROC, "runtime.deferproc", P3(BOOLPTR, FUNC_PTR, POINTER),
|
|
|
220 R0())
|
|
|
221
|
|
|
222
|
|
|
223 // Convert an empty interface to an empty interface, returning ok.
|
|
|
224 DEF_GO_RUNTIME(IFACEE2E2, "runtime.ifaceE2E2", P1(EFACE), R2(EFACE, BOOL))
|
|
|
225
|
|
|
226 // Convert a non-empty interface to an empty interface, returning ok.
|
|
|
227 DEF_GO_RUNTIME(IFACEI2E2, "runtime.ifaceI2E2", P1(IFACE), R2(EFACE, BOOL))
|
|
|
228
|
|
|
229 // Convert an empty interface to a non-empty interface, returning ok.
|
|
|
230 DEF_GO_RUNTIME(IFACEE2I2, "runtime.ifaceE2I2", P2(TYPE, EFACE),
|
|
|
231 R2(IFACE, BOOL))
|
|
|
232
|
|
|
233 // Convert a non-empty interface to a non-empty interface, returning ok.
|
|
|
234 DEF_GO_RUNTIME(IFACEI2I2, "runtime.ifaceI2I2", P2(TYPE, IFACE),
|
|
|
235 R2(IFACE, BOOL))
|
|
|
236
|
|
|
237 // Convert an empty interface to a pointer type, returning ok.
|
|
|
238 DEF_GO_RUNTIME(IFACEE2T2P, "runtime.ifaceE2T2P", P2(TYPE, EFACE),
|
|
|
239 R2(POINTER, BOOL))
|
|
|
240
|
|
|
241 // Convert a non-empty interface to a pointer type, return ok.
|
|
|
242 DEF_GO_RUNTIME(IFACEI2T2P, "runtime.ifaceI2T2P", P2(TYPE, IFACE),
|
|
|
243 R2(POINTER, BOOL))
|
|
|
244
|
|
|
245 // Convert an empty interface to a non-pointer type, returning ok.
|
|
|
246 DEF_GO_RUNTIME(IFACEE2T2, "runtime.ifaceE2T2", P3(TYPE, EFACE, POINTER),
|
|
|
247 R1(BOOL))
|
|
|
248
|
|
|
249 // Convert a non-empty interface to a non-pointer type, returning ok.
|
|
|
250 DEF_GO_RUNTIME(IFACEI2T2, "runtime.ifaceI2T2", P3(TYPE, IFACE, POINTER),
|
|
|
251 R1(BOOL))
|
|
|
252
|
|
|
253 // Return the interface method table for the second type converted to
|
|
|
254 // the first type which is a (possibly empty) interface type. Panics
|
|
|
255 // if the second type is nil (indicating a nil interface value) or if
|
|
|
256 // the conversion is not possible. Used for type assertions. This is
|
|
|
257 // like REQUIREITAB, but for type assertions.
|
|
|
258 DEF_GO_RUNTIME(ASSERTITAB, "runtime.assertitab", P2(TYPE, TYPE), R1(POINTER))
|
|
|
259
|
|
|
260 // Return the interface method table for the second type converted to
|
|
|
261 // the first type, which is a non-empty interface type. Return nil if
|
|
|
262 // the second type is nil, indicating a nil interface value. Panics
|
|
|
263 // if the conversion is not possible. Used for assignments. This is
|
|
|
264 // like ASSERTITAB, but for assignments.
|
|
|
265 DEF_GO_RUNTIME(REQUIREITAB, "runtime.requireitab", P2(TYPE, TYPE),
|
|
|
266 R1(POINTER))
|
|
|
267
|
|
|
268 // Check whether an interface type may be converted to a
|
|
|
269 // non-interface type.
|
|
|
270 DEF_GO_RUNTIME(ASSERTI2T, "runtime.assertI2T", P3(TYPE, TYPE, TYPE), R0())
|
|
|
271
|
|
|
272 // Return whether we can convert a type to an interface type.
|
|
|
273 DEF_GO_RUNTIME(IFACET2IP, "runtime.ifaceT2Ip", P2(TYPE, TYPE), R1(BOOL))
|
|
|
274
|
|
|
275 // Get the type descriptor of an empty interface.
|
|
|
276 DEF_GO_RUNTIME(EFACETYPE, "runtime.efacetype", P1(EFACE), R1(TYPE))
|
|
|
277
|
|
|
278 // Get the type descriptor of a non-empty interface.
|
|
|
279 DEF_GO_RUNTIME(IFACETYPE, "runtime.ifacetype", P1(IFACE), R1(TYPE))
|
|
|
280
|
|
|
281
|
|
|
282 // Compare two type descriptors for equality.
|
|
|
283 DEF_GO_RUNTIME(IFACETYPEEQ, "runtime.ifacetypeeq", P2(TYPE, TYPE), R1(BOOL))
|
|
|
284
|
|
|
285 // Compare two empty interface values.
|
|
|
286 DEF_GO_RUNTIME(EFACEEQ, "runtime.efaceeq", P2(EFACE, EFACE), R1(BOOL))
|
|
|
287
|
|
|
288 // Compare an empty interface value to a non-interface value.
|
|
|
289 DEF_GO_RUNTIME(EFACEVALEQ, "runtime.efacevaleq", P3(EFACE, TYPE, POINTER),
|
|
|
290 R1(BOOL))
|
|
|
291
|
|
|
292 // Compare two non-empty interface values.
|
|
|
293 DEF_GO_RUNTIME(IFACEEQ, "runtime.ifaceeq", P2(IFACE, IFACE), R1(BOOL))
|
|
|
294
|
|
|
295 // Compare a non-empty interface value to a non-interface value.
|
|
|
296 DEF_GO_RUNTIME(IFACEVALEQ, "runtime.ifacevaleq", P3(IFACE, TYPE, POINTER),
|
|
|
297 R1(BOOL))
|
|
|
298
|
|
|
299 // Compare a non-empty interface value to an interface value.
|
|
|
300 DEF_GO_RUNTIME(IFACEEFACEEQ, "runtime.ifaceefaceeq", P2(IFACE, EFACE),
|
|
|
301 R1(BOOL))
|
|
|
302
|
|
|
303
|
|
|
304 // Set *dst = src where dst is a pointer to a pointer and src is a pointer.
|
|
131
|
305 DEF_GO_RUNTIME(GCWRITEBARRIER, "runtime.gcWriteBarrier",
|
|
111
|
306 P2(POINTER, POINTER), R0())
|
|
|
307
|
|
|
308 // Set *dst = *src for an arbitrary type.
|
|
|
309 DEF_GO_RUNTIME(TYPEDMEMMOVE, "runtime.typedmemmove",
|
|
|
310 P3(TYPE, POINTER, POINTER), R0())
|
|
|
311
|
|
|
312
|
|
|
313 // Lock the printer (for print/println).
|
|
|
314 DEF_GO_RUNTIME(PRINTLOCK, "runtime.printlock", P0(), R0())
|
|
|
315
|
|
|
316 // Unlock the printer (for print/println).
|
|
|
317 DEF_GO_RUNTIME(PRINTUNLOCK, "runtime.printunlock", P0(), R0())
|
|
|
318
|
|
|
319 // Print a string (for print/println).
|
|
|
320 DEF_GO_RUNTIME(PRINTSTRING, "runtime.printstring", P1(STRING), R0())
|
|
|
321
|
|
|
322 // Print a uint64 (for print/println).
|
|
|
323 DEF_GO_RUNTIME(PRINTUINT, "runtime.printuint", P1(UINT64), R0())
|
|
|
324
|
|
|
325 // Print a int64 (for print/println).
|
|
|
326 DEF_GO_RUNTIME(PRINTINT, "runtime.printint", P1(INT64), R0())
|
|
|
327
|
|
|
328 // Print a float64 (for print/println).
|
|
|
329 DEF_GO_RUNTIME(PRINTFLOAT, "runtime.printfloat", P1(FLOAT64), R0())
|
|
|
330
|
|
|
331 // Print a complex128 (for print/println).
|
|
|
332 DEF_GO_RUNTIME(PRINTCOMPLEX, "runtime.printcomplex", P1(COMPLEX128), R0())
|
|
|
333
|
|
|
334 // Print a bool (for print/println).
|
|
|
335 DEF_GO_RUNTIME(PRINTBOOL, "runtime.printbool", P1(BOOL), R0())
|
|
|
336
|
|
|
337 // Print a pointer/map/channel/function (for print/println).
|
|
|
338 DEF_GO_RUNTIME(PRINTPOINTER, "runtime.printpointer", P1(POINTER), R0())
|
|
|
339
|
|
|
340 // Print an empty interface (for print/println).
|
|
|
341 DEF_GO_RUNTIME(PRINTEFACE, "runtime.printeface", P1(EFACE), R0())
|
|
|
342
|
|
|
343 // Print a non-empty interface (for print/println).
|
|
|
344 DEF_GO_RUNTIME(PRINTIFACE, "runtime.printiface", P1(IFACE), R0())
|
|
|
345
|
|
|
346 // Print a slice (for print/println).
|
|
|
347 DEF_GO_RUNTIME(PRINTSLICE, "runtime.printslice", P1(SLICE), R0())
|
|
|
348
|
|
|
349 // Print a space (for println).
|
|
|
350 DEF_GO_RUNTIME(PRINTSP, "runtime.printsp", P0(), R0())
|
|
|
351
|
|
|
352 // Print a newline (for println).
|
|
|
353 DEF_GO_RUNTIME(PRINTNL, "runtime.printnl", P0(), R0())
|
|
|
354
|
|
|
355
|
|
|
356 // Used for field tracking for data analysis.
|
|
|
357 DEF_GO_RUNTIME(FIELDTRACK, "__go_fieldtrack", P1(POINTER), R0())
|
|
|
358
|
|
|
359
|
|
131
|
360 // Unreachable code.
|
|
|
361 DEF_GO_RUNTIME(UNREACHABLE, "__builtin_unreachable", P0(), R0())
|
|
|
362
|
|
111
|
363 // Remove helper macros.
|
|
|
364 #undef ABFT6
|
|
|
365 #undef ABFT2
|
|
|
366 #undef P0
|
|
|
367 #undef P1
|
|
|
368 #undef P2
|
|
|
369 #undef P3
|
|
|
370 #undef P4
|
|
|
371 #undef P5
|
|
|
372 #undef P6
|
|
|
373 #undef R0
|
|
|
374 #undef R1
|
|
|
375 #undef R2
|
