]>
Commit | Line | Data |
---|---|---|
107c1cdb ND |
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 | // +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 | package main | |
23 | ||
24 | import ( | |
25 | "bufio" | |
26 | "flag" | |
27 | "fmt" | |
28 | "os" | |
29 | "regexp" | |
30 | "strings" | |
31 | ) | |
32 | ||
33 | var ( | |
34 | b32 = flag.Bool("b32", false, "32bit big-endian") | |
35 | l32 = flag.Bool("l32", false, "32bit little-endian") | |
36 | aix = flag.Bool("aix", false, "aix") | |
37 | tags = flag.String("tags", "", "build tags") | |
38 | ) | |
39 | ||
40 | // cmdLine returns this programs's commandline arguments | |
41 | func cmdLine() string { | |
42 | return "go run mksyscall_aix_ppc.go " + strings.Join(os.Args[1:], " ") | |
43 | } | |
44 | ||
45 | // buildTags returns build tags | |
46 | func buildTags() string { | |
47 | return *tags | |
48 | } | |
49 | ||
50 | // Param is function parameter | |
51 | type Param struct { | |
52 | Name string | |
53 | Type string | |
54 | } | |
55 | ||
56 | // usage prints the program usage | |
57 | func usage() { | |
58 | fmt.Fprintf(os.Stderr, "usage: go run mksyscall_aix_ppc.go [-b32 | -l32] [-tags x,y] [file ...]\n") | |
59 | os.Exit(1) | |
60 | } | |
61 | ||
62 | // parseParamList parses parameter list and returns a slice of parameters | |
63 | func parseParamList(list string) []string { | |
64 | list = strings.TrimSpace(list) | |
65 | if list == "" { | |
66 | return []string{} | |
67 | } | |
68 | return regexp.MustCompile(`\s*,\s*`).Split(list, -1) | |
69 | } | |
70 | ||
71 | // parseParam splits a parameter into name and type | |
72 | func parseParam(p string) Param { | |
73 | ps := regexp.MustCompile(`^(\S*) (\S*)$`).FindStringSubmatch(p) | |
74 | if ps == nil { | |
75 | fmt.Fprintf(os.Stderr, "malformed parameter: %s\n", p) | |
76 | os.Exit(1) | |
77 | } | |
78 | return Param{ps[1], ps[2]} | |
79 | } | |
80 | ||
81 | func main() { | |
82 | flag.Usage = usage | |
83 | flag.Parse() | |
84 | if len(flag.Args()) <= 0 { | |
85 | fmt.Fprintf(os.Stderr, "no files to parse provided\n") | |
86 | usage() | |
87 | } | |
88 | ||
89 | endianness := "" | |
90 | if *b32 { | |
91 | endianness = "big-endian" | |
92 | } else if *l32 { | |
93 | endianness = "little-endian" | |
94 | } | |
95 | ||
96 | pack := "" | |
97 | text := "" | |
98 | cExtern := "/*\n#include <stdint.h>\n#include <stddef.h>\n" | |
99 | for _, path := range flag.Args() { | |
100 | file, err := os.Open(path) | |
101 | if err != nil { | |
102 | fmt.Fprintf(os.Stderr, err.Error()) | |
103 | os.Exit(1) | |
104 | } | |
105 | s := bufio.NewScanner(file) | |
106 | for s.Scan() { | |
107 | t := s.Text() | |
108 | t = strings.TrimSpace(t) | |
109 | t = regexp.MustCompile(`\s+`).ReplaceAllString(t, ` `) | |
110 | if p := regexp.MustCompile(`^package (\S+)$`).FindStringSubmatch(t); p != nil && pack == "" { | |
111 | pack = p[1] | |
112 | } | |
113 | nonblock := regexp.MustCompile(`^\/\/sysnb `).FindStringSubmatch(t) | |
114 | if regexp.MustCompile(`^\/\/sys `).FindStringSubmatch(t) == nil && nonblock == nil { | |
115 | continue | |
116 | } | |
117 | ||
118 | // Line must be of the form | |
119 | // func Open(path string, mode int, perm int) (fd int, err error) | |
120 | // Split into name, in params, out params. | |
121 | f := regexp.MustCompile(`^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*(?:(\w*)\.)?(\w*))?$`).FindStringSubmatch(t) | |
122 | if f == nil { | |
123 | fmt.Fprintf(os.Stderr, "%s:%s\nmalformed //sys declaration\n", path, t) | |
124 | os.Exit(1) | |
125 | } | |
126 | funct, inps, outps, modname, sysname := f[2], f[3], f[4], f[5], f[6] | |
127 | ||
128 | // Split argument lists on comma. | |
129 | in := parseParamList(inps) | |
130 | out := parseParamList(outps) | |
131 | ||
132 | inps = strings.Join(in, ", ") | |
133 | outps = strings.Join(out, ", ") | |
134 | ||
135 | // Try in vain to keep people from editing this file. | |
136 | // The theory is that they jump into the middle of the file | |
137 | // without reading the header. | |
138 | text += "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n" | |
139 | ||
140 | // Check if value return, err return available | |
141 | errvar := "" | |
142 | retvar := "" | |
143 | rettype := "" | |
144 | for _, param := range out { | |
145 | p := parseParam(param) | |
146 | if p.Type == "error" { | |
147 | errvar = p.Name | |
148 | } else { | |
149 | retvar = p.Name | |
150 | rettype = p.Type | |
151 | } | |
152 | } | |
153 | ||
154 | // System call name. | |
155 | if sysname == "" { | |
156 | sysname = funct | |
157 | } | |
158 | sysname = regexp.MustCompile(`([a-z])([A-Z])`).ReplaceAllString(sysname, `${1}_$2`) | |
159 | sysname = strings.ToLower(sysname) // All libc functions are lowercase. | |
160 | ||
161 | cRettype := "" | |
162 | if rettype == "unsafe.Pointer" { | |
163 | cRettype = "uintptr_t" | |
164 | } else if rettype == "uintptr" { | |
165 | cRettype = "uintptr_t" | |
166 | } else if regexp.MustCompile(`^_`).FindStringSubmatch(rettype) != nil { | |
167 | cRettype = "uintptr_t" | |
168 | } else if rettype == "int" { | |
169 | cRettype = "int" | |
170 | } else if rettype == "int32" { | |
171 | cRettype = "int" | |
172 | } else if rettype == "int64" { | |
173 | cRettype = "long long" | |
174 | } else if rettype == "uint32" { | |
175 | cRettype = "unsigned int" | |
176 | } else if rettype == "uint64" { | |
177 | cRettype = "unsigned long long" | |
178 | } else { | |
179 | cRettype = "int" | |
180 | } | |
181 | if sysname == "exit" { | |
182 | cRettype = "void" | |
183 | } | |
184 | ||
185 | // Change p.Types to c | |
186 | var cIn []string | |
187 | for _, param := range in { | |
188 | p := parseParam(param) | |
189 | if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil { | |
190 | cIn = append(cIn, "uintptr_t") | |
191 | } else if p.Type == "string" { | |
192 | cIn = append(cIn, "uintptr_t") | |
193 | } else if regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type) != nil { | |
194 | cIn = append(cIn, "uintptr_t", "size_t") | |
195 | } else if p.Type == "unsafe.Pointer" { | |
196 | cIn = append(cIn, "uintptr_t") | |
197 | } else if p.Type == "uintptr" { | |
198 | cIn = append(cIn, "uintptr_t") | |
199 | } else if regexp.MustCompile(`^_`).FindStringSubmatch(p.Type) != nil { | |
200 | cIn = append(cIn, "uintptr_t") | |
201 | } else if p.Type == "int" { | |
202 | cIn = append(cIn, "int") | |
203 | } else if p.Type == "int32" { | |
204 | cIn = append(cIn, "int") | |
205 | } else if p.Type == "int64" { | |
206 | cIn = append(cIn, "long long") | |
207 | } else if p.Type == "uint32" { | |
208 | cIn = append(cIn, "unsigned int") | |
209 | } else if p.Type == "uint64" { | |
210 | cIn = append(cIn, "unsigned long long") | |
211 | } else { | |
212 | cIn = append(cIn, "int") | |
213 | } | |
214 | } | |
215 | ||
216 | if funct != "fcntl" && funct != "FcntlInt" && funct != "readlen" && funct != "writelen" { | |
217 | if sysname == "select" { | |
218 | // select is a keyword of Go. Its name is | |
219 | // changed to c_select. | |
220 | cExtern += "#define c_select select\n" | |
221 | } | |
222 | // Imports of system calls from libc | |
223 | cExtern += fmt.Sprintf("%s %s", cRettype, sysname) | |
224 | cIn := strings.Join(cIn, ", ") | |
225 | cExtern += fmt.Sprintf("(%s);\n", cIn) | |
226 | } | |
227 | ||
228 | // So file name. | |
229 | if *aix { | |
230 | if modname == "" { | |
231 | modname = "libc.a/shr_64.o" | |
232 | } else { | |
233 | fmt.Fprintf(os.Stderr, "%s: only syscall using libc are available\n", funct) | |
234 | os.Exit(1) | |
235 | } | |
236 | } | |
237 | ||
238 | strconvfunc := "C.CString" | |
239 | ||
240 | // Go function header. | |
241 | if outps != "" { | |
242 | outps = fmt.Sprintf(" (%s)", outps) | |
243 | } | |
244 | if text != "" { | |
245 | text += "\n" | |
246 | } | |
247 | ||
248 | text += fmt.Sprintf("func %s(%s)%s {\n", funct, strings.Join(in, ", "), outps) | |
249 | ||
250 | // Prepare arguments to Syscall. | |
251 | var args []string | |
252 | n := 0 | |
253 | argN := 0 | |
254 | for _, param := range in { | |
255 | p := parseParam(param) | |
256 | if regexp.MustCompile(`^\*`).FindStringSubmatch(p.Type) != nil { | |
257 | args = append(args, "C.uintptr_t(uintptr(unsafe.Pointer("+p.Name+")))") | |
258 | } else if p.Type == "string" && errvar != "" { | |
259 | text += fmt.Sprintf("\t_p%d := uintptr(unsafe.Pointer(%s(%s)))\n", n, strconvfunc, p.Name) | |
260 | args = append(args, fmt.Sprintf("C.uintptr_t(_p%d)", n)) | |
261 | n++ | |
262 | } else if p.Type == "string" { | |
263 | fmt.Fprintf(os.Stderr, path+":"+funct+" uses string arguments, but has no error return\n") | |
264 | text += fmt.Sprintf("\t_p%d := uintptr(unsafe.Pointer(%s(%s)))\n", n, strconvfunc, p.Name) | |
265 | args = append(args, fmt.Sprintf("C.uintptr_t(_p%d)", n)) | |
266 | n++ | |
267 | } else if m := regexp.MustCompile(`^\[\](.*)`).FindStringSubmatch(p.Type); m != nil { | |
268 | // Convert slice into pointer, length. | |
269 | // Have to be careful not to take address of &a[0] if len == 0: | |
270 | // pass nil in that case. | |
271 | text += fmt.Sprintf("\tvar _p%d *%s\n", n, m[1]) | |
272 | text += fmt.Sprintf("\tif len(%s) > 0 {\n\t\t_p%d = &%s[0]\n\t}\n", p.Name, n, p.Name) | |
273 | args = append(args, fmt.Sprintf("C.uintptr_t(uintptr(unsafe.Pointer(_p%d)))", n)) | |
274 | n++ | |
275 | text += fmt.Sprintf("\tvar _p%d int\n", n) | |
276 | text += fmt.Sprintf("\t_p%d = len(%s)\n", n, p.Name) | |
277 | args = append(args, fmt.Sprintf("C.size_t(_p%d)", n)) | |
278 | n++ | |
279 | } else if p.Type == "int64" && endianness != "" { | |
280 | if endianness == "big-endian" { | |
281 | args = append(args, fmt.Sprintf("uintptr(%s>>32)", p.Name), fmt.Sprintf("uintptr(%s)", p.Name)) | |
282 | } else { | |
283 | args = append(args, fmt.Sprintf("uintptr(%s)", p.Name), fmt.Sprintf("uintptr(%s>>32)", p.Name)) | |
284 | } | |
285 | n++ | |
286 | } else if p.Type == "bool" { | |
287 | text += fmt.Sprintf("\tvar _p%d uint32\n", n) | |
288 | text += fmt.Sprintf("\tif %s {\n\t\t_p%d = 1\n\t} else {\n\t\t_p%d = 0\n\t}\n", p.Name, n, n) | |
289 | args = append(args, fmt.Sprintf("_p%d", n)) | |
290 | } else if regexp.MustCompile(`^_`).FindStringSubmatch(p.Type) != nil { | |
291 | args = append(args, fmt.Sprintf("C.uintptr_t(uintptr(%s))", p.Name)) | |
292 | } else if p.Type == "unsafe.Pointer" { | |
293 | args = append(args, fmt.Sprintf("C.uintptr_t(uintptr(%s))", p.Name)) | |
294 | } else if p.Type == "int" { | |
295 | if (argN == 2) && ((funct == "readlen") || (funct == "writelen")) { | |
296 | args = append(args, fmt.Sprintf("C.size_t(%s)", p.Name)) | |
297 | } else if argN == 0 && funct == "fcntl" { | |
298 | args = append(args, fmt.Sprintf("C.uintptr_t(%s)", p.Name)) | |
299 | } else if (argN == 2) && ((funct == "fcntl") || (funct == "FcntlInt")) { | |
300 | args = append(args, fmt.Sprintf("C.uintptr_t(%s)", p.Name)) | |
301 | } else { | |
302 | args = append(args, fmt.Sprintf("C.int(%s)", p.Name)) | |
303 | } | |
304 | } else if p.Type == "int32" { | |
305 | args = append(args, fmt.Sprintf("C.int(%s)", p.Name)) | |
306 | } else if p.Type == "int64" { | |
307 | args = append(args, fmt.Sprintf("C.longlong(%s)", p.Name)) | |
308 | } else if p.Type == "uint32" { | |
309 | args = append(args, fmt.Sprintf("C.uint(%s)", p.Name)) | |
310 | } else if p.Type == "uint64" { | |
311 | args = append(args, fmt.Sprintf("C.ulonglong(%s)", p.Name)) | |
312 | } else if p.Type == "uintptr" { | |
313 | args = append(args, fmt.Sprintf("C.uintptr_t(%s)", p.Name)) | |
314 | } else { | |
315 | args = append(args, fmt.Sprintf("C.int(%s)", p.Name)) | |
316 | } | |
317 | argN++ | |
318 | } | |
319 | ||
320 | // Actual call. | |
321 | arglist := strings.Join(args, ", ") | |
322 | call := "" | |
323 | if sysname == "exit" { | |
324 | if errvar != "" { | |
325 | call += "er :=" | |
326 | } else { | |
327 | call += "" | |
328 | } | |
329 | } else if errvar != "" { | |
330 | call += "r0,er :=" | |
331 | } else if retvar != "" { | |
332 | call += "r0,_ :=" | |
333 | } else { | |
334 | call += "" | |
335 | } | |
336 | if sysname == "select" { | |
337 | // select is a keyword of Go. Its name is | |
338 | // changed to c_select. | |
339 | call += fmt.Sprintf("C.c_%s(%s)", sysname, arglist) | |
340 | } else { | |
341 | call += fmt.Sprintf("C.%s(%s)", sysname, arglist) | |
342 | } | |
343 | ||
344 | // Assign return values. | |
345 | body := "" | |
346 | for i := 0; i < len(out); i++ { | |
347 | p := parseParam(out[i]) | |
348 | reg := "" | |
349 | if p.Name == "err" { | |
350 | reg = "e1" | |
351 | } else { | |
352 | reg = "r0" | |
353 | } | |
354 | if reg != "e1" { | |
355 | body += fmt.Sprintf("\t%s = %s(%s)\n", p.Name, p.Type, reg) | |
356 | } | |
357 | } | |
358 | ||
359 | // verify return | |
360 | if sysname != "exit" && errvar != "" { | |
361 | if regexp.MustCompile(`^uintptr`).FindStringSubmatch(cRettype) != nil { | |
362 | body += "\tif (uintptr(r0) ==^uintptr(0) && er != nil) {\n" | |
363 | body += fmt.Sprintf("\t\t%s = er\n", errvar) | |
364 | body += "\t}\n" | |
365 | } else { | |
366 | body += "\tif (r0 ==-1 && er != nil) {\n" | |
367 | body += fmt.Sprintf("\t\t%s = er\n", errvar) | |
368 | body += "\t}\n" | |
369 | } | |
370 | } else if errvar != "" { | |
371 | body += "\tif (er != nil) {\n" | |
372 | body += fmt.Sprintf("\t\t%s = er\n", errvar) | |
373 | body += "\t}\n" | |
374 | } | |
375 | ||
376 | text += fmt.Sprintf("\t%s\n", call) | |
377 | text += body | |
378 | ||
379 | text += "\treturn\n" | |
380 | text += "}\n" | |
381 | } | |
382 | if err := s.Err(); err != nil { | |
383 | fmt.Fprintf(os.Stderr, err.Error()) | |
384 | os.Exit(1) | |
385 | } | |
386 | file.Close() | |
387 | } | |
388 | imp := "" | |
389 | if pack != "unix" { | |
390 | imp = "import \"golang.org/x/sys/unix\"\n" | |
391 | ||
392 | } | |
393 | fmt.Printf(srcTemplate, cmdLine(), buildTags(), pack, cExtern, imp, text) | |
394 | } | |
395 | ||
396 | const srcTemplate = `// %s | |
397 | // Code generated by the command above; see README.md. DO NOT EDIT. | |
398 | ||
399 | // +build %s | |
400 | ||
401 | package %s | |
402 | ||
403 | ||
404 | %s | |
405 | */ | |
406 | import "C" | |
407 | import ( | |
408 | "unsafe" | |
409 | ) | |
410 | ||
411 | ||
412 | %s | |
413 | ||
414 | %s | |
415 | ` |