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