* src_libgo_go_net_sendfile_gnu.go.diff: New file
* src_libgo_go_net_sock_gnu.go.diff: New file
* src_libgo_go_net_sockopt_gnu.go.diff: New file
* src_libgo_go_net_sockoptip_gnu.go.diff: New file
* src_libgo_go_syscall_libcall_gnu_386.go.diff: New file
* src_libgo_go_syscall_libcall_gnu.go.diff: New file
* src_libgo_go_syscall_libcall_posix-1.go.diff: New file derived from
libcall_posix.go
Removed the mount call for GNU/Hurd, it exists but use translators.
Removed the mlockall/munlockall calls for GNU/Hurd, not yet
implemented.
Removed the madvise call for GNU/Hurd, not yet implemented.
* src_libgo_go_syscall_socket_gnu.go.diff: New file
Index: gcc-6-6.2.1-4.1/src/libgo/go/net/sendfile_gnu.go
===================================================================
--- /dev/null
+++ gcc-6-6.2.1-4.1/src/libgo/go/net/sendfile_gnu.go
@@ -0,0 +1,79 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package net
+
+import (
+ "io"
+ "os"
+ "syscall"
+)
+
+// maxSendfileSize is the largest chunk size we ask the kernel to copy
+// at a time.
+const maxSendfileSize int = 4 << 20
+
+// sendFile copies the contents of r to c using the sendfile
+// system call to minimize copies.
+//
+// if handled == true, sendFile returns the number of bytes copied and any
+// non-EOF error.
+//
+// if handled == false, sendFile performed no work.
+func sendFile(c *netFD, r io.Reader) (written int64, err error, handled bool) {
+ var remain int64 = 1 << 62 // by default, copy until EOF
+
+ lr, ok := r.(*io.LimitedReader)
+ if ok {
+ remain, r = lr.N, lr.R
+ if remain <= 0 {
+ return 0, nil, true
+ }
+ }
+ f, ok := r.(*os.File)
+ if !ok {
+ return 0, nil, false
+ }
+
+ if err := c.writeLock(); err != nil {
+ return 0, err, true
+ }
+ defer c.writeUnlock()
+
+ dst := c.sysfd
+ src := int(f.Fd())
+ for remain > 0 {
+ n := maxSendfileSize
+ if int64(n) > remain {
+ n = int(remain)
+ }
+ n, err1 := syscall.Sendfile(dst, src, nil, n)
+ if n > 0 {
+ written += int64(n)
+ remain -= int64(n)
+ }
+ if n == 0 && err1 == nil {
+ break
+ }
+ if err1 == syscall.EAGAIN {
+ if err1 = c.pd.WaitWrite(); err1 == nil {
+ continue
+ }
+ }
+ if err1 != nil {
+ // This includes syscall.ENOSYS (no kernel
+ // support) and syscall.EINVAL (fd types which
+ // don't implement sendfile)
+ err = err1
+ break
+ }
+ }
+ if lr != nil {
+ lr.N = remain
+ }
+ if err != nil {
+ err = os.NewSyscallError("sendfile", err)
+ }
+ return written, err, written > 0
+}
Index: gcc-6-6.2.1-4.1/src/libgo/go/net/sock_gnu.go
===================================================================
--- /dev/null
+++ gcc-6-6.2.1-4.1/src/libgo/go/net/sock_gnu.go
@@ -0,0 +1,14 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build gnu
+
+package net
+
+import "syscall"
+
+func maxListenerBacklog() int {
+ // From /usr/include/i386-gnu/bits/socket.h
+ return syscall.SOMAXCONN
+}
Index: gcc-6-6.2.1-4.1/src/libgo/go/net/sockopt_gnu.go
===================================================================
--- /dev/null
+++ gcc-6-6.2.1-4.1/src/libgo/go/net/sockopt_gnu.go
@@ -0,0 +1,45 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build gnu
+
+package net
+
+import (
+ "os"
+ "syscall"
+)
+
+func setDefaultSockopts(s, family, sotype int, ipv6only bool) error {
+ if family == syscall.AF_INET6 && sotype != syscall.SOCK_RAW {
+ // Allow both IP versions even if the OS default
+ // is otherwise. Note that some operating systems
+ // never admit this option.
+ syscall.SetsockoptInt(s, syscall.IPPROTO_IPV6, syscall.IPV6_V6ONLY, boolint(ipv6only))
+ }
+ // Allow broadcast.
+ return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(s, syscall.SOL_SOCKET, syscall.SO_BROADCAST, 1))
+}
+
+func setDefaultListenerSockopts(s int) error {
+ // Allow reuse of recently-used addresses.
+ return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(s, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1))
+}
+
+func setDefaultMulticastSockopts(s int) error {
+ // Allow multicast UDP and raw IP datagram sockets to listen
+ // concurrently across multiple listeners.
+ if err := syscall.SetsockoptInt(s, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1); err != nil {
+ return os.NewSyscallError("setsockopt", err)
+ }
+ // Allow reuse of recently-used ports.
+ // This option is supported only in descendants of 4.4BSD,
+ // to make an effective multicast application that requires
+ // quick draw possible.
+ // Not supported on GNU/Hurd
+ //if syscall.SO_REUSEPORT != 0 {
+ // return os.NewSyscallError("setsockopt", syscall.SetsockoptInt(s, syscall.SOL_SOCKET, syscall.SO_REUSEPORT, 1))
+ //}
+ return nil
+}
Index: gcc-6-6.2.1-4.1/src/libgo/go/net/sockoptip_gnu.go
===================================================================
--- /dev/null
+++ gcc-6-6.2.1-4.1/src/libgo/go/net/sockoptip_gnu.go
@@ -0,0 +1,30 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build gnu
+
+package net
+
+import (
+ "os"
+ "syscall"
+)
+
+func setIPv4MulticastInterface(fd *netFD, ifi *Interface) error {
+ ip, err := interfaceToIPv4Addr(ifi)
+ if err != nil {
+ return os.NewSyscallError("setsockopt", err)
+ }
+ var a [4]byte
+ copy(a[:], ip.To4())
+ if err := fd.incref(); err != nil {
+ return err
+ }
+ defer fd.decref()
+ return os.NewSyscallError("setsockopt", syscall.SetsockoptInet4Addr(fd.sysfd, syscall.IPPROTO_IP, syscall.IP_MULTICAST_IF, a))
+}
+
+func setIPv4MulticastLoopback(fd *netFD, v bool) error {
+ return syscall.ENOPROTOOPT
+}
Index: gcc-6-6.2.1-4.1/src/libgo/go/syscall/libcall_gnu.go
===================================================================
--- /dev/null
+++ gcc-6-6.2.1-4.1/src/libgo/go/syscall/libcall_gnu.go
@@ -0,0 +1,185 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// GNU/Hurd library calls.
+
+package syscall
+
+import "unsafe"
+
+//sys Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error)
+//__go_openat(dirfd _C_int, path *byte, flags _C_int, mode Mode_t) _C_int
+
+//sys futimesat(dirfd int, path *byte, times *[2]Timeval) (err error)
+//futimesat(dirfd _C_int, path *byte, times *[2]Timeval) _C_int
+func Futimesat(dirfd int, path string, tv []Timeval) (err error) {
+ if len(tv) != 2 {
+ return EINVAL
+ }
+ return futimesat(dirfd, StringBytePtr(path), (*[2]Timeval)(unsafe.Pointer(&tv[0])))
+}
+
+func Futimes(fd int, tv []Timeval) (err error) {
+ // Believe it or not, this is the best we can do on GNU/Linux
+ // (and is what glibc does).
+ return Utimes("/proc/self/fd/"+itoa(fd), tv)
+}
+
+//sys ptrace(request int, pid int, addr uintptr, data uintptr) (err error)
+//ptrace(request _C_int, pid Pid_t, addr *byte, data *byte) _C_long
+
+// Dummy function
+func raw_ptrace(request int, pid int, addr *byte, data *byte) Errno {
+ return ENOSYS
+}
+
+//sys accept4(fd int, sa *RawSockaddrAny, len *Socklen_t, flags int) (nfd int, err error)
+//accept4(fd _C_int, sa *RawSockaddrAny, len *Socklen_t, flags _C_int) _C_int
+
+func Accept4(fd int, flags int) (nfd int, sa Sockaddr, err error) {
+ var rsa RawSockaddrAny
+ var len Socklen_t = SizeofSockaddrAny
+ nfd, err = accept4(fd, &rsa, &len, flags)
+ if err != nil {
+ return -1, nil, err
+ }
+ sa, err = anyToSockaddr(&rsa)
+ if err != nil {
+ Close(nfd)
+ return -1, nil, err
+ }
+ return nfd, sa, nil
+}
+
+///INCLUDE?
+///sys Acct(path string) (err error)
+///acct(path *byte) _C_int
+
+//sysnb Dup3(oldfd int, newfd int, flags int) (err error)
+//dup3(oldfd _C_int, newfd _C_int, flags _C_int) _C_int
+
+//sys Faccessat(dirfd int, path string, mode uint32, flags int) (err error)
+//faccessat(dirfd _C_int, pathname *byte, mode _C_int, flags _C_int) _C_int
+
+//sys Fallocate(fd int, mode uint32, off int64, len int64) (err error)
+//fallocate(fd _C_int, mode _C_int, offset Offset_t, len Offset_t) _C_int
+
+//sys Fchmodat(dirfd int, path string, mode uint32, flags int) (err error)
+//fchmodat(dirfd _C_int, pathname *byte, mode Mode_t, flags _C_int) _C_int
+
+//sys Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error)
+//fchownat(dirfd _C_int, path *byte, owner Uid_t, group Gid_t, flags _C_int) _C_int
+
+//sys Flock(fd int, how int) (err error)
+//flock(fd _C_int, how _C_int) _C_int
+
+//sys Fstatfs(fd int, buf *Statfs_t) (err error)
+//fstatfs(fd _C_int, buf *Statfs_t) _C_int
+
+func Getdents(fd int, buf []byte) (n int, err error) {
+ var p *byte
+ if len(buf) > 0 {
+ p = &buf[0]
+ } else {
+ p = (*byte)(unsafe.Pointer(&_zero))
+ }
+ s := SYS_GETDENTS64
+ if s == 0 {
+ s = SYS_GETDENTS
+ }
+ r1, _, errno := Syscall(uintptr(s), uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(len(buf)))
+ n = int(r1)
+ if n < 0 {
+ err = errno
+ }
+ return
+}
+
+func clen(n []byte) int {
+ for i := 0; i < len(n); i++ {
+ if n[i] == 0 {
+ return i
+ }
+ }
+ return len(n)
+}
+
+func ReadDirent(fd int, buf []byte) (n int, err error) {
+ return Getdents(fd, buf)
+}
+
+func ParseDirent(buf []byte, max int, names []string) (consumed int, count int, newnames []string) {
+ origlen := len(buf)
+ count = 0
+ for max != 0 && len(buf) > 0 {
+ dirent := (*Dirent)(unsafe.Pointer(&buf[0]))
+ buf = buf[dirent.Reclen:]
+ if dirent.Ino == 0 { // File absent in directory.
+ continue
+ }
+ bytes := (*[10000]byte)(unsafe.Pointer(&dirent.Name[0]))
+ var name = string(bytes[0:clen(bytes[:])])
+ if name == "." || name == ".." { // Useless names
+ continue
+ }
+ max--
+ count++
+ names = append(names, name)
+ }
+ return origlen - len(buf), count, names
+}
+
+///INCLUDE??
+///sys Getxattr(path string, attr string, dest []byte) (sz int, err error)
+///getxattr(path *byte, attr *byte, buf *byte, count Size_t) Ssize_t
+
+///INCLUDE??
+///sys Listxattr(path string, dest []byte) (sz int, err error)
+///listxattr(path *byte, list *byte, size Size_t) Ssize_t
+
+//sys Mkdirat(dirfd int, path string, mode uint32) (err error)
+//mkdirat(dirfd _C_int, path *byte, mode Mode_t) _C_int
+
+//sys Mknodat(dirfd int, path string, mode uint32, dev int) (err error)
+//mknodat(dirfd _C_int, path *byte, mode Mode_t, dev _dev_t) _C_int
+
+//sysnb pipe2(p *[2]_C_int, flags int) (err error)
+//pipe2(p *[2]_C_int, flags _C_int) _C_int
+func Pipe2(p []int, flags int) (err error) {
+ if len(p) != 2 {
+ return EINVAL
+ }
+ var pp [2]_C_int
+ err = pipe2(&pp, flags)
+ p[0] = int(pp[0])
+ p[1] = int(pp[1])
+ return
+}
+
+///INCLUDE??
+///sys Removexattr(path string, attr string) (err error)
+///removexattr(path *byte, name *byte) _C_int
+
+///INCLUDE??
+///sys Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error)
+///renameat(olddirfd _C_int, oldpath *byte, newdirfd _C_int, newpath *byte) _C_int
+
+//INCLUDE??
+///sys Setxattr(path string, attr string, data []byte, flags int) (err error)
+///setxattr(path *byte, name *byte, value *byte, size Size_t, flags _C_int) _C_int
+
+//sys SyncFileRange(fd int, off int64, n int64, flags int) (err error)
+//sync_file_range(fd _C_int, off Offset_t, n Offset_t, flags _C_uint) _C_int
+
+//INCLUDE??
+///sysnb Sysinfo(info *Sysinfo_t) (err error)
+///sysinfo(info *Sysinfo_t) _C_int
+
+//func Unlinkat(dirfd int, path string) (err error) {
+// return unlinkat(dirfd, path, 0)
+//}
+
+///INCLUDE??
+///sys Ustat(dev int, ubuf *Ustat_t) (err error)
+///ustat(dev _dev_t, ubuf *Ustat_t) _C_int
Index: gcc-6-6.2.1-4.1/src/libgo/go/syscall/libcall_gnu_386.go
===================================================================
--- /dev/null
+++ gcc-6-6.2.1-4.1/src/libgo/go/syscall/libcall_gnu_386.go
@@ -0,0 +1,10 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// GNU/Hurd library calls 386 specific.
+
+package syscall
+
+//sys Ioperm(from int, num int, on int) (err error)
+//ioperm(from _C_long, num _C_long, on _C_int) _C_int
Index: gcc-6-6.2.1-4.1/src/libgo/go/syscall/libcall_posix-1.go
===================================================================
--- /dev/null
+++ gcc-6-6.2.1-4.1/src/libgo/go/syscall/libcall_posix-1.go
@@ -0,0 +1,393 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// POSIX library calls.
+// Removed the mount call for GNU/Hurd, it exists but use translators.
+// Functionality is not the same as descibed in Linux <sys/mount.h>
+// Removed the mlockall/munlockall calls for GNU/Hurd, not yet implemented.
+// Removed the madvise call for GNU/Hurd, not yet implemented.
+// This file is compiled as ordinary Go code,
+// but it is also input to mksyscall,
+// which parses the //sys lines and generates library call stubs.
+// Note that sometimes we use a lowercase //sys name and
+// wrap it in our own nicer implementation.
+
+package syscall
+
+import "unsafe"
+
+/*
+ * Wrapped
+ */
+
+//sysnb pipe(p *[2]_C_int) (err error)
+//pipe(p *[2]_C_int) _C_int
+func Pipe(p []int) (err error) {
+ if len(p) != 2 {
+ return EINVAL
+ }
+ var pp [2]_C_int
+ err = pipe(&pp)
+ p[0] = int(pp[0])
+ p[1] = int(pp[1])
+ return
+}
+
+//sys utimes(path string, times *[2]Timeval) (err error)
+//utimes(path *byte, times *[2]Timeval) _C_int
+func Utimes(path string, tv []Timeval) (err error) {
+ if len(tv) != 2 {
+ return EINVAL
+ }
+ return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
+}
+
+//sys getcwd(buf *byte, size Size_t) (err error)
+//getcwd(buf *byte, size Size_t) *byte
+
+const ImplementsGetwd = true
+
+func Getwd() (ret string, err error) {
+ for len := Size_t(4096); ; len *= 2 {
+ b := make([]byte, len)
+ err := getcwd(&b[0], len)
+ if err == nil {
+ i := 0
+ for b[i] != 0 {
+ i++
+ }
+ return string(b[0:i]), nil
+ }
+ if err != ERANGE {
+ return "", err
+ }
+ }
+}
+
+func Getcwd(buf []byte) (n int, err error) {
+ err = getcwd(&buf[0], Size_t(len(buf)))
+ if err == nil {
+ i := 0
+ for buf[i] != 0 {
+ i++
+ }
+ n = i + 1
+ }
+ return
+}
+
+//sysnb getgroups(size int, list *Gid_t) (nn int, err error)
+//getgroups(size _C_int, list *Gid_t) _C_int
+
+func Getgroups() (gids []int, err error) {
+ n, err := getgroups(0, nil)
+ if err != nil {
+ return nil, err
+ }
+ if n == 0 {
+ return nil, nil
+ }
+
+ // Sanity check group count. Max is 1<<16 on GNU/Linux.
+ if n < 0 || n > 1<<20 {
+ return nil, EINVAL
+ }
+
+ a := make([]Gid_t, n)
+ n, err = getgroups(n, &a[0])
+ if err != nil {
+ return nil, err
+ }
+ gids = make([]int, n)
+ for i, v := range a[0:n] {
+ gids[i] = int(v)
+ }
+ return
+}
+
+//sysnb setgroups(n int, list *Gid_t) (err error)
+//setgroups(n Size_t, list *Gid_t) _C_int
+
+func Setgroups(gids []int) (err error) {
+ if len(gids) == 0 {
+ return setgroups(0, nil)
+ }
+
+ a := make([]Gid_t, len(gids))
+ for i, v := range gids {
+ a[i] = Gid_t(v)
+ }
+ return setgroups(len(a), &a[0])
+}
+
+type WaitStatus uint32
+
+// The WaitStatus methods are implemented in C, to pick up the macros
+// #defines in <sys/wait.h>.
+
+func (w WaitStatus) Exited() bool
+func (w WaitStatus) Signaled() bool
+func (w WaitStatus) Stopped() bool
+func (w WaitStatus) Continued() bool
+func (w WaitStatus) CoreDump() bool
+func (w WaitStatus) ExitStatus() int
+func (w WaitStatus) Signal() Signal
+func (w WaitStatus) StopSignal() Signal
+func (w WaitStatus) TrapCause() int
+
+//sys Mkfifo(path string, mode uint32) (err error)
+//mkfifo(path *byte, mode Mode_t) _C_int
+
+//sys Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error)
+//select(nfd _C_int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) _C_int
+
+const nfdbits = int(unsafe.Sizeof(fds_bits_type(0)) * 8)
+
+type FdSet struct {
+ Bits [(FD_SETSIZE + nfdbits - 1) / nfdbits]fds_bits_type
+}
+
+func FDSet(fd int, set *FdSet) {
+ set.Bits[fd/nfdbits] |= (1 << (uint)(fd%nfdbits))
+}
+
+func FDClr(fd int, set *FdSet) {
+ set.Bits[fd/nfdbits] &^= (1 << (uint)(fd%nfdbits))
+}
+
+func FDIsSet(fd int, set *FdSet) bool {
+ if set.Bits[fd/nfdbits]&(1<<(uint)(fd%nfdbits)) != 0 {
+ return true
+ } else {
+ return false
+ }
+}
+
+func FDZero(set *FdSet) {
+ for i := range set.Bits {
+ set.Bits[i] = 0
+ }
+}
+
+//sys Access(path string, mode uint32) (err error)
+//access(path *byte, mode _C_int) _C_int
+
+//sys Chdir(path string) (err error)
+//chdir(path *byte) _C_int
+
+//sys Chmod(path string, mode uint32) (err error)
+//chmod(path *byte, mode Mode_t) _C_int
+
+//sys Chown(path string, uid int, gid int) (err error)
+//chown(path *byte, uid Uid_t, gid Gid_t) _C_int
+
+//sys Chroot(path string) (err error)
+//chroot(path *byte) _C_int
+
+//sys Close(fd int) (err error)
+//close(fd _C_int) _C_int
+
+//sys Creat(path string, mode uint32) (fd int, err error)
+//creat(path *byte, mode Mode_t) _C_int
+
+//sysnb Dup(oldfd int) (fd int, err error)
+//dup(oldfd _C_int) _C_int
+
+//sysnb Dup2(oldfd int, newfd int) (err error)
+//dup2(oldfd _C_int, newfd _C_int) _C_int
+
+//sys Exit(code int)
+//exit(code _C_int)
+
+//sys Fchdir(fd int) (err error)
+//fchdir(fd _C_int) _C_int
+
+//sys Fchmod(fd int, mode uint32) (err error)
+//fchmod(fd _C_int, mode Mode_t) _C_int
+
+//sys Fchown(fd int, uid int, gid int) (err error)
+//fchown(fd _C_int, uid Uid_t, gid Gid_t) _C_int
+
+//sys fcntl(fd int, cmd int, arg int) (val int, err error)
+//__go_fcntl(fd _C_int, cmd _C_int, arg _C_int) _C_int
+
+//sys FcntlFlock(fd uintptr, cmd int, lk *Flock_t) (err error)
+//__go_fcntl_flock(fd _C_int, cmd _C_int, arg *Flock_t) _C_int
+
+//sys Fdatasync(fd int) (err error)
+//fdatasync(fd _C_int) _C_int
+
+//sys Fsync(fd int) (err error)
+//fsync(fd _C_int) _C_int
+
+//sysnb Getegid() (egid int)
+//getegid() Gid_t
+
+//sysnb Geteuid() (euid int)
+//geteuid() Uid_t
+
+//sysnb Getgid() (gid int)
+//getgid() Gid_t
+
+//sysnb Getpagesize() (pagesize int)
+//getpagesize() _C_int
+
+//sysnb Getpgid(pid int) (pgid int, err error)
+//getpgid(pid Pid_t) Pid_t
+
+//sysnb Getpgrp() (pid int)
+//getpgrp() Pid_t
+
+//sysnb Getpid() (pid int)
+//getpid() Pid_t
+
+//sysnb Getppid() (ppid int)
+//getppid() Pid_t
+
+//sys Getpriority(which int, who int) (prio int, err error)
+//getpriority(which _C_int, who _C_int) _C_int
+
+//sysnb Getrusage(who int, rusage *Rusage) (err error)
+//getrusage(who _C_int, rusage *Rusage) _C_int
+
+//sysnb gettimeofday(tv *Timeval, tz *byte) (err error)
+//gettimeofday(tv *Timeval, tz *byte) _C_int
+func Gettimeofday(tv *Timeval) (err error) {
+ return gettimeofday(tv, nil)
+}
+
+//sysnb Getuid() (uid int)
+//getuid() Uid_t
+
+//sysnb Kill(pid int, sig Signal) (err error)
+//kill(pid Pid_t, sig _C_int) _C_int
+
+//sys Lchown(path string, uid int, gid int) (err error)
+//lchown(path *byte, uid Uid_t, gid Gid_t) _C_int
+
+//sys Link(oldpath string, newpath string) (err error)
+//link(oldpath *byte, newpath *byte) _C_int
+
+//sys Mkdir(path string, mode uint32) (err error)
+//mkdir(path *byte, mode Mode_t) _C_int
+
+//sys Mknod(path string, mode uint32, dev int) (err error)
+//mknod(path *byte, mode Mode_t, dev _dev_t) _C_int
+
+//sys Nanosleep(time *Timespec, leftover *Timespec) (err error)
+//nanosleep(time *Timespec, leftover *Timespec) _C_int
+
+//sys Pause() (err error)
+//pause() _C_int
+
+//sys read(fd int, p []byte) (n int, err error)
+//read(fd _C_int, buf *byte, count Size_t) Ssize_t
+
+//sys readlen(fd int, p *byte, np int) (n int, err error)
+//read(fd _C_int, buf *byte, count Size_t) Ssize_t
+
+//sys Readlink(path string, buf []byte) (n int, err error)
+//readlink(path *byte, buf *byte, bufsiz Size_t) Ssize_t
+
+//sys Rename(oldpath string, newpath string) (err error)
+//rename(oldpath *byte, newpath *byte) _C_int
+
+//sys Rmdir(path string) (err error)
+//rmdir(path *byte) _C_int
+
+//sys Setdomainname(p []byte) (err error)
+//setdomainname(name *byte, len Size_t) _C_int
+
+//sys Sethostname(p []byte) (err error)
+//sethostname(name *byte, len Size_t) _C_int
+
+//sysnb Setgid(gid int) (err error)
+//setgid(gid Gid_t) _C_int
+
+//sysnb Setregid(rgid int, egid int) (err error)
+//setregid(rgid Gid_t, egid Gid_t) _C_int
+
+//sysnb Setpgid(pid int, pgid int) (err error)
+//setpgid(pid Pid_t, pgid Pid_t) _C_int
+
+//sys Setpriority(which int, who int, prio int) (err error)
+//setpriority(which _C_int, who _C_int, prio _C_int) _C_int
+
+//sysnb Setreuid(ruid int, euid int) (err error)
+//setreuid(ruid Uid_t, euid Uid_t) _C_int
+
+//sysnb Setsid() (pid int, err error)
+//setsid() Pid_t
+
+//sysnb settimeofday(tv *Timeval, tz *byte) (err error)
+//settimeofday(tv *Timeval, tz *byte) _C_int
+
+func Settimeofday(tv *Timeval) (err error) {
+ return settimeofday(tv, nil)
+}
+
+//sysnb Setuid(uid int) (err error)
+//setuid(uid Uid_t) _C_int
+
+//sys Symlink(oldpath string, newpath string) (err error)
+//symlink(oldpath *byte, newpath *byte) _C_int
+
+//sys Sync()
+//sync()
+
+//sysnb Time(t *Time_t) (tt Time_t, err error)
+//time(t *Time_t) Time_t
+
+//sysnb Times(tms *Tms) (ticks uintptr, err error)
+//times(tms *Tms) _clock_t
+
+//sysnb Umask(mask int) (oldmask int)
+//umask(mask Mode_t) Mode_t
+
+//sys Unlink(path string) (err error)
+//unlink(path *byte) _C_int
+
+//sys Utime(path string, buf *Utimbuf) (err error)
+//utime(path *byte, buf *Utimbuf) _C_int
+
+//sys write(fd int, p []byte) (n int, err error)
+//write(fd _C_int, buf *byte, count Size_t) Ssize_t
+
+//sys writelen(fd int, p *byte, np int) (n int, err error)
+//write(fd _C_int, buf *byte, count Size_t) Ssize_t
+
+//sys munmap(addr uintptr, length uintptr) (err error)
+//munmap(addr *byte, length Size_t) _C_int
+
+//sys Mprotect(b []byte, prot int) (err error)
+//mprotect(addr *byte, len Size_t, prot _C_int) _C_int
+
+//sys Mlock(b []byte) (err error)
+//mlock(addr *byte, len Size_t) _C_int
+
+//sys Munlock(b []byte) (err error)
+//munlock(addr *byte, len Size_t) _C_int
+
+func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
+
+func NsecToTimespec(nsec int64) (ts Timespec) {
+ ts.Sec = Timespec_sec_t(nsec / 1e9)
+ ts.Nsec = Timespec_nsec_t(nsec % 1e9)
+ return
+}
+
+func TimevalToNsec(tv Timeval) int64 { return int64(tv.Sec)*1e9 + int64(tv.Usec)*1e3 }
+
+func NsecToTimeval(nsec int64) (tv Timeval) {
+ nsec += 999 // round up to microsecond
+ tv.Sec = Timeval_sec_t(nsec / 1e9)
+ tv.Usec = Timeval_usec_t(nsec % 1e9 / 1e3)
+ return
+}
+
+//sysnb Tcgetattr(fd int, p *Termios) (err error)
+//tcgetattr(fd _C_int, p *Termios) _C_int
+
+//sys Tcsetattr(fd int, actions int, p *Termios) (err error)
+//tcsetattr(fd _C_int, actions _C_int, p *Termios) _C_int
Index: gcc-6-6.2.1-4.1/src/libgo/go/syscall/socket_gnu.go
===================================================================
--- /dev/null
+++ gcc-6-6.2.1-4.1/src/libgo/go/syscall/socket_gnu.go
@@ -0,0 +1,88 @@
+// socket_gnu.go -- Socket handling specific to GNU/Hurd.
+
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package syscall
+
+import "unsafe"
+
+const SizeofSockaddrInet4 = 16
+const SizeofSockaddrInet6 = 28
+const SizeofSockaddrUnix = 110
+
+type RawSockaddrInet4 struct {
+ Len uint8
+ Family uint8
+ Port uint16
+ Addr [4]byte /* in_addr */
+ Zero [8]uint8
+}
+
+func (sa *RawSockaddrInet4) setLen() Socklen_t {
+ sa.Len = SizeofSockaddrInet4
+ return SizeofSockaddrInet4
+}
+
+type RawSockaddrInet6 struct {
+ Len uint8
+ Family uint8
+ Port uint16
+ Flowinfo uint32
+ Addr [16]byte /* in6_addr */
+ Scope_id uint32
+}
+
+func (sa *RawSockaddrInet6) setLen() Socklen_t {
+ sa.Len = SizeofSockaddrInet6
+ return SizeofSockaddrInet6
+}
+
+type RawSockaddrUnix struct {
+ Len uint8
+ Family uint8
+ Path [108]int8
+}
+
+func (sa *RawSockaddrUnix) setLen(n int) {
+ sa.Len = uint8(3 + n) // 2 for Family, Len; 1 for NUL.
+}
+
+func (sa *RawSockaddrUnix) getLen() (int, error) {
+ if sa.Len < 3 || sa.Len > SizeofSockaddrUnix {
+ return 0, EINVAL
+ }
+ // Assume path ends at NUL.
+ n := 0
+ for n < len(sa.Path) && sa.Path[n] != 0 {
+ n++
+ }
+ return n, nil
+}
+
+func (sa *RawSockaddrUnix) adjustAbstract(sl Socklen_t) Socklen_t {
+ return sl
+}
+
+type RawSockaddr struct {
+ Len uint8
+ Family uint8
+ Data [14]int8
+}
+
+// BindToDevice binds the socket associated with fd to device.
+func BindToDevice(fd int, device string) (err error) {
+ return ENOSYS
+}
+
+func anyToSockaddrOS(rsa *RawSockaddrAny) (Sockaddr, error) {
+ return nil, EAFNOSUPPORT
+}
+
+func GetsockoptIPv6MTUInfo(fd, level, opt int) (*IPv6MTUInfo, error) {
+ var value IPv6MTUInfo
+ vallen := Socklen_t(SizeofIPv6MTUInfo)
+ err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
+ return &value, err
+}