github.com/rafaeltorres324/go/src@v0.0.0-20210519164414-9fdf653a9838/runtime/sys_openbsd3.go (about) 1 // Copyright 2020 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 openbsd,amd64 openbsd,arm64 6 7 package runtime 8 9 import "unsafe" 10 11 // The X versions of syscall expect the libc call to return a 64-bit result. 12 // Otherwise (the non-X version) expects a 32-bit result. 13 // This distinction is required because an error is indicated by returning -1, 14 // and we need to know whether to check 32 or 64 bits of the result. 15 // (Some libc functions that return 32 bits put junk in the upper 32 bits of AX.) 16 17 //go:linkname syscall_syscall syscall.syscall 18 //go:nosplit 19 //go:cgo_unsafe_args 20 func syscall_syscall(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) { 21 entersyscall() 22 libcCall(unsafe.Pointer(funcPC(syscall)), unsafe.Pointer(&fn)) 23 exitsyscall() 24 return 25 } 26 func syscall() 27 28 //go:linkname syscall_syscallX syscall.syscallX 29 //go:nosplit 30 //go:cgo_unsafe_args 31 func syscall_syscallX(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) { 32 entersyscall() 33 libcCall(unsafe.Pointer(funcPC(syscallX)), unsafe.Pointer(&fn)) 34 exitsyscall() 35 return 36 } 37 func syscallX() 38 39 //go:linkname syscall_syscall6 syscall.syscall6 40 //go:nosplit 41 //go:cgo_unsafe_args 42 func syscall_syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) { 43 entersyscall() 44 libcCall(unsafe.Pointer(funcPC(syscall6)), unsafe.Pointer(&fn)) 45 exitsyscall() 46 return 47 } 48 func syscall6() 49 50 //go:linkname syscall_syscall6X syscall.syscall6X 51 //go:nosplit 52 //go:cgo_unsafe_args 53 func syscall_syscall6X(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) { 54 entersyscall() 55 libcCall(unsafe.Pointer(funcPC(syscall6X)), unsafe.Pointer(&fn)) 56 exitsyscall() 57 return 58 } 59 func syscall6X() 60 61 //go:linkname syscall_syscall10 syscall.syscall10 62 //go:nosplit 63 //go:cgo_unsafe_args 64 func syscall_syscall10(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 uintptr) (r1, r2, err uintptr) { 65 entersyscall() 66 libcCall(unsafe.Pointer(funcPC(syscall10)), unsafe.Pointer(&fn)) 67 exitsyscall() 68 return 69 } 70 func syscall10() 71 72 //go:linkname syscall_syscall10X syscall.syscall10X 73 //go:nosplit 74 //go:cgo_unsafe_args 75 func syscall_syscall10X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 uintptr) (r1, r2, err uintptr) { 76 entersyscall() 77 libcCall(unsafe.Pointer(funcPC(syscall10X)), unsafe.Pointer(&fn)) 78 exitsyscall() 79 return 80 } 81 func syscall10X() 82 83 //go:linkname syscall_rawSyscall syscall.rawSyscall 84 //go:nosplit 85 //go:cgo_unsafe_args 86 func syscall_rawSyscall(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) { 87 libcCall(unsafe.Pointer(funcPC(syscall)), unsafe.Pointer(&fn)) 88 return 89 } 90 91 //go:linkname syscall_rawSyscall6 syscall.rawSyscall6 92 //go:nosplit 93 //go:cgo_unsafe_args 94 func syscall_rawSyscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) { 95 libcCall(unsafe.Pointer(funcPC(syscall6)), unsafe.Pointer(&fn)) 96 return 97 } 98 99 //go:linkname syscall_rawSyscall6X syscall.rawSyscall6X 100 //go:nosplit 101 //go:cgo_unsafe_args 102 func syscall_rawSyscall6X(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) { 103 libcCall(unsafe.Pointer(funcPC(syscall6X)), unsafe.Pointer(&fn)) 104 return 105 } 106 107 //go:linkname syscall_rawSyscall10X syscall.rawSyscall10X 108 //go:nosplit 109 //go:cgo_unsafe_args 110 func syscall_rawSyscall10X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 uintptr) (r1, r2, err uintptr) { 111 libcCall(unsafe.Pointer(funcPC(syscall10X)), unsafe.Pointer(&fn)) 112 return 113 }