diff options
Diffstat (limited to 'vendor/golang.org/x/sys/unix/mksyscall.go')
-rw-r--r-- | vendor/golang.org/x/sys/unix/mksyscall.go | 407 |
1 files changed, 407 insertions, 0 deletions
diff --git a/vendor/golang.org/x/sys/unix/mksyscall.go b/vendor/golang.org/x/sys/unix/mksyscall.go new file mode 100644 index 0000000..e4af942 --- /dev/null +++ b/vendor/golang.org/x/sys/unix/mksyscall.go | |||
@@ -0,0 +1,407 @@ | |||
1 | // Copyright 2018 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 | /* | ||
8 | This program reads a file containing function prototypes | ||
9 | (like syscall_darwin.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 errno. | ||
17 | |||
18 | A line beginning with //sysnb is like //sys, except that the | ||
19 | goroutine will not be suspended during the execution of the system | ||
20 | call. This must only be used for system calls which can never | ||
21 | block, as otherwise the system call could cause all goroutines to | ||
22 | hang. | ||
23 | */ | ||
24 | package main | ||
25 | |||
26 | import ( | ||
27 | "bufio" | ||
28 | "flag" | ||
29 | "fmt" | ||
30 | "os" | ||
31 | "regexp" | ||
32 | "strings" | ||
33 | ) | ||
34 | |||
35 | var ( | ||
36 | b32 = flag.Bool("b32", false, "32bit big-endian") | ||
37 | l32 = flag.Bool("l32", false, "32bit little-endian") | ||
38 | plan9 = flag.Bool("plan9", false, "plan9") | ||
39 | openbsd = flag.Bool("openbsd", false, "openbsd") | ||
40 | netbsd = flag.Bool("netbsd", false, "netbsd") | ||
41 | dragonfly = flag.Bool("dragonfly", false, "dragonfly") | ||
42 | arm = flag.Bool("arm", false, "arm") // 64-bit value should use (even, odd)-pair | ||
43 | tags = flag.String("tags", "", "build tags") | ||
44 | filename = flag.String("output", "", "output file name (standard output if omitted)") | ||
45 | ) | ||
46 | |||
47 | // cmdLine returns this programs's commandline arguments | ||
48 | func cmdLine() string { | ||
49 | return "go run mksyscall.go " + strings.Join(os.Args[1:], " ") | ||
50 | } | ||
51 | |||
52 | // buildTags returns build tags | ||
53 | func buildTags() string { | ||
54 | return *tags | ||
55 | } | ||
56 | |||
57 | // Param is function parameter | ||
58 | type Param struct { | ||
59 | Name string | ||
60 | Type string | ||
61 | } | ||
62 | |||
63 | // usage prints the program usage | ||
64 | func usage() { | ||
65 | fmt.Fprintf(os.Stderr, "usage: go run mksyscall.go [-b32 | -l32] [-tags x,y] [file ...]\n") | ||
66 | os.Exit(1) | ||
67 | } | ||
68 | |||
69 | // parseParamList parses parameter list and returns a slice of parameters | ||
70 | func parseParamList(list string) []string { | ||
71 | list = strings.TrimSpace(list) | ||
72 | if list == "" { | ||
73 | return []string{} | ||
74 | } | ||
75 | return regexp.MustCompile(`\s*,\s*`).Split(list, -1) | ||
76 | } | ||
77 | |||
78 | // parseParam splits a parameter into name and type | ||
79 | func parseParam(p string) Param { | ||
80 | ps := regexp.MustCompile(`^(\S*) (\S*)$`).FindStringSubmatch(p) | ||
81 | if ps == nil { | ||
82 | fmt.Fprintf(os.Stderr, "malformed parameter: %s\n", p) | ||
83 | os.Exit(1) | ||
84 | } | ||
85 | return Param{ps[1], ps[2]} | ||
86 | } | ||
87 | |||
88 | func main() { | ||
89 | // Get the OS and architecture (using GOARCH_TARGET if it exists) | ||
90 | goos := os.Getenv("GOOS") | ||
91 | if goos == "" { | ||
92 | fmt.Fprintln(os.Stderr, "GOOS not defined in environment") | ||
93 | os.Exit(1) | ||
94 | } | ||
95 | goarch := os.Getenv("GOARCH_TARGET") | ||
96 | if goarch == "" { | ||
97 | goarch = os.Getenv("GOARCH") | ||
98 | } | ||
99 | |||
100 | // Check that we are using the Docker-based build system if we should | ||
101 | if goos == "linux" { | ||
102 | if os.Getenv("GOLANG_SYS_BUILD") != "docker" { | ||
103 | fmt.Fprintf(os.Stderr, "In the Docker-based build system, mksyscall should not be called directly.\n") | ||
104 | fmt.Fprintf(os.Stderr, "See README.md\n") | ||
105 | os.Exit(1) | ||
106 | } | ||
107 | } | ||
108 | |||
109 | flag.Usage = usage | ||
110 | flag.Parse() | ||
111 | if len(flag.Args()) <= 0 { | ||
112 | fmt.Fprintf(os.Stderr, "no files to parse provided\n") | ||
113 | usage() | ||
114 | } | ||
115 | |||
116 | endianness := "" | ||
117 | if *b32 { | ||
118 | endianness = "big-endian" | ||
119 | } else if *l32 { | ||
120 | endianness = "little-endian" | ||
121 | } | ||
122 | |||
123 | libc := false | ||
124 | if goos == "darwin" && strings.Contains(buildTags(), ",go1.12") { | ||
125 | libc = true | ||
126 | } | ||
127 | trampolines := map[string]bool{} | ||
128 | |||
129 | text := "" | ||
130 | for _, path := range flag.Args() { | ||
131 | file, err := os.Open(path) | ||
132 | if err != nil { | ||
133 | fmt.Fprintf(os.Stderr, err.Error()) | ||
134 | os.Exit(1) | ||
135 | } | ||
136 | s := bufio.NewScanner(file) | ||
137 | for s.Scan() { | ||
138 | t := s.Text() | ||
139 | t = strings.TrimSpace(t) | ||
140 | t = regexp.MustCompile(`\s+`).ReplaceAllString(t, ` `) | ||
141 | nonblock := regexp.MustCompile(`^\/\/sysnb `).FindStringSubmatch(t) | ||
142 | if regexp.MustCompile(`^\/\/sys `).FindStringSubmatch(t) == nil && nonblock == nil { | ||
143 | continue | ||
144 | } | ||
145 | |||
146 | // Line must be of the form | ||
147 | // func Open(path string, mode int, perm int) (fd int, errno error) | ||
148 | // Split into name, in params, out params. | ||
149 | f := regexp.MustCompile(`^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*((?i)SYS_[A-Z0-9_]+))?$`).FindStringSubmatch(t) | ||
150 | if f == nil { | ||
151 | fmt.Fprintf(os.Stderr, "%s:%s\nmalformed //sys declaration\n", path, t) | ||
152 | os.Exit(1) | ||
153 | } | ||
154 | funct, inps, outps, sysname := f[2], f[3], f[4], f[5] | ||
155 | |||
156 | // ClockGettime doesn't have a syscall number on Darwin, only generate libc wrappers. | ||
157 | if goos == "darwin" && !libc && funct == "ClockGettime" { | ||
158 | continue | ||
159 | } | ||
160 | |||
161 | // Split argument lists on comma. | ||
162 | in := parseParamList(inps) | ||
163 | out := parseParamList(outps) | ||
164 | |||
165 | // Try in vain to keep people from editing this file. | ||
166 | // The theory is that they jump into the middle of the file | ||
167 | // without reading the header. | ||
168 | text += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n" | ||
169 | |||
170 | // Go function header. | ||
171 | outDecl := "" | ||
172 | if len(out) > 0 { | ||
173 | outDecl = fmt.Sprintf(" (%s)", strings.Join(out, ", ")) | ||
174 | } | ||
175 | text += fmt.Sprintf("func %s(%s)%s {\n", funct, strings.Join(in, ", "), outDecl) | ||
176 | |||
177 | // Check if err return available | ||
178 | errvar := "" | ||
179 | for _, param := range out { | ||
180 | p := parseParam(param) | ||
181 | if p.Type == "error" { | ||
182 | errvar = p.Name | ||
183 | break | ||
184 | } | ||
185 | } | ||
186 | |||
187 | // Prepare arguments to Syscall. | ||
188 | var args []string | ||
189 | n := 0 | ||
190 | for _, param := range in { | ||
191 | p := parseParam(param) | ||
192 | if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil { | ||
193 | args = append(args, "uintptr(unsafe.Pointer("+p.Name+"))") | ||
194 | } else if p.Type == "string" && errvar != "" { | ||
195 | text += fmt.Sprintf("\tvar _p%d *byte\n", n) | ||
196 | text += fmt.Sprintf("\t_p%d, %s = BytePtrFromString(%s)\n", n, errvar, p.Name) | ||
197 | text += fmt.Sprintf("\tif %s != nil {\n\t\treturn\n\t}\n", errvar) | ||
198 | args = append(args, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n)) | ||
199 | n++ | ||
200 | } else if p.Type == "string" { | ||
201 | fmt.Fprintf(os.Stderr, path+":"+funct+" uses string arguments, but has no error return\n") | ||
202 | text += fmt.Sprintf("\tvar _p%d *byte\n", n) | ||
203 | text += fmt.Sprintf("\t_p%d, _ = BytePtrFromString(%s)\n", n, p.Name) | ||
204 | args = append(args, fmt.Sprintf("uintptr(unsafe.Pointer(_p%d))", n)) | ||
205 | n++ | ||
206 | } else if regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type) != nil { | ||
207 | // Convert slice into pointer, length. | ||
208 | // Have to be careful not to take address of &a[0] if len == 0: | ||
209 | // pass dummy pointer in that case. | ||
210 | // Used to pass nil, but some OSes or simulators reject write(fd, nil, 0). | ||
211 | text += fmt.Sprintf("\tvar _p%d unsafe.Pointer\n", n) | ||
212 | text += fmt.Sprintf("\tif len(%s) > 0 {\n\t\t_p%d = unsafe.Pointer(&%s[0])\n\t}", p.Name, n, p.Name) | ||
213 | text += fmt.Sprintf(" else {\n\t\t_p%d = unsafe.Pointer(&_zero)\n\t}\n", n) | ||
214 | args = append(args, fmt.Sprintf("uintptr(_p%d)", n), fmt.Sprintf("uintptr(len(%s))", p.Name)) | ||
215 | n++ | ||
216 | } else if p.Type == "int64" && (*openbsd || *netbsd) { | ||
217 | args = append(args, "0") | ||
218 | if endianness == "big-endian" { | ||
219 | args = append(args, fmt.Sprintf("uintptr(%s>>32)", p.Name), fmt.Sprintf("uintptr(%s)", p.Name)) | ||
220 | } else if endianness == "little-endian" { | ||
221 | args = append(args, fmt.Sprintf("uintptr(%s)", p.Name), fmt.Sprintf("uintptr(%s>>32)", p.Name)) | ||
222 | } else { | ||
223 | args = append(args, fmt.Sprintf("uintptr(%s)", p.Name)) | ||
224 | } | ||
225 | } else if p.Type == "int64" && *dragonfly { | ||
226 | if regexp.MustCompile(`^(?i)extp(read|write)`).FindStringSubmatch(funct) == nil { | ||
227 | args = append(args, "0") | ||
228 | } | ||
229 | if endianness == "big-endian" { | ||
230 | args = append(args, fmt.Sprintf("uintptr(%s>>32)", p.Name), fmt.Sprintf("uintptr(%s)", p.Name)) | ||
231 | } else if endianness == "little-endian" { | ||
232 | args = append(args, fmt.Sprintf("uintptr(%s)", p.Name), fmt.Sprintf("uintptr(%s>>32)", p.Name)) | ||
233 | } else { | ||
234 | args = append(args, fmt.Sprintf("uintptr(%s)", p.Name)) | ||
235 | } | ||
236 | } else if (p.Type == "int64" || p.Type == "uint64") && endianness != "" { | ||
237 | if len(args)%2 == 1 && *arm { | ||
238 | // arm abi specifies 64-bit argument uses | ||
239 | // (even, odd) pair | ||
240 | args = append(args, "0") | ||
241 | } | ||
242 | if endianness == "big-endian" { | ||
243 | args = append(args, fmt.Sprintf("uintptr(%s>>32)", p.Name), fmt.Sprintf("uintptr(%s)", p.Name)) | ||
244 | } else { | ||
245 | args = append(args, fmt.Sprintf("uintptr(%s)", p.Name), fmt.Sprintf("uintptr(%s>>32)", p.Name)) | ||
246 | } | ||
247 | } else { | ||
248 | args = append(args, fmt.Sprintf("uintptr(%s)", p.Name)) | ||
249 | } | ||
250 | } | ||
251 | |||
252 | // Determine which form to use; pad args with zeros. | ||
253 | asm := "Syscall" | ||
254 | if nonblock != nil { | ||
255 | if errvar == "" && goos == "linux" { | ||
256 | asm = "RawSyscallNoError" | ||
257 | } else { | ||
258 | asm = "RawSyscall" | ||
259 | } | ||
260 | } else { | ||
261 | if errvar == "" && goos == "linux" { | ||
262 | asm = "SyscallNoError" | ||
263 | } | ||
264 | } | ||
265 | if len(args) <= 3 { | ||
266 | for len(args) < 3 { | ||
267 | args = append(args, "0") | ||
268 | } | ||
269 | } else if len(args) <= 6 { | ||
270 | asm += "6" | ||
271 | for len(args) < 6 { | ||
272 | args = append(args, "0") | ||
273 | } | ||
274 | } else if len(args) <= 9 { | ||
275 | asm += "9" | ||
276 | for len(args) < 9 { | ||
277 | args = append(args, "0") | ||
278 | } | ||
279 | } else { | ||
280 | fmt.Fprintf(os.Stderr, "%s:%s too many arguments to system call\n", path, funct) | ||
281 | } | ||
282 | |||
283 | // System call number. | ||
284 | if sysname == "" { | ||
285 | sysname = "SYS_" + funct | ||
286 | sysname = regexp.MustCompile(`([a-z])([A-Z])`).ReplaceAllString(sysname, `${1}_$2`) | ||
287 | sysname = strings.ToUpper(sysname) | ||
288 | } | ||
289 | |||
290 | var libcFn string | ||
291 | if libc { | ||
292 | asm = "syscall_" + strings.ToLower(asm[:1]) + asm[1:] // internal syscall call | ||
293 | sysname = strings.TrimPrefix(sysname, "SYS_") // remove SYS_ | ||
294 | sysname = strings.ToLower(sysname) // lowercase | ||
295 | if sysname == "getdirentries64" { | ||
296 | // Special case - libSystem name and | ||
297 | // raw syscall name don't match. | ||
298 | sysname = "__getdirentries64" | ||
299 | } | ||
300 | libcFn = sysname | ||
301 | sysname = "funcPC(libc_" + sysname + "_trampoline)" | ||
302 | } | ||
303 | |||
304 | // Actual call. | ||
305 | arglist := strings.Join(args, ", ") | ||
306 | call := fmt.Sprintf("%s(%s, %s)", asm, sysname, arglist) | ||
307 | |||
308 | // Assign return values. | ||
309 | body := "" | ||
310 | ret := []string{"_", "_", "_"} | ||
311 | doErrno := false | ||
312 | for i := 0; i < len(out); i++ { | ||
313 | p := parseParam(out[i]) | ||
314 | reg := "" | ||
315 | if p.Name == "err" && !*plan9 { | ||
316 | reg = "e1" | ||
317 | ret[2] = reg | ||
318 | doErrno = true | ||
319 | } else if p.Name == "err" && *plan9 { | ||
320 | ret[0] = "r0" | ||
321 | ret[2] = "e1" | ||
322 | break | ||
323 | } else { | ||
324 | reg = fmt.Sprintf("r%d", i) | ||
325 | ret[i] = reg | ||
326 | } | ||
327 | if p.Type == "bool" { | ||
328 | reg = fmt.Sprintf("%s != 0", reg) | ||
329 | } | ||
330 | if p.Type == "int64" && endianness != "" { | ||
331 | // 64-bit number in r1:r0 or r0:r1. | ||
332 | if i+2 > len(out) { | ||
333 | fmt.Fprintf(os.Stderr, "%s:%s not enough registers for int64 return\n", path, funct) | ||
334 | } | ||
335 | if endianness == "big-endian" { | ||
336 | reg = fmt.Sprintf("int64(r%d)<<32 | int64(r%d)", i, i+1) | ||
337 | } else { | ||
338 | reg = fmt.Sprintf("int64(r%d)<<32 | int64(r%d)", i+1, i) | ||
339 | } | ||
340 | ret[i] = fmt.Sprintf("r%d", i) | ||
341 | ret[i+1] = fmt.Sprintf("r%d", i+1) | ||
342 | } | ||
343 | if reg != "e1" || *plan9 { | ||
344 | body += fmt.Sprintf("\t%s = %s(%s)\n", p.Name, p.Type, reg) | ||
345 | } | ||
346 | } | ||
347 | if ret[0] == "_" && ret[1] == "_" && ret[2] == "_" { | ||
348 | text += fmt.Sprintf("\t%s\n", call) | ||
349 | } else { | ||
350 | if errvar == "" && goos == "linux" { | ||
351 | // raw syscall without error on Linux, see golang.org/issue/22924 | ||
352 | text += fmt.Sprintf("\t%s, %s := %s\n", ret[0], ret[1], call) | ||
353 | } else { | ||
354 | text += fmt.Sprintf("\t%s, %s, %s := %s\n", ret[0], ret[1], ret[2], call) | ||
355 | } | ||
356 | } | ||
357 | text += body | ||
358 | |||
359 | if *plan9 && ret[2] == "e1" { | ||
360 | text += "\tif int32(r0) == -1 {\n" | ||
361 | text += "\t\terr = e1\n" | ||
362 | text += "\t}\n" | ||
363 | } else if doErrno { | ||
364 | text += "\tif e1 != 0 {\n" | ||
365 | text += "\t\terr = errnoErr(e1)\n" | ||
366 | text += "\t}\n" | ||
367 | } | ||
368 | text += "\treturn\n" | ||
369 | text += "}\n\n" | ||
370 | |||
371 | if libc && !trampolines[libcFn] { | ||
372 | // some system calls share a trampoline, like read and readlen. | ||
373 | trampolines[libcFn] = true | ||
374 | // Declare assembly trampoline. | ||
375 | text += fmt.Sprintf("func libc_%s_trampoline()\n", libcFn) | ||
376 | // Assembly trampoline calls the libc_* function, which this magic | ||
377 | // redirects to use the function from libSystem. | ||
378 | text += fmt.Sprintf("//go:linkname libc_%s libc_%s\n", libcFn, libcFn) | ||
379 | text += fmt.Sprintf("//go:cgo_import_dynamic libc_%s %s \"/usr/lib/libSystem.B.dylib\"\n", libcFn, libcFn) | ||
380 | text += "\n" | ||
381 | } | ||
382 | } | ||
383 | if err := s.Err(); err != nil { | ||
384 | fmt.Fprintf(os.Stderr, err.Error()) | ||
385 | os.Exit(1) | ||
386 | } | ||
387 | file.Close() | ||
388 | } | ||
389 | fmt.Printf(srcTemplate, cmdLine(), buildTags(), text) | ||
390 | } | ||
391 | |||
392 | const srcTemplate = `// %s | ||
393 | // Code generated by the command above; see README.md. DO NOT EDIT. | ||
394 | |||
395 | // +build %s | ||
396 | |||
397 | package unix | ||
398 | |||
399 | import ( | ||
400 | "syscall" | ||
401 | "unsafe" | ||
402 | ) | ||
403 | |||
404 | var _ syscall.Errno | ||
405 | |||
406 | %s | ||
407 | ` | ||