Home | History | Annotate | Download | only in unix 
      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 
     20 use strict;
     21 
     22 my $cmdline = "mksyscall_solaris.pl " . join(' ', @ARGV);
     23 my $errors = 0;
     24 my $_32bit = "";
     25 my $tags = "";  # build tags
     26 
     27 binmode STDOUT;
     28 
     29 if($ARGV[0] eq "-b32") {
     30 	$_32bit = "big-endian";
     31 	shift;
     32 } elsif($ARGV[0] eq "-l32") {
     33 	$_32bit = "little-endian";
     34 	shift;
     35 }
     36 if($ARGV[0] eq "-tags") {
     37 	shift;
     38 	$tags = $ARGV[0];
     39 	shift;
     40 }
     41 
     42 if($ARGV[0] =~ /^-/) {
     43 	print STDERR "usage: mksyscall_solaris.pl [-b32 | -l32] [-tags x,y] [file ...]\n";
     44 	exit 1;
     45 }
     46 
     47 sub 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 
     57 sub 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 
     67 my $package = "";
     68 my $text = "";
     69 my $dynimports = "";
     70 my $linknames = "";
     71 my @vars = ();
     72 while(<>) {
     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 
    255 if($errors) {
    256 	exit 1;
    257 }
    258 
    259 print <<EOF;
    260 // $cmdline
    261 // Code generated by the command above; see README.md. DO NOT EDIT.
    262 
    263 // +build $tags
    264 
    265 package $package
    266 
    267 import (
    268 	"syscall"
    269 	"unsafe"
    270 )
    271 EOF
    272 
    273 print "import \"golang.org/x/sys/unix\"\n" if $package ne "unix";
    274 
    275 my $vardecls = "\t" . join(",\n\t", @vars);
    276 $vardecls .= " syscallFunc";
    277 
    278 chomp($_=<<EOF);
    279 
    280 $dynimports
    281 $linknames
    282 var (
    283 $vardecls
    284 )
    285 
    286 $text
    287 EOF
    288 print $_;
    289 exit 0;
    290