vendor/golang.org/x/sys/unix/mksyscall_solaris.pl

   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         # Try in vain to keep people from editing this file.
  96         # The theory is that they jump into the middle of the file
  97         # without reading the header.
  98         $text .= "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n";
  99
 100         # So file name.
 101         if($modname eq "") {
 102                 $modname = "libc";
 103         }
 104
 105         # System call name.
 106         if($sysname eq "") {
 107                 $sysname = "$func";
 108         }
 109
 110         # System call pointer variable name.
 111         my $sysvarname = "proc$sysname";
 112
 113         my $strconvfunc = "BytePtrFromString";
 114         my $strconvtype = "*byte";
 115
 116         $sysname =~ y/A-Z/a-z/; # All libc functions are lowercase.
 117
 118         # Runtime import of function to allow cross-platform builds.
 119         $dynimports .= "//go:cgo_import_dynamic libc_${sysname} ${sysname} \"$modname.so\"\n";
 120         # Link symbol to proc address variable.
 121         $linknames .= "//go:linkname ${sysvarname} libc_${sysname}\n";
 122         # Library proc address variable.
 123         push @vars, $sysvarname;
 124
 125         # Go function header.
 126         $out = join(', ', @out);
 127         if($out ne "") {
 128                 $out = " ($out)";
 129         }
 130         if($text ne "") {
 131                 $text .= "\n"
 132         }
 133         $text .= sprintf "func %s(%s)%s {\n", $func, join(', ', @in), $out;
 134
 135         # Check if err return available
 136         my $errvar = "";
 137         foreach my $p (@out) {
 138                 my ($name, $type) = parseparam($p);
 139                 if($type eq "error") {
 140                         $errvar = $name;
 141                         last;
 142                 }
 143         }
 144
 145         # Prepare arguments to Syscall.
 146         my @args = ();
 147         my $n = 0;
 148         foreach my $p (@in) {
 149                 my ($name, $type) = parseparam($p);
 150                 if($type =~ /^\*/) {
 151                         push @args, "uintptr(unsafe.Pointer($name))";
 152                 } elsif($type eq "string" && $errvar ne "") {
 153                         $text .= "\tvar _p$n $strconvtype\n";
 154                         $text .= "\t_p$n, $errvar = $strconvfunc($name)\n";
 155                         $text .= "\tif $errvar != nil {\n\t\treturn\n\t}\n";
 156                         push @args, "uintptr(unsafe.Pointer(_p$n))";
 157                         $n++;
 158                 } elsif($type eq "string") {
 159                         print STDERR "$ARGV:$.: $func uses string arguments, but has no error return\n";
 160                         $text .= "\tvar _p$n $strconvtype\n";
 161                         $text .= "\t_p$n, _ = $strconvfunc($name)\n";
 162                         push @args, "uintptr(unsafe.Pointer(_p$n))";
 163                         $n++;
 164                 } elsif($type =~ /^\[\](.*)/) {
 165                         # Convert slice into pointer, length.
 166                         # Have to be careful not to take address of &a[0] if len == 0:
 167                         # pass nil in that case.
 168                         $text .= "\tvar _p$n *$1\n";
 169                         $text .= "\tif len($name) > 0 {\n\t\t_p$n = \&$name\[0]\n\t}\n";
 170                         push @args, "uintptr(unsafe.Pointer(_p$n))", "uintptr(len($name))";
 171                         $n++;
 172                 } elsif($type eq "int64" && $_32bit ne "") {
 173                         if($_32bit eq "big-endian") {
 174                                 push @args, "uintptr($name >> 32)", "uintptr($name)";
 175                         } else {
 176                                 push @args, "uintptr($name)", "uintptr($name >> 32)";
 177                         }
 178                 } elsif($type eq "bool") {
 179                         $text .= "\tvar _p$n uint32\n";
 180                         $text .= "\tif $name {\n\t\t_p$n = 1\n\t} else {\n\t\t_p$n = 0\n\t}\n";
 181                         push @args, "uintptr(_p$n)";
 182                         $n++;
 183                 } else {
 184                         push @args, "uintptr($name)";
 185                 }
 186         }
 187         my $nargs = @args;
 188
 189         # Determine which form to use; pad args with zeros.
 190         my $asm = "sysvicall6";
 191         if ($nonblock) {
 192                 $asm = "rawSysvicall6";
 193         }
 194         if(@args <= 6) {
 195                 while(@args < 6) {
 196                         push @args, "0";
 197                 }
 198         } else {
 199                 print STDERR "$ARGV:$.: too many arguments to system call\n";
 200         }
 201
 202         # Actual call.
 203         my $args = join(', ', @args);
 204         my $call = "$asm(uintptr(unsafe.Pointer(&$sysvarname)), $nargs, $args)";
 205
 206         # Assign return values.
 207         my $body = "";
 208         my $failexpr = "";
 209         my @ret = ("_", "_", "_");
 210         my @pout= ();
 211         my $do_errno = 0;
 212         for(my $i=0; $i<@out; $i++) {
 213                 my $p = $out[$i];
 214                 my ($name, $type) = parseparam($p);
 215                 my $reg = "";
 216                 if($name eq "err") {
 217                         $reg = "e1";
 218                         $ret[2] = $reg;
 219                         $do_errno = 1;
 220                 } else {
 221                         $reg = sprintf("r%d", $i);
 222                         $ret[$i] = $reg;
 223                 }
 224                 if($type eq "bool") {
 225                         $reg = "$reg != 0";
 226                 }
 227                 if($type eq "int64" && $_32bit ne "") {
 228                         # 64-bit number in r1:r0 or r0:r1.
 229                         if($i+2 > @out) {
 230                                 print STDERR "$ARGV:$.: not enough registers for int64 return\n";
 231                         }
 232                         if($_32bit eq "big-endian") {
 233                                 $reg = sprintf("int64(r%d)<<32 | int64(r%d)", $i, $i+1);
 234                         } else {
 235                                 $reg = sprintf("int64(r%d)<<32 | int64(r%d)", $i+1, $i);
 236                         }
 237                         $ret[$i] = sprintf("r%d", $i);
 238                         $ret[$i+1] = sprintf("r%d", $i+1);
 239                 }
 240                 if($reg ne "e1") {
 241                         $body .= "\t$name = $type($reg)\n";
 242                 }
 243         }
 244         if ($ret[0] eq "_" && $ret[1] eq "_" && $ret[2] eq "_") {
 245                 $text .= "\t$call\n";
 246         } else {
 247                 $text .= "\t$ret[0], $ret[1], $ret[2] := $call\n";
 248         }
 249         $text .= $body;
 250
 251         if ($do_errno) {
 252                 $text .= "\tif e1 != 0 {\n";
 253                 $text .= "\t\terr = e1\n";
 254                 $text .= "\t}\n";
 255         }
 256         $text .= "\treturn\n";
 257         $text .= "}\n";
 258 }
 259
 260 if($errors) {
 261         exit 1;
 262 }
 263
 264 print <<EOF;
 265 // $cmdline
 266 // Code generated by the command above; see README.md. DO NOT EDIT.
 267
 268 // +build $tags
 269
 270 package $package
 271
 272 import (
 273         "syscall"
 274         "unsafe"
 275 )
 276 EOF
 277
 278 print "import \"golang.org/x/sys/unix\"\n" if $package ne "unix";
 279
 280 my $vardecls = "\t" . join(",\n\t", @vars);
 281 $vardecls .= " syscallFunc";
 282
 283 chomp($_=<<EOF);
 284
 285 $dynimports
 286 $linknames
 287 var (
 288 $vardecls
 289 )
 290
 291 $text
 292 EOF
 293 print $_;
 294 exit 0;