1#!/usr/bin/env perl
2# Copyright 2009 The Go Authors. All rights reserved.
3# Use of this source code is governed by a BSD-style
4# license that can be found in the LICENSE file.
5
6# This program reads a file containing function prototypes
7# (like syscall_solaris.go) and generates system call bodies.
8# The prototypes are marked by lines beginning with "//sys"
9# and read like func declarations if //sys is replaced by func, but:
10# * The parameter lists must give a name for each argument.
11# This includes return parameters.
12# * The parameter lists must give a type for each argument:
13# the (x, y, z int) shorthand is not allowed.
14# * If the return parameter is an error number, it must be named err.
15# * If go func name needs to be different than its libc name,
16# * or the function is not in libc, name could be specified
17# * at the end, after "=" sign, like
18# //sys getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) = libsocket.getsockopt
19
20use strict;
21
22my $cmdline = "mksyscall_solaris.pl " . join(' ', @ARGV);
23my $errors = 0;
24my $_32bit = "";
25my $tags = ""; # build tags
26
27binmode STDOUT;
28
29if($ARGV[0] eq "-b32") {
30 $_32bit = "big-endian";
31 shift;
32} elsif($ARGV[0] eq "-l32") {
33 $_32bit = "little-endian";
34 shift;
35}
36if($ARGV[0] eq "-tags") {
37 shift;
38 $tags = $ARGV[0];
39 shift;
40}
41
42if($ARGV[0] =~ /^-/) {
43 print STDERR "usage: mksyscall_solaris.pl [-b32 | -l32] [-tags x,y] [file ...]\n";
44 exit 1;
45}
46
47sub parseparamlist($) {
48 my ($list) = @_;
49 $list =~ s/^\s*//;
50 $list =~ s/\s*$//;
51 if($list eq "") {
52 return ();
53 }
54 return split(/\s*,\s*/, $list);
55}
56
57sub parseparam($) {
58 my ($p) = @_;
59 if($p !~ /^(\S*) (\S*)$/) {
60 print STDERR "$ARGV:$.: malformed parameter: $p\n";
61 $errors = 1;
62 return ("xx", "int");
63 }
64 return ($1, $2);
65}
66
67my $package = "";
68my $text = "";
69my $dynimports = "";
70my $linknames = "";
71my @vars = ();
72while(<>) {
73 chomp;
74 s/\s+/ /g;
75 s/^\s+//;
76 s/\s+$//;
77 $package = $1 if !$package && /^package (\S+)$/;
78 my $nonblock = /^\/\/sysnb /;
79 next if !/^\/\/sys / && !$nonblock;
80
81 # Line must be of the form
82 # func Open(path string, mode int, perm int) (fd int, err error)
83 # Split into name, in params, out params.
84 if(!/^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*(?:(\w*)\.)?(\w*))?$/) {
85 print STDERR "$ARGV:$.: malformed //sys declaration\n";
86 $errors = 1;
87 next;
88 }
89 my ($nb, $func, $in, $out, $modname, $sysname) = ($1, $2, $3, $4, $5, $6);
90
91 # Split argument lists on comma.
92 my @in = parseparamlist($in);
93 my @out = parseparamlist($out);
94
95 # So file name.
96 if($modname eq "") {
97 $modname = "libc";
98 }
99
100 # System call name.
101 if($sysname eq "") {
102 $sysname = "$func";
103 }
104
105 # System call pointer variable name.
106 my $sysvarname = "proc$sysname";
107
108 my $strconvfunc = "BytePtrFromString";
109 my $strconvtype = "*byte";
110
111 $sysname =~ y/A-Z/a-z/; # All libc functions are lowercase.
112
113 # Runtime import of function to allow cross-platform builds.
114 $dynimports .= "//go:cgo_import_dynamic libc_${sysname} ${sysname} \"$modname.so\"\n";
115 # Link symbol to proc address variable.
116 $linknames .= "//go:linkname ${sysvarname} libc_${sysname}\n";
117 # Library proc address variable.
118 push @vars, $sysvarname;
119
120 # Go function header.
121 $out = join(', ', @out);
122 if($out ne "") {
123 $out = " ($out)";
124 }
125 if($text ne "") {
126 $text .= "\n"
127 }
128 $text .= sprintf "func %s(%s)%s {\n", $func, join(', ', @in), $out;
129
130 # Check if err return available
131 my $errvar = "";
132 foreach my $p (@out) {
133 my ($name, $type) = parseparam($p);
134 if($type eq "error") {
135 $errvar = $name;
136 last;
137 }
138 }
139
140 # Prepare arguments to Syscall.
141 my @args = ();
142 my $n = 0;
143 foreach my $p (@in) {
144 my ($name, $type) = parseparam($p);
145 if($type =~ /^\*/) {
146 push @args, "uintptr(unsafe.Pointer($name))";
147 } elsif($type eq "string" && $errvar ne "") {
148 $text .= "\tvar _p$n $strconvtype\n";
149 $text .= "\t_p$n, $errvar = $strconvfunc($name)\n";
150 $text .= "\tif $errvar != nil {\n\t\treturn\n\t}\n";
151 push @args, "uintptr(unsafe.Pointer(_p$n))";
152 $n++;
153 } elsif($type eq "string") {
154 print STDERR "$ARGV:$.: $func uses string arguments, but has no error return\n";
155 $text .= "\tvar _p$n $strconvtype\n";
156 $text .= "\t_p$n, _ = $strconvfunc($name)\n";
157 push @args, "uintptr(unsafe.Pointer(_p$n))";
158 $n++;
159 } elsif($type =~ /^\[\](.*)/) {
160 # Convert slice into pointer, length.
161 # Have to be careful not to take address of &a[0] if len == 0:
162 # pass nil in that case.
163 $text .= "\tvar _p$n *$1\n";
164 $text .= "\tif len($name) > 0 {\n\t\t_p$n = \&$name\[0]\n\t}\n";
165 push @args, "uintptr(unsafe.Pointer(_p$n))", "uintptr(len($name))";
166 $n++;
167 } elsif($type eq "int64" && $_32bit ne "") {
168 if($_32bit eq "big-endian") {
169 push @args, "uintptr($name >> 32)", "uintptr($name)";
170 } else {
171 push @args, "uintptr($name)", "uintptr($name >> 32)";
172 }
173 } elsif($type eq "bool") {
174 $text .= "\tvar _p$n uint32\n";
175 $text .= "\tif $name {\n\t\t_p$n = 1\n\t} else {\n\t\t_p$n = 0\n\t}\n";
176 push @args, "uintptr(_p$n)";
177 $n++;
178 } else {
179 push @args, "uintptr($name)";
180 }
181 }
182 my $nargs = @args;
183
184 # Determine which form to use; pad args with zeros.
185 my $asm = "sysvicall6";
186 if ($nonblock) {
187 $asm = "rawSysvicall6";
188 }
189 if(@args <= 6) {
190 while(@args < 6) {
191 push @args, "0";
192 }
193 } else {
194 print STDERR "$ARGV:$.: too many arguments to system call\n";
195 }
196
197 # Actual call.
198 my $args = join(', ', @args);
199 my $call = "$asm(uintptr(unsafe.Pointer(&$sysvarname)), $nargs, $args)";
200
201 # Assign return values.
202 my $body = "";
203 my $failexpr = "";
204 my @ret = ("_", "_", "_");
205 my @pout= ();
206 my $do_errno = 0;
207 for(my $i=0; $i<@out; $i++) {
208 my $p = $out[$i];
209 my ($name, $type) = parseparam($p);
210 my $reg = "";
211 if($name eq "err") {
212 $reg = "e1";
213 $ret[2] = $reg;
214 $do_errno = 1;
215 } else {
216 $reg = sprintf("r%d", $i);
217 $ret[$i] = $reg;
218 }
219 if($type eq "bool") {
220 $reg = "$reg != 0";
221 }
222 if($type eq "int64" && $_32bit ne "") {
223 # 64-bit number in r1:r0 or r0:r1.
224 if($i+2 > @out) {
225 print STDERR "$ARGV:$.: not enough registers for int64 return\n";
226 }
227 if($_32bit eq "big-endian") {
228 $reg = sprintf("int64(r%d)<<32 | int64(r%d)", $i, $i+1);
229 } else {
230 $reg = sprintf("int64(r%d)<<32 | int64(r%d)", $i+1, $i);
231 }
232 $ret[$i] = sprintf("r%d", $i);
233 $ret[$i+1] = sprintf("r%d", $i+1);
234 }
235 if($reg ne "e1") {
236 $body .= "\t$name = $type($reg)\n";
237 }
238 }
239 if ($ret[0] eq "_" && $ret[1] eq "_" && $ret[2] eq "_") {
240 $text .= "\t$call\n";
241 } else {
242 $text .= "\t$ret[0], $ret[1], $ret[2] := $call\n";
243 }
244 $text .= $body;
245
246 if ($do_errno) {
247 $text .= "\tif e1 != 0 {\n";
248 $text .= "\t\terr = e1\n";
249 $text .= "\t}\n";
250 }
251 $text .= "\treturn\n";
252 $text .= "}\n";
253}
254
255if($errors) {
256 exit 1;
257}
258
259print <<EOF;
260// $cmdline
261// Code generated by the command above; see README.md. DO NOT EDIT.
262
263// +build $tags
264
265package $package
266
267import (
268 "syscall"
269 "unsafe"
270)
271EOF
272
273print "import \"golang.org/x/sys/unix\"\n" if $package ne "unix";
274
275my $vardecls = "\t" . join(",\n\t", @vars);
276$vardecls .= " syscallFunc";
277
278chomp($_=<<EOF);
279
280$dynimports
281$linknames
282var (
283$vardecls
284)
285
286$text
287EOF
288print $_;
289exit 0;