Debian Codegraph @

unix/mksyscall_aix_ppc64.go

raw
1 // Copyright 2019 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
4
5 //go:build ignore
6
7 /*
8 This program reads a file containing function prototypes
9 (like syscall_aix.go) and generates system call bodies.
10 The prototypes are marked by lines beginning with "//sys"
11 and read like func declarations if //sys is replaced by func, but:
12 * The parameter lists must give a name for each argument.
13 This includes return parameters.
14 * The parameter lists must give a type for each argument:
15 the (x, y, z int) shorthand is not allowed.
16 * If the return parameter is an error number, it must be named err.
17 * If go func name needs to be different than its libc name,
18 * or the function is not in libc, name could be specified
19 * at the end, after "=" sign, like
20 //sys getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) = libsocket.getsockopt
21
22
23 This program will generate three files and handle both gc and gccgo implementation:
24 - zsyscall_aix_ppc64.go: the common part of each implementation (error handler, pointer creation)
25 - zsyscall_aix_ppc64_gc.go: gc part with //go_cgo_import_dynamic and a call to syscall6
26 - zsyscall_aix_ppc64_gccgo.go: gccgo part with C function and conversion to C type.
27
28 The generated code looks like this
29
30 zsyscall_aix_ppc64.go
31 func asyscall(...) (n int, err error) {
32 // Pointer Creation
33 r1, e1 := callasyscall(...)
34 // Type Conversion
35 // Error Handler
36 return
37 }
38
39 zsyscall_aix_ppc64_gc.go
40 //go:cgo_import_dynamic libc_asyscall asyscall "libc.a/shr_64.o"
41 //go:linkname libc_asyscall libc_asyscall
42 var asyscall syscallFunc
43
44 func callasyscall(...) (r1 uintptr, e1 Errno) {
45 r1, _, e1 = syscall6(uintptr(unsafe.Pointer(&libc_asyscall)), "nb_args", ... )
46 return
47 }
48
49 zsyscall_aix_ppc64_ggcgo.go
50
51 // int asyscall(...)
52
53 import "C"
54
55 func callasyscall(...) (r1 uintptr, e1 Errno) {
56 r1 = uintptr(C.asyscall(...))
57 e1 = syscall.GetErrno()
58 return
59 }
60 */
61
62 package main
63
64 import (
65 "bufio"
66 "flag"
67 "fmt"
68 "os"
69 "regexp"
70 "strings"
71 )
72
73 var (
74 b32 = flag.Bool("b32", false, "32bit big-endian")
75 l32 = flag.Bool("l32", false, "32bit little-endian")
76 aix = flag.Bool("aix", false, "aix")
77 tags = flag.String("tags", "", "build tags")
78 )
79
80 // cmdLine returns this programs's commandline arguments
81 func cmdLine() string {
82 return "go run mksyscall_aix_ppc64.go " + strings.Join(os.Args[1:], " ")
83 }
84
85 // goBuildTags returns build tags in the go:build format.
86 func goBuildTags() string {
87 return strings.ReplaceAll(*tags, ",", " && ")
88 }
89
90 // Param is function parameter
91 type Param struct {
92 Name string
93 Type string
94 }
95
96 // usage prints the program usage
97 func usage() {
98 fmt.Fprintf(os.Stderr, "usage: go run mksyscall_aix_ppc64.go [-b32 | -l32] [-tags x,y] [file ...]\n")
99 os.Exit(1)
100 }
101
102 // parseParamList parses parameter list and returns a slice of parameters
103 func parseParamList(list string) []string {
104 list = strings.TrimSpace(list)
105 if list == "" {
106 return []string{}
107 }
108 return regexp.MustCompile(`\s*,\s*`).Split(list, -1)
109 }
110
111 // parseParam splits a parameter into name and type
112 func parseParam(p string) Param {
113 ps := regexp.MustCompile(`^(\S*) (\S*)$`).FindStringSubmatch(p)
114 if ps == nil {
115 fmt.Fprintf(os.Stderr, "malformed parameter: %s\n", p)
116 os.Exit(1)
117 }
118 return Param{ps[1], ps[2]}
119 }
120
121 func main() {
122 flag.Usage = usage
123 flag.Parse()
124 if len(flag.Args()) <= 0 {
125 fmt.Fprintf(os.Stderr, "no files to parse provided\n")
126 usage()
127 }
128
129 endianness := ""
130 if *b32 {
131 endianness = "big-endian"
132 } else if *l32 {
133 endianness = "little-endian"
134 }
135
136 pack := ""
137 // GCCGO
138 textgccgo := ""
139 cExtern := "/*\n#include <stdint.h>\n"
140 // GC
141 textgc := ""
142 dynimports := ""
143 linknames := ""
144 var vars []string
145 // COMMON
146 textcommon := ""
147 for _, path := range flag.Args() {
148 file, err := os.Open(path)
149 if err != nil {
150 fmt.Fprintf(os.Stderr, err.Error())
151 os.Exit(1)
152 }
153 s := bufio.NewScanner(file)
154 for s.Scan() {
155 t := s.Text()
156 if p := regexp.MustCompile(`^package (\S+)$`).FindStringSubmatch(t); p != nil && pack == "" {
157 pack = p[1]
158 }
159 nonblock := regexp.MustCompile(`^\/\/sysnb\t`).FindStringSubmatch(t)
160 if regexp.MustCompile(`^\/\/sys\t`).FindStringSubmatch(t) == nil && nonblock == nil {
161 continue
162 }
163
164 // Line must be of the form
165 // func Open(path string, mode int, perm int) (fd int, err error)
166 // Split into name, in params, out params.
167 f := regexp.MustCompile(`^\/\/sys(nb)?\t(\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*(?:(\w*)\.)?(\w*))?$`).FindStringSubmatch(t)
168 if f == nil {
169 fmt.Fprintf(os.Stderr, "%s:%s\nmalformed //sys declaration\n", path, t)
170 os.Exit(1)
171 }
172 funct, inps, outps, modname, sysname := f[2], f[3], f[4], f[5], f[6]
173
174 // Split argument lists on comma.
175 in := parseParamList(inps)
176 out := parseParamList(outps)
177
178 inps = strings.Join(in, ", ")
179 outps = strings.Join(out, ", ")
180
181 if sysname == "" {
182 sysname = funct
183 }
184
185 onlyCommon := false
186 if funct == "FcntlInt" || funct == "FcntlFlock" || funct == "ioctlPtr" {
187 // This function call another syscall which is already implemented.
188 // Therefore, the gc and gccgo part must not be generated.
189 onlyCommon = true
190 }
191
192 // Try in vain to keep people from editing this file.
193 // The theory is that they jump into the middle of the file
194 // without reading the header.
195
196 textcommon += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n"
197 if !onlyCommon {
198 textgccgo += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n"
199 textgc += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n"
200 }
201
202 // Check if value return, err return available
203 errvar := ""
204 rettype := ""
205 for _, param := range out {
206 p := parseParam(param)
207 if p.Type == "error" {
208 errvar = p.Name
209 } else {
210 rettype = p.Type
211 }
212 }
213
214 sysname = regexp.MustCompile(`([a-z])([A-Z])`).ReplaceAllString(sysname, `${1}_$2`)
215 sysname = strings.ToLower(sysname) // All libc functions are lowercase.
216
217 // GCCGO Prototype return type
218 cRettype := ""
219 if rettype == "unsafe.Pointer" {
220 cRettype = "uintptr_t"
221 } else if rettype == "uintptr" {
222 cRettype = "uintptr_t"
223 } else if regexp.MustCompile(`^_`).FindStringSubmatch(rettype) != nil {
224 cRettype = "uintptr_t"
225 } else if rettype == "int" {
226 cRettype = "int"
227 } else if rettype == "int32" {
228 cRettype = "int"
229 } else if rettype == "int64" {
230 cRettype = "long long"
231 } else if rettype == "uint32" {
232 cRettype = "unsigned int"
233 } else if rettype == "uint64" {
234 cRettype = "unsigned long long"
235 } else {
236 cRettype = "int"
237 }
238 if sysname == "exit" {
239 cRettype = "void"
240 }
241
242 // GCCGO Prototype arguments type
243 var cIn []string
244 for i, param := range in {
245 p := parseParam(param)
246 if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil {
247 cIn = append(cIn, "uintptr_t")
248 } else if p.Type == "string" {
249 cIn = append(cIn, "uintptr_t")
250 } else if regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type) != nil {
251 cIn = append(cIn, "uintptr_t", "size_t")
252 } else if p.Type == "unsafe.Pointer" {
253 cIn = append(cIn, "uintptr_t")
254 } else if p.Type == "uintptr" {
255 cIn = append(cIn, "uintptr_t")
256 } else if regexp.MustCompile(`^_`).FindStringSubmatch(p.Type) != nil {
257 cIn = append(cIn, "uintptr_t")
258 } else if p.Type == "int" {
259 if (i == 0 || i == 2) && funct == "fcntl" {
260 // These fcntl arguments needs to be uintptr to be able to call FcntlInt and FcntlFlock
261 cIn = append(cIn, "uintptr_t")
262 } else {
263 cIn = append(cIn, "int")
264 }
265
266 } else if p.Type == "int32" {
267 cIn = append(cIn, "int")
268 } else if p.Type == "int64" {
269 cIn = append(cIn, "long long")
270 } else if p.Type == "uint32" {
271 cIn = append(cIn, "unsigned int")
272 } else if p.Type == "uint64" {
273 cIn = append(cIn, "unsigned long long")
274 } else {
275 cIn = append(cIn, "int")
276 }
277 }
278
279 if !onlyCommon {
280 // GCCGO Prototype Generation
281 // Imports of system calls from libc
282 if sysname == "select" {
283 // select is a keyword of Go. Its name is
284 // changed to c_select.
285 cExtern += "#define c_select select\n"
286 }
287 cExtern += fmt.Sprintf("%s %s", cRettype, sysname)
288 cIn := strings.Join(cIn, ", ")
289 cExtern += fmt.Sprintf("(%s);\n", cIn)
290 }
291 // GC Library name
292 if modname == "" {
293 modname = "libc.a/shr_64.o"
294 } else {
295 fmt.Fprintf(os.Stderr, "%s: only syscall using libc are available\n", funct)
296 os.Exit(1)
297 }
298 sysvarname := fmt.Sprintf("libc_%s", sysname)
299
300 if !onlyCommon {
301 // GC Runtime import of function to allow cross-platform builds.
302 dynimports += fmt.Sprintf("//go:cgo_import_dynamic %s %s \"%s\"\n", sysvarname, sysname, modname)
303 // GC Link symbol to proc address variable.
304 linknames += fmt.Sprintf("//go:linkname %s %s\n", sysvarname, sysvarname)
305 // GC Library proc address variable.
306 vars = append(vars, sysvarname)
307 }
308
309 strconvfunc := "BytePtrFromString"
310 strconvtype := "*byte"
311
312 // Go function header.
313 if outps != "" {
314 outps = fmt.Sprintf(" (%s)", outps)
315 }
316 if textcommon != "" {
317 textcommon += "\n"
318 }
319
320 textcommon += fmt.Sprintf("func %s(%s)%s {\n", funct, strings.Join(in, ", "), outps)
321
322 // Prepare arguments tocall.
323 var argscommon []string // Arguments in the common part
324 var argscall []string // Arguments for call prototype
325 var argsgc []string // Arguments for gc call (with syscall6)
326 var argsgccgo []string // Arguments for gccgo call (with C.name_of_syscall)
327 n := 0
328 argN := 0
329 for _, param := range in {
330 p := parseParam(param)
331 if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil {
332 argscommon = append(argscommon, fmt.Sprintf("uintptr(unsafe.Pointer(%s))", p.Name))
333 argscall = append(argscall, fmt.Sprintf("%s uintptr", p.Name))
334 argsgc = append(argsgc, p.Name)
335 argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
336 } else if p.Type == "string" && errvar != "" {
337 textcommon += fmt.Sprintf("\tvar _p%d %s\n", n, strconvtype)
338 textcommon += fmt.Sprintf("\t_p%d, %s = %s(%s)\n", n, errvar, strconvfunc, p.Name)
339 textcommon += fmt.Sprintf("\tif %s != nil {\n\t\treturn\n\t}\n", errvar)
340
341 argscommon = append(argscommon, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n))
342 argscall = append(argscall, fmt.Sprintf("_p%d uintptr ", n))
343 argsgc = append(argsgc, fmt.Sprintf("_p%d", n))
344 argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(_p%d)", n))
345 n++
346 } else if p.Type == "string" {
347 fmt.Fprintf(os.Stderr, path+":"+funct+" uses string arguments, but has no error return\n")
348 textcommon += fmt.Sprintf("\tvar _p%d %s\n", n, strconvtype)
349 textcommon += fmt.Sprintf("\t_p%d, %s = %s(%s)\n", n, errvar, strconvfunc, p.Name)
350 textcommon += fmt.Sprintf("\tif %s != nil {\n\t\treturn\n\t}\n", errvar)
351
352 argscommon = append(argscommon, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n))
353 argscall = append(argscall, fmt.Sprintf("_p%d uintptr", n))
354 argsgc = append(argsgc, fmt.Sprintf("_p%d", n))
355 argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(_p%d)", n))
356 n++
357 } else if m := regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type); m != nil {
358 // Convert slice into pointer, length.
359 // Have to be careful not to take address of &a[0] if len == 0:
360 // pass nil in that case.
361 textcommon += fmt.Sprintf("\tvar _p%d *%s\n", n, m[1])
362 textcommon += fmt.Sprintf("\tif len(%s) > 0 {\n\t\t_p%d = &%s[0]\n\t}\n", p.Name, n, p.Name)
363 argscommon = append(argscommon, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n), fmt.Sprintf("len(%s)", p.Name))
364 argscall = append(argscall, fmt.Sprintf("_p%d uintptr", n), fmt.Sprintf("_lenp%d int", n))
365 argsgc = append(argsgc, fmt.Sprintf("_p%d", n), fmt.Sprintf("uintptr(_lenp%d)", n))
366 argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(_p%d)", n), fmt.Sprintf("C.size_t(_lenp%d)", n))
367 n++
368 } else if p.Type == "int64" && endianness != "" {
369 fmt.Fprintf(os.Stderr, path+":"+funct+" uses int64 with 32 bits mode. Case not yet implemented\n")
370 } else if p.Type == "bool" {
371 fmt.Fprintf(os.Stderr, path+":"+funct+" uses bool. Case not yet implemented\n")
372 } else if regexp.MustCompile(`^_`).FindStringSubmatch(p.Type) != nil || p.Type == "unsafe.Pointer" {
373 argscommon = append(argscommon, fmt.Sprintf("uintptr(%s)", p.Name))
374 argscall = append(argscall, fmt.Sprintf("%s uintptr", p.Name))
375 argsgc = append(argsgc, p.Name)
376 argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
377 } else if p.Type == "int" {
378 if (argN == 0 || argN == 2) && ((funct == "fcntl") || (funct == "FcntlInt") || (funct == "FcntlFlock")) {
379 // These fcntl arguments need to be uintptr to be able to call FcntlInt and FcntlFlock
380 argscommon = append(argscommon, fmt.Sprintf("uintptr(%s)", p.Name))
381 argscall = append(argscall, fmt.Sprintf("%s uintptr", p.Name))
382 argsgc = append(argsgc, p.Name)
383 argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
384
385 } else {
386 argscommon = append(argscommon, p.Name)
387 argscall = append(argscall, fmt.Sprintf("%s int", p.Name))
388 argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
389 argsgccgo = append(argsgccgo, fmt.Sprintf("C.int(%s)", p.Name))
390 }
391 } else if p.Type == "int32" {
392 argscommon = append(argscommon, p.Name)
393 argscall = append(argscall, fmt.Sprintf("%s int32", p.Name))
394 argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
395 argsgccgo = append(argsgccgo, fmt.Sprintf("C.int(%s)", p.Name))
396 } else if p.Type == "int64" {
397 argscommon = append(argscommon, p.Name)
398 argscall = append(argscall, fmt.Sprintf("%s int64", p.Name))
399 argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
400 argsgccgo = append(argsgccgo, fmt.Sprintf("C.longlong(%s)", p.Name))
401 } else if p.Type == "uint32" {
402 argscommon = append(argscommon, p.Name)
403 argscall = append(argscall, fmt.Sprintf("%s uint32", p.Name))
404 argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
405 argsgccgo = append(argsgccgo, fmt.Sprintf("C.uint(%s)", p.Name))
406 } else if p.Type == "uint64" {
407 argscommon = append(argscommon, p.Name)
408 argscall = append(argscall, fmt.Sprintf("%s uint64", p.Name))
409 argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
410 argsgccgo = append(argsgccgo, fmt.Sprintf("C.ulonglong(%s)", p.Name))
411 } else if p.Type == "uintptr" {
412 argscommon = append(argscommon, p.Name)
413 argscall = append(argscall, fmt.Sprintf("%s uintptr", p.Name))
414 argsgc = append(argsgc, p.Name)
415 argsgccgo = append(argsgccgo, fmt.Sprintf("C.uintptr_t(%s)", p.Name))
416 } else {
417 argscommon = append(argscommon, fmt.Sprintf("int(%s)", p.Name))
418 argscall = append(argscall, fmt.Sprintf("%s int", p.Name))
419 argsgc = append(argsgc, fmt.Sprintf("uintptr(%s)", p.Name))
420 argsgccgo = append(argsgccgo, fmt.Sprintf("C.int(%s)", p.Name))
421 }
422 argN++
423 }
424 nargs := len(argsgc)
425
426 // COMMON function generation
427 argscommonlist := strings.Join(argscommon, ", ")
428 callcommon := fmt.Sprintf("call%s(%s)", sysname, argscommonlist)
429 ret := []string{"_", "_"}
430 body := ""
431 doErrno := false
432 for i := 0; i < len(out); i++ {
433 p := parseParam(out[i])
434 reg := ""
435 if p.Name == "err" {
436 reg = "e1"
437 ret[1] = reg
438 doErrno = true
439 } else {
440 reg = "r0"
441 ret[0] = reg
442 }
443 if p.Type == "bool" {
444 reg = fmt.Sprintf("%s != 0", reg)
445 }
446 if reg != "e1" {
447 body += fmt.Sprintf("\t%s = %s(%s)\n", p.Name, p.Type, reg)
448 }
449 }
450 if ret[0] == "_" && ret[1] == "_" {
451 textcommon += fmt.Sprintf("\t%s\n", callcommon)
452 } else {
453 textcommon += fmt.Sprintf("\t%s, %s := %s\n", ret[0], ret[1], callcommon)
454 }
455 textcommon += body
456
457 if doErrno {
458 textcommon += "\tif e1 != 0 {\n"
459 textcommon += "\t\terr = errnoErr(e1)\n"
460 textcommon += "\t}\n"
461 }
462 textcommon += "\treturn\n"
463 textcommon += "}\n"
464
465 if onlyCommon {
466 continue
467 }
468
469 // CALL Prototype
470 callProto := fmt.Sprintf("func call%s(%s) (r1 uintptr, e1 Errno) {\n", sysname, strings.Join(argscall, ", "))
471
472 // GC function generation
473 asm := "syscall6"
474 if nonblock != nil {
475 asm = "rawSyscall6"
476 }
477
478 if len(argsgc) <= 6 {
479 for len(argsgc) < 6 {
480 argsgc = append(argsgc, "0")
481 }
482 } else {
483 fmt.Fprintf(os.Stderr, "%s: too many arguments to system call", funct)
484 os.Exit(1)
485 }
486 argsgclist := strings.Join(argsgc, ", ")
487 callgc := fmt.Sprintf("%s(uintptr(unsafe.Pointer(&%s)), %d, %s)", asm, sysvarname, nargs, argsgclist)
488
489 textgc += callProto
490 textgc += fmt.Sprintf("\tr1, _, e1 = %s\n", callgc)
491 textgc += "\treturn\n}\n"
492
493 // GCCGO function generation
494 argsgccgolist := strings.Join(argsgccgo, ", ")
495 var callgccgo string
496 if sysname == "select" {
497 // select is a keyword of Go. Its name is
498 // changed to c_select.
499 callgccgo = fmt.Sprintf("C.c_%s(%s)", sysname, argsgccgolist)
500 } else {
501 callgccgo = fmt.Sprintf("C.%s(%s)", sysname, argsgccgolist)
502 }
503 textgccgo += callProto
504 textgccgo += fmt.Sprintf("\tr1 = uintptr(%s)\n", callgccgo)
505 textgccgo += "\te1 = syscall.GetErrno()\n"
506 textgccgo += "\treturn\n}\n"
507 }
508 if err := s.Err(); err != nil {
509 fmt.Fprintf(os.Stderr, err.Error())
510 os.Exit(1)
511 }
512 file.Close()
513 }
514 imp := ""
515 if pack != "unix" {
516 imp = "import \"golang.org/x/sys/unix\"\n"
517
518 }
519
520 // Print zsyscall_aix_ppc64.go
521 err := os.WriteFile("zsyscall_aix_ppc64.go",
522 []byte(fmt.Sprintf(srcTemplate1, cmdLine(), goBuildTags(), pack, imp, textcommon)),
523 0644)
524 if err != nil {
525 fmt.Fprintf(os.Stderr, err.Error())
526 os.Exit(1)
527 }
528
529 // Print zsyscall_aix_ppc64_gc.go
530 vardecls := "\t" + strings.Join(vars, ",\n\t")
531 vardecls += " syscallFunc"
532 err = os.WriteFile("zsyscall_aix_ppc64_gc.go",
533 []byte(fmt.Sprintf(srcTemplate2, cmdLine(), goBuildTags(), pack, imp, dynimports, linknames, vardecls, textgc)),
534 0644)
535 if err != nil {
536 fmt.Fprintf(os.Stderr, err.Error())
537 os.Exit(1)
538 }
539
540 // Print zsyscall_aix_ppc64_gccgo.go
541 err = os.WriteFile("zsyscall_aix_ppc64_gccgo.go",
542 []byte(fmt.Sprintf(srcTemplate3, cmdLine(), goBuildTags(), pack, cExtern, imp, textgccgo)),
543 0644)
544 if err != nil {
545 fmt.Fprintf(os.Stderr, err.Error())
546 os.Exit(1)
547 }
548 }
549
550 const srcTemplate1 = `// %s
551 // Code generated by the command above; see README.md. DO NOT EDIT.
552
553 //go:build %s
554
555 package %s
556
557 import (
558 "unsafe"
559 )
560
561
562 %s
563
564 %s
565 `
566 const srcTemplate2 = `// %s
567 // Code generated by the command above; see README.md. DO NOT EDIT.
568
569 //go:build %s && gc
570
571 package %s
572
573 import (
574 "unsafe"
575 )
576 %s
577 %s
578 %s
579 type syscallFunc uintptr
580
581 var (
582 %s
583 )
584
585 // Implemented in runtime/syscall_aix.go.
586 func rawSyscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
587 func syscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
588
589 %s
590 `
591 const srcTemplate3 = `// %s
592 // Code generated by the command above; see README.md. DO NOT EDIT.
593
594 //go:build %s && gccgo
595
596 package %s
597
598 %s
599 */
600 import "C"
601 import (
602 "syscall"
603 )
604
605
606 %s
607
608 %s
609 `