From 799c178aea0699e51e8e61c1142d6e0e29458bec Mon Sep 17 00:00:00 2001 From: jsing Date: Tue, 20 Sep 2022 12:02:33 +0000 Subject: [PATCH] lang/go: add support for openbsd/riscv64 This adds support for Go on openbsd/riscv64. Requested by and ok jca@ ok abieber@ --- lang/go/Makefile | 5 +- lang/go/distinfo | 2 + ...-src_cmd_asm_internal_asm_endtoend_test_go | 15 + ...rc_cmd_asm_internal_asm_testdata_riscv64_s | 24 + lang/go/patches/patch-src_cmd_dist_build_go | 11 + .../patch-src_cmd_internal_obj_riscv_cpu_go | 32 + .../patch-src_cmd_internal_obj_riscv_obj_go | 204 ++ ...patch-src_cmd_internal_objabi_reloctype_go | 52 +- ...rc_cmd_internal_objabi_reloctype_string_go | 56 +- .../patch-src_cmd_link_internal_amd64_asm_go | 12 + .../patch-src_cmd_link_internal_arm64_asm_go | 12 + .../patch-src_cmd_link_internal_arm_asm_go | 12 + .../patch-src_cmd_link_internal_ld_config_go | 12 + .../patch-src_cmd_link_internal_ld_data_go | 40 + .../patch-src_cmd_link_internal_ld_elf_go | 8 +- .../patch-src_cmd_link_internal_ld_lib_go | 10 +- .../patch-src_cmd_link_internal_ld_pcln_go | 17 + ...tch-src_cmd_link_internal_loadelf_ldelf_go | 87 + ...patch-src_cmd_link_internal_loong64_asm_go | 12 + .../patch-src_cmd_link_internal_mips64_asm_go | 7 +- .../patch-src_cmd_link_internal_mips_asm_go | 12 + .../patch-src_cmd_link_internal_ppc64_asm_go | 12 + ...patch-src_cmd_link_internal_riscv64_asm_go | 500 +++++ ...patch-src_cmd_link_internal_riscv64_obj_go | 33 + .../patch-src_cmd_link_internal_s390x_asm_go | 12 + .../patch-src_cmd_link_internal_sym_reloc_go | 12 + .../patch-src_cmd_link_internal_x86_asm_go | 12 + ...olang_org_x_sys_unix_asm_openbsd_riscv64_s | 34 + ..._org_x_sys_unix_syscall_openbsd_riscv64_go | 46 + ..._org_x_sys_unix_zerrors_openbsd_riscv64_go | 1802 ++++++++++++++++ ...org_x_sys_unix_zsyscall_openbsd_riscv64_go | 1697 +++++++++++++++ ..._org_x_sys_unix_zsysctl_openbsd_riscv64_go | 280 +++ ..._org_x_sys_unix_zsysnum_openbsd_riscv64_go | 222 ++ ...g_org_x_sys_unix_ztypes_openbsd_riscv64_go | 572 +++++ .../patches/patch-src_runtime_asm_mips64x_s | 2 +- .../patches/patch-src_runtime_asm_riscv64_s | 19 + ...atch-src_runtime_cgo_gcc_openbsd_riscv64_c | 71 + .../patch-src_runtime_defs_openbsd_riscv64_go | 182 ++ .../patch-src_runtime_rt0_openbsd_riscv64_s | 18 + ...atch-src_runtime_signal_openbsd_riscv64_go | 76 + .../patch-src_runtime_signal_riscv64_go | 12 + .../patch-src_runtime_stubs_riscv64_go | 18 + .../patch-src_runtime_sys_openbsd_riscv64_s | 734 +++++++ .../patches/patch-src_runtime_tls_riscv64_s | 29 + .../patch-src_syscall_asm_openbsd_riscv64_s | 36 + lang/go/patches/patch-src_syscall_mkall_sh | 14 +- ...tch-src_syscall_syscall_openbsd_riscv64_go | 42 + ...tch-src_syscall_zerrors_openbsd_riscv64_go | 1697 +++++++++++++++ ...ch-src_syscall_zsyscall_openbsd_riscv64_go | 1915 +++++++++++++++++ ...tch-src_syscall_zsyscall_openbsd_riscv64_s | 239 ++ .../patch-src_syscall_zsysctl_openbsd_go | 204 ++ ...tch-src_syscall_zsysnum_openbsd_riscv64_go | 232 ++ ...atch-src_syscall_ztypes_openbsd_riscv64_go | 450 ++++ ..._golang_org_x_sys_cpu_cpu_other_riscv64_go | 16 + lang/go/pkg/PLIST | 20 + 55 files changed, 11880 insertions(+), 22 deletions(-) create mode 100644 lang/go/patches/patch-src_cmd_asm_internal_asm_endtoend_test_go create mode 100644 lang/go/patches/patch-src_cmd_asm_internal_asm_testdata_riscv64_s create mode 100644 lang/go/patches/patch-src_cmd_dist_build_go create mode 100644 lang/go/patches/patch-src_cmd_internal_obj_riscv_cpu_go create mode 100644 lang/go/patches/patch-src_cmd_internal_obj_riscv_obj_go create mode 100644 lang/go/patches/patch-src_cmd_link_internal_amd64_asm_go create mode 100644 lang/go/patches/patch-src_cmd_link_internal_arm64_asm_go create mode 100644 lang/go/patches/patch-src_cmd_link_internal_arm_asm_go create mode 100644 lang/go/patches/patch-src_cmd_link_internal_ld_config_go create mode 100644 lang/go/patches/patch-src_cmd_link_internal_ld_data_go create mode 100644 lang/go/patches/patch-src_cmd_link_internal_ld_pcln_go create mode 100644 lang/go/patches/patch-src_cmd_link_internal_loadelf_ldelf_go create mode 100644 lang/go/patches/patch-src_cmd_link_internal_loong64_asm_go create mode 100644 lang/go/patches/patch-src_cmd_link_internal_mips_asm_go create mode 100644 lang/go/patches/patch-src_cmd_link_internal_ppc64_asm_go create mode 100644 lang/go/patches/patch-src_cmd_link_internal_riscv64_asm_go create mode 100644 lang/go/patches/patch-src_cmd_link_internal_riscv64_obj_go create mode 100644 lang/go/patches/patch-src_cmd_link_internal_s390x_asm_go create mode 100644 lang/go/patches/patch-src_cmd_link_internal_sym_reloc_go create mode 100644 lang/go/patches/patch-src_cmd_link_internal_x86_asm_go create mode 100644 lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_asm_openbsd_riscv64_s create mode 100644 lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_syscall_openbsd_riscv64_go create mode 100644 lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_zerrors_openbsd_riscv64_go create mode 100644 lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_zsyscall_openbsd_riscv64_go create mode 100644 lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_zsysctl_openbsd_riscv64_go create mode 100644 lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_zsysnum_openbsd_riscv64_go create mode 100644 lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_ztypes_openbsd_riscv64_go create mode 100644 lang/go/patches/patch-src_runtime_asm_riscv64_s create mode 100644 lang/go/patches/patch-src_runtime_cgo_gcc_openbsd_riscv64_c create mode 100644 lang/go/patches/patch-src_runtime_defs_openbsd_riscv64_go create mode 100644 lang/go/patches/patch-src_runtime_rt0_openbsd_riscv64_s create mode 100644 lang/go/patches/patch-src_runtime_signal_openbsd_riscv64_go create mode 100644 lang/go/patches/patch-src_runtime_signal_riscv64_go create mode 100644 lang/go/patches/patch-src_runtime_stubs_riscv64_go create mode 100644 lang/go/patches/patch-src_runtime_sys_openbsd_riscv64_s create mode 100644 lang/go/patches/patch-src_runtime_tls_riscv64_s create mode 100644 lang/go/patches/patch-src_syscall_asm_openbsd_riscv64_s create mode 100644 lang/go/patches/patch-src_syscall_syscall_openbsd_riscv64_go create mode 100644 lang/go/patches/patch-src_syscall_zerrors_openbsd_riscv64_go create mode 100644 lang/go/patches/patch-src_syscall_zsyscall_openbsd_riscv64_go create mode 100644 lang/go/patches/patch-src_syscall_zsyscall_openbsd_riscv64_s create mode 100644 lang/go/patches/patch-src_syscall_zsysctl_openbsd_go create mode 100644 lang/go/patches/patch-src_syscall_zsysnum_openbsd_riscv64_go create mode 100644 lang/go/patches/patch-src_syscall_ztypes_openbsd_riscv64_go create mode 100644 lang/go/patches/patch-src_vendor_golang_org_x_sys_cpu_cpu_other_riscv64_go diff --git a/lang/go/Makefile b/lang/go/Makefile index bf66c4f73df9..654df9d6c730 100644 --- a/lang/go/Makefile +++ b/lang/go/Makefile @@ -1,11 +1,12 @@ ONLY_FOR_ARCHS = ${GO_ARCHS} -BIN_BOOTSTRAP_GOARCHS = 386 amd64 arm arm64 mips64 +BIN_BOOTSTRAP_GOARCHS = 386 amd64 arm arm64 mips64 riscv64 BIN_BOOTSTRAP_VERSION = 1.18.4 COMMENT = Go programming language VERSION = 1.19.1 +REVISION = 0 DISTNAME = go${VERSION}.src PKGNAME = go-${VERSION} PKGSPEC = ${FULLPKGNAME:S/go-/go-=/} @@ -56,6 +57,8 @@ GOARCH = arm64 GOARCH = 386 .elif ${MACHINE_ARCH} == "mips64" GOARCH = mips64 +.elif ${MACHINE_ARCH} == "riscv64" +GOARCH = riscv64 .endif # We cannot assume that the machine running the built code will have SSE, diff --git a/lang/go/distinfo b/lang/go/distinfo index 3afa3efae1cf..a6c0eff40570 100644 --- a/lang/go/distinfo +++ b/lang/go/distinfo @@ -3,10 +3,12 @@ SHA256 (go-openbsd-amd64-bootstrap-1.18.4.tar.gz) = ireh8OvOgYBMUJcdsMLjGHyqYorn SHA256 (go-openbsd-arm-bootstrap-1.18.4.tar.gz) = oxYr3cphgkHHW3fhD4MWmZy6wWGRxHL1/HgXGoR0deE= SHA256 (go-openbsd-arm64-bootstrap-1.18.4.tar.gz) = M7OML+r3ofvr5UaIoZ12jqDBB4ogT3sePUVDR+l2mwY= SHA256 (go-openbsd-mips64-bootstrap-1.18.4.tar.gz) = voP9dDKZ3hcXjyqF9r3jBSxGMZwgeBt27p41GzCKoEI= +SHA256 (go-openbsd-riscv64-bootstrap-1.18.4.tar.gz) = je0AbR0bVy+KMXzcmzkJ3pRBUfXoQUI44LjrrdIQOOQ= SHA256 (go1.19.1.src.tar.gz) = J4cbqkkPNAFBSteT+6SQhvbIVbHFhDhe13ceEgTH4Xk= SIZE (go-openbsd-386-bootstrap-1.18.4.tar.gz) = 148679005 SIZE (go-openbsd-amd64-bootstrap-1.18.4.tar.gz) = 149910861 SIZE (go-openbsd-arm-bootstrap-1.18.4.tar.gz) = 145777001 SIZE (go-openbsd-arm64-bootstrap-1.18.4.tar.gz) = 144201762 SIZE (go-openbsd-mips64-bootstrap-1.18.4.tar.gz) = 148034418 +SIZE (go-openbsd-riscv64-bootstrap-1.18.4.tar.gz) = 142272942 SIZE (go1.19.1.src.tar.gz) = 26527375 diff --git a/lang/go/patches/patch-src_cmd_asm_internal_asm_endtoend_test_go b/lang/go/patches/patch-src_cmd_asm_internal_asm_endtoend_test_go new file mode 100644 index 000000000000..4b1cf2f45bac --- /dev/null +++ b/lang/go/patches/patch-src_cmd_asm_internal_asm_endtoend_test_go @@ -0,0 +1,15 @@ +Index: src/cmd/asm/internal/asm/endtoend_test.go +--- src/cmd/asm/internal/asm/endtoend_test.go.orig ++++ src/cmd/asm/internal/asm/endtoend_test.go +@@ -69,6 +69,11 @@ Diff: + continue + } + ++ // Ignore GLOBL. ++ if strings.HasPrefix(line, "GLOBL ") { ++ continue ++ } ++ + // The general form of a test input line is: + // // comment + // INST args [// printed form] [// hex encoding] diff --git a/lang/go/patches/patch-src_cmd_asm_internal_asm_testdata_riscv64_s b/lang/go/patches/patch-src_cmd_asm_internal_asm_testdata_riscv64_s new file mode 100644 index 000000000000..2f48c7552c58 --- /dev/null +++ b/lang/go/patches/patch-src_cmd_asm_internal_asm_testdata_riscv64_s @@ -0,0 +1,24 @@ +Index: src/cmd/asm/internal/asm/testdata/riscv64.s +--- src/cmd/asm/internal/asm/testdata/riscv64.s.orig ++++ src/cmd/asm/internal/asm/testdata/riscv64.s +@@ -352,6 +352,14 @@ start: + MOVD F0, 4(X5) // 27b20200 + MOVD F0, F1 // d3000022 + ++ // TLS load with local-exec (LUI + ADDIW + ADD of TP + load) ++ MOV tls(SB), X5 // b70f00009b8f0f00b38f4f0083b20f00 ++ MOVB tls(SB), X5 // b70f00009b8f0f00b38f4f0083820f00 ++ ++ // TLS store with local-exec (LUI + ADDIW + ADD of TP + store) ++ MOV X5, tls(SB) // b70f00009b8f0f00b38f4f0023b05f00 ++ MOVB X5, tls(SB) // b70f00009b8f0f00b38f4f0023805f00 ++ + // NOT pseudo-instruction + NOT X5 // 93c2f2ff + NOT X5, X6 // 13c3f2ff +@@ -405,3 +413,5 @@ start: + FLTD F0, F1, X5 // d39200a2 + FLED F0, F1, X5 // d38200a2 + FEQD F0, F1, X5 // d3a200a2 ++ ++GLOBL tls(SB), TLSBSS, $8 diff --git a/lang/go/patches/patch-src_cmd_dist_build_go b/lang/go/patches/patch-src_cmd_dist_build_go new file mode 100644 index 000000000000..dcc3ea210eb3 --- /dev/null +++ b/lang/go/patches/patch-src_cmd_dist_build_go @@ -0,0 +1,11 @@ +Index: src/cmd/dist/build.go +--- src/cmd/dist/build.go.orig ++++ src/cmd/dist/build.go +@@ -1589,6 +1589,7 @@ var cgoEnabled = map[string]bool{ + "openbsd/arm": true, + "openbsd/arm64": true, + "openbsd/mips64": true, ++ "openbsd/riscv64": true, + "plan9/386": false, + "plan9/amd64": false, + "plan9/arm": false, diff --git a/lang/go/patches/patch-src_cmd_internal_obj_riscv_cpu_go b/lang/go/patches/patch-src_cmd_internal_obj_riscv_cpu_go new file mode 100644 index 000000000000..4c6aa8e26d86 --- /dev/null +++ b/lang/go/patches/patch-src_cmd_internal_obj_riscv_cpu_go @@ -0,0 +1,32 @@ +Index: src/cmd/internal/obj/riscv/cpu.go +--- src/cmd/internal/obj/riscv/cpu.go.orig ++++ src/cmd/internal/obj/riscv/cpu.go +@@ -632,13 +632,25 @@ var unaryDst = map[obj.As]bool{ + + // Instruction encoding masks. + const ( +- // JTypeImmMask is a mask including only the immediate portion of +- // J-type instructions. +- JTypeImmMask = 0xfffff000 ++ // BTypeImmMask is a mask including only the immediate portion of ++ // B-type instructions. ++ BTypeImmMask = 0xfe000f80 + ++ // CBTypeImmMask is a mask including only the immediate portion of ++ // CB-type instructions. ++ CBTypeImmMask = 0x1c7c ++ ++ // CJTypeImmMask is a mask including only the immediate portion of ++ // CJ-type instructions. ++ CJTypeImmMask = 0x1f7c ++ + // ITypeImmMask is a mask including only the immediate portion of + // I-type instructions. + ITypeImmMask = 0xfff00000 ++ ++ // JTypeImmMask is a mask including only the immediate portion of ++ // J-type instructions. ++ JTypeImmMask = 0xfffff000 + + // STypeImmMask is a mask including only the immediate portion of + // S-type instructions. diff --git a/lang/go/patches/patch-src_cmd_internal_obj_riscv_obj_go b/lang/go/patches/patch-src_cmd_internal_obj_riscv_obj_go new file mode 100644 index 000000000000..2c48063b01de --- /dev/null +++ b/lang/go/patches/patch-src_cmd_internal_obj_riscv_obj_go @@ -0,0 +1,204 @@ +Index: src/cmd/internal/obj/riscv/obj.go +--- src/cmd/internal/obj/riscv/obj.go.orig ++++ src/cmd/internal/obj/riscv/obj.go +@@ -1264,6 +1264,11 @@ func encodeSF(ins *instruction) uint32 { + return encodeS(ins.as, regI(ins.rd), regF(ins.rs1), uint32(ins.imm)) + } + ++// encodeBImmediate encodes an immediate for a B-type RISC-V instruction. ++func encodeBImmediate(imm uint32) uint32 { ++ return (imm>>12)<<31 | ((imm>>5)&0x3f)<<25 | ((imm>>1)&0xf)<<8 | ((imm>>11)&0x1)<<7 ++} ++ + // encodeB encodes a B-type RISC-V instruction. + func encodeB(ins *instruction) uint32 { + imm := immI(ins.as, ins.imm, 13) +@@ -1273,7 +1278,7 @@ func encodeB(ins *instruction) uint32 { + if enc == nil { + panic("encodeB: could not encode instruction") + } +- return (imm>>12)<<31 | ((imm>>5)&0x3f)<<25 | rs2<<20 | rs1<<15 | enc.funct3<<12 | ((imm>>1)&0xf)<<8 | ((imm>>11)&0x1)<<7 | enc.opcode ++ return encodeBImmediate(imm) | rs2<<20 | rs1<<15 | enc.funct3<<12 | enc.opcode + } + + // encodeU encodes a U-type RISC-V instruction. +@@ -1316,16 +1321,67 @@ func encodeRawIns(ins *instruction) uint32 { + return uint32(ins.imm) + } + +-func EncodeJImmediate(imm int64) (int64, error) { +- if !immIFits(imm, 21) { +- return 0, fmt.Errorf("immediate %#x does not fit in 21 bits", imm) ++func extractAndShift(imm int64, bit, pos int) int64 { ++ return ((imm >> (bit - 1)) & 1) << (pos - 1) ++} ++ ++func EncodeBImmediate(imm int64) (int64, error) { ++ if !immIFits(imm, 13) { ++ return 0, fmt.Errorf("immediate %#x does not fit in 13 bits", imm) + } + if imm&1 != 0 { + return 0, fmt.Errorf("immediate %#x is not a multiple of two", imm) + } +- return int64(encodeJImmediate(uint32(imm))), nil ++ return int64(encodeBImmediate(uint32(imm))), nil + } + ++func EncodeCBImmediate(imm int64) (int64, error) { ++ if !immIFits(imm, 9) { ++ return 0, fmt.Errorf("immediate %#x does not fit in 9 bits", imm) ++ } ++ if imm&1 != 0 { ++ return 0, fmt.Errorf("immediate %#x is not a multiple of two", imm) ++ } ++ imm = imm >> 1 ++ ++ // Bit order - [8|4:3|7:6|2:1|5] ++ bits := extractAndShift(imm, 8, 8) ++ bits |= extractAndShift(imm, 4, 7) ++ bits |= extractAndShift(imm, 3, 6) ++ bits |= extractAndShift(imm, 7, 5) ++ bits |= extractAndShift(imm, 6, 4) ++ bits |= extractAndShift(imm, 2, 3) ++ bits |= extractAndShift(imm, 1, 2) ++ bits |= extractAndShift(imm, 5, 1) ++ ++ return (bits>>5)<<10 | (bits&0x1f)<<2, nil ++} ++ ++func EncodeCJImmediate(imm int64) (int64, error) { ++ if !immIFits(imm, 12) { ++ return 0, fmt.Errorf("immediate %#x does not fit in 12 bits", imm) ++ } ++ if imm&1 != 0 { ++ return 0, fmt.Errorf("immediate %#x is not a multiple of two", imm) ++ } ++ imm = imm >> 1 ++ ++ // Bit order - [11|4|9:8|10|6|7|3:1|5] ++ bits := extractAndShift(imm, 11, 11) ++ bits |= extractAndShift(imm, 4, 10) ++ bits |= extractAndShift(imm, 9, 9) ++ bits |= extractAndShift(imm, 8, 8) ++ bits |= extractAndShift(imm, 10, 7) ++ bits |= extractAndShift(imm, 6, 6) ++ bits |= extractAndShift(imm, 7, 5) ++ bits |= extractAndShift(imm, 3, 4) ++ bits |= extractAndShift(imm, 2, 3) ++ bits |= extractAndShift(imm, 1, 2) ++ bits |= extractAndShift(imm, 5, 1) ++ ++ return bits << 2, nil ++} ++ + func EncodeIImmediate(imm int64) (int64, error) { + if !immIFits(imm, 12) { + return 0, fmt.Errorf("immediate %#x does not fit in 12 bits", imm) +@@ -1333,6 +1389,16 @@ func EncodeIImmediate(imm int64) (int64, error) { + return imm << 20, nil + } + ++func EncodeJImmediate(imm int64) (int64, error) { ++ if !immIFits(imm, 21) { ++ return 0, fmt.Errorf("immediate %#x does not fit in 21 bits", imm) ++ } ++ if imm&1 != 0 { ++ return 0, fmt.Errorf("immediate %#x is not a multiple of two", imm) ++ } ++ return int64(encodeJImmediate(uint32(imm))), nil ++} ++ + func EncodeSImmediate(imm int64) (int64, error) { + if !immIFits(imm, 12) { + return 0, fmt.Errorf("immediate %#x does not fit in 12 bits", imm) +@@ -1819,6 +1885,53 @@ func instructionsForStore(p *obj.Prog, as obj.As, rd i + return []*instruction{insLUI, insADD, ins} + } + ++func instructionsForTLS(p *obj.Prog, ins *instruction) []*instruction { ++ insAddTP := &instruction{as: AADD, rd: REG_TMP, rs1: REG_TMP, rs2: REG_TP} ++ ++ var inss []*instruction ++ if p.Ctxt.Flag_shared { ++ // TLS initial-exec mode - load TLS offset from GOT, add the thread pointer ++ // register, then load from or store to the resulting memory location. ++ insAUIPC := &instruction{as: AAUIPC, rd: REG_TMP} ++ insLoadTLSOffset := &instruction{as: ALD, rd: REG_TMP, rs1: REG_TMP} ++ inss = []*instruction{insAUIPC, insLoadTLSOffset, insAddTP, ins} ++ } else { ++ // TLS local-exec mode - load upper TLS offset, add the lower TLS offset, ++ // add the thread pointer register, then load from or store to the resulting ++ // memory location. Note that this differs from the suggested three ++ // instruction sequence, as the Go linker does not currently have an ++ // easy way to handle relocation across 12 bytes of machine code. ++ insLUI := &instruction{as: ALUI, rd: REG_TMP} ++ insADDIW := &instruction{as: AADDIW, rd: REG_TMP, rs1: REG_TMP} ++ inss = []*instruction{insLUI, insADDIW, insAddTP, ins} ++ } ++ return inss ++} ++ ++func instructionsForTLSLoad(p *obj.Prog) []*instruction { ++ if p.From.Sym.Type != objabi.STLSBSS { ++ p.Ctxt.Diag("%v: %v is not a TLS symbol", p, p.From.Sym) ++ return nil ++ } ++ ++ ins := instructionForProg(p) ++ ins.as, ins.rs1, ins.rs2, ins.imm = movToLoad(p.As), REG_TMP, obj.REG_NONE, 0 ++ ++ return instructionsForTLS(p, ins) ++} ++ ++func instructionsForTLSStore(p *obj.Prog) []*instruction { ++ if p.To.Sym.Type != objabi.STLSBSS { ++ p.Ctxt.Diag("%v: %v is not a TLS symbol", p, p.To.Sym) ++ return nil ++ } ++ ++ ins := instructionForProg(p) ++ ins.as, ins.rd, ins.rs1, ins.rs2, ins.imm = movToStore(p.As), REG_TMP, uint32(p.From.Reg), obj.REG_NONE, 0 ++ ++ return instructionsForTLS(p, ins) ++} ++ + // instructionsForMOV returns the machine instructions for an *obj.Prog that + // uses a MOV pseudo-instruction. + func instructionsForMOV(p *obj.Prog) []*instruction { +@@ -1908,6 +2021,10 @@ func instructionsForMOV(p *obj.Prog) []*instruction { + inss = instructionsForLoad(p, movToLoad(p.As), addrToReg(p.From)) + + case obj.NAME_EXTERN, obj.NAME_STATIC: ++ if p.From.Sym.Type == objabi.STLSBSS { ++ return instructionsForTLSLoad(p) ++ } ++ + // Note that the values for $off_hi and $off_lo are currently + // zero and will be assigned during relocation. + // +@@ -1935,6 +2052,10 @@ func instructionsForMOV(p *obj.Prog) []*instruction { + inss = instructionsForStore(p, movToStore(p.As), addrToReg(p.To)) + + case obj.NAME_EXTERN, obj.NAME_STATIC: ++ if p.To.Sym.Type == objabi.STLSBSS { ++ return instructionsForTLSStore(p) ++ } ++ + // Note that the values for $off_hi and $off_lo are currently + // zero and will be assigned during relocation. + // +@@ -2198,10 +2319,10 @@ func assemble(ctxt *obj.Link, cursym *obj.LSym, newpro + break + } + if addr.Sym.Type == objabi.STLSBSS { +- if rt == objabi.R_RISCV_PCREL_ITYPE { +- rt = objabi.R_RISCV_TLS_IE_ITYPE +- } else if rt == objabi.R_RISCV_PCREL_STYPE { +- rt = objabi.R_RISCV_TLS_IE_STYPE ++ if ctxt.Flag_shared { ++ rt = objabi.R_RISCV_TLS_IE ++ } else { ++ rt = objabi.R_RISCV_TLS_LE + } + } + diff --git a/lang/go/patches/patch-src_cmd_internal_objabi_reloctype_go b/lang/go/patches/patch-src_cmd_internal_objabi_reloctype_go index 9ac653dbc1e0..560964c19f74 100644 --- a/lang/go/patches/patch-src_cmd_internal_objabi_reloctype_go +++ b/lang/go/patches/patch-src_cmd_internal_objabi_reloctype_go @@ -1,7 +1,57 @@ Index: src/cmd/internal/objabi/reloctype.go --- src/cmd/internal/objabi/reloctype.go.orig +++ src/cmd/internal/objabi/reloctype.go -@@ -279,9 +279,24 @@ const ( +@@ -238,14 +238,43 @@ const ( + // AUIPC + S-type instruction pair. + R_RISCV_PCREL_STYPE + +- // R_RISCV_TLS_IE_ITYPE resolves a 32-bit TLS initial-exec TOC offset +- // address using an AUIPC + I-type instruction pair. +- R_RISCV_TLS_IE_ITYPE ++ // R_RISCV_TLS_IE resolves a 32-bit TLS initial-exec address using an ++ // AUIPC + I-type instruction pair. ++ R_RISCV_TLS_IE + +- // R_RISCV_TLS_IE_STYPE resolves a 32-bit TLS initial-exec TOC offset +- // address using an AUIPC + S-type instruction pair. +- R_RISCV_TLS_IE_STYPE ++ // R_RISCV_TLS_LE_ITYPE resolves a 32-bit TLS local-exec address using an ++ // LUI + I-type instruction sequence. ++ R_RISCV_TLS_LE + ++ // R_RISCV_GOT_HI20 resolves the high 20 bits of a 32-bit PC-relative GOT ++ // address. ++ R_RISCV_GOT_HI20 ++ ++ // R_RISCV_PCREL_32 resolves a 32-bit PC-relative address to an absolute ++ // value. ++ R_RISCV_PCREL_32 ++ ++ // R_RISCV_PCREL_HI20 resolves the high 20 bits of a 32-bit PC-relative ++ // address. ++ R_RISCV_PCREL_HI20 ++ ++ // R_RISCV_PCREL_LO12_I resolves the low 12 bits of a 32-bit PC-relative ++ // address using an I-type instruction. ++ R_RISCV_PCREL_LO12_I ++ ++ // R_RISCV_PCREL_LO12_S resolves the low 12 bits of a 32-bit PC-relative ++ // address using an S-type instruction. ++ R_RISCV_PCREL_LO12_S ++ ++ // R_RISCV_BRANCH resolves a 12-bit PC-relative branch offset. ++ R_RISCV_BRANCH ++ ++ // R_RISCV_RVC_BRANCH resolves an 8-bit PC-relative branch offset. ++ R_RISCV_RVC_BRANCH ++ ++ // R_RISCV_RVC_JUMP resolves an 11-bit PC-relative jump offset. ++ R_RISCV_RVC_JUMP ++ + // R_PCRELDBL relocates s390x 2-byte aligned PC-relative addresses. + // TODO(mundaym): remove once variants can be serialized - see issue 14218. + R_PCRELDBL +@@ -279,9 +308,24 @@ const ( // R_ADDRMIPSU (only used on mips/mips64) resolves to the sign-adjusted "upper" 16 // bits (bit 16-31) of an external address, by encoding it into the instruction. R_ADDRMIPSU diff --git a/lang/go/patches/patch-src_cmd_internal_objabi_reloctype_string_go b/lang/go/patches/patch-src_cmd_internal_objabi_reloctype_string_go index e4b6eb55e9ff..a29655e12126 100644 --- a/lang/go/patches/patch-src_cmd_internal_objabi_reloctype_string_go +++ b/lang/go/patches/patch-src_cmd_internal_objabi_reloctype_string_go @@ -1,27 +1,57 @@ Index: src/cmd/internal/objabi/reloctype_string.go --- src/cmd/internal/objabi/reloctype_string.go.orig +++ src/cmd/internal/objabi/reloctype_string.go -@@ -73,14 +73,18 @@ func _() { - _ = x[R_JMPLOONG64-63] - _ = x[R_ADDRMIPSU-64] - _ = x[R_ADDRMIPSTLS-65] +@@ -62,25 +62,37 @@ func _() { + _ = x[R_RISCV_CALL_TRAMP-52] + _ = x[R_RISCV_PCREL_ITYPE-53] + _ = x[R_RISCV_PCREL_STYPE-54] +- _ = x[R_RISCV_TLS_IE_ITYPE-55] +- _ = x[R_RISCV_TLS_IE_STYPE-56] +- _ = x[R_PCRELDBL-57] +- _ = x[R_ADDRLOONG64-58] +- _ = x[R_ADDRLOONG64U-59] +- _ = x[R_ADDRLOONG64TLS-60] +- _ = x[R_ADDRLOONG64TLSU-61] +- _ = x[R_CALLLOONG64-62] +- _ = x[R_JMPLOONG64-63] +- _ = x[R_ADDRMIPSU-64] +- _ = x[R_ADDRMIPSTLS-65] - _ = x[R_ADDRCUOFF-66] - _ = x[R_WASMIMPORT-67] - _ = x[R_XCOFFREF-68] -+ _ = x[R_MIPS_GPREL_HI16-66] -+ _ = x[R_MIPS_GPREL_LO16-67] -+ _ = x[R_MIPS_CALL16-68] -+ _ = x[R_MIPS_JALR-69] -+ _ = x[R_ADDRCUOFF-70] -+ _ = x[R_WASMIMPORT-71] -+ _ = x[R_XCOFFREF-72] ++ _ = x[R_RISCV_TLS_IE-55] ++ _ = x[R_RISCV_TLS_LE-56] ++ _ = x[R_RISCV_GOT_HI20-57] ++ _ = x[R_RISCV_PCREL_32-58] ++ _ = x[R_RISCV_PCREL_HI20-59] ++ _ = x[R_RISCV_PCREL_LO12_I-60] ++ _ = x[R_RISCV_PCREL_LO12_S-61] ++ _ = x[R_RISCV_BRANCH-62] ++ _ = x[R_RISCV_RVC_BRANCH-63] ++ _ = x[R_RISCV_RVC_JUMP-64] ++ _ = x[R_PCRELDBL-65] ++ _ = x[R_ADDRLOONG64-66] ++ _ = x[R_ADDRLOONG64U-67] ++ _ = x[R_ADDRLOONG64TLS-68] ++ _ = x[R_ADDRLOONG64TLSU-69] ++ _ = x[R_CALLLOONG64-70] ++ _ = x[R_JMPLOONG64-71] ++ _ = x[R_ADDRMIPSU-72] ++ _ = x[R_ADDRMIPSTLS-73] ++ _ = x[R_MIPS_GPREL_HI16-74] ++ _ = x[R_MIPS_GPREL_LO16-75] ++ _ = x[R_MIPS_CALL16-76] ++ _ = x[R_MIPS_JALR-77] ++ _ = x[R_ADDRCUOFF-78] ++ _ = x[R_WASMIMPORT-79] ++ _ = x[R_XCOFFREF-80] } -const _RelocType_name = "R_ADDRR_ADDRPOWERR_ADDRARM64R_ADDRMIPSR_ADDROFFR_SIZER_CALLR_CALLARMR_CALLARM64R_CALLINDR_CALLPOWERR_CALLMIPSR_CONSTR_PCRELR_TLS_LER_TLS_IER_GOTOFFR_PLT0R_PLT1R_PLT2R_USEFIELDR_USETYPER_USEIFACER_USEIFACEMETHODR_USEGENERICIFACEMETHODR_METHODOFFR_KEEPR_POWER_TOCR_GOTPCRELR_JMPMIPSR_DWARFSECREFR_DWARFFILEREFR_ARM64_TLS_LER_ARM64_TLS_IER_ARM64_GOTPCRELR_ARM64_GOTR_ARM64_PCRELR_ARM64_LDST8R_ARM64_LDST16R_ARM64_LDST32R_ARM64_LDST64R_ARM64_LDST128R_POWER_TLS_LER_POWER_TLS_IER_POWER_TLSR_ADDRPOWER_DSR_ADDRPOWER_GOTR_ADDRPOWER_PCRELR_ADDRPOWER_TOCRELR_ADDRPOWER_TOCREL_DSR_RISCV_CALLR_RISCV_CALL_TRAMPR_RISCV_PCREL_ITYPER_RISCV_PCREL_STYPER_RISCV_TLS_IE_ITYPER_RISCV_TLS_IE_STYPER_PCRELDBLR_ADDRLOONG64R_ADDRLOONG64UR_ADDRLOONG64TLSR_ADDRLOONG64TLSUR_CALLLOONG64R_JMPLOONG64R_ADDRMIPSUR_ADDRMIPSTLSR_ADDRCUOFFR_WASMIMPORTR_XCOFFREF" -+const _RelocType_name = "R_ADDRR_ADDRPOWERR_ADDRARM64R_ADDRMIPSR_ADDROFFR_SIZER_CALLR_CALLARMR_CALLARM64R_CALLINDR_CALLPOWERR_CALLMIPSR_CONSTR_PCRELR_TLS_LER_TLS_IER_GOTOFFR_PLT0R_PLT1R_PLT2R_USEFIELDR_USETYPER_USEIFACER_USEIFACEMETHODR_USEGENERICIFACEMETHODR_METHODOFFR_KEEPR_POWER_TOCR_GOTPCRELR_JMPMIPSR_DWARFSECREFR_DWARFFILEREFR_ARM64_TLS_LER_ARM64_TLS_IER_ARM64_GOTPCRELR_ARM64_GOTR_ARM64_PCRELR_ARM64_LDST8R_ARM64_LDST16R_ARM64_LDST32R_ARM64_LDST64R_ARM64_LDST128R_POWER_TLS_LER_POWER_TLS_IER_POWER_TLSR_ADDRPOWER_DSR_ADDRPOWER_GOTR_ADDRPOWER_PCRELR_ADDRPOWER_TOCRELR_ADDRPOWER_TOCREL_DSR_RISCV_CALLR_RISCV_CALL_TRAMPR_RISCV_PCREL_ITYPER_RISCV_PCREL_STYPER_RISCV_TLS_IE_ITYPER_RISCV_TLS_IE_STYPER_PCRELDBLR_ADDRLOONG64R_ADDRLOONG64UR_ADDRLOONG64TLSR_ADDRLOONG64TLSUR_CALLLOONG64R_JMPLOONG64R_ADDRMIPSUR_ADDRMIPSTLSR_MIPS_GPREL_HI16R_MIPS_GPREL_LO16R_MIPS_CALL16R_MIPS_JALRR_ADDRCUOFFR_WASMIMPORTR_XCOFFREF" ++const _RelocType_name = "R_ADDRR_ADDRPOWERR_ADDRARM64R_ADDRMIPSR_ADDROFFR_SIZER_CALLR_CALLARMR_CALLARM64R_CALLINDR_CALLPOWERR_CALLMIPSR_CONSTR_PCRELR_TLS_LER_TLS_IER_GOTOFFR_PLT0R_PLT1R_PLT2R_USEFIELDR_USETYPER_USEIFACER_USEIFACEMETHODR_USEGENERICIFACEMETHODR_METHODOFFR_KEEPR_POWER_TOCR_GOTPCRELR_JMPMIPSR_DWARFSECREFR_DWARFFILEREFR_ARM64_TLS_LER_ARM64_TLS_IER_ARM64_GOTPCRELR_ARM64_GOTR_ARM64_PCRELR_ARM64_LDST8R_ARM64_LDST16R_ARM64_LDST32R_ARM64_LDST64R_ARM64_LDST128R_POWER_TLS_LER_POWER_TLS_IER_POWER_TLSR_ADDRPOWER_DSR_ADDRPOWER_GOTR_ADDRPOWER_PCRELR_ADDRPOWER_TOCRELR_ADDRPOWER_TOCREL_DSR_RISCV_CALLR_RISCV_CALL_TRAMPR_RISCV_PCREL_ITYPER_RISCV_PCREL_STYPER_RISCV_TLS_IER_RISCV_TLS_LER_RISCV_GOT_HI20R_RISCV_PCREL_32R_RISCV_PCREL_HI20R_RISCV_PCREL_LO12_IR_RISCV_PCREL_LO12_SR_RISCV_BRANCHR_RISCV_RVC_BRANCHR_RISCV_RVC_JUMPR_PCRELDBLR_ADDRLOONG64R_ADDRLOONG64UR_ADDRLOONG64TLSR_ADDRLOONG64TLSUR_CALLLOONG64R_JMPLOONG64R_ADDRMIPSUR_ADDRMIPSTLSR_MIPS_GPREL_HI16R_MIPS_GPREL_LO16R_MIPS_CALL16R_MIPS_JALRR_ADDRCUOFFR_WASMIMPORTR_XCOFFREF" -var _RelocType_index = [...]uint16{0, 6, 17, 28, 38, 47, 53, 59, 68, 79, 88, 99, 109, 116, 123, 131, 139, 147, 153, 159, 165, 175, 184, 194, 210, 233, 244, 250, 261, 271, 280, 293, 307, 321, 335, 351, 362, 375, 388, 402, 416, 430, 445, 459, 473, 484, 498, 513, 530, 548, 569, 581, 599, 618, 637, 657, 677, 687, 700, 714, 730, 747, 760, 772, 783, 796, 807, 819, 829} -+var _RelocType_index = [...]uint16{0, 6, 17, 28, 38, 47, 53, 59, 68, 79, 88, 99, 109, 116, 123, 131, 139, 147, 153, 159, 165, 175, 184, 194, 210, 233, 244, 250, 261, 271, 280, 293, 307, 321, 335, 351, 362, 375, 388, 402, 416, 430, 445, 459, 473, 484, 498, 513, 530, 548, 569, 581, 599, 618, 637, 657, 677, 687, 700, 714, 730, 747, 760, 772, 783, 796, 813, 830, 843, 854, 865, 877, 887} ++var _RelocType_index = [...]uint16{0, 6, 17, 28, 38, 47, 53, 59, 68, 79, 88, 99, 109, 116, 123, 131, 139, 147, 153, 159, 165, 175, 184, 194, 210, 233, 244, 250, 261, 271, 280, 293, 307, 321, 335, 351, 362, 375, 388, 402, 416, 430, 445, 459, 473, 484, 498, 513, 530, 548, 569, 581, 599, 618, 637, 651, 665, 681, 697, 715, 735, 755, 769, 787, 803, 813, 826, 840, 856, 873, 886, 898, 909, 922, 939, 956, 969, 980, 991, 1003, 1013} func (i RelocType) String() string { i -= 1 diff --git a/lang/go/patches/patch-src_cmd_link_internal_amd64_asm_go b/lang/go/patches/patch-src_cmd_link_internal_amd64_asm_go new file mode 100644 index 000000000000..c20d30210d0f --- /dev/null +++ b/lang/go/patches/patch-src_cmd_link_internal_amd64_asm_go @@ -0,0 +1,12 @@ +Index: src/cmd/link/internal/amd64/asm.go +--- src/cmd/link/internal/amd64/asm.go.orig ++++ src/cmd/link/internal/amd64/asm.go +@@ -551,7 +551,7 @@ func archrelocvariant(*ld.Target, *loader.Loader, load + return -1 + } + +-func elfsetupplt(ctxt *ld.Link, plt, got *loader.SymbolBuilder, dynamic loader.Sym) { ++func elfsetupplt(ctxt *ld.Link, ldr *loader.Loader, plt, got *loader.SymbolBuilder, dynamic loader.Sym) { + if plt.Size() == 0 { + // pushq got+8(IP) + plt.AddUint8(0xff) diff --git a/lang/go/patches/patch-src_cmd_link_internal_arm64_asm_go b/lang/go/patches/patch-src_cmd_link_internal_arm64_asm_go new file mode 100644 index 000000000000..e42be8dd16bc --- /dev/null +++ b/lang/go/patches/patch-src_cmd_link_internal_arm64_asm_go @@ -0,0 +1,12 @@ +Index: src/cmd/link/internal/arm64/asm.go +--- src/cmd/link/internal/arm64/asm.go.orig ++++ src/cmd/link/internal/arm64/asm.go +@@ -969,7 +969,7 @@ func extreloc(target *ld.Target, ldr *loader.Loader, r + return loader.ExtReloc{}, false + } + +-func elfsetupplt(ctxt *ld.Link, plt, gotplt *loader.SymbolBuilder, dynamic loader.Sym) { ++func elfsetupplt(ctxt *ld.Link, ldr *loader.Loader, plt, gotplt *loader.SymbolBuilder, dynamic loader.Sym) { + if plt.Size() == 0 { + // stp x16, x30, [sp, #-16]! + // identifying information diff --git a/lang/go/patches/patch-src_cmd_link_internal_arm_asm_go b/lang/go/patches/patch-src_cmd_link_internal_arm_asm_go new file mode 100644 index 000000000000..1fcb2852423a --- /dev/null +++ b/lang/go/patches/patch-src_cmd_link_internal_arm_asm_go @@ -0,0 +1,12 @@ +Index: src/cmd/link/internal/arm/asm.go +--- src/cmd/link/internal/arm/asm.go.orig ++++ src/cmd/link/internal/arm/asm.go +@@ -304,7 +304,7 @@ func elfreloc1(ctxt *ld.Link, out *ld.OutBuf, ldr *loa + return true + } + +-func elfsetupplt(ctxt *ld.Link, plt, got *loader.SymbolBuilder, dynamic loader.Sym) { ++func elfsetupplt(ctxt *ld.Link, ldr *loader.Loader, plt, got *loader.SymbolBuilder, dynamic loader.Sym) { + if plt.Size() == 0 { + // str lr, [sp, #-4]! + plt.AddUint32(ctxt.Arch, 0xe52de004) diff --git a/lang/go/patches/patch-src_cmd_link_internal_ld_config_go b/lang/go/patches/patch-src_cmd_link_internal_ld_config_go new file mode 100644 index 000000000000..3d166d150ae9 --- /dev/null +++ b/lang/go/patches/patch-src_cmd_link_internal_ld_config_go @@ -0,0 +1,12 @@ +Index: src/cmd/link/internal/ld/config.go +--- src/cmd/link/internal/ld/config.go.orig ++++ src/cmd/link/internal/ld/config.go +@@ -199,7 +199,7 @@ func mustLinkExternal(ctxt *Link) (res bool, reason st + + // Internally linking cgo is incomplete on some architectures. + // https://golang.org/issue/14449 +- if iscgo && ctxt.Arch.InFamily(sys.Loong64, sys.MIPS64, sys.MIPS, sys.RISCV64) { ++ if iscgo && ctxt.Arch.InFamily(sys.Loong64, sys.MIPS64, sys.MIPS) { + return true, buildcfg.GOARCH + " does not support internal cgo" + } + if iscgo && (buildcfg.GOOS == "android" || buildcfg.GOOS == "dragonfly") { diff --git a/lang/go/patches/patch-src_cmd_link_internal_ld_data_go b/lang/go/patches/patch-src_cmd_link_internal_ld_data_go new file mode 100644 index 000000000000..dd66b826a37f --- /dev/null +++ b/lang/go/patches/patch-src_cmd_link_internal_ld_data_go @@ -0,0 +1,40 @@ +Index: src/cmd/link/internal/ld/data.go +--- src/cmd/link/internal/ld/data.go.orig ++++ src/cmd/link/internal/ld/data.go +@@ -269,6 +269,7 @@ func (st *relocSymState) relocsym(s loader.Sym, P []by + } + + var o int64 ++ var archReloc bool + switch rt { + default: + switch siz { +@@ -283,6 +284,7 @@ func (st *relocSymState) relocsym(s loader.Sym, P []by + case 8: + o = int64(target.Arch.ByteOrder.Uint64(P[off:])) + } ++ archReloc = true + out, n, ok := thearch.Archreloc(target, ldr, syms, r, s, o) + if target.IsExternal() { + nExtReloc += n +@@ -562,17 +564,17 @@ func (st *relocSymState) relocsym(s loader.Sym, P []by + case 1: + P[off] = byte(int8(o)) + case 2: +- if o != int64(int16(o)) { ++ if !archReloc && o != int64(int16(o)) { + st.err.Errorf(s, "relocation address for %s is too big: %#x", ldr.SymName(rs), o) + } + target.Arch.ByteOrder.PutUint16(P[off:], uint16(o)) + case 4: + if rt == objabi.R_PCREL || rt == objabi.R_CALL { +- if o != int64(int32(o)) { ++ if !archReloc && o != int64(int32(o)) { + st.err.Errorf(s, "pc-relative relocation address for %s is too big: %#x", ldr.SymName(rs), o) + } + } else { +- if o != int64(int32(o)) && o != int64(uint32(o)) { ++ if !archReloc && o != int64(int32(o)) && o != int64(uint32(o)) { + st.err.Errorf(s, "non-pc-relative relocation address for %s is too big: %#x", ldr.SymName(rs), uint64(o)) + } + } diff --git a/lang/go/patches/patch-src_cmd_link_internal_ld_elf_go b/lang/go/patches/patch-src_cmd_link_internal_ld_elf_go index ef073a106472..228d884b1bc7 100644 --- a/lang/go/patches/patch-src_cmd_link_internal_ld_elf_go +++ b/lang/go/patches/patch-src_cmd_link_internal_ld_elf_go @@ -1,7 +1,7 @@ Index: src/cmd/link/internal/ld/elf.go --- src/cmd/link/internal/ld/elf.go.orig +++ src/cmd/link/internal/ld/elf.go -@@ -1475,6 +1475,15 @@ func (ctxt *Link) doelf() { +@@ -1475,11 +1475,20 @@ func (ctxt *Link) doelf() { dynamic := ldr.CreateSymForUpdate(".dynamic", 0) dynamic.SetType(sym.SELFSECT) // writable @@ -17,6 +17,12 @@ Index: src/cmd/link/internal/ld/elf.go if ctxt.IsS390X() { // S390X uses .got instead of .got.plt gotplt = got + } +- thearch.Elfsetupplt(ctxt, plt, gotplt, dynamic.Sym()) ++ thearch.Elfsetupplt(ctxt, ctxt.loader, plt, gotplt, dynamic.Sym()) + + /* + * .dynamic table @@ -1524,6 +1533,7 @@ func (ctxt *Link) doelf() { // DT_JMPREL is emitted so we have to defer generation of elf.DT_PLTREL, // DT_PLTRELSZ, and elf.DT_JMPREL dynamic entries until after we know the diff --git a/lang/go/patches/patch-src_cmd_link_internal_ld_lib_go b/lang/go/patches/patch-src_cmd_link_internal_ld_lib_go index 7bf9779c1049..2bdecd23a71c 100644 --- a/lang/go/patches/patch-src_cmd_link_internal_ld_lib_go +++ b/lang/go/patches/patch-src_cmd_link_internal_ld_lib_go @@ -1,7 +1,15 @@ Index: src/cmd/link/internal/ld/lib.go --- src/cmd/link/internal/ld/lib.go.orig +++ src/cmd/link/internal/ld/lib.go -@@ -252,8 +252,11 @@ type Arch struct { +@@ -245,15 +245,18 @@ type Arch struct { + + Elfreloc1 func(*Link, *OutBuf, *loader.Loader, loader.Sym, loader.ExtReloc, int, int64) bool + ElfrelocSize uint32 // size of an ELF relocation record, must match Elfreloc1. +- Elfsetupplt func(ctxt *Link, plt, gotplt *loader.SymbolBuilder, dynamic loader.Sym) ++ Elfsetupplt func(ctxt *Link, ldr *loader.Loader, plt, gotplt *loader.SymbolBuilder, dynamic loader.Sym) + Gentext func(*Link, *loader.Loader) // Generate text before addressing has been performed. + Machoreloc1 func(*sys.Arch, *OutBuf, *loader.Loader, loader.Sym, loader.ExtReloc, int64) bool + MachorelocSize uint32 // size of an Mach-O relocation record, must match Machoreloc1. PEreloc1 func(*sys.Arch, *OutBuf, *loader.Loader, loader.Sym, loader.ExtReloc, int64) bool Xcoffreloc1 func(*sys.Arch, *OutBuf, *loader.Loader, loader.Sym, loader.ExtReloc, int64) bool diff --git a/lang/go/patches/patch-src_cmd_link_internal_ld_pcln_go b/lang/go/patches/patch-src_cmd_link_internal_ld_pcln_go new file mode 100644 index 000000000000..f2bc697ebada --- /dev/null +++ b/lang/go/patches/patch-src_cmd_link_internal_ld_pcln_go @@ -0,0 +1,17 @@ +Index: src/cmd/link/internal/ld/pcln.go +--- src/cmd/link/internal/ld/pcln.go.orig ++++ src/cmd/link/internal/ld/pcln.go +@@ -99,6 +99,13 @@ func makePclntab(ctxt *Link, container loader.Bitmap) + } + + func emitPcln(ctxt *Link, s loader.Sym, container loader.Bitmap) bool { ++ if ctxt.Target.IsRISCV64() { ++ symName := ctxt.loader.SymName(s) ++ if symName == "" || strings.HasPrefix(symName, ".L") { ++ return false ++ } ++ } ++ + // We want to generate func table entries only for the "lowest + // level" symbols, not containers of subsymbols. + return !container.Has(s) diff --git a/lang/go/patches/patch-src_cmd_link_internal_loadelf_ldelf_go b/lang/go/patches/patch-src_cmd_link_internal_loadelf_ldelf_go new file mode 100644 index 000000000000..b7ae0c77bf5b --- /dev/null +++ b/lang/go/patches/patch-src_cmd_link_internal_loadelf_ldelf_go @@ -0,0 +1,87 @@ +Index: src/cmd/link/internal/loadelf/ldelf.go +--- src/cmd/link/internal/loadelf/ldelf.go.orig ++++ src/cmd/link/internal/loadelf/ldelf.go +@@ -583,27 +583,41 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVe + } + sect = &elfobj.sect[elfsym.shndx] + if sect.sym == 0 { +- if strings.HasPrefix(elfsym.name, ".Linfo_string") { // clang does this +- continue +- } ++ if elfsym.type_ == 0 { ++ if strings.HasPrefix(sect.name, ".debug_") && elfsym.name == "" { ++ // clang on arm and riscv64. ++ // This reportedly happens with clang 3.7 on ARM. ++ // See issue 13139. ++ continue ++ } ++ if strings.HasPrefix(elfsym.name, ".Ldebug_") || elfsym.name == ".L0 " { ++ // gcc on riscv64. ++ continue ++ } ++ if elfsym.name == ".Lline_table_start0" { ++ // clang on riscv64. ++ continue ++ } + +- if elfsym.name == "" && elfsym.type_ == 0 && sect.name == ".debug_str" { +- // This reportedly happens with clang 3.7 on ARM. +- // See issue 13139. +- continue ++ if strings.HasPrefix(elfsym.name, "$d") && sect.name == ".debug_frame" { ++ // "$d" is a marker, not a real symbol. ++ // This happens with gcc on ARM64. ++ // See https://sourceware.org/bugzilla/show_bug.cgi?id=21809 ++ continue ++ } + } + +- if strings.HasPrefix(elfsym.name, "$d") && elfsym.type_ == 0 && sect.name == ".debug_frame" { +- // "$d" is a marker, not a real symbol. +- // This happens with gcc on ARM64. +- // See https://sourceware.org/bugzilla/show_bug.cgi?id=21809 ++ if strings.HasPrefix(elfsym.name, ".Linfo_string") { ++ // clang does this + continue + } + +- if strings.HasPrefix(elfsym.name, ".LASF") { // gcc on s390x does this ++ if strings.HasPrefix(elfsym.name, ".LASF") || strings.HasPrefix(elfsym.name, ".LLST") { ++ // gcc on s390x and riscv64 does this. + continue + } +- return errorf("%v: sym#%d (%s): ignoring symbol in section %d (type %d)", elfsym.sym, i, elfsym.name, elfsym.shndx, elfsym.type_) ++ ++ return errorf("%v: sym#%d (%q): ignoring symbol in section %d (%q) (type %d)", elfsym.sym, i, elfsym.name, elfsym.shndx, sect.name, elfsym.type_) + } + + s := elfsym.sym +@@ -1079,8 +1093,16 @@ func relSize(arch *sys.Arch, pn string, elftype uint32 + S390X | uint32(elf.R_390_PLT64)<<16: + return 8, 8, nil + ++ case RISCV64 | uint32(elf.R_RISCV_SET6)<<16, ++ RISCV64 | uint32(elf.R_RISCV_SUB6)<<16, ++ RISCV64 | uint32(elf.R_RISCV_SET8)<<16, ++ RISCV64 | uint32(elf.R_RISCV_SUB8)<<16: ++ return 1, 1, nil ++ + case RISCV64 | uint32(elf.R_RISCV_RVC_BRANCH)<<16, +- RISCV64 | uint32(elf.R_RISCV_RVC_JUMP)<<16: ++ RISCV64 | uint32(elf.R_RISCV_RVC_JUMP)<<16, ++ RISCV64 | uint32(elf.R_RISCV_SET16)<<16, ++ RISCV64 | uint32(elf.R_RISCV_SUB16)<<16: + return 2, 2, nil + + case RISCV64 | uint32(elf.R_RISCV_32)<<16, +@@ -1092,6 +1114,10 @@ func relSize(arch *sys.Arch, pn string, elftype uint32 + RISCV64 | uint32(elf.R_RISCV_PCREL_HI20)<<16, + RISCV64 | uint32(elf.R_RISCV_PCREL_LO12_I)<<16, + RISCV64 | uint32(elf.R_RISCV_PCREL_LO12_S)<<16, ++ RISCV64 | uint32(elf.R_RISCV_ADD32)<<16, ++ RISCV64 | uint32(elf.R_RISCV_SET32)<<16, ++ RISCV64 | uint32(elf.R_RISCV_SUB32)<<16, ++ RISCV64 | uint32(elf.R_RISCV_32_PCREL)<<16, + RISCV64 | uint32(elf.R_RISCV_RELAX)<<16: + return 4, 4, nil + diff --git a/lang/go/patches/patch-src_cmd_link_internal_loong64_asm_go b/lang/go/patches/patch-src_cmd_link_internal_loong64_asm_go new file mode 100644 index 000000000000..02ee1a298a5f --- /dev/null +++ b/lang/go/patches/patch-src_cmd_link_internal_loong64_asm_go @@ -0,0 +1,12 @@ +Index: src/cmd/link/internal/loong64/asm.go +--- src/cmd/link/internal/loong64/asm.go.orig ++++ src/cmd/link/internal/loong64/asm.go +@@ -145,7 +145,7 @@ func elfreloc1(ctxt *ld.Link, out *ld.OutBuf, ldr *loa + return true + } + +-func elfsetupplt(ctxt *ld.Link, plt, gotplt *loader.SymbolBuilder, dynamic loader.Sym) { ++func elfsetupplt(ctxt *ld.Link, ldr *loader.Loader, plt, gotplt *loader.SymbolBuilder, dynamic loader.Sym) { + return + } + diff --git a/lang/go/patches/patch-src_cmd_link_internal_mips64_asm_go b/lang/go/patches/patch-src_cmd_link_internal_mips64_asm_go index 108de75ec19a..7d0fdc44dba1 100644 --- a/lang/go/patches/patch-src_cmd_link_internal_mips64_asm_go +++ b/lang/go/patches/patch-src_cmd_link_internal_mips64_asm_go @@ -134,7 +134,7 @@ Index: src/cmd/link/internal/mips64/asm.go return false case objabi.R_ADDR, objabi.R_DWARFSECREF: switch r.Size { -@@ -85,9 +193,16 @@ func elfreloc1(ctxt *ld.Link, out *ld.OutBuf, ldr *loa +@@ -85,23 +193,193 @@ func elfreloc1(ctxt *ld.Link, out *ld.OutBuf, ldr *loa // via the external linker. addend += 0x7000 } @@ -153,11 +153,12 @@ Index: src/cmd/link/internal/mips64/asm.go } out.Write64(uint64(addend)) -@@ -95,13 +210,176 @@ func elfreloc1(ctxt *ld.Link, out *ld.OutBuf, ldr *loa + return true } - func elfsetupplt(ctxt *ld.Link, plt, gotplt *loader.SymbolBuilder, dynamic loader.Sym) { +-func elfsetupplt(ctxt *ld.Link, plt, gotplt *loader.SymbolBuilder, dynamic loader.Sym) { - return ++func elfsetupplt(ctxt *ld.Link, ldr *loader.Loader, plt, gotplt *loader.SymbolBuilder, dynamic loader.Sym) { + if plt.Size() != 0 { + return + } diff --git a/lang/go/patches/patch-src_cmd_link_internal_mips_asm_go b/lang/go/patches/patch-src_cmd_link_internal_mips_asm_go new file mode 100644 index 000000000000..4747d416fbee --- /dev/null +++ b/lang/go/patches/patch-src_cmd_link_internal_mips_asm_go @@ -0,0 +1,12 @@ +Index: src/cmd/link/internal/mips/asm.go +--- src/cmd/link/internal/mips/asm.go.orig ++++ src/cmd/link/internal/mips/asm.go +@@ -68,7 +68,7 @@ func elfreloc1(ctxt *ld.Link, out *ld.OutBuf, ldr *loa + return true + } + +-func elfsetupplt(ctxt *ld.Link, plt, gotplt *loader.SymbolBuilder, dynamic loader.Sym) { ++func elfsetupplt(ctxt *ld.Link, ldr *loader.Loader, plt, gotplt *loader.SymbolBuilder, dynamic loader.Sym) { + return + } + diff --git a/lang/go/patches/patch-src_cmd_link_internal_ppc64_asm_go b/lang/go/patches/patch-src_cmd_link_internal_ppc64_asm_go new file mode 100644 index 000000000000..c7805edbb3b3 --- /dev/null +++ b/lang/go/patches/patch-src_cmd_link_internal_ppc64_asm_go @@ -0,0 +1,12 @@ +Index: src/cmd/link/internal/ppc64/asm.go +--- src/cmd/link/internal/ppc64/asm.go.orig ++++ src/cmd/link/internal/ppc64/asm.go +@@ -689,7 +689,7 @@ func elfreloc1(ctxt *ld.Link, out *ld.OutBuf, ldr *loa + return true + } + +-func elfsetupplt(ctxt *ld.Link, plt, got *loader.SymbolBuilder, dynamic loader.Sym) { ++func elfsetupplt(ctxt *ld.Link, ldr *loader.Loader, plt, got *loader.SymbolBuilder, dynamic loader.Sym) { + if plt.Size() == 0 { + // The dynamic linker stores the address of the + // dynamic resolver and the DSO identifier in the two diff --git a/lang/go/patches/patch-src_cmd_link_internal_riscv64_asm_go b/lang/go/patches/patch-src_cmd_link_internal_riscv64_asm_go new file mode 100644 index 000000000000..857e71c8b33b --- /dev/null +++ b/lang/go/patches/patch-src_cmd_link_internal_riscv64_asm_go @@ -0,0 +1,500 @@ +Index: src/cmd/link/internal/riscv64/asm.go +--- src/cmd/link/internal/riscv64/asm.go.orig ++++ src/cmd/link/internal/riscv64/asm.go +@@ -20,9 +20,146 @@ import ( + // fakeLabelName matches the RISCV_FAKE_LABEL_NAME from binutils. + const fakeLabelName = ".L0 " + +-func gentext(ctxt *ld.Link, ldr *loader.Loader) { ++func gentext(ctxt *ld.Link, ldr *loader.Loader) {} ++ ++func findHI20Reloc(ldr *loader.Loader, s loader.Sym, val int64) *loader.Reloc { ++ outer := ldr.OuterSym(s) ++ if outer == 0 { ++ return nil ++ } ++ relocs := ldr.Relocs(outer) ++ start := sort.Search(relocs.Count(), func(i int) bool { return ldr.SymValue(outer)+int64(relocs.At(i).Off()) >= val }) ++ for idx := start; idx < relocs.Count(); idx++ { ++ r := relocs.At(idx) ++ if ldr.SymValue(outer)+int64(r.Off()) != val { ++ break ++ } ++ if r.Type() == objabi.R_RISCV_GOT_HI20 || r.Type() == objabi.R_RISCV_PCREL_HI20 { ++ return &r ++ } ++ } ++ return nil + } + ++func adddynrel(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, s loader.Sym, r loader.Reloc, rIdx int) bool { ++ targ := r.Sym() ++ ++ var targType sym.SymKind ++ if targ != 0 { ++ targType = ldr.SymType(targ) ++ } ++ ++ switch r.Type() { ++ case objabi.ElfRelocOffset + objabi.RelocType(elf.R_RISCV_CALL), ++ objabi.ElfRelocOffset + objabi.RelocType(elf.R_RISCV_CALL_PLT): ++ ++ if targType == sym.SDYNIMPORT { ++ addpltsym(target, ldr, syms, targ) ++ su := ldr.MakeSymbolUpdater(s) ++ su.SetRelocSym(rIdx, syms.PLT) ++ su.SetRelocAdd(rIdx, r.Add()+int64(ldr.SymPlt(targ))) ++ } ++ if (targType == 0 || targType == sym.SXREF) && !ldr.AttrVisibilityHidden(targ) { ++ ldr.Errorf(s, "unknown symbol %s in RISCV call", ldr.SymName(targ)) ++ } ++ su := ldr.MakeSymbolUpdater(s) ++ su.SetRelocType(rIdx, objabi.R_RISCV_PCREL_ITYPE) ++ return true ++ ++ case objabi.ElfRelocOffset + objabi.RelocType(elf.R_RISCV_GOT_HI20): ++ if targType != sym.SDYNIMPORT { ++ // TODO(jsing): Could convert to non-GOT reference. ++ } ++ ++ ld.AddGotSym(target, ldr, syms, targ, uint32(elf.R_RISCV_64)) ++ su := ldr.MakeSymbolUpdater(s) ++ su.SetRelocType(rIdx, objabi.R_RISCV_GOT_HI20) ++ su.SetRelocSym(rIdx, syms.GOT) ++ su.SetRelocAdd(rIdx, r.Add()+int64(ldr.SymGot(targ))) ++ return true ++ ++ case objabi.ElfRelocOffset + objabi.RelocType(elf.R_RISCV_PCREL_HI20): ++ su := ldr.MakeSymbolUpdater(s) ++ su.SetRelocType(rIdx, objabi.R_RISCV_PCREL_HI20) ++ return true ++ ++ case objabi.ElfRelocOffset + objabi.RelocType(elf.R_RISCV_PCREL_LO12_I): ++ if r.Add() != 0 { ++ ldr.Errorf(s, "R_RISCV_PCREL_LO12_I with non-zero addend") ++ } ++ su := ldr.MakeSymbolUpdater(s) ++ su.SetRelocType(rIdx, objabi.R_RISCV_PCREL_LO12_I) ++ return true ++ ++ case objabi.ElfRelocOffset + objabi.RelocType(elf.R_RISCV_PCREL_LO12_S): ++ if r.Add() != 0 { ++ ldr.Errorf(s, "R_RISCV_PCREL_LO12_S with non-zero addend") ++ } ++ su := ldr.MakeSymbolUpdater(s) ++ su.SetRelocType(rIdx, objabi.R_RISCV_PCREL_LO12_S) ++ return true ++ ++ case objabi.ElfRelocOffset + objabi.RelocType(elf.R_RISCV_32_PCREL): ++ su := ldr.MakeSymbolUpdater(s) ++ su.SetRelocType(rIdx, objabi.R_RISCV_PCREL_32) ++ return true ++ ++ case objabi.ElfRelocOffset + objabi.RelocType(elf.R_RISCV_RVC_BRANCH): ++ su := ldr.MakeSymbolUpdater(s) ++ su.SetRelocType(rIdx, objabi.R_RISCV_RVC_BRANCH) ++ return true ++ ++ case objabi.ElfRelocOffset + objabi.RelocType(elf.R_RISCV_RVC_JUMP): ++ su := ldr.MakeSymbolUpdater(s) ++ su.SetRelocType(rIdx, objabi.R_RISCV_RVC_JUMP) ++ return true ++ ++ case objabi.ElfRelocOffset + objabi.RelocType(elf.R_RISCV_BRANCH): ++ su := ldr.MakeSymbolUpdater(s) ++ su.SetRelocType(rIdx, objabi.R_RISCV_BRANCH) ++ return true ++ ++ case objabi.ElfRelocOffset + objabi.RelocType(elf.R_RISCV_RELAX): ++ // Ignore relaxations, at least for now. ++ return true ++ ++ default: ++ if r.Type() >= objabi.ElfRelocOffset { ++ ldr.Errorf(s, "unexpected relocation type %d (%s)", r.Type(), sym.RelocName(target.Arch, r.Type())) ++ return false ++ } ++ } ++ ++ // Reread the reloc to incorporate any changes in type above. ++ relocs := ldr.Relocs(s) ++ r = relocs.At(rIdx) ++ ++ switch r.Type() { ++ case objabi.R_RISCV_PCREL_ITYPE: ++ if targType != sym.SDYNIMPORT { ++ // nothing to do, the relocation will be laid out in reloc ++ return true ++ } ++ if target.IsExternal() { ++ // External linker will do this relocation. ++ return true ++ } ++ // Internal linking. ++ if r.Add() != 0 { ++ ldr.Errorf(s, "PLT reference with non-zero addend (%v)", r.Add()) ++ } ++ // Build a PLT entry and change the relocation target to that entry. ++ addpltsym(target, ldr, syms, targ) ++ su := ldr.MakeSymbolUpdater(s) ++ su.SetRelocSym(rIdx, syms.PLT) ++ su.SetRelocAdd(rIdx, int64(ldr.SymPlt(targ))) ++ ++ return true ++ } ++ ++ return false ++} ++ + func genSymsLate(ctxt *ld.Link, ldr *loader.Loader) { + if ctxt.LinkMode != ld.LinkExternal { + return +@@ -39,7 +176,7 @@ func genSymsLate(ctxt *ld.Link, ldr *loader.Loader) { + for ri := 0; ri < relocs.Count(); ri++ { + r := relocs.At(ri) + if r.Type() != objabi.R_RISCV_PCREL_ITYPE && r.Type() != objabi.R_RISCV_PCREL_STYPE && +- r.Type() != objabi.R_RISCV_TLS_IE_ITYPE && r.Type() != objabi.R_RISCV_TLS_IE_STYPE { ++ r.Type() != objabi.R_RISCV_TLS_IE { + continue + } + if r.Off() == 0 && ldr.SymType(s) == sym.STEXT { +@@ -101,7 +238,7 @@ func elfreloc1(ctxt *ld.Link, out *ld.OutBuf, ldr *loa + out.Write64(uint64(elf.R_RISCV_JAL) | uint64(elfsym)<<32) + out.Write64(uint64(r.Xadd)) + +- case objabi.R_RISCV_PCREL_ITYPE, objabi.R_RISCV_PCREL_STYPE, objabi.R_RISCV_TLS_IE_ITYPE, objabi.R_RISCV_TLS_IE_STYPE: ++ case objabi.R_RISCV_PCREL_ITYPE, objabi.R_RISCV_PCREL_STYPE, objabi.R_RISCV_TLS_IE: + // Find the text symbol for the AUIPC instruction targeted + // by this relocation. + relocs := ldr.Relocs(s) +@@ -127,10 +264,8 @@ func elfreloc1(ctxt *ld.Link, out *ld.OutBuf, ldr *loa + hiRel, loRel = elf.R_RISCV_PCREL_HI20, elf.R_RISCV_PCREL_LO12_I + case objabi.R_RISCV_PCREL_STYPE: + hiRel, loRel = elf.R_RISCV_PCREL_HI20, elf.R_RISCV_PCREL_LO12_S +- case objabi.R_RISCV_TLS_IE_ITYPE: ++ case objabi.R_RISCV_TLS_IE: + hiRel, loRel = elf.R_RISCV_TLS_GOT_HI20, elf.R_RISCV_PCREL_LO12_I +- case objabi.R_RISCV_TLS_IE_STYPE: +- hiRel, loRel = elf.R_RISCV_TLS_GOT_HI20, elf.R_RISCV_PCREL_LO12_S + } + out.Write64(uint64(sectoff)) + out.Write64(uint64(hiRel) | uint64(elfsym)<<32) +@@ -139,6 +274,17 @@ func elfreloc1(ctxt *ld.Link, out *ld.OutBuf, ldr *loa + out.Write64(uint64(loRel) | uint64(hi20ElfSym)<<32) + out.Write64(uint64(0)) + ++ case objabi.R_RISCV_TLS_LE: ++ out.Write64(uint64(sectoff)) ++ out.Write64(uint64(elf.R_RISCV_TPREL_HI20) | uint64(elfsym)<<32) ++ out.Write64(uint64(r.Xadd)) ++ out.Write64(uint64(sectoff + 4)) ++ out.Write64(uint64(elf.R_RISCV_TPREL_LO12_I) | uint64(elfsym)<<32) ++ out.Write64(uint64(r.Xadd)) ++ out.Write64(uint64(sectoff + 8)) ++ out.Write64(uint64(elf.R_RISCV_TPREL_ADD) | uint64(elfsym)<<32) ++ out.Write64(uint64(0)) ++ + default: + return false + } +@@ -146,10 +292,104 @@ func elfreloc1(ctxt *ld.Link, out *ld.OutBuf, ldr *loa + return true + } + +-func elfsetupplt(ctxt *ld.Link, plt, gotplt *loader.SymbolBuilder, dynamic loader.Sym) { +- log.Fatalf("elfsetupplt") ++func elfsetupplt(ctxt *ld.Link, ldr *loader.Loader, plt, gotplt *loader.SymbolBuilder, dynamic loader.Sym) { ++ if plt.Size() != 0 { ++ return ++ } ++ if gotplt.Size() != 0 { ++ ctxt.Errorf(gotplt.Sym(), "got.plt is not empty") ++ } ++ ++ // https://github.com/riscv/riscv-elf-psabi-doc/blob/master/riscv-elf.md#program-linkage-table ++ // ++ // 1: auipc t2, %pcrel_hi(.got.plt) ++ // sub t1, t1, t3 # shifted .got.plt offset + hdr size + 12 ++ // l[w|d] t3, %pcrel_lo(1b)(t2) # _dl_runtime_resolve ++ // addi t1, t1, -(hdr size + 12) # shifted .got.plt offset ++ // addi t0, t2, %pcrel_lo(1b) # &.got.plt ++ // srli t1, t1, log2(16/PTRSIZE) # .got.plt offset ++ // l[w|d] t0, PTRSIZE(t0) # link map ++ // jr t3 ++ ++ plt.AddSymRef(ctxt.Arch, gotplt.Sym(), 0, objabi.R_RISCV_PCREL_HI20, 4) ++ plt.SetUint32(ctxt.Arch, plt.Size()-4, 0x00000397) // auipc t2,0x0 ++ ++ sb := ldr.MakeSymbolBuilder(fakeLabelName) ++ sb.SetType(sym.STEXT) ++ sb.SetValue(ldr.SymValue(plt.Sym()) + plt.Size() - 4) ++ sb.SetLocal(true) ++ sb.SetReachable(true) ++ sb.SetVisibilityHidden(true) ++ plt.AddInteriorSym(sb.Sym()) ++ ++ plt.AddUint32(ctxt.Arch, 0x41c30333) // sub t1,t1,t3 ++ ++ plt.AddSymRef(ctxt.Arch, sb.Sym(), 0, objabi.R_RISCV_PCREL_LO12_I, 4) ++ plt.SetUint32(ctxt.Arch, plt.Size()-4, 0x0003be03) // ld t3,0(t2) ++ ++ plt.AddUint32(ctxt.Arch, 0xfd430313) // addi t1,t1,-44 ++ ++ plt.AddSymRef(ctxt.Arch, sb.Sym(), 0, objabi.R_RISCV_PCREL_LO12_I, 4) ++ plt.SetUint32(ctxt.Arch, plt.Size()-4, 0x00038293) // addi t0,t2,0 ++ ++ plt.AddUint32(ctxt.Arch, 0x00135313) // srli t1,t1,0x1 ++ plt.AddUint32(ctxt.Arch, 0x0082b283) // ld t0,8(t0) ++ plt.AddUint32(ctxt.Arch, 0x00008e02) // jr t3 ++ ++ gotplt.AddAddrPlus(ctxt.Arch, dynamic, 0) // got.plt[0] = _dl_runtime_resolve ++ gotplt.AddUint64(ctxt.Arch, 0) // got.plt[1] = link map + } + ++func addpltsym(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, s loader.Sym) { ++ if ldr.SymPlt(s) >= 0 { ++ return ++ } ++ ++ ld.Adddynsym(ldr, target, syms, s) ++ ++ plt := ldr.MakeSymbolUpdater(syms.PLT) ++ gotplt := ldr.MakeSymbolUpdater(syms.GOTPLT) ++ rela := ldr.MakeSymbolUpdater(syms.RelaPLT) ++ if plt.Size() == 0 { ++ panic("plt is not set up") ++ } ++ ++ // https://github.com/riscv/riscv-elf-psabi-doc/blob/master/riscv-elf.md#program-linkage-table ++ // ++ // 1: auipc t3, %pcrel_hi(function@.got.plt) ++ // l[w|d] t3, %pcrel_lo(1b)(t3) ++ // jalr t1, t3 ++ // nop ++ ++ plt.AddSymRef(target.Arch, gotplt.Sym(), gotplt.Size(), objabi.R_RISCV_PCREL_HI20, 4) ++ plt.SetUint32(target.Arch, plt.Size()-4, 0x00000e17) // auipc t3,0x0 ++ ++ sb := ldr.MakeSymbolBuilder(fakeLabelName) ++ sb.SetType(sym.STEXT) ++ sb.SetValue(ldr.SymValue(plt.Sym()) + plt.Size() - 4) ++ sb.SetLocal(true) ++ sb.SetReachable(true) ++ sb.SetVisibilityHidden(true) ++ plt.AddInteriorSym(sb.Sym()) ++ ++ plt.AddSymRef(target.Arch, sb.Sym(), 0, objabi.R_RISCV_PCREL_LO12_I, 4) ++ plt.SetUint32(target.Arch, plt.Size()-4, 0x000e3e03) // ld t3,0(t3) ++ plt.AddUint32(target.Arch, 0x000e0367) // jalr t1,t3 ++ plt.AddUint32(target.Arch, 0x00000001) // nop ++ ++ ldr.SetPlt(s, int32(plt.Size()-16)) ++ ++ // add to got.plt: pointer to plt[0] ++ gotplt.AddAddrPlus(target.Arch, plt.Sym(), 0) ++ ++ // rela ++ rela.AddAddrPlus(target.Arch, gotplt.Sym(), gotplt.Size()-8) ++ sDynid := ldr.SymDynid(s) ++ ++ rela.AddUint64(target.Arch, elf.R_INFO(uint32(sDynid), uint32(elf.R_RISCV_JUMP_SLOT))) ++ rela.AddUint64(target.Arch, 0) ++} ++ + func machoreloc1(*sys.Arch, *ld.OutBuf, *loader.Loader, loader.Sym, loader.ExtReloc, int64) bool { + log.Fatalf("machoreloc1 not implemented") + return false +@@ -189,8 +429,11 @@ func archreloc(target *ld.Target, ldr *loader.Loader, + case objabi.R_RISCV_CALL, objabi.R_RISCV_CALL_TRAMP: + return val, 1, true + +- case objabi.R_RISCV_PCREL_ITYPE, objabi.R_RISCV_PCREL_STYPE, objabi.R_RISCV_TLS_IE_ITYPE, objabi.R_RISCV_TLS_IE_STYPE: ++ case objabi.R_RISCV_PCREL_ITYPE, objabi.R_RISCV_PCREL_STYPE, objabi.R_RISCV_TLS_IE: + return val, 2, true ++ ++ case objabi.R_RISCV_TLS_LE: ++ return val, 3, true + } + + return val, 0, false +@@ -211,16 +454,132 @@ func archreloc(target *ld.Target, ldr *loader.Loader, + + return val, 0, true + +- case objabi.R_RISCV_TLS_IE_ITYPE, objabi.R_RISCV_TLS_IE_STYPE: +- // TLS relocations are not currently handled for internal linking. +- // For now, TLS is only used when cgo is in use and cgo currently +- // requires external linking. However, we need to accept these +- // relocations so that code containing TLS variables will link, +- // even when they're not being used. For now, replace these +- // instructions with EBREAK to detect accidental use. +- const ebreakIns = 0x00100073 +- return ebreakIns<<32 | ebreakIns, 0, true ++ case objabi.R_RISCV_TLS_IE: ++ log.Fatalf("cannot handle R_RISCV_TLS_IE (sym %s) when linking internally", ldr.SymName(s)) ++ return val, 0, false + ++ case objabi.R_RISCV_TLS_LE: ++ // Generate LUI and ADDIW instruction immediates. ++ off := r.Add() ++ ++ low, high, err := riscv.Split32BitImmediate(off) ++ if err != nil { ++ ldr.Errorf(s, "relocation does not fit in 32-bits: %d", off) ++ } ++ ++ luiImm, err := riscv.EncodeUImmediate(high) ++ if err != nil { ++ ldr.Errorf(s, "cannot encode R_RISCV_TLS_LE LUI relocation offset for %s: %v", ldr.SymName(rs), err) ++ } ++ ++ addiwImm, err := riscv.EncodeIImmediate(low) ++ if err != nil { ++ ldr.Errorf(s, "cannot encode R_RISCV_TLS_LE I-type instruction relocation offset for %s: %v", ldr.SymName(rs), err) ++ } ++ ++ lui := int64(uint32(val)) ++ addiw := int64(uint32(val >> 32)) ++ ++ lui = (lui &^ riscv.UTypeImmMask) | int64(uint32(luiImm)) ++ addiw = (addiw &^ riscv.ITypeImmMask) | int64(uint32(addiwImm)) ++ ++ return addiw<<32 | lui, 0, true ++ ++ case objabi.R_RISCV_BRANCH: ++ pc := ldr.SymValue(s) + int64(r.Off()) ++ off := ldr.SymValue(rs) + r.Add() - pc ++ ++ imm, err := riscv.EncodeBImmediate(off) ++ if err != nil { ++ ldr.Errorf(s, "cannot encode B-type instruction relocation offset for %s: %v", ldr.SymName(rs), err) ++ } ++ ins := (int64(uint32(val)) &^ riscv.BTypeImmMask) | int64(uint32(imm)) ++ ++ return ins, 0, true ++ ++ case objabi.R_RISCV_RVC_BRANCH, objabi.R_RISCV_RVC_JUMP: ++ pc := ldr.SymValue(s) + int64(r.Off()) ++ off := ldr.SymValue(rs) + r.Add() - pc ++ ++ var err error ++ var imm, immMask int64 ++ switch r.Type() { ++ case objabi.R_RISCV_RVC_BRANCH: ++ immMask = riscv.CBTypeImmMask ++ imm, err = riscv.EncodeCBImmediate(off) ++ if err != nil { ++ ldr.Errorf(s, "cannot encode CB-type instruction relocation offset for %s: %v", ldr.SymName(rs), err) ++ } ++ case objabi.R_RISCV_RVC_JUMP: ++ immMask = riscv.CJTypeImmMask ++ imm, err = riscv.EncodeCJImmediate(off) ++ if err != nil { ++ ldr.Errorf(s, "cannot encode CJ-type instruction relocation offset for %s: %v", ldr.SymName(rs), err) ++ } ++ default: ++ panic(fmt.Sprintf("unknown relocation type: %v", r.Type())) ++ } ++ ++ ins := (int64(uint16(val)) &^ immMask) | int64(uint16(imm)) ++ ++ return ins, 0, true ++ ++ case objabi.R_RISCV_GOT_HI20, objabi.R_RISCV_PCREL_HI20: ++ pc := ldr.SymValue(s) + int64(r.Off()) ++ off := ldr.SymValue(rs) + r.Add() - pc ++ ++ // Generate AUIPC immediates. ++ _, high, err := riscv.Split32BitImmediate(off) ++ if err != nil { ++ ldr.Errorf(s, "relocation does not fit in 32-bits: %d", off) ++ } ++ ++ auipcImm, err := riscv.EncodeUImmediate(high) ++ if err != nil { ++ ldr.Errorf(s, "cannot encode R_RISCV_PCREL_ AUIPC relocation offset for %s: %v", ldr.SymName(rs), err) ++ } ++ ++ auipc := int64(uint32(val)) ++ auipc = (auipc &^ riscv.UTypeImmMask) | int64(uint32(auipcImm)) ++ ++ return auipc, 0, true ++ ++ case objabi.R_RISCV_PCREL_LO12_I, objabi.R_RISCV_PCREL_LO12_S: ++ hi20Reloc := findHI20Reloc(ldr, rs, ldr.SymValue(rs)) ++ if hi20Reloc == nil { ++ ldr.Errorf(s, "missing HI20 relocation for LO12 relocation with %s (%d)", ldr.SymName(rs), rs) ++ } ++ ++ pc := ldr.SymValue(s) + int64(hi20Reloc.Off()) ++ off := ldr.SymValue(hi20Reloc.Sym()) + hi20Reloc.Add() - pc ++ ++ low, _, err := riscv.Split32BitImmediate(off) ++ if err != nil { ++ ldr.Errorf(s, "relocation does not fit in 32-bits: %d", off) ++ } ++ ++ var imm, immMask int64 ++ switch r.Type() { ++ case objabi.R_RISCV_PCREL_LO12_I: ++ immMask = riscv.ITypeImmMask ++ imm, err = riscv.EncodeIImmediate(low) ++ if err != nil { ++ ldr.Errorf(s, "cannot encode objabi.R_RISCV_PCREL_LO12_I I-type instruction relocation offset for %s: %v", ldr.SymName(rs), err) ++ } ++ case objabi.R_RISCV_PCREL_LO12_S: ++ immMask = riscv.STypeImmMask ++ imm, err = riscv.EncodeSImmediate(low) ++ if err != nil { ++ ldr.Errorf(s, "cannot encode R_RISCV_PCREL_LO12_S S-type instruction relocation offset for %s: %v", ldr.SymName(rs), err) ++ } ++ default: ++ panic(fmt.Sprintf("unknown relocation type: %v", r.Type())) ++ } ++ ++ second := int64(uint32(val)) ++ second = (second &^ immMask) | int64(uint32(imm)) ++ return second, 0, true ++ + case objabi.R_RISCV_PCREL_ITYPE, objabi.R_RISCV_PCREL_STYPE: + // Generate AUIPC and second instruction immediates. + low, high, err := riscv.Split32BitImmediate(off) +@@ -248,7 +607,7 @@ func archreloc(target *ld.Target, ldr *loader.Loader, + ldr.Errorf(s, "cannot encode R_RISCV_PCREL_STYPE S-type instruction relocation offset for %s: %v", ldr.SymName(rs), err) + } + default: +- panic(fmt.Sprintf("Unknown relocation type: %v", r.Type())) ++ panic(fmt.Sprintf("unknown relocation type: %v", r.Type())) + } + + auipc := int64(uint32(val)) +@@ -258,6 +617,11 @@ func archreloc(target *ld.Target, ldr *loader.Loader, + second = (second &^ secondImmMask) | int64(uint32(secondImm)) + + return second<<32 | auipc, 0, true ++ ++ case objabi.R_RISCV_PCREL_32: ++ pc := ldr.SymValue(s) + int64(r.Off()) ++ off := ldr.SymValue(rs) + r.Add() - pc ++ return off, 0, true + } + + return val, 0, false +@@ -273,7 +637,7 @@ func extreloc(target *ld.Target, ldr *loader.Loader, r + case objabi.R_RISCV_CALL, objabi.R_RISCV_CALL_TRAMP: + return ld.ExtrelocSimple(ldr, r), true + +- case objabi.R_RISCV_PCREL_ITYPE, objabi.R_RISCV_PCREL_STYPE, objabi.R_RISCV_TLS_IE_ITYPE, objabi.R_RISCV_TLS_IE_STYPE: ++ case objabi.R_RISCV_PCREL_ITYPE, objabi.R_RISCV_PCREL_STYPE, objabi.R_RISCV_TLS_IE, objabi.R_RISCV_TLS_LE: + return ld.ExtrelocViaOuterSym(ldr, r, s), true + } + return loader.ExtReloc{}, false +@@ -352,7 +716,7 @@ func trampoline(ctxt *ld.Link, ldr *loader.Loader, ri + + func genCallTramp(arch *sys.Arch, linkmode ld.LinkMode, ldr *loader.Loader, tramp *loader.SymbolBuilder, target loader.Sym, offset int64) { + tramp.AddUint32(arch, 0x00000f97) // AUIPC $0, X31 +- tramp.AddUint32(arch, 0x000f8067) // JALR X0, (X31) ++ tramp.AddUint32(arch, 0x000f8067) // JALR X0, (X31) + + r, _ := tramp.AddRel(objabi.R_RISCV_PCREL_ITYPE) + r.SetSiz(8) diff --git a/lang/go/patches/patch-src_cmd_link_internal_riscv64_obj_go b/lang/go/patches/patch-src_cmd_link_internal_riscv64_obj_go new file mode 100644 index 000000000000..fec9dfb96ef0 --- /dev/null +++ b/lang/go/patches/patch-src_cmd_link_internal_riscv64_obj_go @@ -0,0 +1,33 @@ +Index: src/cmd/link/internal/riscv64/obj.go +--- src/cmd/link/internal/riscv64/obj.go.orig ++++ src/cmd/link/internal/riscv64/obj.go +@@ -20,6 +20,7 @@ func Init() (*sys.Arch, ld.Arch) { + Dwarfregsp: dwarfRegSP, + Dwarfreglr: dwarfRegLR, + ++ Adddynrel: adddynrel, + Archinit: archinit, + Archreloc: archreloc, + Archrelocvariant: archrelocvariant, +@@ -41,10 +42,10 @@ func Init() (*sys.Arch, ld.Arch) { + + Linuxdynld: "/lib/ld.so.1", + ++ Dragonflydynld: "XXX", + Freebsddynld: "XXX", + Netbsddynld: "XXX", +- Openbsddynld: "XXX", +- Dragonflydynld: "XXX", ++ Openbsddynld: "/usr/libexec/ld.so", + Solarisdynld: "XXX", + } + +@@ -53,7 +54,7 @@ func Init() (*sys.Arch, ld.Arch) { + + func archinit(ctxt *ld.Link) { + switch ctxt.HeadType { +- case objabi.Hlinux: ++ case objabi.Hlinux, objabi.Hopenbsd: + ld.Elfinit(ctxt) + ld.HEADR = ld.ELFRESERVE + if *ld.FlagTextAddr == -1 { diff --git a/lang/go/patches/patch-src_cmd_link_internal_s390x_asm_go b/lang/go/patches/patch-src_cmd_link_internal_s390x_asm_go new file mode 100644 index 000000000000..d6b19e7ab601 --- /dev/null +++ b/lang/go/patches/patch-src_cmd_link_internal_s390x_asm_go @@ -0,0 +1,12 @@ +Index: src/cmd/link/internal/s390x/asm.go +--- src/cmd/link/internal/s390x/asm.go.orig ++++ src/cmd/link/internal/s390x/asm.go +@@ -313,7 +313,7 @@ func elfreloc1(ctxt *ld.Link, out *ld.OutBuf, ldr *loa + return true + } + +-func elfsetupplt(ctxt *ld.Link, plt, got *loader.SymbolBuilder, dynamic loader.Sym) { ++func elfsetupplt(ctxt *ld.Link, ldr *loader.Loader, plt, got *loader.SymbolBuilder, dynamic loader.Sym) { + if plt.Size() == 0 { + // stg %r1,56(%r15) + plt.AddUint8(0xe3) diff --git a/lang/go/patches/patch-src_cmd_link_internal_sym_reloc_go b/lang/go/patches/patch-src_cmd_link_internal_sym_reloc_go new file mode 100644 index 000000000000..fa793cfdebeb --- /dev/null +++ b/lang/go/patches/patch-src_cmd_link_internal_sym_reloc_go @@ -0,0 +1,12 @@ +Index: src/cmd/link/internal/sym/reloc.go +--- src/cmd/link/internal/sym/reloc.go.orig ++++ src/cmd/link/internal/sym/reloc.go +@@ -67,6 +67,8 @@ func RelocName(arch *sys.Arch, r objabi.RelocType) str + return elf.R_PPC64(nr).String() + case sys.S390X: + return elf.R_390(nr).String() ++ case sys.RISCV64: ++ return elf.R_RISCV(nr).String() + default: + panic("unreachable") + } diff --git a/lang/go/patches/patch-src_cmd_link_internal_x86_asm_go b/lang/go/patches/patch-src_cmd_link_internal_x86_asm_go new file mode 100644 index 000000000000..c6ec19edbdb7 --- /dev/null +++ b/lang/go/patches/patch-src_cmd_link_internal_x86_asm_go @@ -0,0 +1,12 @@ +Index: src/cmd/link/internal/x86/asm.go +--- src/cmd/link/internal/x86/asm.go.orig ++++ src/cmd/link/internal/x86/asm.go +@@ -418,7 +418,7 @@ func archrelocvariant(*ld.Target, *loader.Loader, load + return -1 + } + +-func elfsetupplt(ctxt *ld.Link, plt, got *loader.SymbolBuilder, dynamic loader.Sym) { ++func elfsetupplt(ctxt *ld.Link, ldr *loader.Loader, plt, got *loader.SymbolBuilder, dynamic loader.Sym) { + if plt.Size() == 0 { + // pushl got+4 + plt.AddUint8(0xff) diff --git a/lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_asm_openbsd_riscv64_s b/lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_asm_openbsd_riscv64_s new file mode 100644 index 000000000000..9e0ce41ab438 --- /dev/null +++ b/lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_asm_openbsd_riscv64_s @@ -0,0 +1,34 @@ +Index: src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_riscv64.s +--- src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_riscv64.s.orig ++++ src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_riscv64.s +@@ -0,0 +1,30 @@ ++// Copyright 2019 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. ++ ++//go:build gc ++// +build gc ++ ++#include "textflag.h" ++ ++// ++// System call support for riscv64, OpenBSD ++// ++ ++// Just jump to package syscall's implementation for all these functions. ++// The runtime may know about them. ++ ++TEXT ·Syscall(SB),NOSPLIT,$0-56 ++ JMP syscall·Syscall(SB) ++ ++TEXT ·Syscall6(SB),NOSPLIT,$0-80 ++ JMP syscall·Syscall6(SB) ++ ++TEXT ·Syscall9(SB),NOSPLIT,$0-104 ++ JMP syscall·Syscall9(SB) ++ ++TEXT ·RawSyscall(SB),NOSPLIT,$0-56 ++ JMP syscall·RawSyscall(SB) ++ ++TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 ++ JMP syscall·RawSyscall6(SB) diff --git a/lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_syscall_openbsd_riscv64_go b/lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_syscall_openbsd_riscv64_go new file mode 100644 index 000000000000..3b2bdfb512fc --- /dev/null +++ b/lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_syscall_openbsd_riscv64_go @@ -0,0 +1,46 @@ +Index: src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_riscv64.go +--- src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_riscv64.go.orig ++++ src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_riscv64.go +@@ -0,0 +1,42 @@ ++// Copyright 2019 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. ++ ++//go:build riscv64 && openbsd ++// +build riscv64,openbsd ++ ++package unix ++ ++func setTimespec(sec, nsec int64) Timespec { ++ return Timespec{Sec: sec, Nsec: nsec} ++} ++ ++func setTimeval(sec, usec int64) Timeval { ++ return Timeval{Sec: sec, Usec: usec} ++} ++ ++func SetKevent(k *Kevent_t, fd, mode, flags int) { ++ k.Ident = uint64(fd) ++ k.Filter = int16(mode) ++ k.Flags = uint16(flags) ++} ++ ++func (iov *Iovec) SetLen(length int) { ++ iov.Len = uint64(length) ++} ++ ++func (msghdr *Msghdr) SetControllen(length int) { ++ msghdr.Controllen = uint32(length) ++} ++ ++func (msghdr *Msghdr) SetIovlen(length int) { ++ msghdr.Iovlen = uint32(length) ++} ++ ++func (cmsg *Cmsghdr) SetLen(length int) { ++ cmsg.Len = uint32(length) ++} ++ ++// SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions ++// of openbsd/amd64 the syscall is called sysctl instead of __sysctl. ++const SYS___SYSCTL = SYS_SYSCTL diff --git a/lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_zerrors_openbsd_riscv64_go b/lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_zerrors_openbsd_riscv64_go new file mode 100644 index 000000000000..ceb2a5daefeb --- /dev/null +++ b/lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_zerrors_openbsd_riscv64_go @@ -0,0 +1,1802 @@ +Index: src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_riscv64.go +--- src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_riscv64.go.orig ++++ src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_riscv64.go +@@ -0,0 +1,1798 @@ ++// mkerrors.sh -m64 ++// Code generated by the command above; see README.md. DO NOT EDIT. ++ ++//go:build riscv64 && openbsd ++// +build riscv64,openbsd ++ ++// Code generated by cmd/cgo -godefs; DO NOT EDIT. ++// cgo -godefs -- -m64 _const.go ++ ++package unix ++ ++import "syscall" ++ ++const ( ++ AF_APPLETALK = 0x10 ++ AF_BLUETOOTH = 0x20 ++ AF_CCITT = 0xa ++ AF_CHAOS = 0x5 ++ AF_CNT = 0x15 ++ AF_COIP = 0x14 ++ AF_DATAKIT = 0x9 ++ AF_DECnet = 0xc ++ AF_DLI = 0xd ++ AF_E164 = 0x1a ++ AF_ECMA = 0x8 ++ AF_ENCAP = 0x1c ++ AF_HYLINK = 0xf ++ AF_IMPLINK = 0x3 ++ AF_INET = 0x2 ++ AF_INET6 = 0x18 ++ AF_IPX = 0x17 ++ AF_ISDN = 0x1a ++ AF_ISO = 0x7 ++ AF_KEY = 0x1e ++ AF_LAT = 0xe ++ AF_LINK = 0x12 ++ AF_LOCAL = 0x1 ++ AF_MAX = 0x24 ++ AF_MPLS = 0x21 ++ AF_NATM = 0x1b ++ AF_NS = 0x6 ++ AF_OSI = 0x7 ++ AF_PUP = 0x4 ++ AF_ROUTE = 0x11 ++ AF_SIP = 0x1d ++ AF_SNA = 0xb ++ AF_UNIX = 0x1 ++ AF_UNSPEC = 0x0 ++ ALTWERASE = 0x200 ++ ARPHRD_ETHER = 0x1 ++ ARPHRD_FRELAY = 0xf ++ ARPHRD_IEEE1394 = 0x18 ++ ARPHRD_IEEE802 = 0x6 ++ B0 = 0x0 ++ B110 = 0x6e ++ B115200 = 0x1c200 ++ B1200 = 0x4b0 ++ B134 = 0x86 ++ B14400 = 0x3840 ++ B150 = 0x96 ++ B1800 = 0x708 ++ B19200 = 0x4b00 ++ B200 = 0xc8 ++ B230400 = 0x38400 ++ B2400 = 0x960 ++ B28800 = 0x7080 ++ B300 = 0x12c ++ B38400 = 0x9600 ++ B4800 = 0x12c0 ++ B50 = 0x32 ++ B57600 = 0xe100 ++ B600 = 0x258 ++ B7200 = 0x1c20 ++ B75 = 0x4b ++ B76800 = 0x12c00 ++ B9600 = 0x2580 ++ BIOCFLUSH = 0x20004268 ++ BIOCGBLEN = 0x40044266 ++ BIOCGDIRFILT = 0x4004427c ++ BIOCGDLT = 0x4004426a ++ BIOCGDLTLIST = 0xc010427b ++ BIOCGETIF = 0x4020426b ++ BIOCGFILDROP = 0x40044278 ++ BIOCGHDRCMPLT = 0x40044274 ++ BIOCGRSIG = 0x40044273 ++ BIOCGRTIMEOUT = 0x4010426e ++ BIOCGSTATS = 0x4008426f ++ BIOCIMMEDIATE = 0x80044270 ++ BIOCLOCK = 0x20004276 ++ BIOCPROMISC = 0x20004269 ++ BIOCSBLEN = 0xc0044266 ++ BIOCSDIRFILT = 0x8004427d ++ BIOCSDLT = 0x8004427a ++ BIOCSETF = 0x80104267 ++ BIOCSETIF = 0x8020426c ++ BIOCSETWF = 0x80104277 ++ BIOCSFILDROP = 0x80044279 ++ BIOCSHDRCMPLT = 0x80044275 ++ BIOCSRSIG = 0x80044272 ++ BIOCSRTIMEOUT = 0x8010426d ++ BIOCVERSION = 0x40044271 ++ BPF_A = 0x10 ++ BPF_ABS = 0x20 ++ BPF_ADD = 0x0 ++ BPF_ALIGNMENT = 0x4 ++ BPF_ALU = 0x4 ++ BPF_AND = 0x50 ++ BPF_B = 0x10 ++ BPF_DIRECTION_IN = 0x1 ++ BPF_DIRECTION_OUT = 0x2 ++ BPF_DIV = 0x30 ++ BPF_FILDROP_CAPTURE = 0x1 ++ BPF_FILDROP_DROP = 0x2 ++ BPF_FILDROP_PASS = 0x0 ++ BPF_H = 0x8 ++ BPF_IMM = 0x0 ++ BPF_IND = 0x40 ++ BPF_JA = 0x0 ++ BPF_JEQ = 0x10 ++ BPF_JGE = 0x30 ++ BPF_JGT = 0x20 ++ BPF_JMP = 0x5 ++ BPF_JSET = 0x40 ++ BPF_K = 0x0 ++ BPF_LD = 0x0 ++ BPF_LDX = 0x1 ++ BPF_LEN = 0x80 ++ BPF_LSH = 0x60 ++ BPF_MAJOR_VERSION = 0x1 ++ BPF_MAXBUFSIZE = 0x200000 ++ BPF_MAXINSNS = 0x200 ++ BPF_MEM = 0x60 ++ BPF_MEMWORDS = 0x10 ++ BPF_MINBUFSIZE = 0x20 ++ BPF_MINOR_VERSION = 0x1 ++ BPF_MISC = 0x7 ++ BPF_MSH = 0xa0 ++ BPF_MUL = 0x20 ++ BPF_NEG = 0x80 ++ BPF_OR = 0x40 ++ BPF_RELEASE = 0x30bb6 ++ BPF_RET = 0x6 ++ BPF_RSH = 0x70 ++ BPF_ST = 0x2 ++ BPF_STX = 0x3 ++ BPF_SUB = 0x10 ++ BPF_TAX = 0x0 ++ BPF_TXA = 0x80 ++ BPF_W = 0x0 ++ BPF_X = 0x8 ++ BRKINT = 0x2 ++ CFLUSH = 0xf ++ CLOCAL = 0x8000 ++ CLOCK_BOOTTIME = 0x6 ++ CLOCK_MONOTONIC = 0x3 ++ CLOCK_PROCESS_CPUTIME_ID = 0x2 ++ CLOCK_REALTIME = 0x0 ++ CLOCK_THREAD_CPUTIME_ID = 0x4 ++ CLOCK_UPTIME = 0x5 ++ CPUSTATES = 0x6 ++ CP_IDLE = 0x5 ++ CP_INTR = 0x4 ++ CP_NICE = 0x1 ++ CP_SPIN = 0x3 ++ CP_SYS = 0x2 ++ CP_USER = 0x0 ++ CREAD = 0x800 ++ CRTSCTS = 0x10000 ++ CS5 = 0x0 ++ CS6 = 0x100 ++ CS7 = 0x200 ++ CS8 = 0x300 ++ CSIZE = 0x300 ++ CSTART = 0x11 ++ CSTATUS = 0xff ++ CSTOP = 0x13 ++ CSTOPB = 0x400 ++ CSUSP = 0x1a ++ CTL_HW = 0x6 ++ CTL_KERN = 0x1 ++ CTL_MAXNAME = 0xc ++ CTL_NET = 0x4 ++ DIOCOSFPFLUSH = 0x2000444e ++ DLT_ARCNET = 0x7 ++ DLT_ATM_RFC1483 = 0xb ++ DLT_AX25 = 0x3 ++ DLT_CHAOS = 0x5 ++ DLT_C_HDLC = 0x68 ++ DLT_EN10MB = 0x1 ++ DLT_EN3MB = 0x2 ++ DLT_ENC = 0xd ++ DLT_FDDI = 0xa ++ DLT_IEEE802 = 0x6 ++ DLT_IEEE802_11 = 0x69 ++ DLT_IEEE802_11_RADIO = 0x7f ++ DLT_LOOP = 0xc ++ DLT_MPLS = 0xdb ++ DLT_NULL = 0x0 ++ DLT_OPENFLOW = 0x10b ++ DLT_PFLOG = 0x75 ++ DLT_PFSYNC = 0x12 ++ DLT_PPP = 0x9 ++ DLT_PPP_BSDOS = 0x10 ++ DLT_PPP_ETHER = 0x33 ++ DLT_PPP_SERIAL = 0x32 ++ DLT_PRONET = 0x4 ++ DLT_RAW = 0xe ++ DLT_SLIP = 0x8 ++ DLT_SLIP_BSDOS = 0xf ++ DLT_USBPCAP = 0xf9 ++ DLT_USER0 = 0x93 ++ DLT_USER1 = 0x94 ++ DLT_USER10 = 0x9d ++ DLT_USER11 = 0x9e ++ DLT_USER12 = 0x9f ++ DLT_USER13 = 0xa0 ++ DLT_USER14 = 0xa1 ++ DLT_USER15 = 0xa2 ++ DLT_USER2 = 0x95 ++ DLT_USER3 = 0x96 ++ DLT_USER4 = 0x97 ++ DLT_USER5 = 0x98 ++ DLT_USER6 = 0x99 ++ DLT_USER7 = 0x9a ++ DLT_USER8 = 0x9b ++ DLT_USER9 = 0x9c ++ DT_BLK = 0x6 ++ DT_CHR = 0x2 ++ DT_DIR = 0x4 ++ DT_FIFO = 0x1 ++ DT_LNK = 0xa ++ DT_REG = 0x8 ++ DT_SOCK = 0xc ++ DT_UNKNOWN = 0x0 ++ ECHO = 0x8 ++ ECHOCTL = 0x40 ++ ECHOE = 0x2 ++ ECHOK = 0x4 ++ ECHOKE = 0x1 ++ ECHONL = 0x10 ++ ECHOPRT = 0x20 ++ EMT_TAGOVF = 0x1 ++ EMUL_ENABLED = 0x1 ++ EMUL_NATIVE = 0x2 ++ ENDRUNDISC = 0x9 ++ ETHERMIN = 0x2e ++ ETHERMTU = 0x5dc ++ ETHERTYPE_8023 = 0x4 ++ ETHERTYPE_AARP = 0x80f3 ++ ETHERTYPE_ACCTON = 0x8390 ++ ETHERTYPE_AEONIC = 0x8036 ++ ETHERTYPE_ALPHA = 0x814a ++ ETHERTYPE_AMBER = 0x6008 ++ ETHERTYPE_AMOEBA = 0x8145 ++ ETHERTYPE_AOE = 0x88a2 ++ ETHERTYPE_APOLLO = 0x80f7 ++ ETHERTYPE_APOLLODOMAIN = 0x8019 ++ ETHERTYPE_APPLETALK = 0x809b ++ ETHERTYPE_APPLITEK = 0x80c7 ++ ETHERTYPE_ARGONAUT = 0x803a ++ ETHERTYPE_ARP = 0x806 ++ ETHERTYPE_AT = 0x809b ++ ETHERTYPE_ATALK = 0x809b ++ ETHERTYPE_ATOMIC = 0x86df ++ ETHERTYPE_ATT = 0x8069 ++ ETHERTYPE_ATTSTANFORD = 0x8008 ++ ETHERTYPE_AUTOPHON = 0x806a ++ ETHERTYPE_AXIS = 0x8856 ++ ETHERTYPE_BCLOOP = 0x9003 ++ ETHERTYPE_BOFL = 0x8102 ++ ETHERTYPE_CABLETRON = 0x7034 ++ ETHERTYPE_CHAOS = 0x804 ++ ETHERTYPE_COMDESIGN = 0x806c ++ ETHERTYPE_COMPUGRAPHIC = 0x806d ++ ETHERTYPE_COUNTERPOINT = 0x8062 ++ ETHERTYPE_CRONUS = 0x8004 ++ ETHERTYPE_CRONUSVLN = 0x8003 ++ ETHERTYPE_DCA = 0x1234 ++ ETHERTYPE_DDE = 0x807b ++ ETHERTYPE_DEBNI = 0xaaaa ++ ETHERTYPE_DECAM = 0x8048 ++ ETHERTYPE_DECCUST = 0x6006 ++ ETHERTYPE_DECDIAG = 0x6005 ++ ETHERTYPE_DECDNS = 0x803c ++ ETHERTYPE_DECDTS = 0x803e ++ ETHERTYPE_DECEXPER = 0x6000 ++ ETHERTYPE_DECLAST = 0x8041 ++ ETHERTYPE_DECLTM = 0x803f ++ ETHERTYPE_DECMUMPS = 0x6009 ++ ETHERTYPE_DECNETBIOS = 0x8040 ++ ETHERTYPE_DELTACON = 0x86de ++ ETHERTYPE_DIDDLE = 0x4321 ++ ETHERTYPE_DLOG1 = 0x660 ++ ETHERTYPE_DLOG2 = 0x661 ++ ETHERTYPE_DN = 0x6003 ++ ETHERTYPE_DOGFIGHT = 0x1989 ++ ETHERTYPE_DSMD = 0x8039 ++ ETHERTYPE_ECMA = 0x803 ++ ETHERTYPE_ENCRYPT = 0x803d ++ ETHERTYPE_ES = 0x805d ++ ETHERTYPE_EXCELAN = 0x8010 ++ ETHERTYPE_EXPERDATA = 0x8049 ++ ETHERTYPE_FLIP = 0x8146 ++ ETHERTYPE_FLOWCONTROL = 0x8808 ++ ETHERTYPE_FRARP = 0x808 ++ ETHERTYPE_GENDYN = 0x8068 ++ ETHERTYPE_HAYES = 0x8130 ++ ETHERTYPE_HIPPI_FP = 0x8180 ++ ETHERTYPE_HITACHI = 0x8820 ++ ETHERTYPE_HP = 0x8005 ++ ETHERTYPE_IEEEPUP = 0xa00 ++ ETHERTYPE_IEEEPUPAT = 0xa01 ++ ETHERTYPE_IMLBL = 0x4c42 ++ ETHERTYPE_IMLBLDIAG = 0x424c ++ ETHERTYPE_IP = 0x800 ++ ETHERTYPE_IPAS = 0x876c ++ ETHERTYPE_IPV6 = 0x86dd ++ ETHERTYPE_IPX = 0x8137 ++ ETHERTYPE_IPXNEW = 0x8037 ++ ETHERTYPE_KALPANA = 0x8582 ++ ETHERTYPE_LANBRIDGE = 0x8038 ++ ETHERTYPE_LANPROBE = 0x8888 ++ ETHERTYPE_LAT = 0x6004 ++ ETHERTYPE_LBACK = 0x9000 ++ ETHERTYPE_LITTLE = 0x8060 ++ ETHERTYPE_LLDP = 0x88cc ++ ETHERTYPE_LOGICRAFT = 0x8148 ++ ETHERTYPE_LOOPBACK = 0x9000 ++ ETHERTYPE_MATRA = 0x807a ++ ETHERTYPE_MAX = 0xffff ++ ETHERTYPE_MERIT = 0x807c ++ ETHERTYPE_MICP = 0x873a ++ ETHERTYPE_MOPDL = 0x6001 ++ ETHERTYPE_MOPRC = 0x6002 ++ ETHERTYPE_MOTOROLA = 0x818d ++ ETHERTYPE_MPLS = 0x8847 ++ ETHERTYPE_MPLS_MCAST = 0x8848 ++ ETHERTYPE_MUMPS = 0x813f ++ ETHERTYPE_NBPCC = 0x3c04 ++ ETHERTYPE_NBPCLAIM = 0x3c09 ++ ETHERTYPE_NBPCLREQ = 0x3c05 ++ ETHERTYPE_NBPCLRSP = 0x3c06 ++ ETHERTYPE_NBPCREQ = 0x3c02 ++ ETHERTYPE_NBPCRSP = 0x3c03 ++ ETHERTYPE_NBPDG = 0x3c07 ++ ETHERTYPE_NBPDGB = 0x3c08 ++ ETHERTYPE_NBPDLTE = 0x3c0a ++ ETHERTYPE_NBPRAR = 0x3c0c ++ ETHERTYPE_NBPRAS = 0x3c0b ++ ETHERTYPE_NBPRST = 0x3c0d ++ ETHERTYPE_NBPSCD = 0x3c01 ++ ETHERTYPE_NBPVCD = 0x3c00 ++ ETHERTYPE_NBS = 0x802 ++ ETHERTYPE_NCD = 0x8149 ++ ETHERTYPE_NESTAR = 0x8006 ++ ETHERTYPE_NETBEUI = 0x8191 ++ ETHERTYPE_NOVELL = 0x8138 ++ ETHERTYPE_NS = 0x600 ++ ETHERTYPE_NSAT = 0x601 ++ ETHERTYPE_NSCOMPAT = 0x807 ++ ETHERTYPE_NTRAILER = 0x10 ++ ETHERTYPE_OS9 = 0x7007 ++ ETHERTYPE_OS9NET = 0x7009 ++ ETHERTYPE_PACER = 0x80c6 ++ ETHERTYPE_PAE = 0x888e ++ ETHERTYPE_PBB = 0x88e7 ++ ETHERTYPE_PCS = 0x4242 ++ ETHERTYPE_PLANNING = 0x8044 ++ ETHERTYPE_PPP = 0x880b ++ ETHERTYPE_PPPOE = 0x8864 ++ ETHERTYPE_PPPOEDISC = 0x8863 ++ ETHERTYPE_PRIMENTS = 0x7031 ++ ETHERTYPE_PUP = 0x200 ++ ETHERTYPE_PUPAT = 0x200 ++ ETHERTYPE_QINQ = 0x88a8 ++ ETHERTYPE_RACAL = 0x7030 ++ ETHERTYPE_RATIONAL = 0x8150 ++ ETHERTYPE_RAWFR = 0x6559 ++ ETHERTYPE_RCL = 0x1995 ++ ETHERTYPE_RDP = 0x8739 ++ ETHERTYPE_RETIX = 0x80f2 ++ ETHERTYPE_REVARP = 0x8035 ++ ETHERTYPE_SCA = 0x6007 ++ ETHERTYPE_SECTRA = 0x86db ++ ETHERTYPE_SECUREDATA = 0x876d ++ ETHERTYPE_SGITW = 0x817e ++ ETHERTYPE_SG_BOUNCE = 0x8016 ++ ETHERTYPE_SG_DIAG = 0x8013 ++ ETHERTYPE_SG_NETGAMES = 0x8014 ++ ETHERTYPE_SG_RESV = 0x8015 ++ ETHERTYPE_SIMNET = 0x5208 ++ ETHERTYPE_SLOW = 0x8809 ++ ETHERTYPE_SNA = 0x80d5 ++ ETHERTYPE_SNMP = 0x814c ++ ETHERTYPE_SONIX = 0xfaf5 ++ ETHERTYPE_SPIDER = 0x809f ++ ETHERTYPE_SPRITE = 0x500 ++ ETHERTYPE_STP = 0x8181 ++ ETHERTYPE_TALARIS = 0x812b ++ ETHERTYPE_TALARISMC = 0x852b ++ ETHERTYPE_TCPCOMP = 0x876b ++ ETHERTYPE_TCPSM = 0x9002 ++ ETHERTYPE_TEC = 0x814f ++ ETHERTYPE_TIGAN = 0x802f ++ ETHERTYPE_TRAIL = 0x1000 ++ ETHERTYPE_TRANSETHER = 0x6558 ++ ETHERTYPE_TYMSHARE = 0x802e ++ ETHERTYPE_UBBST = 0x7005 ++ ETHERTYPE_UBDEBUG = 0x900 ++ ETHERTYPE_UBDIAGLOOP = 0x7002 ++ ETHERTYPE_UBDL = 0x7000 ++ ETHERTYPE_UBNIU = 0x7001 ++ ETHERTYPE_UBNMC = 0x7003 ++ ETHERTYPE_VALID = 0x1600 ++ ETHERTYPE_VARIAN = 0x80dd ++ ETHERTYPE_VAXELN = 0x803b ++ ETHERTYPE_VEECO = 0x8067 ++ ETHERTYPE_VEXP = 0x805b ++ ETHERTYPE_VGLAB = 0x8131 ++ ETHERTYPE_VINES = 0xbad ++ ETHERTYPE_VINESECHO = 0xbaf ++ ETHERTYPE_VINESLOOP = 0xbae ++ ETHERTYPE_VITAL = 0xff00 ++ ETHERTYPE_VLAN = 0x8100 ++ ETHERTYPE_VLTLMAN = 0x8080 ++ ETHERTYPE_VPROD = 0x805c ++ ETHERTYPE_VURESERVED = 0x8147 ++ ETHERTYPE_WATERLOO = 0x8130 ++ ETHERTYPE_WELLFLEET = 0x8103 ++ ETHERTYPE_X25 = 0x805 ++ ETHERTYPE_X75 = 0x801 ++ ETHERTYPE_XNSSM = 0x9001 ++ ETHERTYPE_XTP = 0x817d ++ ETHER_ADDR_LEN = 0x6 ++ ETHER_ALIGN = 0x2 ++ ETHER_CRC_LEN = 0x4 ++ ETHER_CRC_POLY_BE = 0x4c11db6 ++ ETHER_CRC_POLY_LE = 0xedb88320 ++ ETHER_HDR_LEN = 0xe ++ ETHER_MAX_DIX_LEN = 0x600 ++ ETHER_MAX_HARDMTU_LEN = 0xff9b ++ ETHER_MAX_LEN = 0x5ee ++ ETHER_MIN_LEN = 0x40 ++ ETHER_TYPE_LEN = 0x2 ++ ETHER_VLAN_ENCAP_LEN = 0x4 ++ EVFILT_AIO = -0x3 ++ EVFILT_DEVICE = -0x8 ++ EVFILT_PROC = -0x5 ++ EVFILT_READ = -0x1 ++ EVFILT_SIGNAL = -0x6 ++ EVFILT_SYSCOUNT = 0x8 ++ EVFILT_TIMER = -0x7 ++ EVFILT_VNODE = -0x4 ++ EVFILT_WRITE = -0x2 ++ EVL_ENCAPLEN = 0x4 ++ EVL_PRIO_BITS = 0xd ++ EVL_PRIO_MAX = 0x7 ++ EVL_VLID_MASK = 0xfff ++ EVL_VLID_MAX = 0xffe ++ EVL_VLID_MIN = 0x1 ++ EVL_VLID_NULL = 0x0 ++ EV_ADD = 0x1 ++ EV_CLEAR = 0x20 ++ EV_DELETE = 0x2 ++ EV_DISABLE = 0x8 ++ EV_DISPATCH = 0x80 ++ EV_ENABLE = 0x4 ++ EV_EOF = 0x8000 ++ EV_ERROR = 0x4000 ++ EV_FLAG1 = 0x2000 ++ EV_ONESHOT = 0x10 ++ EV_RECEIPT = 0x40 ++ EV_SYSFLAGS = 0xf000 ++ EXTA = 0x4b00 ++ EXTB = 0x9600 ++ EXTPROC = 0x800 ++ FD_CLOEXEC = 0x1 ++ FD_SETSIZE = 0x400 ++ FLUSHO = 0x800000 ++ F_DUPFD = 0x0 ++ F_DUPFD_CLOEXEC = 0xa ++ F_GETFD = 0x1 ++ F_GETFL = 0x3 ++ F_GETLK = 0x7 ++ F_GETOWN = 0x5 ++ F_ISATTY = 0xb ++ F_OK = 0x0 ++ F_RDLCK = 0x1 ++ F_SETFD = 0x2 ++ F_SETFL = 0x4 ++ F_SETLK = 0x8 ++ F_SETLKW = 0x9 ++ F_SETOWN = 0x6 ++ F_UNLCK = 0x2 ++ F_WRLCK = 0x3 ++ HUPCL = 0x4000 ++ HW_MACHINE = 0x1 ++ ICANON = 0x100 ++ ICMP6_FILTER = 0x12 ++ ICRNL = 0x100 ++ IEXTEN = 0x400 ++ IFAN_ARRIVAL = 0x0 ++ IFAN_DEPARTURE = 0x1 ++ IFF_ALLMULTI = 0x200 ++ IFF_BROADCAST = 0x2 ++ IFF_CANTCHANGE = 0x8e52 ++ IFF_DEBUG = 0x4 ++ IFF_LINK0 = 0x1000 ++ IFF_LINK1 = 0x2000 ++ IFF_LINK2 = 0x4000 ++ IFF_LOOPBACK = 0x8 ++ IFF_MULTICAST = 0x8000 ++ IFF_NOARP = 0x80 ++ IFF_OACTIVE = 0x400 ++ IFF_POINTOPOINT = 0x10 ++ IFF_PROMISC = 0x100 ++ IFF_RUNNING = 0x40 ++ IFF_SIMPLEX = 0x800 ++ IFF_STATICARP = 0x20 ++ IFF_UP = 0x1 ++ IFNAMSIZ = 0x10 ++ IFT_1822 = 0x2 ++ IFT_A12MPPSWITCH = 0x82 ++ IFT_AAL2 = 0xbb ++ IFT_AAL5 = 0x31 ++ IFT_ADSL = 0x5e ++ IFT_AFLANE8023 = 0x3b ++ IFT_AFLANE8025 = 0x3c ++ IFT_ARAP = 0x58 ++ IFT_ARCNET = 0x23 ++ IFT_ARCNETPLUS = 0x24 ++ IFT_ASYNC = 0x54 ++ IFT_ATM = 0x25 ++ IFT_ATMDXI = 0x69 ++ IFT_ATMFUNI = 0x6a ++ IFT_ATMIMA = 0x6b ++ IFT_ATMLOGICAL = 0x50 ++ IFT_ATMRADIO = 0xbd ++ IFT_ATMSUBINTERFACE = 0x86 ++ IFT_ATMVCIENDPT = 0xc2 ++ IFT_ATMVIRTUAL = 0x95 ++ IFT_BGPPOLICYACCOUNTING = 0xa2 ++ IFT_BLUETOOTH = 0xf8 ++ IFT_BRIDGE = 0xd1 ++ IFT_BSC = 0x53 ++ IFT_CARP = 0xf7 ++ IFT_CCTEMUL = 0x3d ++ IFT_CEPT = 0x13 ++ IFT_CES = 0x85 ++ IFT_CHANNEL = 0x46 ++ IFT_CNR = 0x55 ++ IFT_COFFEE = 0x84 ++ IFT_COMPOSITELINK = 0x9b ++ IFT_DCN = 0x8d ++ IFT_DIGITALPOWERLINE = 0x8a ++ IFT_DIGITALWRAPPEROVERHEADCHANNEL = 0xba ++ IFT_DLSW = 0x4a ++ IFT_DOCSCABLEDOWNSTREAM = 0x80 ++ IFT_DOCSCABLEMACLAYER = 0x7f ++ IFT_DOCSCABLEUPSTREAM = 0x81 ++ IFT_DOCSCABLEUPSTREAMCHANNEL = 0xcd ++ IFT_DS0 = 0x51 ++ IFT_DS0BUNDLE = 0x52 ++ IFT_DS1FDL = 0xaa ++ IFT_DS3 = 0x1e ++ IFT_DTM = 0x8c ++ IFT_DUMMY = 0xf1 ++ IFT_DVBASILN = 0xac ++ IFT_DVBASIOUT = 0xad ++ IFT_DVBRCCDOWNSTREAM = 0x93 ++ IFT_DVBRCCMACLAYER = 0x92 ++ IFT_DVBRCCUPSTREAM = 0x94 ++ IFT_ECONET = 0xce ++ IFT_ENC = 0xf4 ++ IFT_EON = 0x19 ++ IFT_EPLRS = 0x57 ++ IFT_ESCON = 0x49 ++ IFT_ETHER = 0x6 ++ IFT_FAITH = 0xf3 ++ IFT_FAST = 0x7d ++ IFT_FASTETHER = 0x3e ++ IFT_FASTETHERFX = 0x45 ++ IFT_FDDI = 0xf ++ IFT_FIBRECHANNEL = 0x38 ++ IFT_FRAMERELAYINTERCONNECT = 0x3a ++ IFT_FRAMERELAYMPI = 0x5c ++ IFT_FRDLCIENDPT = 0xc1 ++ IFT_FRELAY = 0x20 ++ IFT_FRELAYDCE = 0x2c ++ IFT_FRF16MFRBUNDLE = 0xa3 ++ IFT_FRFORWARD = 0x9e ++ IFT_G703AT2MB = 0x43 ++ IFT_G703AT64K = 0x42 ++ IFT_GIF = 0xf0 ++ IFT_GIGABITETHERNET = 0x75 ++ IFT_GR303IDT = 0xb2 ++ IFT_GR303RDT = 0xb1 ++ IFT_H323GATEKEEPER = 0xa4 ++ IFT_H323PROXY = 0xa5 ++ IFT_HDH1822 = 0x3 ++ IFT_HDLC = 0x76 ++ IFT_HDSL2 = 0xa8 ++ IFT_HIPERLAN2 = 0xb7 ++ IFT_HIPPI = 0x2f ++ IFT_HIPPIINTERFACE = 0x39 ++ IFT_HOSTPAD = 0x5a ++ IFT_HSSI = 0x2e ++ IFT_HY = 0xe ++ IFT_IBM370PARCHAN = 0x48 ++ IFT_IDSL = 0x9a ++ IFT_IEEE1394 = 0x90 ++ IFT_IEEE80211 = 0x47 ++ IFT_IEEE80212 = 0x37 ++ IFT_IEEE8023ADLAG = 0xa1 ++ IFT_IFGSN = 0x91 ++ IFT_IMT = 0xbe ++ IFT_INFINIBAND = 0xc7 ++ IFT_INTERLEAVE = 0x7c ++ IFT_IP = 0x7e ++ IFT_IPFORWARD = 0x8e ++ IFT_IPOVERATM = 0x72 ++ IFT_IPOVERCDLC = 0x6d ++ IFT_IPOVERCLAW = 0x6e ++ IFT_IPSWITCH = 0x4e ++ IFT_ISDN = 0x3f ++ IFT_ISDNBASIC = 0x14 ++ IFT_ISDNPRIMARY = 0x15 ++ IFT_ISDNS = 0x4b ++ IFT_ISDNU = 0x4c ++ IFT_ISO88022LLC = 0x29 ++ IFT_ISO88023 = 0x7 ++ IFT_ISO88024 = 0x8 ++ IFT_ISO88025 = 0x9 ++ IFT_ISO88025CRFPINT = 0x62 ++ IFT_ISO88025DTR = 0x56 ++ IFT_ISO88025FIBER = 0x73 ++ IFT_ISO88026 = 0xa ++ IFT_ISUP = 0xb3 ++ IFT_L2VLAN = 0x87 ++ IFT_L3IPVLAN = 0x88 ++ IFT_L3IPXVLAN = 0x89 ++ IFT_LAPB = 0x10 ++ IFT_LAPD = 0x4d ++ IFT_LAPF = 0x77 ++ IFT_LINEGROUP = 0xd2 ++ IFT_LOCALTALK = 0x2a ++ IFT_LOOP = 0x18 ++ IFT_MBIM = 0xfa ++ IFT_MEDIAMAILOVERIP = 0x8b ++ IFT_MFSIGLINK = 0xa7 ++ IFT_MIOX25 = 0x26 ++ IFT_MODEM = 0x30 ++ IFT_MPC = 0x71 ++ IFT_MPLS = 0xa6 ++ IFT_MPLSTUNNEL = 0x96 ++ IFT_MSDSL = 0x8f ++ IFT_MVL = 0xbf ++ IFT_MYRINET = 0x63 ++ IFT_NFAS = 0xaf ++ IFT_NSIP = 0x1b ++ IFT_OPTICALCHANNEL = 0xc3 ++ IFT_OPTICALTRANSPORT = 0xc4 ++ IFT_OTHER = 0x1 ++ IFT_P10 = 0xc ++ IFT_P80 = 0xd ++ IFT_PARA = 0x22 ++ IFT_PFLOG = 0xf5 ++ IFT_PFLOW = 0xf9 ++ IFT_PFSYNC = 0xf6 ++ IFT_PLC = 0xae ++ IFT_PON155 = 0xcf ++ IFT_PON622 = 0xd0 ++ IFT_POS = 0xab ++ IFT_PPP = 0x17 ++ IFT_PPPMULTILINKBUNDLE = 0x6c ++ IFT_PROPATM = 0xc5 ++ IFT_PROPBWAP2MP = 0xb8 ++ IFT_PROPCNLS = 0x59 ++ IFT_PROPDOCSWIRELESSDOWNSTREAM = 0xb5 ++ IFT_PROPDOCSWIRELESSMACLAYER = 0xb4 ++ IFT_PROPDOCSWIRELESSUPSTREAM = 0xb6 ++ IFT_PROPMUX = 0x36 ++ IFT_PROPVIRTUAL = 0x35 ++ IFT_PROPWIRELESSP2P = 0x9d ++ IFT_PTPSERIAL = 0x16 ++ IFT_PVC = 0xf2 ++ IFT_Q2931 = 0xc9 ++ IFT_QLLC = 0x44 ++ IFT_RADIOMAC = 0xbc ++ IFT_RADSL = 0x5f ++ IFT_REACHDSL = 0xc0 ++ IFT_RFC1483 = 0x9f ++ IFT_RS232 = 0x21 ++ IFT_RSRB = 0x4f ++ IFT_SDLC = 0x11 ++ IFT_SDSL = 0x60 ++ IFT_SHDSL = 0xa9 ++ IFT_SIP = 0x1f ++ IFT_SIPSIG = 0xcc ++ IFT_SIPTG = 0xcb ++ IFT_SLIP = 0x1c ++ IFT_SMDSDXI = 0x2b ++ IFT_SMDSICIP = 0x34 ++ IFT_SONET = 0x27 ++ IFT_SONETOVERHEADCHANNEL = 0xb9 ++ IFT_SONETPATH = 0x32 ++ IFT_SONETVT = 0x33 ++ IFT_SRP = 0x97 ++ IFT_SS7SIGLINK = 0x9c ++ IFT_STACKTOSTACK = 0x6f ++ IFT_STARLAN = 0xb ++ IFT_T1 = 0x12 ++ IFT_TDLC = 0x74 ++ IFT_TELINK = 0xc8 ++ IFT_TERMPAD = 0x5b ++ IFT_TR008 = 0xb0 ++ IFT_TRANSPHDLC = 0x7b ++ IFT_TUNNEL = 0x83 ++ IFT_ULTRA = 0x1d ++ IFT_USB = 0xa0 ++ IFT_V11 = 0x40 ++ IFT_V35 = 0x2d ++ IFT_V36 = 0x41 ++ IFT_V37 = 0x78 ++ IFT_VDSL = 0x61 ++ IFT_VIRTUALIPADDRESS = 0x70 ++ IFT_VIRTUALTG = 0xca ++ IFT_VOICEDID = 0xd5 ++ IFT_VOICEEM = 0x64 ++ IFT_VOICEEMFGD = 0xd3 ++ IFT_VOICEENCAP = 0x67 ++ IFT_VOICEFGDEANA = 0xd4 ++ IFT_VOICEFXO = 0x65 ++ IFT_VOICEFXS = 0x66 ++ IFT_VOICEOVERATM = 0x98 ++ IFT_VOICEOVERCABLE = 0xc6 ++ IFT_VOICEOVERFRAMERELAY = 0x99 ++ IFT_VOICEOVERIP = 0x68 ++ IFT_X213 = 0x5d ++ IFT_X25 = 0x5 ++ IFT_X25DDN = 0x4 ++ IFT_X25HUNTGROUP = 0x7a ++ IFT_X25MLP = 0x79 ++ IFT_X25PLE = 0x28 ++ IFT_XETHER = 0x1a ++ IGNBRK = 0x1 ++ IGNCR = 0x80 ++ IGNPAR = 0x4 ++ IMAXBEL = 0x2000 ++ INLCR = 0x40 ++ INPCK = 0x10 ++ IN_CLASSA_HOST = 0xffffff ++ IN_CLASSA_MAX = 0x80 ++ IN_CLASSA_NET = 0xff000000 ++ IN_CLASSA_NSHIFT = 0x18 ++ IN_CLASSB_HOST = 0xffff ++ IN_CLASSB_MAX = 0x10000 ++ IN_CLASSB_NET = 0xffff0000 ++ IN_CLASSB_NSHIFT = 0x10 ++ IN_CLASSC_HOST = 0xff ++ IN_CLASSC_NET = 0xffffff00 ++ IN_CLASSC_NSHIFT = 0x8 ++ IN_CLASSD_HOST = 0xfffffff ++ IN_CLASSD_NET = 0xf0000000 ++ IN_CLASSD_NSHIFT = 0x1c ++ IN_LOOPBACKNET = 0x7f ++ IN_RFC3021_HOST = 0x1 ++ IN_RFC3021_NET = 0xfffffffe ++ IN_RFC3021_NSHIFT = 0x1f ++ IPPROTO_AH = 0x33 ++ IPPROTO_CARP = 0x70 ++ IPPROTO_DIVERT = 0x102 ++ IPPROTO_DONE = 0x101 ++ IPPROTO_DSTOPTS = 0x3c ++ IPPROTO_EGP = 0x8 ++ IPPROTO_ENCAP = 0x62 ++ IPPROTO_EON = 0x50 ++ IPPROTO_ESP = 0x32 ++ IPPROTO_ETHERIP = 0x61 ++ IPPROTO_FRAGMENT = 0x2c ++ IPPROTO_GGP = 0x3 ++ IPPROTO_GRE = 0x2f ++ IPPROTO_HOPOPTS = 0x0 ++ IPPROTO_ICMP = 0x1 ++ IPPROTO_ICMPV6 = 0x3a ++ IPPROTO_IDP = 0x16 ++ IPPROTO_IGMP = 0x2 ++ IPPROTO_IP = 0x0 ++ IPPROTO_IPCOMP = 0x6c ++ IPPROTO_IPIP = 0x4 ++ IPPROTO_IPV4 = 0x4 ++ IPPROTO_IPV6 = 0x29 ++ IPPROTO_MAX = 0x100 ++ IPPROTO_MAXID = 0x103 ++ IPPROTO_MOBILE = 0x37 ++ IPPROTO_MPLS = 0x89 ++ IPPROTO_NONE = 0x3b ++ IPPROTO_PFSYNC = 0xf0 ++ IPPROTO_PIM = 0x67 ++ IPPROTO_PUP = 0xc ++ IPPROTO_RAW = 0xff ++ IPPROTO_ROUTING = 0x2b ++ IPPROTO_RSVP = 0x2e ++ IPPROTO_TCP = 0x6 ++ IPPROTO_TP = 0x1d ++ IPPROTO_UDP = 0x11 ++ IPV6_AUTH_LEVEL = 0x35 ++ IPV6_AUTOFLOWLABEL = 0x3b ++ IPV6_CHECKSUM = 0x1a ++ IPV6_DEFAULT_MULTICAST_HOPS = 0x1 ++ IPV6_DEFAULT_MULTICAST_LOOP = 0x1 ++ IPV6_DEFHLIM = 0x40 ++ IPV6_DONTFRAG = 0x3e ++ IPV6_DSTOPTS = 0x32 ++ IPV6_ESP_NETWORK_LEVEL = 0x37 ++ IPV6_ESP_TRANS_LEVEL = 0x36 ++ IPV6_FAITH = 0x1d ++ IPV6_FLOWINFO_MASK = 0xffffff0f ++ IPV6_FLOWLABEL_MASK = 0xffff0f00 ++ IPV6_FRAGTTL = 0x78 ++ IPV6_HLIMDEC = 0x1 ++ IPV6_HOPLIMIT = 0x2f ++ IPV6_HOPOPTS = 0x31 ++ IPV6_IPCOMP_LEVEL = 0x3c ++ IPV6_JOIN_GROUP = 0xc ++ IPV6_LEAVE_GROUP = 0xd ++ IPV6_MAXHLIM = 0xff ++ IPV6_MAXPACKET = 0xffff ++ IPV6_MINHOPCOUNT = 0x41 ++ IPV6_MMTU = 0x500 ++ IPV6_MULTICAST_HOPS = 0xa ++ IPV6_MULTICAST_IF = 0x9 ++ IPV6_MULTICAST_LOOP = 0xb ++ IPV6_NEXTHOP = 0x30 ++ IPV6_OPTIONS = 0x1 ++ IPV6_PATHMTU = 0x2c ++ IPV6_PIPEX = 0x3f ++ IPV6_PKTINFO = 0x2e ++ IPV6_PORTRANGE = 0xe ++ IPV6_PORTRANGE_DEFAULT = 0x0 ++ IPV6_PORTRANGE_HIGH = 0x1 ++ IPV6_PORTRANGE_LOW = 0x2 ++ IPV6_RECVDSTOPTS = 0x28 ++ IPV6_RECVDSTPORT = 0x40 ++ IPV6_RECVHOPLIMIT = 0x25 ++ IPV6_RECVHOPOPTS = 0x27 ++ IPV6_RECVPATHMTU = 0x2b ++ IPV6_RECVPKTINFO = 0x24 ++ IPV6_RECVRTHDR = 0x26 ++ IPV6_RECVTCLASS = 0x39 ++ IPV6_RTABLE = 0x1021 ++ IPV6_RTHDR = 0x33 ++ IPV6_RTHDRDSTOPTS = 0x23 ++ IPV6_RTHDR_LOOSE = 0x0 ++ IPV6_RTHDR_STRICT = 0x1 ++ IPV6_RTHDR_TYPE_0 = 0x0 ++ IPV6_SOCKOPT_RESERVED1 = 0x3 ++ IPV6_TCLASS = 0x3d ++ IPV6_UNICAST_HOPS = 0x4 ++ IPV6_USE_MIN_MTU = 0x2a ++ IPV6_V6ONLY = 0x1b ++ IPV6_VERSION = 0x60 ++ IPV6_VERSION_MASK = 0xf0 ++ IP_ADD_MEMBERSHIP = 0xc ++ IP_AUTH_LEVEL = 0x14 ++ IP_DEFAULT_MULTICAST_LOOP = 0x1 ++ IP_DEFAULT_MULTICAST_TTL = 0x1 ++ IP_DF = 0x4000 ++ IP_DROP_MEMBERSHIP = 0xd ++ IP_ESP_NETWORK_LEVEL = 0x16 ++ IP_ESP_TRANS_LEVEL = 0x15 ++ IP_HDRINCL = 0x2 ++ IP_IPCOMP_LEVEL = 0x1d ++ IP_IPDEFTTL = 0x25 ++ IP_IPSECFLOWINFO = 0x24 ++ IP_IPSEC_LOCAL_AUTH = 0x1b ++ IP_IPSEC_LOCAL_CRED = 0x19 ++ IP_IPSEC_LOCAL_ID = 0x17 ++ IP_IPSEC_REMOTE_AUTH = 0x1c ++ IP_IPSEC_REMOTE_CRED = 0x1a ++ IP_IPSEC_REMOTE_ID = 0x18 ++ IP_MAXPACKET = 0xffff ++ IP_MAX_MEMBERSHIPS = 0xfff ++ IP_MF = 0x2000 ++ IP_MINTTL = 0x20 ++ IP_MIN_MEMBERSHIPS = 0xf ++ IP_MSS = 0x240 ++ IP_MULTICAST_IF = 0x9 ++ IP_MULTICAST_LOOP = 0xb ++ IP_MULTICAST_TTL = 0xa ++ IP_OFFMASK = 0x1fff ++ IP_OPTIONS = 0x1 ++ IP_PIPEX = 0x22 ++ IP_PORTRANGE = 0x13 ++ IP_PORTRANGE_DEFAULT = 0x0 ++ IP_PORTRANGE_HIGH = 0x1 ++ IP_PORTRANGE_LOW = 0x2 ++ IP_RECVDSTADDR = 0x7 ++ IP_RECVDSTPORT = 0x21 ++ IP_RECVIF = 0x1e ++ IP_RECVOPTS = 0x5 ++ IP_RECVRETOPTS = 0x6 ++ IP_RECVRTABLE = 0x23 ++ IP_RECVTTL = 0x1f ++ IP_RETOPTS = 0x8 ++ IP_RF = 0x8000 ++ IP_RTABLE = 0x1021 ++ IP_SENDSRCADDR = 0x7 ++ IP_TOS = 0x3 ++ IP_TTL = 0x4 ++ ISIG = 0x80 ++ ISTRIP = 0x20 ++ IUCLC = 0x1000 ++ IXANY = 0x800 ++ IXOFF = 0x400 ++ IXON = 0x200 ++ KERN_HOSTNAME = 0xa ++ KERN_OSRELEASE = 0x2 ++ KERN_OSTYPE = 0x1 ++ KERN_VERSION = 0x4 ++ LCNT_OVERLOAD_FLUSH = 0x6 ++ LOCK_EX = 0x2 ++ LOCK_NB = 0x4 ++ LOCK_SH = 0x1 ++ LOCK_UN = 0x8 ++ MADV_DONTNEED = 0x4 ++ MADV_FREE = 0x6 ++ MADV_NORMAL = 0x0 ++ MADV_RANDOM = 0x1 ++ MADV_SEQUENTIAL = 0x2 ++ MADV_SPACEAVAIL = 0x5 ++ MADV_WILLNEED = 0x3 ++ MAP_ANON = 0x1000 ++ MAP_ANONYMOUS = 0x1000 ++ MAP_CONCEAL = 0x8000 ++ MAP_COPY = 0x2 ++ MAP_FILE = 0x0 ++ MAP_FIXED = 0x10 ++ MAP_FLAGMASK = 0xfff7 ++ MAP_HASSEMAPHORE = 0x0 ++ MAP_INHERIT = 0x0 ++ MAP_INHERIT_COPY = 0x1 ++ MAP_INHERIT_NONE = 0x2 ++ MAP_INHERIT_SHARE = 0x0 ++ MAP_INHERIT_ZERO = 0x3 ++ MAP_NOEXTEND = 0x0 ++ MAP_NORESERVE = 0x0 ++ MAP_PRIVATE = 0x2 ++ MAP_RENAME = 0x0 ++ MAP_SHARED = 0x1 ++ MAP_STACK = 0x4000 ++ MAP_TRYFIXED = 0x0 ++ MCL_CURRENT = 0x1 ++ MCL_FUTURE = 0x2 ++ MNT_ASYNC = 0x40 ++ MNT_DEFEXPORTED = 0x200 ++ MNT_DELEXPORT = 0x20000 ++ MNT_DOOMED = 0x8000000 ++ MNT_EXPORTANON = 0x400 ++ MNT_EXPORTED = 0x100 ++ MNT_EXRDONLY = 0x80 ++ MNT_FORCE = 0x80000 ++ MNT_LAZY = 0x3 ++ MNT_LOCAL = 0x1000 ++ MNT_NOATIME = 0x8000 ++ MNT_NODEV = 0x10 ++ MNT_NOEXEC = 0x4 ++ MNT_NOPERM = 0x20 ++ MNT_NOSUID = 0x8 ++ MNT_NOWAIT = 0x2 ++ MNT_QUOTA = 0x2000 ++ MNT_RDONLY = 0x1 ++ MNT_RELOAD = 0x40000 ++ MNT_ROOTFS = 0x4000 ++ MNT_SOFTDEP = 0x4000000 ++ MNT_STALLED = 0x100000 ++ MNT_SWAPPABLE = 0x200000 ++ MNT_SYNCHRONOUS = 0x2 ++ MNT_UPDATE = 0x10000 ++ MNT_VISFLAGMASK = 0x400ffff ++ MNT_WAIT = 0x1 ++ MNT_WANTRDWR = 0x2000000 ++ MNT_WXALLOWED = 0x800 ++ MSG_BCAST = 0x100 ++ MSG_CMSG_CLOEXEC = 0x800 ++ MSG_CTRUNC = 0x20 ++ MSG_DONTROUTE = 0x4 ++ MSG_DONTWAIT = 0x80 ++ MSG_EOR = 0x8 ++ MSG_MCAST = 0x200 ++ MSG_NOSIGNAL = 0x400 ++ MSG_OOB = 0x1 ++ MSG_PEEK = 0x2 ++ MSG_TRUNC = 0x10 ++ MSG_WAITALL = 0x40 ++ MS_ASYNC = 0x1 ++ MS_INVALIDATE = 0x4 ++ MS_SYNC = 0x2 ++ NAME_MAX = 0xff ++ NET_RT_DUMP = 0x1 ++ NET_RT_FLAGS = 0x2 ++ NET_RT_IFLIST = 0x3 ++ NET_RT_IFNAMES = 0x6 ++ NET_RT_MAXID = 0x7 ++ NET_RT_STATS = 0x4 ++ NET_RT_TABLE = 0x5 ++ NFDBITS = 0x20 ++ NOFLSH = 0x80000000 ++ NOKERNINFO = 0x2000000 ++ NOTE_ATTRIB = 0x8 ++ NOTE_CHANGE = 0x1 ++ NOTE_CHILD = 0x4 ++ NOTE_DELETE = 0x1 ++ NOTE_EOF = 0x2 ++ NOTE_EXEC = 0x20000000 ++ NOTE_EXIT = 0x80000000 ++ NOTE_EXTEND = 0x4 ++ NOTE_FORK = 0x40000000 ++ NOTE_LINK = 0x10 ++ NOTE_LOWAT = 0x1 ++ NOTE_PCTRLMASK = 0xf0000000 ++ NOTE_PDATAMASK = 0xfffff ++ NOTE_RENAME = 0x20 ++ NOTE_REVOKE = 0x40 ++ NOTE_TRACK = 0x1 ++ NOTE_TRACKERR = 0x2 ++ NOTE_TRUNCATE = 0x80 ++ NOTE_WRITE = 0x2 ++ OCRNL = 0x10 ++ OLCUC = 0x20 ++ ONLCR = 0x2 ++ ONLRET = 0x80 ++ ONOCR = 0x40 ++ ONOEOT = 0x8 ++ OPOST = 0x1 ++ OXTABS = 0x4 ++ O_ACCMODE = 0x3 ++ O_APPEND = 0x8 ++ O_ASYNC = 0x40 ++ O_CLOEXEC = 0x10000 ++ O_CREAT = 0x200 ++ O_DIRECTORY = 0x20000 ++ O_DSYNC = 0x80 ++ O_EXCL = 0x800 ++ O_EXLOCK = 0x20 ++ O_FSYNC = 0x80 ++ O_NDELAY = 0x4 ++ O_NOCTTY = 0x8000 ++ O_NOFOLLOW = 0x100 ++ O_NONBLOCK = 0x4 ++ O_RDONLY = 0x0 ++ O_RDWR = 0x2 ++ O_RSYNC = 0x80 ++ O_SHLOCK = 0x10 ++ O_SYNC = 0x80 ++ O_TRUNC = 0x400 ++ O_WRONLY = 0x1 ++ PARENB = 0x1000 ++ PARMRK = 0x8 ++ PARODD = 0x2000 ++ PENDIN = 0x20000000 ++ PF_FLUSH = 0x1 ++ PRIO_PGRP = 0x1 ++ PRIO_PROCESS = 0x0 ++ PRIO_USER = 0x2 ++ PROT_EXEC = 0x4 ++ PROT_NONE = 0x0 ++ PROT_READ = 0x1 ++ PROT_WRITE = 0x2 ++ RLIMIT_CORE = 0x4 ++ RLIMIT_CPU = 0x0 ++ RLIMIT_DATA = 0x2 ++ RLIMIT_FSIZE = 0x1 ++ RLIMIT_MEMLOCK = 0x6 ++ RLIMIT_NOFILE = 0x8 ++ RLIMIT_NPROC = 0x7 ++ RLIMIT_RSS = 0x5 ++ RLIMIT_STACK = 0x3 ++ RLIM_INFINITY = 0x7fffffffffffffff ++ RTAX_AUTHOR = 0x6 ++ RTAX_BFD = 0xb ++ RTAX_BRD = 0x7 ++ RTAX_DNS = 0xc ++ RTAX_DST = 0x0 ++ RTAX_GATEWAY = 0x1 ++ RTAX_GENMASK = 0x3 ++ RTAX_IFA = 0x5 ++ RTAX_IFP = 0x4 ++ RTAX_LABEL = 0xa ++ RTAX_MAX = 0xf ++ RTAX_NETMASK = 0x2 ++ RTAX_SEARCH = 0xe ++ RTAX_SRC = 0x8 ++ RTAX_SRCMASK = 0x9 ++ RTAX_STATIC = 0xd ++ RTA_AUTHOR = 0x40 ++ RTA_BFD = 0x800 ++ RTA_BRD = 0x80 ++ RTA_DNS = 0x1000 ++ RTA_DST = 0x1 ++ RTA_GATEWAY = 0x2 ++ RTA_GENMASK = 0x8 ++ RTA_IFA = 0x20 ++ RTA_IFP = 0x10 ++ RTA_LABEL = 0x400 ++ RTA_NETMASK = 0x4 ++ RTA_SEARCH = 0x4000 ++ RTA_SRC = 0x100 ++ RTA_SRCMASK = 0x200 ++ RTA_STATIC = 0x2000 ++ RTF_ANNOUNCE = 0x4000 ++ RTF_BFD = 0x1000000 ++ RTF_BLACKHOLE = 0x1000 ++ RTF_BROADCAST = 0x400000 ++ RTF_CACHED = 0x20000 ++ RTF_CLONED = 0x10000 ++ RTF_CLONING = 0x100 ++ RTF_CONNECTED = 0x800000 ++ RTF_DONE = 0x40 ++ RTF_DYNAMIC = 0x10 ++ RTF_FMASK = 0x110fc08 ++ RTF_GATEWAY = 0x2 ++ RTF_HOST = 0x4 ++ RTF_LLINFO = 0x400 ++ RTF_LOCAL = 0x200000 ++ RTF_MODIFIED = 0x20 ++ RTF_MPATH = 0x40000 ++ RTF_MPLS = 0x100000 ++ RTF_MULTICAST = 0x200 ++ RTF_PERMANENT_ARP = 0x2000 ++ RTF_PROTO1 = 0x8000 ++ RTF_PROTO2 = 0x4000 ++ RTF_PROTO3 = 0x2000 ++ RTF_REJECT = 0x8 ++ RTF_STATIC = 0x800 ++ RTF_UP = 0x1 ++ RTF_USETRAILERS = 0x8000 ++ RTM_80211INFO = 0x15 ++ RTM_ADD = 0x1 ++ RTM_BFD = 0x12 ++ RTM_CHANGE = 0x3 ++ RTM_CHGADDRATTR = 0x14 ++ RTM_DELADDR = 0xd ++ RTM_DELETE = 0x2 ++ RTM_DESYNC = 0x10 ++ RTM_GET = 0x4 ++ RTM_IFANNOUNCE = 0xf ++ RTM_IFINFO = 0xe ++ RTM_INVALIDATE = 0x11 ++ RTM_LOSING = 0x5 ++ RTM_MAXSIZE = 0x800 ++ RTM_MISS = 0x7 ++ RTM_NEWADDR = 0xc ++ RTM_PROPOSAL = 0x13 ++ RTM_REDIRECT = 0x6 ++ RTM_RESOLVE = 0xb ++ RTM_RTTUNIT = 0xf4240 ++ RTM_VERSION = 0x5 ++ RTV_EXPIRE = 0x4 ++ RTV_HOPCOUNT = 0x2 ++ RTV_MTU = 0x1 ++ RTV_RPIPE = 0x8 ++ RTV_RTT = 0x40 ++ RTV_RTTVAR = 0x80 ++ RTV_SPIPE = 0x10 ++ RTV_SSTHRESH = 0x20 ++ RT_TABLEID_BITS = 0x8 ++ RT_TABLEID_MASK = 0xff ++ RT_TABLEID_MAX = 0xff ++ RUSAGE_CHILDREN = -0x1 ++ RUSAGE_SELF = 0x0 ++ RUSAGE_THREAD = 0x1 ++ SCM_RIGHTS = 0x1 ++ SCM_TIMESTAMP = 0x4 ++ SHUT_RD = 0x0 ++ SHUT_RDWR = 0x2 ++ SHUT_WR = 0x1 ++ SIOCADDMULTI = 0x80206931 ++ SIOCAIFADDR = 0x8040691a ++ SIOCAIFGROUP = 0x80286987 ++ SIOCATMARK = 0x40047307 ++ SIOCBRDGADD = 0x8060693c ++ SIOCBRDGADDL = 0x80606949 ++ SIOCBRDGADDS = 0x80606941 ++ SIOCBRDGARL = 0x808c694d ++ SIOCBRDGDADDR = 0x81286947 ++ SIOCBRDGDEL = 0x8060693d ++ SIOCBRDGDELS = 0x80606942 ++ SIOCBRDGFLUSH = 0x80606948 ++ SIOCBRDGFRL = 0x808c694e ++ SIOCBRDGGCACHE = 0xc0186941 ++ SIOCBRDGGFD = 0xc0186952 ++ SIOCBRDGGHT = 0xc0186951 ++ SIOCBRDGGIFFLGS = 0xc060693e ++ SIOCBRDGGMA = 0xc0186953 ++ SIOCBRDGGPARAM = 0xc0406958 ++ SIOCBRDGGPRI = 0xc0186950 ++ SIOCBRDGGRL = 0xc030694f ++ SIOCBRDGGTO = 0xc0186946 ++ SIOCBRDGIFS = 0xc0606942 ++ SIOCBRDGRTS = 0xc0206943 ++ SIOCBRDGSADDR = 0xc1286944 ++ SIOCBRDGSCACHE = 0x80186940 ++ SIOCBRDGSFD = 0x80186952 ++ SIOCBRDGSHT = 0x80186951 ++ SIOCBRDGSIFCOST = 0x80606955 ++ SIOCBRDGSIFFLGS = 0x8060693f ++ SIOCBRDGSIFPRIO = 0x80606954 ++ SIOCBRDGSIFPROT = 0x8060694a ++ SIOCBRDGSMA = 0x80186953 ++ SIOCBRDGSPRI = 0x80186950 ++ SIOCBRDGSPROTO = 0x8018695a ++ SIOCBRDGSTO = 0x80186945 ++ SIOCBRDGSTXHC = 0x80186959 ++ SIOCDELLABEL = 0x80206997 ++ SIOCDELMULTI = 0x80206932 ++ SIOCDIFADDR = 0x80206919 ++ SIOCDIFGROUP = 0x80286989 ++ SIOCDIFPARENT = 0x802069b4 ++ SIOCDIFPHYADDR = 0x80206949 ++ SIOCDPWE3NEIGHBOR = 0x802069de ++ SIOCDVNETID = 0x802069af ++ SIOCGETKALIVE = 0xc01869a4 ++ SIOCGETLABEL = 0x8020699a ++ SIOCGETMPWCFG = 0xc02069ae ++ SIOCGETPFLOW = 0xc02069fe ++ SIOCGETPFSYNC = 0xc02069f8 ++ SIOCGETSGCNT = 0xc0207534 ++ SIOCGETVIFCNT = 0xc0287533 ++ SIOCGETVLAN = 0xc0206990 ++ SIOCGIFADDR = 0xc0206921 ++ SIOCGIFBRDADDR = 0xc0206923 ++ SIOCGIFCONF = 0xc0106924 ++ SIOCGIFDATA = 0xc020691b ++ SIOCGIFDESCR = 0xc0206981 ++ SIOCGIFDSTADDR = 0xc0206922 ++ SIOCGIFFLAGS = 0xc0206911 ++ SIOCGIFGATTR = 0xc028698b ++ SIOCGIFGENERIC = 0xc020693a ++ SIOCGIFGLIST = 0xc028698d ++ SIOCGIFGMEMB = 0xc028698a ++ SIOCGIFGROUP = 0xc0286988 ++ SIOCGIFHARDMTU = 0xc02069a5 ++ SIOCGIFLLPRIO = 0xc02069b6 ++ SIOCGIFMEDIA = 0xc0406938 ++ SIOCGIFMETRIC = 0xc0206917 ++ SIOCGIFMTU = 0xc020697e ++ SIOCGIFNETMASK = 0xc0206925 ++ SIOCGIFPAIR = 0xc02069b1 ++ SIOCGIFPARENT = 0xc02069b3 ++ SIOCGIFPRIORITY = 0xc020699c ++ SIOCGIFRDOMAIN = 0xc02069a0 ++ SIOCGIFRTLABEL = 0xc0206983 ++ SIOCGIFRXR = 0x802069aa ++ SIOCGIFSFFPAGE = 0xc1126939 ++ SIOCGIFXFLAGS = 0xc020699e ++ SIOCGLIFPHYADDR = 0xc218694b ++ SIOCGLIFPHYDF = 0xc02069c2 ++ SIOCGLIFPHYECN = 0xc02069c8 ++ SIOCGLIFPHYRTABLE = 0xc02069a2 ++ SIOCGLIFPHYTTL = 0xc02069a9 ++ SIOCGPGRP = 0x40047309 ++ SIOCGPWE3 = 0xc0206998 ++ SIOCGPWE3CTRLWORD = 0xc02069dc ++ SIOCGPWE3FAT = 0xc02069dd ++ SIOCGPWE3NEIGHBOR = 0xc21869de ++ SIOCGSPPPPARAMS = 0xc0206994 ++ SIOCGTXHPRIO = 0xc02069c6 ++ SIOCGUMBINFO = 0xc02069be ++ SIOCGUMBPARAM = 0xc02069c0 ++ SIOCGVH = 0xc02069f6 ++ SIOCGVNETFLOWID = 0xc02069c4 ++ SIOCGVNETID = 0xc02069a7 ++ SIOCIFAFATTACH = 0x801169ab ++ SIOCIFAFDETACH = 0x801169ac ++ SIOCIFCREATE = 0x8020697a ++ SIOCIFDESTROY = 0x80206979 ++ SIOCIFGCLONERS = 0xc0106978 ++ SIOCSETKALIVE = 0x801869a3 ++ SIOCSETLABEL = 0x80206999 ++ SIOCSETMPWCFG = 0x802069ad ++ SIOCSETPFLOW = 0x802069fd ++ SIOCSETPFSYNC = 0x802069f7 ++ SIOCSETVLAN = 0x8020698f ++ SIOCSIFADDR = 0x8020690c ++ SIOCSIFBRDADDR = 0x80206913 ++ SIOCSIFDESCR = 0x80206980 ++ SIOCSIFDSTADDR = 0x8020690e ++ SIOCSIFFLAGS = 0x80206910 ++ SIOCSIFGATTR = 0x8028698c ++ SIOCSIFGENERIC = 0x80206939 ++ SIOCSIFLLADDR = 0x8020691f ++ SIOCSIFLLPRIO = 0x802069b5 ++ SIOCSIFMEDIA = 0xc0206937 ++ SIOCSIFMETRIC = 0x80206918 ++ SIOCSIFMTU = 0x8020697f ++ SIOCSIFNETMASK = 0x80206916 ++ SIOCSIFPAIR = 0x802069b0 ++ SIOCSIFPARENT = 0x802069b2 ++ SIOCSIFPRIORITY = 0x8020699b ++ SIOCSIFRDOMAIN = 0x8020699f ++ SIOCSIFRTLABEL = 0x80206982 ++ SIOCSIFXFLAGS = 0x8020699d ++ SIOCSLIFPHYADDR = 0x8218694a ++ SIOCSLIFPHYDF = 0x802069c1 ++ SIOCSLIFPHYECN = 0x802069c7 ++ SIOCSLIFPHYRTABLE = 0x802069a1 ++ SIOCSLIFPHYTTL = 0x802069a8 ++ SIOCSPGRP = 0x80047308 ++ SIOCSPWE3CTRLWORD = 0x802069dc ++ SIOCSPWE3FAT = 0x802069dd ++ SIOCSPWE3NEIGHBOR = 0x821869de ++ SIOCSSPPPPARAMS = 0x80206993 ++ SIOCSTXHPRIO = 0x802069c5 ++ SIOCSUMBPARAM = 0x802069bf ++ SIOCSVH = 0xc02069f5 ++ SIOCSVNETFLOWID = 0x802069c3 ++ SIOCSVNETID = 0x802069a6 ++ SIOCSWGDPID = 0xc018695b ++ SIOCSWGMAXFLOW = 0xc0186960 ++ SIOCSWGMAXGROUP = 0xc018695d ++ SIOCSWSDPID = 0x8018695c ++ SIOCSWSPORTNO = 0xc060695f ++ SOCK_CLOEXEC = 0x8000 ++ SOCK_DGRAM = 0x2 ++ SOCK_DNS = 0x1000 ++ SOCK_NONBLOCK = 0x4000 ++ SOCK_RAW = 0x3 ++ SOCK_RDM = 0x4 ++ SOCK_SEQPACKET = 0x5 ++ SOCK_STREAM = 0x1 ++ SOL_SOCKET = 0xffff ++ SOMAXCONN = 0x80 ++ SO_ACCEPTCONN = 0x2 ++ SO_BINDANY = 0x1000 ++ SO_BROADCAST = 0x20 ++ SO_DEBUG = 0x1 ++ SO_DONTROUTE = 0x10 ++ SO_ERROR = 0x1007 ++ SO_KEEPALIVE = 0x8 ++ SO_LINGER = 0x80 ++ SO_NETPROC = 0x1020 ++ SO_OOBINLINE = 0x100 ++ SO_PEERCRED = 0x1022 ++ SO_RCVBUF = 0x1002 ++ SO_RCVLOWAT = 0x1004 ++ SO_RCVTIMEO = 0x1006 ++ SO_REUSEADDR = 0x4 ++ SO_REUSEPORT = 0x200 ++ SO_RTABLE = 0x1021 ++ SO_SNDBUF = 0x1001 ++ SO_SNDLOWAT = 0x1003 ++ SO_SNDTIMEO = 0x1005 ++ SO_SPLICE = 0x1023 ++ SO_TIMESTAMP = 0x800 ++ SO_TYPE = 0x1008 ++ SO_USELOOPBACK = 0x40 ++ SO_ZEROIZE = 0x2000 ++ S_BLKSIZE = 0x200 ++ S_IEXEC = 0x40 ++ S_IFBLK = 0x6000 ++ S_IFCHR = 0x2000 ++ S_IFDIR = 0x4000 ++ S_IFIFO = 0x1000 ++ S_IFLNK = 0xa000 ++ S_IFMT = 0xf000 ++ S_IFREG = 0x8000 ++ S_IFSOCK = 0xc000 ++ S_IREAD = 0x100 ++ S_IRGRP = 0x20 ++ S_IROTH = 0x4 ++ S_IRUSR = 0x100 ++ S_IRWXG = 0x38 ++ S_IRWXO = 0x7 ++ S_IRWXU = 0x1c0 ++ S_ISGID = 0x400 ++ S_ISTXT = 0x200 ++ S_ISUID = 0x800 ++ S_ISVTX = 0x200 ++ S_IWGRP = 0x10 ++ S_IWOTH = 0x2 ++ S_IWRITE = 0x80 ++ S_IWUSR = 0x80 ++ S_IXGRP = 0x8 ++ S_IXOTH = 0x1 ++ S_IXUSR = 0x40 ++ TCIFLUSH = 0x1 ++ TCIOFF = 0x3 ++ TCIOFLUSH = 0x3 ++ TCION = 0x4 ++ TCOFLUSH = 0x2 ++ TCOOFF = 0x1 ++ TCOON = 0x2 ++ TCP_MAXBURST = 0x4 ++ TCP_MAXSEG = 0x2 ++ TCP_MAXWIN = 0xffff ++ TCP_MAX_SACK = 0x3 ++ TCP_MAX_WINSHIFT = 0xe ++ TCP_MD5SIG = 0x4 ++ TCP_MSS = 0x200 ++ TCP_NODELAY = 0x1 ++ TCP_NOPUSH = 0x10 ++ TCP_SACK_ENABLE = 0x8 ++ TCSAFLUSH = 0x2 ++ TIMER_ABSTIME = 0x1 ++ TIMER_RELTIME = 0x0 ++ TIOCCBRK = 0x2000747a ++ TIOCCDTR = 0x20007478 ++ TIOCCHKVERAUTH = 0x2000741e ++ TIOCCLRVERAUTH = 0x2000741d ++ TIOCCONS = 0x80047462 ++ TIOCDRAIN = 0x2000745e ++ TIOCEXCL = 0x2000740d ++ TIOCEXT = 0x80047460 ++ TIOCFLAG_CLOCAL = 0x2 ++ TIOCFLAG_CRTSCTS = 0x4 ++ TIOCFLAG_MDMBUF = 0x8 ++ TIOCFLAG_PPS = 0x10 ++ TIOCFLAG_SOFTCAR = 0x1 ++ TIOCFLUSH = 0x80047410 ++ TIOCGETA = 0x402c7413 ++ TIOCGETD = 0x4004741a ++ TIOCGFLAGS = 0x4004745d ++ TIOCGPGRP = 0x40047477 ++ TIOCGSID = 0x40047463 ++ TIOCGTSTAMP = 0x4010745b ++ TIOCGWINSZ = 0x40087468 ++ TIOCMBIC = 0x8004746b ++ TIOCMBIS = 0x8004746c ++ TIOCMGET = 0x4004746a ++ TIOCMODG = 0x4004746a ++ TIOCMODS = 0x8004746d ++ TIOCMSET = 0x8004746d ++ TIOCM_CAR = 0x40 ++ TIOCM_CD = 0x40 ++ TIOCM_CTS = 0x20 ++ TIOCM_DSR = 0x100 ++ TIOCM_DTR = 0x2 ++ TIOCM_LE = 0x1 ++ TIOCM_RI = 0x80 ++ TIOCM_RNG = 0x80 ++ TIOCM_RTS = 0x4 ++ TIOCM_SR = 0x10 ++ TIOCM_ST = 0x8 ++ TIOCNOTTY = 0x20007471 ++ TIOCNXCL = 0x2000740e ++ TIOCOUTQ = 0x40047473 ++ TIOCPKT = 0x80047470 ++ TIOCPKT_DATA = 0x0 ++ TIOCPKT_DOSTOP = 0x20 ++ TIOCPKT_FLUSHREAD = 0x1 ++ TIOCPKT_FLUSHWRITE = 0x2 ++ TIOCPKT_IOCTL = 0x40 ++ TIOCPKT_NOSTOP = 0x10 ++ TIOCPKT_START = 0x8 ++ TIOCPKT_STOP = 0x4 ++ TIOCREMOTE = 0x80047469 ++ TIOCSBRK = 0x2000747b ++ TIOCSCTTY = 0x20007461 ++ TIOCSDTR = 0x20007479 ++ TIOCSETA = 0x802c7414 ++ TIOCSETAF = 0x802c7416 ++ TIOCSETAW = 0x802c7415 ++ TIOCSETD = 0x8004741b ++ TIOCSETVERAUTH = 0x8004741c ++ TIOCSFLAGS = 0x8004745c ++ TIOCSIG = 0x8004745f ++ TIOCSPGRP = 0x80047476 ++ TIOCSTART = 0x2000746e ++ TIOCSTAT = 0x20007465 ++ TIOCSTOP = 0x2000746f ++ TIOCSTSTAMP = 0x8008745a ++ TIOCSWINSZ = 0x80087467 ++ TIOCUCNTL = 0x80047466 ++ TIOCUCNTL_CBRK = 0x7a ++ TIOCUCNTL_SBRK = 0x7b ++ TOSTOP = 0x400000 ++ UTIME_NOW = -0x2 ++ UTIME_OMIT = -0x1 ++ VDISCARD = 0xf ++ VDSUSP = 0xb ++ VEOF = 0x0 ++ VEOL = 0x1 ++ VEOL2 = 0x2 ++ VERASE = 0x3 ++ VINTR = 0x8 ++ VKILL = 0x5 ++ VLNEXT = 0xe ++ VMIN = 0x10 ++ VM_ANONMIN = 0x7 ++ VM_LOADAVG = 0x2 ++ VM_MALLOC_CONF = 0xc ++ VM_MAXID = 0xd ++ VM_MAXSLP = 0xa ++ VM_METER = 0x1 ++ VM_NKMEMPAGES = 0x6 ++ VM_PSSTRINGS = 0x3 ++ VM_SWAPENCRYPT = 0x5 ++ VM_USPACE = 0xb ++ VM_UVMEXP = 0x4 ++ VM_VNODEMIN = 0x9 ++ VM_VTEXTMIN = 0x8 ++ VQUIT = 0x9 ++ VREPRINT = 0x6 ++ VSTART = 0xc ++ VSTATUS = 0x12 ++ VSTOP = 0xd ++ VSUSP = 0xa ++ VTIME = 0x11 ++ VWERASE = 0x4 ++ WALTSIG = 0x4 ++ WCONTINUED = 0x8 ++ WCOREFLAG = 0x80 ++ WNOHANG = 0x1 ++ WUNTRACED = 0x2 ++ XCASE = 0x1000000 ++) ++ ++// Errors ++const ( ++ E2BIG = syscall.Errno(0x7) ++ EACCES = syscall.Errno(0xd) ++ EADDRINUSE = syscall.Errno(0x30) ++ EADDRNOTAVAIL = syscall.Errno(0x31) ++ EAFNOSUPPORT = syscall.Errno(0x2f) ++ EAGAIN = syscall.Errno(0x23) ++ EALREADY = syscall.Errno(0x25) ++ EAUTH = syscall.Errno(0x50) ++ EBADF = syscall.Errno(0x9) ++ EBADMSG = syscall.Errno(0x5c) ++ EBADRPC = syscall.Errno(0x48) ++ EBUSY = syscall.Errno(0x10) ++ ECANCELED = syscall.Errno(0x58) ++ ECHILD = syscall.Errno(0xa) ++ ECONNABORTED = syscall.Errno(0x35) ++ ECONNREFUSED = syscall.Errno(0x3d) ++ ECONNRESET = syscall.Errno(0x36) ++ EDEADLK = syscall.Errno(0xb) ++ EDESTADDRREQ = syscall.Errno(0x27) ++ EDOM = syscall.Errno(0x21) ++ EDQUOT = syscall.Errno(0x45) ++ EEXIST = syscall.Errno(0x11) ++ EFAULT = syscall.Errno(0xe) ++ EFBIG = syscall.Errno(0x1b) ++ EFTYPE = syscall.Errno(0x4f) ++ EHOSTDOWN = syscall.Errno(0x40) ++ EHOSTUNREACH = syscall.Errno(0x41) ++ EIDRM = syscall.Errno(0x59) ++ EILSEQ = syscall.Errno(0x54) ++ EINPROGRESS = syscall.Errno(0x24) ++ EINTR = syscall.Errno(0x4) ++ EINVAL = syscall.Errno(0x16) ++ EIO = syscall.Errno(0x5) ++ EIPSEC = syscall.Errno(0x52) ++ EISCONN = syscall.Errno(0x38) ++ EISDIR = syscall.Errno(0x15) ++ ELAST = syscall.Errno(0x5f) ++ ELOOP = syscall.Errno(0x3e) ++ EMEDIUMTYPE = syscall.Errno(0x56) ++ EMFILE = syscall.Errno(0x18) ++ EMLINK = syscall.Errno(0x1f) ++ EMSGSIZE = syscall.Errno(0x28) ++ ENAMETOOLONG = syscall.Errno(0x3f) ++ ENEEDAUTH = syscall.Errno(0x51) ++ ENETDOWN = syscall.Errno(0x32) ++ ENETRESET = syscall.Errno(0x34) ++ ENETUNREACH = syscall.Errno(0x33) ++ ENFILE = syscall.Errno(0x17) ++ ENOATTR = syscall.Errno(0x53) ++ ENOBUFS = syscall.Errno(0x37) ++ ENODEV = syscall.Errno(0x13) ++ ENOENT = syscall.Errno(0x2) ++ ENOEXEC = syscall.Errno(0x8) ++ ENOLCK = syscall.Errno(0x4d) ++ ENOMEDIUM = syscall.Errno(0x55) ++ ENOMEM = syscall.Errno(0xc) ++ ENOMSG = syscall.Errno(0x5a) ++ ENOPROTOOPT = syscall.Errno(0x2a) ++ ENOSPC = syscall.Errno(0x1c) ++ ENOSYS = syscall.Errno(0x4e) ++ ENOTBLK = syscall.Errno(0xf) ++ ENOTCONN = syscall.Errno(0x39) ++ ENOTDIR = syscall.Errno(0x14) ++ ENOTEMPTY = syscall.Errno(0x42) ++ ENOTRECOVERABLE = syscall.Errno(0x5d) ++ ENOTSOCK = syscall.Errno(0x26) ++ ENOTSUP = syscall.Errno(0x5b) ++ ENOTTY = syscall.Errno(0x19) ++ ENXIO = syscall.Errno(0x6) ++ EOPNOTSUPP = syscall.Errno(0x2d) ++ EOVERFLOW = syscall.Errno(0x57) ++ EOWNERDEAD = syscall.Errno(0x5e) ++ EPERM = syscall.Errno(0x1) ++ EPFNOSUPPORT = syscall.Errno(0x2e) ++ EPIPE = syscall.Errno(0x20) ++ EPROCLIM = syscall.Errno(0x43) ++ EPROCUNAVAIL = syscall.Errno(0x4c) ++ EPROGMISMATCH = syscall.Errno(0x4b) ++ EPROGUNAVAIL = syscall.Errno(0x4a) ++ EPROTO = syscall.Errno(0x5f) ++ EPROTONOSUPPORT = syscall.Errno(0x2b) ++ EPROTOTYPE = syscall.Errno(0x29) ++ ERANGE = syscall.Errno(0x22) ++ EREMOTE = syscall.Errno(0x47) ++ EROFS = syscall.Errno(0x1e) ++ ERPCMISMATCH = syscall.Errno(0x49) ++ ESHUTDOWN = syscall.Errno(0x3a) ++ ESOCKTNOSUPPORT = syscall.Errno(0x2c) ++ ESPIPE = syscall.Errno(0x1d) ++ ESRCH = syscall.Errno(0x3) ++ ESTALE = syscall.Errno(0x46) ++ ETIMEDOUT = syscall.Errno(0x3c) ++ ETOOMANYREFS = syscall.Errno(0x3b) ++ ETXTBSY = syscall.Errno(0x1a) ++ EUSERS = syscall.Errno(0x44) ++ EWOULDBLOCK = syscall.Errno(0x23) ++ EXDEV = syscall.Errno(0x12) ++) ++ ++// Signals ++const ( ++ SIGABRT = syscall.Signal(0x6) ++ SIGALRM = syscall.Signal(0xe) ++ SIGBUS = syscall.Signal(0xa) ++ SIGCHLD = syscall.Signal(0x14) ++ SIGCONT = syscall.Signal(0x13) ++ SIGEMT = syscall.Signal(0x7) ++ SIGFPE = syscall.Signal(0x8) ++ SIGHUP = syscall.Signal(0x1) ++ SIGILL = syscall.Signal(0x4) ++ SIGINFO = syscall.Signal(0x1d) ++ SIGINT = syscall.Signal(0x2) ++ SIGIO = syscall.Signal(0x17) ++ SIGIOT = syscall.Signal(0x6) ++ SIGKILL = syscall.Signal(0x9) ++ SIGPIPE = syscall.Signal(0xd) ++ SIGPROF = syscall.Signal(0x1b) ++ SIGQUIT = syscall.Signal(0x3) ++ SIGSEGV = syscall.Signal(0xb) ++ SIGSTOP = syscall.Signal(0x11) ++ SIGSYS = syscall.Signal(0xc) ++ SIGTERM = syscall.Signal(0xf) ++ SIGTHR = syscall.Signal(0x20) ++ SIGTRAP = syscall.Signal(0x5) ++ SIGTSTP = syscall.Signal(0x12) ++ SIGTTIN = syscall.Signal(0x15) ++ SIGTTOU = syscall.Signal(0x16) ++ SIGURG = syscall.Signal(0x10) ++ SIGUSR1 = syscall.Signal(0x1e) ++ SIGUSR2 = syscall.Signal(0x1f) ++ SIGVTALRM = syscall.Signal(0x1a) ++ SIGWINCH = syscall.Signal(0x1c) ++ SIGXCPU = syscall.Signal(0x18) ++ SIGXFSZ = syscall.Signal(0x19) ++) ++ ++// Error table ++var errorList = [...]struct { ++ num syscall.Errno ++ name string ++ desc string ++}{ ++ {1, "EPERM", "operation not permitted"}, ++ {2, "ENOENT", "no such file or directory"}, ++ {3, "ESRCH", "no such process"}, ++ {4, "EINTR", "interrupted system call"}, ++ {5, "EIO", "input/output error"}, ++ {6, "ENXIO", "device not configured"}, ++ {7, "E2BIG", "argument list too long"}, ++ {8, "ENOEXEC", "exec format error"}, ++ {9, "EBADF", "bad file descriptor"}, ++ {10, "ECHILD", "no child processes"}, ++ {11, "EDEADLK", "resource deadlock avoided"}, ++ {12, "ENOMEM", "cannot allocate memory"}, ++ {13, "EACCES", "permission denied"}, ++ {14, "EFAULT", "bad address"}, ++ {15, "ENOTBLK", "block device required"}, ++ {16, "EBUSY", "device busy"}, ++ {17, "EEXIST", "file exists"}, ++ {18, "EXDEV", "cross-device link"}, ++ {19, "ENODEV", "operation not supported by device"}, ++ {20, "ENOTDIR", "not a directory"}, ++ {21, "EISDIR", "is a directory"}, ++ {22, "EINVAL", "invalid argument"}, ++ {23, "ENFILE", "too many open files in system"}, ++ {24, "EMFILE", "too many open files"}, ++ {25, "ENOTTY", "inappropriate ioctl for device"}, ++ {26, "ETXTBSY", "text file busy"}, ++ {27, "EFBIG", "file too large"}, ++ {28, "ENOSPC", "no space left on device"}, ++ {29, "ESPIPE", "illegal seek"}, ++ {30, "EROFS", "read-only file system"}, ++ {31, "EMLINK", "too many links"}, ++ {32, "EPIPE", "broken pipe"}, ++ {33, "EDOM", "numerical argument out of domain"}, ++ {34, "ERANGE", "result too large"}, ++ {35, "EAGAIN", "resource temporarily unavailable"}, ++ {36, "EINPROGRESS", "operation now in progress"}, ++ {37, "EALREADY", "operation already in progress"}, ++ {38, "ENOTSOCK", "socket operation on non-socket"}, ++ {39, "EDESTADDRREQ", "destination address required"}, ++ {40, "EMSGSIZE", "message too long"}, ++ {41, "EPROTOTYPE", "protocol wrong type for socket"}, ++ {42, "ENOPROTOOPT", "protocol not available"}, ++ {43, "EPROTONOSUPPORT", "protocol not supported"}, ++ {44, "ESOCKTNOSUPPORT", "socket type not supported"}, ++ {45, "EOPNOTSUPP", "operation not supported"}, ++ {46, "EPFNOSUPPORT", "protocol family not supported"}, ++ {47, "EAFNOSUPPORT", "address family not supported by protocol family"}, ++ {48, "EADDRINUSE", "address already in use"}, ++ {49, "EADDRNOTAVAIL", "can't assign requested address"}, ++ {50, "ENETDOWN", "network is down"}, ++ {51, "ENETUNREACH", "network is unreachable"}, ++ {52, "ENETRESET", "network dropped connection on reset"}, ++ {53, "ECONNABORTED", "software caused connection abort"}, ++ {54, "ECONNRESET", "connection reset by peer"}, ++ {55, "ENOBUFS", "no buffer space available"}, ++ {56, "EISCONN", "socket is already connected"}, ++ {57, "ENOTCONN", "socket is not connected"}, ++ {58, "ESHUTDOWN", "can't send after socket shutdown"}, ++ {59, "ETOOMANYREFS", "too many references: can't splice"}, ++ {60, "ETIMEDOUT", "operation timed out"}, ++ {61, "ECONNREFUSED", "connection refused"}, ++ {62, "ELOOP", "too many levels of symbolic links"}, ++ {63, "ENAMETOOLONG", "file name too long"}, ++ {64, "EHOSTDOWN", "host is down"}, ++ {65, "EHOSTUNREACH", "no route to host"}, ++ {66, "ENOTEMPTY", "directory not empty"}, ++ {67, "EPROCLIM", "too many processes"}, ++ {68, "EUSERS", "too many users"}, ++ {69, "EDQUOT", "disk quota exceeded"}, ++ {70, "ESTALE", "stale NFS file handle"}, ++ {71, "EREMOTE", "too many levels of remote in path"}, ++ {72, "EBADRPC", "RPC struct is bad"}, ++ {73, "ERPCMISMATCH", "RPC version wrong"}, ++ {74, "EPROGUNAVAIL", "RPC program not available"}, ++ {75, "EPROGMISMATCH", "program version wrong"}, ++ {76, "EPROCUNAVAIL", "bad procedure for program"}, ++ {77, "ENOLCK", "no locks available"}, ++ {78, "ENOSYS", "function not implemented"}, ++ {79, "EFTYPE", "inappropriate file type or format"}, ++ {80, "EAUTH", "authentication error"}, ++ {81, "ENEEDAUTH", "need authenticator"}, ++ {82, "EIPSEC", "IPsec processing failure"}, ++ {83, "ENOATTR", "attribute not found"}, ++ {84, "EILSEQ", "illegal byte sequence"}, ++ {85, "ENOMEDIUM", "no medium found"}, ++ {86, "EMEDIUMTYPE", "wrong medium type"}, ++ {87, "EOVERFLOW", "value too large to be stored in data type"}, ++ {88, "ECANCELED", "operation canceled"}, ++ {89, "EIDRM", "identifier removed"}, ++ {90, "ENOMSG", "no message of desired type"}, ++ {91, "ENOTSUP", "not supported"}, ++ {92, "EBADMSG", "bad message"}, ++ {93, "ENOTRECOVERABLE", "state not recoverable"}, ++ {94, "EOWNERDEAD", "previous owner died"}, ++ {95, "ELAST", "protocol error"}, ++} ++ ++// Signal table ++var signalList = [...]struct { ++ num syscall.Signal ++ name string ++ desc string ++}{ ++ {1, "SIGHUP", "hangup"}, ++ {2, "SIGINT", "interrupt"}, ++ {3, "SIGQUIT", "quit"}, ++ {4, "SIGILL", "illegal instruction"}, ++ {5, "SIGTRAP", "trace/BPT trap"}, ++ {6, "SIGABRT", "abort trap"}, ++ {7, "SIGEMT", "EMT trap"}, ++ {8, "SIGFPE", "floating point exception"}, ++ {9, "SIGKILL", "killed"}, ++ {10, "SIGBUS", "bus error"}, ++ {11, "SIGSEGV", "segmentation fault"}, ++ {12, "SIGSYS", "bad system call"}, ++ {13, "SIGPIPE", "broken pipe"}, ++ {14, "SIGALRM", "alarm clock"}, ++ {15, "SIGTERM", "terminated"}, ++ {16, "SIGURG", "urgent I/O condition"}, ++ {17, "SIGSTOP", "suspended (signal)"}, ++ {18, "SIGTSTP", "suspended"}, ++ {19, "SIGCONT", "continued"}, ++ {20, "SIGCHLD", "child exited"}, ++ {21, "SIGTTIN", "stopped (tty input)"}, ++ {22, "SIGTTOU", "stopped (tty output)"}, ++ {23, "SIGIO", "I/O possible"}, ++ {24, "SIGXCPU", "cputime limit exceeded"}, ++ {25, "SIGXFSZ", "filesize limit exceeded"}, ++ {26, "SIGVTALRM", "virtual timer expired"}, ++ {27, "SIGPROF", "profiling timer expired"}, ++ {28, "SIGWINCH", "window size changes"}, ++ {29, "SIGINFO", "information request"}, ++ {30, "SIGUSR1", "user defined signal 1"}, ++ {31, "SIGUSR2", "user defined signal 2"}, ++ {32, "SIGTHR", "thread AST"}, ++} diff --git a/lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_zsyscall_openbsd_riscv64_go b/lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_zsyscall_openbsd_riscv64_go new file mode 100644 index 000000000000..b135b1fe9757 --- /dev/null +++ b/lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_zsyscall_openbsd_riscv64_go @@ -0,0 +1,1697 @@ +Index: src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.go +--- src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.go.orig ++++ src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.go +@@ -0,0 +1,1693 @@ ++// go run mksyscall.go -openbsd -tags openbsd,riscv64 syscall_bsd.go syscall_openbsd.go syscall_openbsd_riscv64.go ++// Code generated by the command above; see README.md. DO NOT EDIT. ++ ++//go:build openbsd && riscv64 ++// +build openbsd,riscv64 ++ ++package unix ++ ++import ( ++ "syscall" ++ "unsafe" ++) ++ ++var _ syscall.Errno ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func getgroups(ngid int, gid *_Gid_t) (n int, err error) { ++ r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func setgroups(ngid int, gid *_Gid_t) (err error) { ++ _, _, e1 := RawSyscall(SYS_SETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) { ++ r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0) ++ wpid = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) { ++ r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { ++ _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { ++ _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func socket(domain int, typ int, proto int) (fd int, err error) { ++ r0, _, e1 := RawSyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto)) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { ++ _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) { ++ _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) { ++ _, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) { ++ _, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Shutdown(s int, how int) (err error) { ++ _, _, e1 := Syscall(SYS_SHUTDOWN, uintptr(s), uintptr(how), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) { ++ _, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(p) > 0 { ++ _p0 = unsafe.Pointer(&p[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen))) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) { ++ var _p0 unsafe.Pointer ++ if len(buf) > 0 { ++ _p0 = unsafe.Pointer(&buf[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := Syscall6(SYS_SENDTO, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { ++ r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { ++ r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) { ++ r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout))) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func utimes(path string, timeval *[2]Timeval) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func futimes(fd int, timeval *[2]Timeval) (err error) { ++ _, _, e1 := Syscall(SYS_FUTIMES, uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func poll(fds *PollFd, nfds int, timeout int) (n int, err error) { ++ r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout)) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Madvise(b []byte, behav int) (err error) { ++ var _p0 unsafe.Pointer ++ if len(b) > 0 { ++ _p0 = unsafe.Pointer(&b[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := Syscall(SYS_MADVISE, uintptr(_p0), uintptr(len(b)), uintptr(behav)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Mlock(b []byte) (err error) { ++ var _p0 unsafe.Pointer ++ if len(b) > 0 { ++ _p0 = unsafe.Pointer(&b[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := Syscall(SYS_MLOCK, uintptr(_p0), uintptr(len(b)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Mlockall(flags int) (err error) { ++ _, _, e1 := Syscall(SYS_MLOCKALL, uintptr(flags), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Mprotect(b []byte, prot int) (err error) { ++ var _p0 unsafe.Pointer ++ if len(b) > 0 { ++ _p0 = unsafe.Pointer(&b[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := Syscall(SYS_MPROTECT, uintptr(_p0), uintptr(len(b)), uintptr(prot)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Msync(b []byte, flags int) (err error) { ++ var _p0 unsafe.Pointer ++ if len(b) > 0 { ++ _p0 = unsafe.Pointer(&b[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := Syscall(SYS_MSYNC, uintptr(_p0), uintptr(len(b)), uintptr(flags)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Munlock(b []byte) (err error) { ++ var _p0 unsafe.Pointer ++ if len(b) > 0 { ++ _p0 = unsafe.Pointer(&b[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := Syscall(SYS_MUNLOCK, uintptr(_p0), uintptr(len(b)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Munlockall() (err error) { ++ _, _, e1 := Syscall(SYS_MUNLOCKALL, 0, 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func pipe2(p *[2]_C_int, flags int) (err error) { ++ _, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getdents(fd int, buf []byte) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(buf) > 0 { ++ _p0 = unsafe.Pointer(&buf[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall(SYS_GETDENTS, uintptr(fd), uintptr(_p0), uintptr(len(buf))) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getcwd(buf []byte) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(buf) > 0 { ++ _p0 = unsafe.Pointer(&buf[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall(SYS___GETCWD, uintptr(_p0), uintptr(len(buf)), 0) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func ioctl(fd int, req uint, arg uintptr) (err error) { ++ _, _, e1 := Syscall(SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) { ++ var _p0 unsafe.Pointer ++ if len(mib) > 0 { ++ _p0 = unsafe.Pointer(&mib[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := Syscall6(SYS___SYSCTL, uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func ppoll(fds *PollFd, nfds int, timeout *Timespec, sigmask *Sigset_t) (n int, err error) { ++ r0, _, e1 := Syscall6(SYS_PPOLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(unsafe.Pointer(timeout)), uintptr(unsafe.Pointer(sigmask)), 0, 0) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Access(path string, mode uint32) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_ACCESS, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Adjtime(delta *Timeval, olddelta *Timeval) (err error) { ++ _, _, e1 := Syscall(SYS_ADJTIME, uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Chdir(path string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Chflags(path string, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_CHFLAGS, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Chmod(path string, mode uint32) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_CHMOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Chown(path string, uid int, gid int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_CHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Chroot(path string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Close(fd int) (err error) { ++ _, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Dup(fd int) (nfd int, err error) { ++ r0, _, e1 := Syscall(SYS_DUP, uintptr(fd), 0, 0) ++ nfd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Dup2(from int, to int) (err error) { ++ _, _, e1 := Syscall(SYS_DUP2, uintptr(from), uintptr(to), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Dup3(from int, to int, flags int) (err error) { ++ _, _, e1 := Syscall(SYS_DUP3, uintptr(from), uintptr(to), uintptr(flags)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Exit(code int) { ++ Syscall(SYS_EXIT, uintptr(code), 0, 0) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_FACCESSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fchdir(fd int) (err error) { ++ _, _, e1 := Syscall(SYS_FCHDIR, uintptr(fd), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fchflags(fd int, flags int) (err error) { ++ _, _, e1 := Syscall(SYS_FCHFLAGS, uintptr(fd), uintptr(flags), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fchmod(fd int, mode uint32) (err error) { ++ _, _, e1 := Syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fchown(fd int, uid int, gid int) (err error) { ++ _, _, e1 := Syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_FCHOWNAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Flock(fd int, how int) (err error) { ++ _, _, e1 := Syscall(SYS_FLOCK, uintptr(fd), uintptr(how), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fpathconf(fd int, name int) (val int, err error) { ++ r0, _, e1 := Syscall(SYS_FPATHCONF, uintptr(fd), uintptr(name), 0) ++ val = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fstat(fd int, stat *Stat_t) (err error) { ++ _, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_FSTATAT, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fstatfs(fd int, stat *Statfs_t) (err error) { ++ _, _, e1 := Syscall(SYS_FSTATFS, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fsync(fd int) (err error) { ++ _, _, e1 := Syscall(SYS_FSYNC, uintptr(fd), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Ftruncate(fd int, length int64) (err error) { ++ _, _, e1 := Syscall(SYS_FTRUNCATE, uintptr(fd), 0, uintptr(length)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getegid() (egid int) { ++ r0, _, _ := RawSyscall(SYS_GETEGID, 0, 0, 0) ++ egid = int(r0) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Geteuid() (uid int) { ++ r0, _, _ := RawSyscall(SYS_GETEUID, 0, 0, 0) ++ uid = int(r0) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getgid() (gid int) { ++ r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0) ++ gid = int(r0) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getpgid(pid int) (pgid int, err error) { ++ r0, _, e1 := RawSyscall(SYS_GETPGID, uintptr(pid), 0, 0) ++ pgid = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getpgrp() (pgrp int) { ++ r0, _, _ := RawSyscall(SYS_GETPGRP, 0, 0, 0) ++ pgrp = int(r0) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getpid() (pid int) { ++ r0, _, _ := RawSyscall(SYS_GETPID, 0, 0, 0) ++ pid = int(r0) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getppid() (ppid int) { ++ r0, _, _ := RawSyscall(SYS_GETPPID, 0, 0, 0) ++ ppid = int(r0) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getpriority(which int, who int) (prio int, err error) { ++ r0, _, e1 := Syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0) ++ prio = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getrlimit(which int, lim *Rlimit) (err error) { ++ _, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getrtable() (rtable int, err error) { ++ r0, _, e1 := RawSyscall(SYS_GETRTABLE, 0, 0, 0) ++ rtable = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getrusage(who int, rusage *Rusage) (err error) { ++ _, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getsid(pid int) (sid int, err error) { ++ r0, _, e1 := RawSyscall(SYS_GETSID, uintptr(pid), 0, 0) ++ sid = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Gettimeofday(tv *Timeval) (err error) { ++ _, _, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getuid() (uid int) { ++ r0, _, _ := RawSyscall(SYS_GETUID, 0, 0, 0) ++ uid = int(r0) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Issetugid() (tainted bool) { ++ r0, _, _ := Syscall(SYS_ISSETUGID, 0, 0, 0) ++ tainted = bool(r0 != 0) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Kill(pid int, signum syscall.Signal) (err error) { ++ _, _, e1 := Syscall(SYS_KILL, uintptr(pid), uintptr(signum), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Kqueue() (fd int, err error) { ++ r0, _, e1 := Syscall(SYS_KQUEUE, 0, 0, 0) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Lchown(path string, uid int, gid int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Link(path string, link string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(link) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Linkat(pathfd int, path string, linkfd int, link string, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(link) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_LINKAT, uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Listen(s int, backlog int) (err error) { ++ _, _, e1 := Syscall(SYS_LISTEN, uintptr(s), uintptr(backlog), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Lstat(path string, stat *Stat_t) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_LSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Mkdir(path string, mode uint32) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_MKDIR, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Mkdirat(dirfd int, path string, mode uint32) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_MKDIRAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Mkfifo(path string, mode uint32) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_MKFIFO, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Mkfifoat(dirfd int, path string, mode uint32) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_MKFIFOAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Mknod(path string, mode uint32, dev int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_MKNOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Mknodat(dirfd int, path string, mode uint32, dev int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_MKNODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Nanosleep(time *Timespec, leftover *Timespec) (err error) { ++ _, _, e1 := Syscall(SYS_NANOSLEEP, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Open(path string, mode int, perm uint32) (fd int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm)) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ r0, _, e1 := Syscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Pathconf(path string, name int) (val int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ r0, _, e1 := Syscall(SYS_PATHCONF, uintptr(unsafe.Pointer(_p0)), uintptr(name), 0) ++ val = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func pread(fd int, p []byte, offset int64) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(p) > 0 { ++ _p0 = unsafe.Pointer(&p[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), 0, uintptr(offset), 0) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func pwrite(fd int, p []byte, offset int64) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(p) > 0 { ++ _p0 = unsafe.Pointer(&p[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), 0, uintptr(offset), 0) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func read(fd int, p []byte) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(p) > 0 { ++ _p0 = unsafe.Pointer(&p[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p))) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Readlink(path string, buf []byte) (n int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 unsafe.Pointer ++ if len(buf) > 0 { ++ _p1 = unsafe.Pointer(&buf[0]) ++ } else { ++ _p1 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall(SYS_READLINK, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf))) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Readlinkat(dirfd int, path string, buf []byte) (n int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 unsafe.Pointer ++ if len(buf) > 0 { ++ _p1 = unsafe.Pointer(&buf[0]) ++ } else { ++ _p1 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall6(SYS_READLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Rename(from string, to string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(from) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(to) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_RENAME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Renameat(fromfd int, from string, tofd int, to string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(from) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(to) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_RENAMEAT, uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Revoke(path string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_REVOKE, uintptr(unsafe.Pointer(_p0)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Rmdir(path string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_RMDIR, uintptr(unsafe.Pointer(_p0)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Seek(fd int, offset int64, whence int) (newoffset int64, err error) { ++ r0, _, e1 := Syscall6(SYS_LSEEK, uintptr(fd), 0, uintptr(offset), uintptr(whence), 0, 0) ++ newoffset = int64(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error) { ++ r0, _, e1 := Syscall6(SYS_SELECT, uintptr(nfd), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setegid(egid int) (err error) { ++ _, _, e1 := RawSyscall(SYS_SETEGID, uintptr(egid), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Seteuid(euid int) (err error) { ++ _, _, e1 := RawSyscall(SYS_SETEUID, uintptr(euid), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setgid(gid int) (err error) { ++ _, _, e1 := RawSyscall(SYS_SETGID, uintptr(gid), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setlogin(name string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(name) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_SETLOGIN, uintptr(unsafe.Pointer(_p0)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setpgid(pid int, pgid int) (err error) { ++ _, _, e1 := RawSyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setpriority(which int, who int, prio int) (err error) { ++ _, _, e1 := Syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setregid(rgid int, egid int) (err error) { ++ _, _, e1 := RawSyscall(SYS_SETREGID, uintptr(rgid), uintptr(egid), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setreuid(ruid int, euid int) (err error) { ++ _, _, e1 := RawSyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setresgid(rgid int, egid int, sgid int) (err error) { ++ _, _, e1 := RawSyscall(SYS_SETRESGID, uintptr(rgid), uintptr(egid), uintptr(sgid)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setresuid(ruid int, euid int, suid int) (err error) { ++ _, _, e1 := RawSyscall(SYS_SETRESUID, uintptr(ruid), uintptr(euid), uintptr(suid)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setrlimit(which int, lim *Rlimit) (err error) { ++ _, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setrtable(rtable int) (err error) { ++ _, _, e1 := RawSyscall(SYS_SETRTABLE, uintptr(rtable), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setsid() (pid int, err error) { ++ r0, _, e1 := RawSyscall(SYS_SETSID, 0, 0, 0) ++ pid = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Settimeofday(tp *Timeval) (err error) { ++ _, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setuid(uid int) (err error) { ++ _, _, e1 := RawSyscall(SYS_SETUID, uintptr(uid), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Stat(path string, stat *Stat_t) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Statfs(path string, stat *Statfs_t) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_STATFS, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Symlink(path string, link string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(link) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_SYMLINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Symlinkat(oldpath string, newdirfd int, newpath string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(oldpath) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(newpath) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_SYMLINKAT, uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1))) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Sync() (err error) { ++ _, _, e1 := Syscall(SYS_SYNC, 0, 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Truncate(path string, length int64) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), 0, uintptr(length)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Umask(newmask int) (oldmask int) { ++ r0, _, _ := Syscall(SYS_UMASK, uintptr(newmask), 0, 0) ++ oldmask = int(r0) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Unlink(path string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_UNLINK, uintptr(unsafe.Pointer(_p0)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Unlinkat(dirfd int, path string, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_UNLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Unmount(path string, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_UNMOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func write(fd int, p []byte) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(p) > 0 { ++ _p0 = unsafe.Pointer(&p[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p))) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) { ++ r0, _, e1 := Syscall9(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), 0, uintptr(pos), 0, 0) ++ ret = uintptr(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func munmap(addr uintptr, length uintptr) (err error) { ++ _, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func readlen(fd int, buf *byte, nbuf int) (n int, err error) { ++ r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf)) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func writelen(fd int, buf *byte, nbuf int) (n int, err error) { ++ r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf)) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func utimensat(dirfd int, path string, times *[2]Timespec, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_UTIMENSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flags), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} diff --git a/lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_zsysctl_openbsd_riscv64_go b/lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_zsysctl_openbsd_riscv64_go new file mode 100644 index 000000000000..34ff03aba24d --- /dev/null +++ b/lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_zsysctl_openbsd_riscv64_go @@ -0,0 +1,280 @@ +Index: src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_riscv64.go +--- src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_riscv64.go.orig ++++ src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_riscv64.go +@@ -0,0 +1,276 @@ ++// go run mksysctl_openbsd.go ++// Code generated by the command above; DO NOT EDIT. ++ ++//go:build riscv64 && openbsd ++// +build riscv64,openbsd ++ ++package unix ++ ++type mibentry struct { ++ ctlname string ++ ctloid []_C_int ++} ++ ++var sysctlMib = []mibentry{ ++ {"ddb.console", []_C_int{9, 6}}, ++ {"ddb.log", []_C_int{9, 7}}, ++ {"ddb.max_line", []_C_int{9, 3}}, ++ {"ddb.max_width", []_C_int{9, 2}}, ++ {"ddb.panic", []_C_int{9, 5}}, ++ {"ddb.profile", []_C_int{9, 9}}, ++ {"ddb.radix", []_C_int{9, 1}}, ++ {"ddb.tab_stop_width", []_C_int{9, 4}}, ++ {"ddb.trigger", []_C_int{9, 8}}, ++ {"fs.posix.setuid", []_C_int{3, 1, 1}}, ++ {"hw.allowpowerdown", []_C_int{6, 22}}, ++ {"hw.byteorder", []_C_int{6, 4}}, ++ {"hw.cpuspeed", []_C_int{6, 12}}, ++ {"hw.diskcount", []_C_int{6, 10}}, ++ {"hw.disknames", []_C_int{6, 8}}, ++ {"hw.diskstats", []_C_int{6, 9}}, ++ {"hw.machine", []_C_int{6, 1}}, ++ {"hw.model", []_C_int{6, 2}}, ++ {"hw.ncpu", []_C_int{6, 3}}, ++ {"hw.ncpufound", []_C_int{6, 21}}, ++ {"hw.ncpuonline", []_C_int{6, 25}}, ++ {"hw.pagesize", []_C_int{6, 7}}, ++ {"hw.perfpolicy", []_C_int{6, 23}}, ++ {"hw.physmem", []_C_int{6, 19}}, ++ {"hw.product", []_C_int{6, 15}}, ++ {"hw.serialno", []_C_int{6, 17}}, ++ {"hw.setperf", []_C_int{6, 13}}, ++ {"hw.smt", []_C_int{6, 24}}, ++ {"hw.usermem", []_C_int{6, 20}}, ++ {"hw.uuid", []_C_int{6, 18}}, ++ {"hw.vendor", []_C_int{6, 14}}, ++ {"hw.version", []_C_int{6, 16}}, ++ {"kern.allowkmem", []_C_int{1, 52}}, ++ {"kern.argmax", []_C_int{1, 8}}, ++ {"kern.audio", []_C_int{1, 84}}, ++ {"kern.boottime", []_C_int{1, 21}}, ++ {"kern.bufcachepercent", []_C_int{1, 72}}, ++ {"kern.ccpu", []_C_int{1, 45}}, ++ {"kern.clockrate", []_C_int{1, 12}}, ++ {"kern.consdev", []_C_int{1, 75}}, ++ {"kern.cp_time", []_C_int{1, 40}}, ++ {"kern.cp_time2", []_C_int{1, 71}}, ++ {"kern.cpustats", []_C_int{1, 85}}, ++ {"kern.domainname", []_C_int{1, 22}}, ++ {"kern.file", []_C_int{1, 73}}, ++ {"kern.forkstat", []_C_int{1, 42}}, ++ {"kern.fscale", []_C_int{1, 46}}, ++ {"kern.fsync", []_C_int{1, 33}}, ++ {"kern.global_ptrace", []_C_int{1, 81}}, ++ {"kern.hostid", []_C_int{1, 11}}, ++ {"kern.hostname", []_C_int{1, 10}}, ++ {"kern.intrcnt.nintrcnt", []_C_int{1, 63, 1}}, ++ {"kern.job_control", []_C_int{1, 19}}, ++ {"kern.malloc.buckets", []_C_int{1, 39, 1}}, ++ {"kern.malloc.kmemnames", []_C_int{1, 39, 3}}, ++ {"kern.maxclusters", []_C_int{1, 67}}, ++ {"kern.maxfiles", []_C_int{1, 7}}, ++ {"kern.maxlocksperuid", []_C_int{1, 70}}, ++ {"kern.maxpartitions", []_C_int{1, 23}}, ++ {"kern.maxproc", []_C_int{1, 6}}, ++ {"kern.maxthread", []_C_int{1, 25}}, ++ {"kern.maxvnodes", []_C_int{1, 5}}, ++ {"kern.mbstat", []_C_int{1, 59}}, ++ {"kern.msgbuf", []_C_int{1, 48}}, ++ {"kern.msgbufsize", []_C_int{1, 38}}, ++ {"kern.nchstats", []_C_int{1, 41}}, ++ {"kern.netlivelocks", []_C_int{1, 76}}, ++ {"kern.nfiles", []_C_int{1, 56}}, ++ {"kern.ngroups", []_C_int{1, 18}}, ++ {"kern.nosuidcoredump", []_C_int{1, 32}}, ++ {"kern.nprocs", []_C_int{1, 47}}, ++ {"kern.nselcoll", []_C_int{1, 43}}, ++ {"kern.nthreads", []_C_int{1, 26}}, ++ {"kern.numvnodes", []_C_int{1, 58}}, ++ {"kern.osrelease", []_C_int{1, 2}}, ++ {"kern.osrevision", []_C_int{1, 3}}, ++ {"kern.ostype", []_C_int{1, 1}}, ++ {"kern.osversion", []_C_int{1, 27}}, ++ {"kern.pool_debug", []_C_int{1, 77}}, ++ {"kern.posix1version", []_C_int{1, 17}}, ++ {"kern.proc", []_C_int{1, 66}}, ++ {"kern.rawpartition", []_C_int{1, 24}}, ++ {"kern.saved_ids", []_C_int{1, 20}}, ++ {"kern.securelevel", []_C_int{1, 9}}, ++ {"kern.seminfo", []_C_int{1, 61}}, ++ {"kern.shminfo", []_C_int{1, 62}}, ++ {"kern.somaxconn", []_C_int{1, 28}}, ++ {"kern.sominconn", []_C_int{1, 29}}, ++ {"kern.splassert", []_C_int{1, 54}}, ++ {"kern.stackgap_random", []_C_int{1, 50}}, ++ {"kern.sysvipc_info", []_C_int{1, 51}}, ++ {"kern.sysvmsg", []_C_int{1, 34}}, ++ {"kern.sysvsem", []_C_int{1, 35}}, ++ {"kern.sysvshm", []_C_int{1, 36}}, ++ {"kern.timecounter.choice", []_C_int{1, 69, 4}}, ++ {"kern.timecounter.hardware", []_C_int{1, 69, 3}}, ++ {"kern.timecounter.tick", []_C_int{1, 69, 1}}, ++ {"kern.timecounter.timestepwarnings", []_C_int{1, 69, 2}}, ++ {"kern.tty.tk_cancc", []_C_int{1, 44, 4}}, ++ {"kern.tty.tk_nin", []_C_int{1, 44, 1}}, ++ {"kern.tty.tk_nout", []_C_int{1, 44, 2}}, ++ {"kern.tty.tk_rawcc", []_C_int{1, 44, 3}}, ++ {"kern.tty.ttyinfo", []_C_int{1, 44, 5}}, ++ {"kern.ttycount", []_C_int{1, 57}}, ++ {"kern.version", []_C_int{1, 4}}, ++ {"kern.watchdog.auto", []_C_int{1, 64, 2}}, ++ {"kern.watchdog.period", []_C_int{1, 64, 1}}, ++ {"kern.witnesswatch", []_C_int{1, 53}}, ++ {"kern.wxabort", []_C_int{1, 74}}, ++ {"net.bpf.bufsize", []_C_int{4, 31, 1}}, ++ {"net.bpf.maxbufsize", []_C_int{4, 31, 2}}, ++ {"net.inet.ah.enable", []_C_int{4, 2, 51, 1}}, ++ {"net.inet.ah.stats", []_C_int{4, 2, 51, 2}}, ++ {"net.inet.carp.allow", []_C_int{4, 2, 112, 1}}, ++ {"net.inet.carp.log", []_C_int{4, 2, 112, 3}}, ++ {"net.inet.carp.preempt", []_C_int{4, 2, 112, 2}}, ++ {"net.inet.carp.stats", []_C_int{4, 2, 112, 4}}, ++ {"net.inet.divert.recvspace", []_C_int{4, 2, 258, 1}}, ++ {"net.inet.divert.sendspace", []_C_int{4, 2, 258, 2}}, ++ {"net.inet.divert.stats", []_C_int{4, 2, 258, 3}}, ++ {"net.inet.esp.enable", []_C_int{4, 2, 50, 1}}, ++ {"net.inet.esp.stats", []_C_int{4, 2, 50, 4}}, ++ {"net.inet.esp.udpencap", []_C_int{4, 2, 50, 2}}, ++ {"net.inet.esp.udpencap_port", []_C_int{4, 2, 50, 3}}, ++ {"net.inet.etherip.allow", []_C_int{4, 2, 97, 1}}, ++ {"net.inet.etherip.stats", []_C_int{4, 2, 97, 2}}, ++ {"net.inet.gre.allow", []_C_int{4, 2, 47, 1}}, ++ {"net.inet.gre.wccp", []_C_int{4, 2, 47, 2}}, ++ {"net.inet.icmp.bmcastecho", []_C_int{4, 2, 1, 2}}, ++ {"net.inet.icmp.errppslimit", []_C_int{4, 2, 1, 3}}, ++ {"net.inet.icmp.maskrepl", []_C_int{4, 2, 1, 1}}, ++ {"net.inet.icmp.rediraccept", []_C_int{4, 2, 1, 4}}, ++ {"net.inet.icmp.redirtimeout", []_C_int{4, 2, 1, 5}}, ++ {"net.inet.icmp.stats", []_C_int{4, 2, 1, 7}}, ++ {"net.inet.icmp.tstamprepl", []_C_int{4, 2, 1, 6}}, ++ {"net.inet.igmp.stats", []_C_int{4, 2, 2, 1}}, ++ {"net.inet.ip.arpdown", []_C_int{4, 2, 0, 40}}, ++ {"net.inet.ip.arpqueued", []_C_int{4, 2, 0, 36}}, ++ {"net.inet.ip.arptimeout", []_C_int{4, 2, 0, 39}}, ++ {"net.inet.ip.encdebug", []_C_int{4, 2, 0, 12}}, ++ {"net.inet.ip.forwarding", []_C_int{4, 2, 0, 1}}, ++ {"net.inet.ip.ifq.congestion", []_C_int{4, 2, 0, 30, 4}}, ++ {"net.inet.ip.ifq.drops", []_C_int{4, 2, 0, 30, 3}}, ++ {"net.inet.ip.ifq.len", []_C_int{4, 2, 0, 30, 1}}, ++ {"net.inet.ip.ifq.maxlen", []_C_int{4, 2, 0, 30, 2}}, ++ {"net.inet.ip.maxqueue", []_C_int{4, 2, 0, 11}}, ++ {"net.inet.ip.mforwarding", []_C_int{4, 2, 0, 31}}, ++ {"net.inet.ip.mrtmfc", []_C_int{4, 2, 0, 37}}, ++ {"net.inet.ip.mrtproto", []_C_int{4, 2, 0, 34}}, ++ {"net.inet.ip.mrtstats", []_C_int{4, 2, 0, 35}}, ++ {"net.inet.ip.mrtvif", []_C_int{4, 2, 0, 38}}, ++ {"net.inet.ip.mtu", []_C_int{4, 2, 0, 4}}, ++ {"net.inet.ip.mtudisc", []_C_int{4, 2, 0, 27}}, ++ {"net.inet.ip.mtudisctimeout", []_C_int{4, 2, 0, 28}}, ++ {"net.inet.ip.multipath", []_C_int{4, 2, 0, 32}}, ++ {"net.inet.ip.portfirst", []_C_int{4, 2, 0, 7}}, ++ {"net.inet.ip.porthifirst", []_C_int{4, 2, 0, 9}}, ++ {"net.inet.ip.porthilast", []_C_int{4, 2, 0, 10}}, ++ {"net.inet.ip.portlast", []_C_int{4, 2, 0, 8}}, ++ {"net.inet.ip.redirect", []_C_int{4, 2, 0, 2}}, ++ {"net.inet.ip.sourceroute", []_C_int{4, 2, 0, 5}}, ++ {"net.inet.ip.stats", []_C_int{4, 2, 0, 33}}, ++ {"net.inet.ip.ttl", []_C_int{4, 2, 0, 3}}, ++ {"net.inet.ipcomp.enable", []_C_int{4, 2, 108, 1}}, ++ {"net.inet.ipcomp.stats", []_C_int{4, 2, 108, 2}}, ++ {"net.inet.ipip.allow", []_C_int{4, 2, 4, 1}}, ++ {"net.inet.ipip.stats", []_C_int{4, 2, 4, 2}}, ++ {"net.inet.mobileip.allow", []_C_int{4, 2, 55, 1}}, ++ {"net.inet.pfsync.stats", []_C_int{4, 2, 240, 1}}, ++ {"net.inet.tcp.ackonpush", []_C_int{4, 2, 6, 13}}, ++ {"net.inet.tcp.always_keepalive", []_C_int{4, 2, 6, 22}}, ++ {"net.inet.tcp.baddynamic", []_C_int{4, 2, 6, 6}}, ++ {"net.inet.tcp.drop", []_C_int{4, 2, 6, 19}}, ++ {"net.inet.tcp.ecn", []_C_int{4, 2, 6, 14}}, ++ {"net.inet.tcp.ident", []_C_int{4, 2, 6, 9}}, ++ {"net.inet.tcp.keepidle", []_C_int{4, 2, 6, 3}}, ++ {"net.inet.tcp.keepinittime", []_C_int{4, 2, 6, 2}}, ++ {"net.inet.tcp.keepintvl", []_C_int{4, 2, 6, 4}}, ++ {"net.inet.tcp.mssdflt", []_C_int{4, 2, 6, 11}}, ++ {"net.inet.tcp.reasslimit", []_C_int{4, 2, 6, 18}}, ++ {"net.inet.tcp.rfc1323", []_C_int{4, 2, 6, 1}}, ++ {"net.inet.tcp.rfc3390", []_C_int{4, 2, 6, 17}}, ++ {"net.inet.tcp.rootonly", []_C_int{4, 2, 6, 24}}, ++ {"net.inet.tcp.rstppslimit", []_C_int{4, 2, 6, 12}}, ++ {"net.inet.tcp.sack", []_C_int{4, 2, 6, 10}}, ++ {"net.inet.tcp.sackholelimit", []_C_int{4, 2, 6, 20}}, ++ {"net.inet.tcp.slowhz", []_C_int{4, 2, 6, 5}}, ++ {"net.inet.tcp.stats", []_C_int{4, 2, 6, 21}}, ++ {"net.inet.tcp.synbucketlimit", []_C_int{4, 2, 6, 16}}, ++ {"net.inet.tcp.syncachelimit", []_C_int{4, 2, 6, 15}}, ++ {"net.inet.tcp.synhashsize", []_C_int{4, 2, 6, 25}}, ++ {"net.inet.tcp.synuselimit", []_C_int{4, 2, 6, 23}}, ++ {"net.inet.udp.baddynamic", []_C_int{4, 2, 17, 2}}, ++ {"net.inet.udp.checksum", []_C_int{4, 2, 17, 1}}, ++ {"net.inet.udp.recvspace", []_C_int{4, 2, 17, 3}}, ++ {"net.inet.udp.rootonly", []_C_int{4, 2, 17, 6}}, ++ {"net.inet.udp.sendspace", []_C_int{4, 2, 17, 4}}, ++ {"net.inet.udp.stats", []_C_int{4, 2, 17, 5}}, ++ {"net.inet6.divert.recvspace", []_C_int{4, 24, 86, 1}}, ++ {"net.inet6.divert.sendspace", []_C_int{4, 24, 86, 2}}, ++ {"net.inet6.divert.stats", []_C_int{4, 24, 86, 3}}, ++ {"net.inet6.icmp6.errppslimit", []_C_int{4, 24, 30, 14}}, ++ {"net.inet6.icmp6.mtudisc_hiwat", []_C_int{4, 24, 30, 16}}, ++ {"net.inet6.icmp6.mtudisc_lowat", []_C_int{4, 24, 30, 17}}, ++ {"net.inet6.icmp6.nd6_debug", []_C_int{4, 24, 30, 18}}, ++ {"net.inet6.icmp6.nd6_delay", []_C_int{4, 24, 30, 8}}, ++ {"net.inet6.icmp6.nd6_maxnudhint", []_C_int{4, 24, 30, 15}}, ++ {"net.inet6.icmp6.nd6_mmaxtries", []_C_int{4, 24, 30, 10}}, ++ {"net.inet6.icmp6.nd6_umaxtries", []_C_int{4, 24, 30, 9}}, ++ {"net.inet6.icmp6.redirtimeout", []_C_int{4, 24, 30, 3}}, ++ {"net.inet6.ip6.auto_flowlabel", []_C_int{4, 24, 17, 17}}, ++ {"net.inet6.ip6.dad_count", []_C_int{4, 24, 17, 16}}, ++ {"net.inet6.ip6.dad_pending", []_C_int{4, 24, 17, 49}}, ++ {"net.inet6.ip6.defmcasthlim", []_C_int{4, 24, 17, 18}}, ++ {"net.inet6.ip6.forwarding", []_C_int{4, 24, 17, 1}}, ++ {"net.inet6.ip6.forwsrcrt", []_C_int{4, 24, 17, 5}}, ++ {"net.inet6.ip6.hdrnestlimit", []_C_int{4, 24, 17, 15}}, ++ {"net.inet6.ip6.hlim", []_C_int{4, 24, 17, 3}}, ++ {"net.inet6.ip6.log_interval", []_C_int{4, 24, 17, 14}}, ++ {"net.inet6.ip6.maxdynroutes", []_C_int{4, 24, 17, 48}}, ++ {"net.inet6.ip6.maxfragpackets", []_C_int{4, 24, 17, 9}}, ++ {"net.inet6.ip6.maxfrags", []_C_int{4, 24, 17, 41}}, ++ {"net.inet6.ip6.mforwarding", []_C_int{4, 24, 17, 42}}, ++ {"net.inet6.ip6.mrtmfc", []_C_int{4, 24, 17, 53}}, ++ {"net.inet6.ip6.mrtmif", []_C_int{4, 24, 17, 52}}, ++ {"net.inet6.ip6.mrtproto", []_C_int{4, 24, 17, 8}}, ++ {"net.inet6.ip6.mtudisctimeout", []_C_int{4, 24, 17, 50}}, ++ {"net.inet6.ip6.multicast_mtudisc", []_C_int{4, 24, 17, 44}}, ++ {"net.inet6.ip6.multipath", []_C_int{4, 24, 17, 43}}, ++ {"net.inet6.ip6.neighborgcthresh", []_C_int{4, 24, 17, 45}}, ++ {"net.inet6.ip6.redirect", []_C_int{4, 24, 17, 2}}, ++ {"net.inet6.ip6.soiikey", []_C_int{4, 24, 17, 54}}, ++ {"net.inet6.ip6.sourcecheck", []_C_int{4, 24, 17, 10}}, ++ {"net.inet6.ip6.sourcecheck_logint", []_C_int{4, 24, 17, 11}}, ++ {"net.inet6.ip6.use_deprecated", []_C_int{4, 24, 17, 21}}, ++ {"net.key.sadb_dump", []_C_int{4, 30, 1}}, ++ {"net.key.spd_dump", []_C_int{4, 30, 2}}, ++ {"net.mpls.ifq.congestion", []_C_int{4, 33, 3, 4}}, ++ {"net.mpls.ifq.drops", []_C_int{4, 33, 3, 3}}, ++ {"net.mpls.ifq.len", []_C_int{4, 33, 3, 1}}, ++ {"net.mpls.ifq.maxlen", []_C_int{4, 33, 3, 2}}, ++ {"net.mpls.mapttl_ip", []_C_int{4, 33, 5}}, ++ {"net.mpls.mapttl_ip6", []_C_int{4, 33, 6}}, ++ {"net.mpls.maxloop_inkernel", []_C_int{4, 33, 4}}, ++ {"net.mpls.ttl", []_C_int{4, 33, 2}}, ++ {"net.pflow.stats", []_C_int{4, 34, 1}}, ++ {"net.pipex.enable", []_C_int{4, 35, 1}}, ++ {"vm.anonmin", []_C_int{2, 7}}, ++ {"vm.loadavg", []_C_int{2, 2}}, ++ {"vm.malloc_conf", []_C_int{2, 12}}, ++ {"vm.maxslp", []_C_int{2, 10}}, ++ {"vm.nkmempages", []_C_int{2, 6}}, ++ {"vm.psstrings", []_C_int{2, 3}}, ++ {"vm.swapencrypt.enable", []_C_int{2, 5, 0}}, ++ {"vm.swapencrypt.keyscreated", []_C_int{2, 5, 1}}, ++ {"vm.swapencrypt.keysdeleted", []_C_int{2, 5, 2}}, ++ {"vm.uspace", []_C_int{2, 11}}, ++ {"vm.uvmexp", []_C_int{2, 4}}, ++ {"vm.vmmeter", []_C_int{2, 1}}, ++ {"vm.vnodemin", []_C_int{2, 9}}, ++ {"vm.vtextmin", []_C_int{2, 8}}, ++} diff --git a/lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_zsysnum_openbsd_riscv64_go b/lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_zsysnum_openbsd_riscv64_go new file mode 100644 index 000000000000..94d5c4eb5bc3 --- /dev/null +++ b/lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_zsysnum_openbsd_riscv64_go @@ -0,0 +1,222 @@ +Index: src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_riscv64.go +--- src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_riscv64.go.orig ++++ src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_riscv64.go +@@ -0,0 +1,218 @@ ++// go run mksysnum.go https://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master ++// Code generated by the command above; see README.md. DO NOT EDIT. ++ ++//go:build riscv64 && openbsd ++// +build riscv64,openbsd ++ ++package unix ++ ++const ( ++ SYS_EXIT = 1 // { void sys_exit(int rval); } ++ SYS_FORK = 2 // { int sys_fork(void); } ++ SYS_READ = 3 // { ssize_t sys_read(int fd, void *buf, size_t nbyte); } ++ SYS_WRITE = 4 // { ssize_t sys_write(int fd, const void *buf, size_t nbyte); } ++ SYS_OPEN = 5 // { int sys_open(const char *path, int flags, ... mode_t mode); } ++ SYS_CLOSE = 6 // { int sys_close(int fd); } ++ SYS_GETENTROPY = 7 // { int sys_getentropy(void *buf, size_t nbyte); } ++ SYS___TFORK = 8 // { int sys___tfork(const struct __tfork *param, size_t psize); } ++ SYS_LINK = 9 // { int sys_link(const char *path, const char *link); } ++ SYS_UNLINK = 10 // { int sys_unlink(const char *path); } ++ SYS_WAIT4 = 11 // { pid_t sys_wait4(pid_t pid, int *status, int options, struct rusage *rusage); } ++ SYS_CHDIR = 12 // { int sys_chdir(const char *path); } ++ SYS_FCHDIR = 13 // { int sys_fchdir(int fd); } ++ SYS_MKNOD = 14 // { int sys_mknod(const char *path, mode_t mode, dev_t dev); } ++ SYS_CHMOD = 15 // { int sys_chmod(const char *path, mode_t mode); } ++ SYS_CHOWN = 16 // { int sys_chown(const char *path, uid_t uid, gid_t gid); } ++ SYS_OBREAK = 17 // { int sys_obreak(char *nsize); } break ++ SYS_GETDTABLECOUNT = 18 // { int sys_getdtablecount(void); } ++ SYS_GETRUSAGE = 19 // { int sys_getrusage(int who, struct rusage *rusage); } ++ SYS_GETPID = 20 // { pid_t sys_getpid(void); } ++ SYS_MOUNT = 21 // { int sys_mount(const char *type, const char *path, int flags, void *data); } ++ SYS_UNMOUNT = 22 // { int sys_unmount(const char *path, int flags); } ++ SYS_SETUID = 23 // { int sys_setuid(uid_t uid); } ++ SYS_GETUID = 24 // { uid_t sys_getuid(void); } ++ SYS_GETEUID = 25 // { uid_t sys_geteuid(void); } ++ SYS_PTRACE = 26 // { int sys_ptrace(int req, pid_t pid, caddr_t addr, int data); } ++ SYS_RECVMSG = 27 // { ssize_t sys_recvmsg(int s, struct msghdr *msg, int flags); } ++ SYS_SENDMSG = 28 // { ssize_t sys_sendmsg(int s, const struct msghdr *msg, int flags); } ++ SYS_RECVFROM = 29 // { ssize_t sys_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlenaddr); } ++ SYS_ACCEPT = 30 // { int sys_accept(int s, struct sockaddr *name, socklen_t *anamelen); } ++ SYS_GETPEERNAME = 31 // { int sys_getpeername(int fdes, struct sockaddr *asa, socklen_t *alen); } ++ SYS_GETSOCKNAME = 32 // { int sys_getsockname(int fdes, struct sockaddr *asa, socklen_t *alen); } ++ SYS_ACCESS = 33 // { int sys_access(const char *path, int amode); } ++ SYS_CHFLAGS = 34 // { int sys_chflags(const char *path, u_int flags); } ++ SYS_FCHFLAGS = 35 // { int sys_fchflags(int fd, u_int flags); } ++ SYS_SYNC = 36 // { void sys_sync(void); } ++ SYS_STAT = 38 // { int sys_stat(const char *path, struct stat *ub); } ++ SYS_GETPPID = 39 // { pid_t sys_getppid(void); } ++ SYS_LSTAT = 40 // { int sys_lstat(const char *path, struct stat *ub); } ++ SYS_DUP = 41 // { int sys_dup(int fd); } ++ SYS_FSTATAT = 42 // { int sys_fstatat(int fd, const char *path, struct stat *buf, int flag); } ++ SYS_GETEGID = 43 // { gid_t sys_getegid(void); } ++ SYS_PROFIL = 44 // { int sys_profil(caddr_t samples, size_t size, u_long offset, u_int scale); } ++ SYS_KTRACE = 45 // { int sys_ktrace(const char *fname, int ops, int facs, pid_t pid); } ++ SYS_SIGACTION = 46 // { int sys_sigaction(int signum, const struct sigaction *nsa, struct sigaction *osa); } ++ SYS_GETGID = 47 // { gid_t sys_getgid(void); } ++ SYS_SIGPROCMASK = 48 // { int sys_sigprocmask(int how, sigset_t mask); } ++ SYS_SETLOGIN = 50 // { int sys_setlogin(const char *namebuf); } ++ SYS_ACCT = 51 // { int sys_acct(const char *path); } ++ SYS_SIGPENDING = 52 // { int sys_sigpending(void); } ++ SYS_FSTAT = 53 // { int sys_fstat(int fd, struct stat *sb); } ++ SYS_IOCTL = 54 // { int sys_ioctl(int fd, u_long com, ... void *data); } ++ SYS_REBOOT = 55 // { int sys_reboot(int opt); } ++ SYS_REVOKE = 56 // { int sys_revoke(const char *path); } ++ SYS_SYMLINK = 57 // { int sys_symlink(const char *path, const char *link); } ++ SYS_READLINK = 58 // { ssize_t sys_readlink(const char *path, char *buf, size_t count); } ++ SYS_EXECVE = 59 // { int sys_execve(const char *path, char * const *argp, char * const *envp); } ++ SYS_UMASK = 60 // { mode_t sys_umask(mode_t newmask); } ++ SYS_CHROOT = 61 // { int sys_chroot(const char *path); } ++ SYS_GETFSSTAT = 62 // { int sys_getfsstat(struct statfs *buf, size_t bufsize, int flags); } ++ SYS_STATFS = 63 // { int sys_statfs(const char *path, struct statfs *buf); } ++ SYS_FSTATFS = 64 // { int sys_fstatfs(int fd, struct statfs *buf); } ++ SYS_FHSTATFS = 65 // { int sys_fhstatfs(const fhandle_t *fhp, struct statfs *buf); } ++ SYS_VFORK = 66 // { int sys_vfork(void); } ++ SYS_GETTIMEOFDAY = 67 // { int sys_gettimeofday(struct timeval *tp, struct timezone *tzp); } ++ SYS_SETTIMEOFDAY = 68 // { int sys_settimeofday(const struct timeval *tv, const struct timezone *tzp); } ++ SYS_SETITIMER = 69 // { int sys_setitimer(int which, const struct itimerval *itv, struct itimerval *oitv); } ++ SYS_GETITIMER = 70 // { int sys_getitimer(int which, struct itimerval *itv); } ++ SYS_SELECT = 71 // { int sys_select(int nd, fd_set *in, fd_set *ou, fd_set *ex, struct timeval *tv); } ++ SYS_KEVENT = 72 // { int sys_kevent(int fd, const struct kevent *changelist, int nchanges, struct kevent *eventlist, int nevents, const struct timespec *timeout); } ++ SYS_MUNMAP = 73 // { int sys_munmap(void *addr, size_t len); } ++ SYS_MPROTECT = 74 // { int sys_mprotect(void *addr, size_t len, int prot); } ++ SYS_MADVISE = 75 // { int sys_madvise(void *addr, size_t len, int behav); } ++ SYS_UTIMES = 76 // { int sys_utimes(const char *path, const struct timeval *tptr); } ++ SYS_FUTIMES = 77 // { int sys_futimes(int fd, const struct timeval *tptr); } ++ SYS_GETGROUPS = 79 // { int sys_getgroups(int gidsetsize, gid_t *gidset); } ++ SYS_SETGROUPS = 80 // { int sys_setgroups(int gidsetsize, const gid_t *gidset); } ++ SYS_GETPGRP = 81 // { int sys_getpgrp(void); } ++ SYS_SETPGID = 82 // { int sys_setpgid(pid_t pid, pid_t pgid); } ++ SYS_FUTEX = 83 // { int sys_futex(uint32_t *f, int op, int val, const struct timespec *timeout, uint32_t *g); } ++ SYS_UTIMENSAT = 84 // { int sys_utimensat(int fd, const char *path, const struct timespec *times, int flag); } ++ SYS_FUTIMENS = 85 // { int sys_futimens(int fd, const struct timespec *times); } ++ SYS_KBIND = 86 // { int sys_kbind(const struct __kbind *param, size_t psize, int64_t proc_cookie); } ++ SYS_CLOCK_GETTIME = 87 // { int sys_clock_gettime(clockid_t clock_id, struct timespec *tp); } ++ SYS_CLOCK_SETTIME = 88 // { int sys_clock_settime(clockid_t clock_id, const struct timespec *tp); } ++ SYS_CLOCK_GETRES = 89 // { int sys_clock_getres(clockid_t clock_id, struct timespec *tp); } ++ SYS_DUP2 = 90 // { int sys_dup2(int from, int to); } ++ SYS_NANOSLEEP = 91 // { int sys_nanosleep(const struct timespec *rqtp, struct timespec *rmtp); } ++ SYS_FCNTL = 92 // { int sys_fcntl(int fd, int cmd, ... void *arg); } ++ SYS_ACCEPT4 = 93 // { int sys_accept4(int s, struct sockaddr *name, socklen_t *anamelen, int flags); } ++ SYS___THRSLEEP = 94 // { int sys___thrsleep(const volatile void *ident, clockid_t clock_id, const struct timespec *tp, void *lock, const int *abort); } ++ SYS_FSYNC = 95 // { int sys_fsync(int fd); } ++ SYS_SETPRIORITY = 96 // { int sys_setpriority(int which, id_t who, int prio); } ++ SYS_SOCKET = 97 // { int sys_socket(int domain, int type, int protocol); } ++ SYS_CONNECT = 98 // { int sys_connect(int s, const struct sockaddr *name, socklen_t namelen); } ++ SYS_GETDENTS = 99 // { int sys_getdents(int fd, void *buf, size_t buflen); } ++ SYS_GETPRIORITY = 100 // { int sys_getpriority(int which, id_t who); } ++ SYS_PIPE2 = 101 // { int sys_pipe2(int *fdp, int flags); } ++ SYS_DUP3 = 102 // { int sys_dup3(int from, int to, int flags); } ++ SYS_SIGRETURN = 103 // { int sys_sigreturn(struct sigcontext *sigcntxp); } ++ SYS_BIND = 104 // { int sys_bind(int s, const struct sockaddr *name, socklen_t namelen); } ++ SYS_SETSOCKOPT = 105 // { int sys_setsockopt(int s, int level, int name, const void *val, socklen_t valsize); } ++ SYS_LISTEN = 106 // { int sys_listen(int s, int backlog); } ++ SYS_CHFLAGSAT = 107 // { int sys_chflagsat(int fd, const char *path, u_int flags, int atflags); } ++ SYS_PLEDGE = 108 // { int sys_pledge(const char *promises, const char *execpromises); } ++ SYS_PPOLL = 109 // { int sys_ppoll(struct pollfd *fds, u_int nfds, const struct timespec *ts, const sigset_t *mask); } ++ SYS_PSELECT = 110 // { int sys_pselect(int nd, fd_set *in, fd_set *ou, fd_set *ex, const struct timespec *ts, const sigset_t *mask); } ++ SYS_SIGSUSPEND = 111 // { int sys_sigsuspend(int mask); } ++ SYS_SENDSYSLOG = 112 // { int sys_sendsyslog(const char *buf, size_t nbyte, int flags); } ++ SYS_UNVEIL = 114 // { int sys_unveil(const char *path, const char *permissions); } ++ SYS_GETSOCKOPT = 118 // { int sys_getsockopt(int s, int level, int name, void *val, socklen_t *avalsize); } ++ SYS_THRKILL = 119 // { int sys_thrkill(pid_t tid, int signum, void *tcb); } ++ SYS_READV = 120 // { ssize_t sys_readv(int fd, const struct iovec *iovp, int iovcnt); } ++ SYS_WRITEV = 121 // { ssize_t sys_writev(int fd, const struct iovec *iovp, int iovcnt); } ++ SYS_KILL = 122 // { int sys_kill(int pid, int signum); } ++ SYS_FCHOWN = 123 // { int sys_fchown(int fd, uid_t uid, gid_t gid); } ++ SYS_FCHMOD = 124 // { int sys_fchmod(int fd, mode_t mode); } ++ SYS_SETREUID = 126 // { int sys_setreuid(uid_t ruid, uid_t euid); } ++ SYS_SETREGID = 127 // { int sys_setregid(gid_t rgid, gid_t egid); } ++ SYS_RENAME = 128 // { int sys_rename(const char *from, const char *to); } ++ SYS_FLOCK = 131 // { int sys_flock(int fd, int how); } ++ SYS_MKFIFO = 132 // { int sys_mkfifo(const char *path, mode_t mode); } ++ SYS_SENDTO = 133 // { ssize_t sys_sendto(int s, const void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen); } ++ SYS_SHUTDOWN = 134 // { int sys_shutdown(int s, int how); } ++ SYS_SOCKETPAIR = 135 // { int sys_socketpair(int domain, int type, int protocol, int *rsv); } ++ SYS_MKDIR = 136 // { int sys_mkdir(const char *path, mode_t mode); } ++ SYS_RMDIR = 137 // { int sys_rmdir(const char *path); } ++ SYS_ADJTIME = 140 // { int sys_adjtime(const struct timeval *delta, struct timeval *olddelta); } ++ SYS_GETLOGIN_R = 141 // { int sys_getlogin_r(char *namebuf, u_int namelen); } ++ SYS_SETSID = 147 // { int sys_setsid(void); } ++ SYS_QUOTACTL = 148 // { int sys_quotactl(const char *path, int cmd, int uid, char *arg); } ++ SYS_NFSSVC = 155 // { int sys_nfssvc(int flag, void *argp); } ++ SYS_GETFH = 161 // { int sys_getfh(const char *fname, fhandle_t *fhp); } ++ SYS_SYSARCH = 165 // { int sys_sysarch(int op, void *parms); } ++ SYS_PREAD = 173 // { ssize_t sys_pread(int fd, void *buf, size_t nbyte, int pad, off_t offset); } ++ SYS_PWRITE = 174 // { ssize_t sys_pwrite(int fd, const void *buf, size_t nbyte, int pad, off_t offset); } ++ SYS_SETGID = 181 // { int sys_setgid(gid_t gid); } ++ SYS_SETEGID = 182 // { int sys_setegid(gid_t egid); } ++ SYS_SETEUID = 183 // { int sys_seteuid(uid_t euid); } ++ SYS_PATHCONF = 191 // { long sys_pathconf(const char *path, int name); } ++ SYS_FPATHCONF = 192 // { long sys_fpathconf(int fd, int name); } ++ SYS_SWAPCTL = 193 // { int sys_swapctl(int cmd, const void *arg, int misc); } ++ SYS_GETRLIMIT = 194 // { int sys_getrlimit(int which, struct rlimit *rlp); } ++ SYS_SETRLIMIT = 195 // { int sys_setrlimit(int which, const struct rlimit *rlp); } ++ SYS_MMAP = 197 // { void *sys_mmap(void *addr, size_t len, int prot, int flags, int fd, long pad, off_t pos); } ++ SYS_LSEEK = 199 // { off_t sys_lseek(int fd, int pad, off_t offset, int whence); } ++ SYS_TRUNCATE = 200 // { int sys_truncate(const char *path, int pad, off_t length); } ++ SYS_FTRUNCATE = 201 // { int sys_ftruncate(int fd, int pad, off_t length); } ++ SYS_SYSCTL = 202 // { int sys_sysctl(const int *name, u_int namelen, void *old, size_t *oldlenp, void *new, size_t newlen); } ++ SYS_MLOCK = 203 // { int sys_mlock(const void *addr, size_t len); } ++ SYS_MUNLOCK = 204 // { int sys_munlock(const void *addr, size_t len); } ++ SYS_GETPGID = 207 // { pid_t sys_getpgid(pid_t pid); } ++ SYS_UTRACE = 209 // { int sys_utrace(const char *label, const void *addr, size_t len); } ++ SYS_SEMGET = 221 // { int sys_semget(key_t key, int nsems, int semflg); } ++ SYS_MSGGET = 225 // { int sys_msgget(key_t key, int msgflg); } ++ SYS_MSGSND = 226 // { int sys_msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg); } ++ SYS_MSGRCV = 227 // { int sys_msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg); } ++ SYS_SHMAT = 228 // { void *sys_shmat(int shmid, const void *shmaddr, int shmflg); } ++ SYS_SHMDT = 230 // { int sys_shmdt(const void *shmaddr); } ++ SYS_MINHERIT = 250 // { int sys_minherit(void *addr, size_t len, int inherit); } ++ SYS_POLL = 252 // { int sys_poll(struct pollfd *fds, u_int nfds, int timeout); } ++ SYS_ISSETUGID = 253 // { int sys_issetugid(void); } ++ SYS_LCHOWN = 254 // { int sys_lchown(const char *path, uid_t uid, gid_t gid); } ++ SYS_GETSID = 255 // { pid_t sys_getsid(pid_t pid); } ++ SYS_MSYNC = 256 // { int sys_msync(void *addr, size_t len, int flags); } ++ SYS_PIPE = 263 // { int sys_pipe(int *fdp); } ++ SYS_FHOPEN = 264 // { int sys_fhopen(const fhandle_t *fhp, int flags); } ++ SYS_PREADV = 267 // { ssize_t sys_preadv(int fd, const struct iovec *iovp, int iovcnt, int pad, off_t offset); } ++ SYS_PWRITEV = 268 // { ssize_t sys_pwritev(int fd, const struct iovec *iovp, int iovcnt, int pad, off_t offset); } ++ SYS_KQUEUE = 269 // { int sys_kqueue(void); } ++ SYS_MLOCKALL = 271 // { int sys_mlockall(int flags); } ++ SYS_MUNLOCKALL = 272 // { int sys_munlockall(void); } ++ SYS_GETRESUID = 281 // { int sys_getresuid(uid_t *ruid, uid_t *euid, uid_t *suid); } ++ SYS_SETRESUID = 282 // { int sys_setresuid(uid_t ruid, uid_t euid, uid_t suid); } ++ SYS_GETRESGID = 283 // { int sys_getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid); } ++ SYS_SETRESGID = 284 // { int sys_setresgid(gid_t rgid, gid_t egid, gid_t sgid); } ++ SYS_MQUERY = 286 // { void *sys_mquery(void *addr, size_t len, int prot, int flags, int fd, long pad, off_t pos); } ++ SYS_CLOSEFROM = 287 // { int sys_closefrom(int fd); } ++ SYS_SIGALTSTACK = 288 // { int sys_sigaltstack(const struct sigaltstack *nss, struct sigaltstack *oss); } ++ SYS_SHMGET = 289 // { int sys_shmget(key_t key, size_t size, int shmflg); } ++ SYS_SEMOP = 290 // { int sys_semop(int semid, struct sembuf *sops, size_t nsops); } ++ SYS_FHSTAT = 294 // { int sys_fhstat(const fhandle_t *fhp, struct stat *sb); } ++ SYS___SEMCTL = 295 // { int sys___semctl(int semid, int semnum, int cmd, union semun *arg); } ++ SYS_SHMCTL = 296 // { int sys_shmctl(int shmid, int cmd, struct shmid_ds *buf); } ++ SYS_MSGCTL = 297 // { int sys_msgctl(int msqid, int cmd, struct msqid_ds *buf); } ++ SYS_SCHED_YIELD = 298 // { int sys_sched_yield(void); } ++ SYS_GETTHRID = 299 // { pid_t sys_getthrid(void); } ++ SYS___THRWAKEUP = 301 // { int sys___thrwakeup(const volatile void *ident, int n); } ++ SYS___THREXIT = 302 // { void sys___threxit(pid_t *notdead); } ++ SYS___THRSIGDIVERT = 303 // { int sys___thrsigdivert(sigset_t sigmask, siginfo_t *info, const struct timespec *timeout); } ++ SYS___GETCWD = 304 // { int sys___getcwd(char *buf, size_t len); } ++ SYS_ADJFREQ = 305 // { int sys_adjfreq(const int64_t *freq, int64_t *oldfreq); } ++ SYS_SETRTABLE = 310 // { int sys_setrtable(int rtableid); } ++ SYS_GETRTABLE = 311 // { int sys_getrtable(void); } ++ SYS_FACCESSAT = 313 // { int sys_faccessat(int fd, const char *path, int amode, int flag); } ++ SYS_FCHMODAT = 314 // { int sys_fchmodat(int fd, const char *path, mode_t mode, int flag); } ++ SYS_FCHOWNAT = 315 // { int sys_fchownat(int fd, const char *path, uid_t uid, gid_t gid, int flag); } ++ SYS_LINKAT = 317 // { int sys_linkat(int fd1, const char *path1, int fd2, const char *path2, int flag); } ++ SYS_MKDIRAT = 318 // { int sys_mkdirat(int fd, const char *path, mode_t mode); } ++ SYS_MKFIFOAT = 319 // { int sys_mkfifoat(int fd, const char *path, mode_t mode); } ++ SYS_MKNODAT = 320 // { int sys_mknodat(int fd, const char *path, mode_t mode, dev_t dev); } ++ SYS_OPENAT = 321 // { int sys_openat(int fd, const char *path, int flags, ... mode_t mode); } ++ SYS_READLINKAT = 322 // { ssize_t sys_readlinkat(int fd, const char *path, char *buf, size_t count); } ++ SYS_RENAMEAT = 323 // { int sys_renameat(int fromfd, const char *from, int tofd, const char *to); } ++ SYS_SYMLINKAT = 324 // { int sys_symlinkat(const char *path, int fd, const char *link); } ++ SYS_UNLINKAT = 325 // { int sys_unlinkat(int fd, const char *path, int flag); } ++ SYS___SET_TCB = 329 // { void sys___set_tcb(void *tcb); } ++ SYS___GET_TCB = 330 // { void *sys___get_tcb(void); } ++) diff --git a/lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_ztypes_openbsd_riscv64_go b/lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_ztypes_openbsd_riscv64_go new file mode 100644 index 000000000000..614c053426ee --- /dev/null +++ b/lang/go/patches/patch-src_cmd_vendor_golang_org_x_sys_unix_ztypes_openbsd_riscv64_go @@ -0,0 +1,572 @@ +Index: src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_riscv64.go +--- src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_riscv64.go.orig ++++ src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_riscv64.go +@@ -0,0 +1,568 @@ ++// cgo -godefs -- -fsigned-char types_openbsd.go | go run mkpost.go ++// Code generated by the command above; see README.md. DO NOT EDIT. ++ ++//go:build riscv64 && openbsd ++// +build riscv64,openbsd ++ ++package unix ++ ++const ( ++ SizeofPtr = 0x8 ++ SizeofShort = 0x2 ++ SizeofInt = 0x4 ++ SizeofLong = 0x8 ++ SizeofLongLong = 0x8 ++) ++ ++type ( ++ _C_short int16 ++ _C_int int32 ++ _C_long int64 ++ _C_long_long int64 ++) ++ ++type Timespec struct { ++ Sec int64 ++ Nsec int64 ++} ++ ++type Timeval struct { ++ Sec int64 ++ Usec int64 ++} ++ ++type Rusage struct { ++ Utime Timeval ++ Stime Timeval ++ Maxrss int64 ++ Ixrss int64 ++ Idrss int64 ++ Isrss int64 ++ Minflt int64 ++ Majflt int64 ++ Nswap int64 ++ Inblock int64 ++ Oublock int64 ++ Msgsnd int64 ++ Msgrcv int64 ++ Nsignals int64 ++ Nvcsw int64 ++ Nivcsw int64 ++} ++ ++type Rlimit struct { ++ Cur uint64 ++ Max uint64 ++} ++ ++type _Gid_t uint32 ++ ++type Stat_t struct { ++ Mode uint32 ++ Dev int32 ++ Ino uint64 ++ Nlink uint32 ++ Uid uint32 ++ Gid uint32 ++ Rdev int32 ++ Atim Timespec ++ Mtim Timespec ++ Ctim Timespec ++ Size int64 ++ Blocks int64 ++ Blksize int32 ++ Flags uint32 ++ Gen uint32 ++ _ Timespec ++} ++ ++type Statfs_t struct { ++ F_flags uint32 ++ F_bsize uint32 ++ F_iosize uint32 ++ F_blocks uint64 ++ F_bfree uint64 ++ F_bavail int64 ++ F_files uint64 ++ F_ffree uint64 ++ F_favail int64 ++ F_syncwrites uint64 ++ F_syncreads uint64 ++ F_asyncwrites uint64 ++ F_asyncreads uint64 ++ F_fsid Fsid ++ F_namemax uint32 ++ F_owner uint32 ++ F_ctime uint64 ++ F_fstypename [16]byte ++ F_mntonname [90]byte ++ F_mntfromname [90]byte ++ F_mntfromspec [90]byte ++ _ [2]byte ++ Mount_info [160]byte ++} ++ ++type Flock_t struct { ++ Start int64 ++ Len int64 ++ Pid int32 ++ Type int16 ++ Whence int16 ++} ++ ++type Dirent struct { ++ Fileno uint64 ++ Off int64 ++ Reclen uint16 ++ Type uint8 ++ Namlen uint8 ++ _ [4]uint8 ++ Name [256]int8 ++} ++ ++type Fsid struct { ++ Val [2]int32 ++} ++ ++const ( ++ PathMax = 0x400 ++) ++ ++type RawSockaddrInet4 struct { ++ Len uint8 ++ Family uint8 ++ Port uint16 ++ Addr [4]byte /* in_addr */ ++ Zero [8]int8 ++} ++ ++type RawSockaddrInet6 struct { ++ Len uint8 ++ Family uint8 ++ Port uint16 ++ Flowinfo uint32 ++ Addr [16]byte /* in6_addr */ ++ Scope_id uint32 ++} ++ ++type RawSockaddrUnix struct { ++ Len uint8 ++ Family uint8 ++ Path [104]int8 ++} ++ ++type RawSockaddrDatalink struct { ++ Len uint8 ++ Family uint8 ++ Index uint16 ++ Type uint8 ++ Nlen uint8 ++ Alen uint8 ++ Slen uint8 ++ Data [24]int8 ++} ++ ++type RawSockaddr struct { ++ Len uint8 ++ Family uint8 ++ Data [14]int8 ++} ++ ++type RawSockaddrAny struct { ++ Addr RawSockaddr ++ Pad [92]int8 ++} ++ ++type _Socklen uint32 ++ ++type Linger struct { ++ Onoff int32 ++ Linger int32 ++} ++ ++type Iovec struct { ++ Base *byte ++ Len uint64 ++} ++ ++type IPMreq struct { ++ Multiaddr [4]byte /* in_addr */ ++ Interface [4]byte /* in_addr */ ++} ++ ++type IPv6Mreq struct { ++ Multiaddr [16]byte /* in6_addr */ ++ Interface uint32 ++} ++ ++type Msghdr struct { ++ Name *byte ++ Namelen uint32 ++ Iov *Iovec ++ Iovlen uint32 ++ Control *byte ++ Controllen uint32 ++ Flags int32 ++} ++ ++type Cmsghdr struct { ++ Len uint32 ++ Level int32 ++ Type int32 ++} ++ ++type Inet6Pktinfo struct { ++ Addr [16]byte /* in6_addr */ ++ Ifindex uint32 ++} ++ ++type IPv6MTUInfo struct { ++ Addr RawSockaddrInet6 ++ Mtu uint32 ++} ++ ++type ICMPv6Filter struct { ++ Filt [8]uint32 ++} ++ ++const ( ++ SizeofSockaddrInet4 = 0x10 ++ SizeofSockaddrInet6 = 0x1c ++ SizeofSockaddrAny = 0x6c ++ SizeofSockaddrUnix = 0x6a ++ SizeofSockaddrDatalink = 0x20 ++ SizeofLinger = 0x8 ++ SizeofIovec = 0x10 ++ SizeofIPMreq = 0x8 ++ SizeofIPv6Mreq = 0x14 ++ SizeofMsghdr = 0x30 ++ SizeofCmsghdr = 0xc ++ SizeofInet6Pktinfo = 0x14 ++ SizeofIPv6MTUInfo = 0x20 ++ SizeofICMPv6Filter = 0x20 ++) ++ ++const ( ++ PTRACE_TRACEME = 0x0 ++ PTRACE_CONT = 0x7 ++ PTRACE_KILL = 0x8 ++) ++ ++type Kevent_t struct { ++ Ident uint64 ++ Filter int16 ++ Flags uint16 ++ Fflags uint32 ++ Data int64 ++ Udata *byte ++} ++ ++type FdSet struct { ++ Bits [32]uint32 ++} ++ ++const ( ++ SizeofIfMsghdr = 0xa8 ++ SizeofIfData = 0x90 ++ SizeofIfaMsghdr = 0x18 ++ SizeofIfAnnounceMsghdr = 0x1a ++ SizeofRtMsghdr = 0x60 ++ SizeofRtMetrics = 0x38 ++) ++ ++type IfMsghdr struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Hdrlen uint16 ++ Index uint16 ++ Tableid uint16 ++ Pad1 uint8 ++ Pad2 uint8 ++ Addrs int32 ++ Flags int32 ++ Xflags int32 ++ Data IfData ++} ++ ++type IfData struct { ++ Type uint8 ++ Addrlen uint8 ++ Hdrlen uint8 ++ Link_state uint8 ++ Mtu uint32 ++ Metric uint32 ++ Rdomain uint32 ++ Baudrate uint64 ++ Ipackets uint64 ++ Ierrors uint64 ++ Opackets uint64 ++ Oerrors uint64 ++ Collisions uint64 ++ Ibytes uint64 ++ Obytes uint64 ++ Imcasts uint64 ++ Omcasts uint64 ++ Iqdrops uint64 ++ Oqdrops uint64 ++ Noproto uint64 ++ Capabilities uint32 ++ Lastchange Timeval ++} ++ ++type IfaMsghdr struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Hdrlen uint16 ++ Index uint16 ++ Tableid uint16 ++ Pad1 uint8 ++ Pad2 uint8 ++ Addrs int32 ++ Flags int32 ++ Metric int32 ++} ++ ++type IfAnnounceMsghdr struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Hdrlen uint16 ++ Index uint16 ++ What uint16 ++ Name [16]int8 ++} ++ ++type RtMsghdr struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Hdrlen uint16 ++ Index uint16 ++ Tableid uint16 ++ Priority uint8 ++ Mpls uint8 ++ Addrs int32 ++ Flags int32 ++ Fmask int32 ++ Pid int32 ++ Seq int32 ++ Errno int32 ++ Inits uint32 ++ Rmx RtMetrics ++} ++ ++type RtMetrics struct { ++ Pksent uint64 ++ Expire int64 ++ Locks uint32 ++ Mtu uint32 ++ Refcnt uint32 ++ Hopcount uint32 ++ Recvpipe uint32 ++ Sendpipe uint32 ++ Ssthresh uint32 ++ Rtt uint32 ++ Rttvar uint32 ++ Pad uint32 ++} ++ ++type Mclpool struct{} ++ ++const ( ++ SizeofBpfVersion = 0x4 ++ SizeofBpfStat = 0x8 ++ SizeofBpfProgram = 0x10 ++ SizeofBpfInsn = 0x8 ++ SizeofBpfHdr = 0x14 ++) ++ ++type BpfVersion struct { ++ Major uint16 ++ Minor uint16 ++} ++ ++type BpfStat struct { ++ Recv uint32 ++ Drop uint32 ++} ++ ++type BpfProgram struct { ++ Len uint32 ++ Insns *BpfInsn ++} ++ ++type BpfInsn struct { ++ Code uint16 ++ Jt uint8 ++ Jf uint8 ++ K uint32 ++} ++ ++type BpfHdr struct { ++ Tstamp BpfTimeval ++ Caplen uint32 ++ Datalen uint32 ++ Hdrlen uint16 ++ _ [2]byte ++} ++ ++type BpfTimeval struct { ++ Sec uint32 ++ Usec uint32 ++} ++ ++type Termios struct { ++ Iflag uint32 ++ Oflag uint32 ++ Cflag uint32 ++ Lflag uint32 ++ Cc [20]uint8 ++ Ispeed int32 ++ Ospeed int32 ++} ++ ++type Winsize struct { ++ Row uint16 ++ Col uint16 ++ Xpixel uint16 ++ Ypixel uint16 ++} ++ ++const ( ++ AT_FDCWD = -0x64 ++ AT_EACCESS = 0x1 ++ AT_SYMLINK_NOFOLLOW = 0x2 ++ AT_SYMLINK_FOLLOW = 0x4 ++ AT_REMOVEDIR = 0x8 ++) ++ ++type PollFd struct { ++ Fd int32 ++ Events int16 ++ Revents int16 ++} ++ ++const ( ++ POLLERR = 0x8 ++ POLLHUP = 0x10 ++ POLLIN = 0x1 ++ POLLNVAL = 0x20 ++ POLLOUT = 0x4 ++ POLLPRI = 0x2 ++ POLLRDBAND = 0x80 ++ POLLRDNORM = 0x40 ++ POLLWRBAND = 0x100 ++ POLLWRNORM = 0x4 ++) ++ ++type Sigset_t uint32 ++ ++type Utsname struct { ++ Sysname [256]byte ++ Nodename [256]byte ++ Release [256]byte ++ Version [256]byte ++ Machine [256]byte ++} ++ ++const SizeofUvmexp = 0x158 ++ ++type Uvmexp struct { ++ Pagesize int32 ++ Pagemask int32 ++ Pageshift int32 ++ Npages int32 ++ Free int32 ++ Active int32 ++ Inactive int32 ++ Paging int32 ++ Wired int32 ++ Zeropages int32 ++ Reserve_pagedaemon int32 ++ Reserve_kernel int32 ++ Unused01 int32 ++ Vnodepages int32 ++ Vtextpages int32 ++ Freemin int32 ++ Freetarg int32 ++ Inactarg int32 ++ Wiredmax int32 ++ Anonmin int32 ++ Vtextmin int32 ++ Vnodemin int32 ++ Anonminpct int32 ++ Vtextminpct int32 ++ Vnodeminpct int32 ++ Nswapdev int32 ++ Swpages int32 ++ Swpginuse int32 ++ Swpgonly int32 ++ Nswget int32 ++ Nanon int32 ++ Unused05 int32 ++ Unused06 int32 ++ Faults int32 ++ Traps int32 ++ Intrs int32 ++ Swtch int32 ++ Softs int32 ++ Syscalls int32 ++ Pageins int32 ++ Unused07 int32 ++ Unused08 int32 ++ Pgswapin int32 ++ Pgswapout int32 ++ Forks int32 ++ Forks_ppwait int32 ++ Forks_sharevm int32 ++ Pga_zerohit int32 ++ Pga_zeromiss int32 ++ Unused09 int32 ++ Fltnoram int32 ++ Fltnoanon int32 ++ Fltnoamap int32 ++ Fltpgwait int32 ++ Fltpgrele int32 ++ Fltrelck int32 ++ Fltrelckok int32 ++ Fltanget int32 ++ Fltanretry int32 ++ Fltamcopy int32 ++ Fltnamap int32 ++ Fltnomap int32 ++ Fltlget int32 ++ Fltget int32 ++ Flt_anon int32 ++ Flt_acow int32 ++ Flt_obj int32 ++ Flt_prcopy int32 ++ Flt_przero int32 ++ Pdwoke int32 ++ Pdrevs int32 ++ Pdswout int32 ++ Pdfreed int32 ++ Pdscans int32 ++ Pdanscan int32 ++ Pdobscan int32 ++ Pdreact int32 ++ Pdbusy int32 ++ Pdpageouts int32 ++ Pdpending int32 ++ Pddeact int32 ++ Unused11 int32 ++ Unused12 int32 ++ Unused13 int32 ++ Fpswtch int32 ++ Kmapent int32 ++} ++ ++const SizeofClockinfo = 0x10 ++ ++type Clockinfo struct { ++ Hz int32 ++ Tick int32 ++ Stathz int32 ++ Profhz int32 ++} diff --git a/lang/go/patches/patch-src_runtime_asm_mips64x_s b/lang/go/patches/patch-src_runtime_asm_mips64x_s index 58049f0b04bb..5f1035079298 100644 --- a/lang/go/patches/patch-src_runtime_asm_mips64x_s +++ b/lang/go/patches/patch-src_runtime_asm_mips64x_s @@ -1,7 +1,7 @@ Index: src/runtime/asm_mips64x.s --- src/runtime/asm_mips64x.s.orig +++ src/runtime/asm_mips64x.s -@@ -463,9 +463,12 @@ TEXT ·cgocallback(SB),NOSPLIT,$24-24 +@@ -470,9 +470,12 @@ TEXT ·cgocallback(SB),NOSPLIT,$24-24 NO_LOCAL_POINTERS // Load m and g from thread-local storage. diff --git a/lang/go/patches/patch-src_runtime_asm_riscv64_s b/lang/go/patches/patch-src_runtime_asm_riscv64_s new file mode 100644 index 000000000000..66583f45901f --- /dev/null +++ b/lang/go/patches/patch-src_runtime_asm_riscv64_s @@ -0,0 +1,19 @@ +Index: src/runtime/asm_riscv64.s +--- src/runtime/asm_riscv64.s.orig ++++ src/runtime/asm_riscv64.s +@@ -313,6 +313,15 @@ TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$ + CALL runtime·abort(SB) + RET + ++// func asmcgocall_no_g(fn, arg unsafe.Pointer) ++// Call fn(arg) aligned appropriately for the gcc ABI. ++// Called on a system stack, and there may be no g yet (during needm). ++TEXT ·asmcgocall_no_g(SB),NOSPLIT,$0-16 ++ MOV fn+0(FP), X5 ++ MOV arg+8(FP), X10 ++ JALR RA, (X5) ++ RET ++ + // func asmcgocall(fn, arg unsafe.Pointer) int32 + // Call fn(arg) on the scheduler stack, + // aligned appropriately for the gcc ABI. diff --git a/lang/go/patches/patch-src_runtime_cgo_gcc_openbsd_riscv64_c b/lang/go/patches/patch-src_runtime_cgo_gcc_openbsd_riscv64_c new file mode 100644 index 000000000000..01cbd37b8b95 --- /dev/null +++ b/lang/go/patches/patch-src_runtime_cgo_gcc_openbsd_riscv64_c @@ -0,0 +1,71 @@ +Index: src/runtime/cgo/gcc_openbsd_riscv64.c +--- src/runtime/cgo/gcc_openbsd_riscv64.c.orig ++++ src/runtime/cgo/gcc_openbsd_riscv64.c +@@ -0,0 +1,67 @@ ++// Copyright 2019 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. ++ ++#include ++#include ++#include ++#include ++#include "libcgo.h" ++#include "libcgo_unix.h" ++ ++static void* threadentry(void*); ++static void (*setg_gcc)(void*); ++ ++void ++x_cgo_init(G *g, void (*setg)(void*)) ++{ ++ pthread_attr_t attr; ++ size_t size; ++ ++ setg_gcc = setg; ++ pthread_attr_init(&attr); ++ pthread_attr_getstacksize(&attr, &size); ++ g->stacklo = (uintptr)&attr - size + 4096; ++ pthread_attr_destroy(&attr); ++} ++ ++void ++_cgo_sys_thread_start(ThreadStart *ts) ++{ ++ pthread_attr_t attr; ++ sigset_t ign, oset; ++ pthread_t p; ++ size_t size; ++ int err; ++ ++ sigfillset(&ign); ++ pthread_sigmask(SIG_SETMASK, &ign, &oset); ++ ++ pthread_attr_init(&attr); ++ pthread_attr_getstacksize(&attr, &size); ++ ++ // Leave stacklo=0 and set stackhi=size; mstart will do the rest. ++ ts->g->stackhi = size; ++ err = _cgo_try_pthread_create(&p, &attr, threadentry, ts); ++ ++ pthread_sigmask(SIG_SETMASK, &oset, nil); ++ ++ if (err != 0) { ++ fprintf(stderr, "runtime/cgo: pthread_create failed: %s\n", strerror(err)); ++ abort(); ++ } ++} ++ ++extern void crosscall1(void (*fn)(void), void (*setg_gcc)(void*), void *g); ++ ++static void* ++threadentry(void *v) ++{ ++ ThreadStart ts; ++ ++ ts = *(ThreadStart*)v; ++ free(v); ++ ++ crosscall1(ts.fn, setg_gcc, (void*)ts.g); ++ return nil; ++} diff --git a/lang/go/patches/patch-src_runtime_defs_openbsd_riscv64_go b/lang/go/patches/patch-src_runtime_defs_openbsd_riscv64_go new file mode 100644 index 000000000000..d814fdc68cb6 --- /dev/null +++ b/lang/go/patches/patch-src_runtime_defs_openbsd_riscv64_go @@ -0,0 +1,182 @@ +Index: src/runtime/defs_openbsd_riscv64.go +--- src/runtime/defs_openbsd_riscv64.go.orig ++++ src/runtime/defs_openbsd_riscv64.go +@@ -0,0 +1,178 @@ ++// Copyright 2022 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 runtime ++ ++import "unsafe" ++ ++const ( ++ _EINTR = 0x4 ++ _EFAULT = 0xe ++ _EAGAIN = 0x23 ++ _ENOSYS = 0x4e ++ ++ _O_NONBLOCK = 0x4 ++ _O_CLOEXEC = 0x10000 ++ ++ _PROT_NONE = 0x0 ++ _PROT_READ = 0x1 ++ _PROT_WRITE = 0x2 ++ _PROT_EXEC = 0x4 ++ ++ _MAP_ANON = 0x1000 ++ _MAP_PRIVATE = 0x2 ++ _MAP_FIXED = 0x10 ++ _MAP_STACK = 0x4000 ++ ++ _MADV_FREE = 0x6 ++ ++ _SA_SIGINFO = 0x40 ++ _SA_RESTART = 0x2 ++ _SA_ONSTACK = 0x1 ++ ++ _PTHREAD_CREATE_DETACHED = 0x1 ++ ++ _F_SETFD = 0x2 ++ _F_GETFL = 0x3 ++ _F_SETFL = 0x4 ++ _FD_CLOEXEC = 0x1 ++ ++ _SIGHUP = 0x1 ++ _SIGINT = 0x2 ++ _SIGQUIT = 0x3 ++ _SIGILL = 0x4 ++ _SIGTRAP = 0x5 ++ _SIGABRT = 0x6 ++ _SIGEMT = 0x7 ++ _SIGFPE = 0x8 ++ _SIGKILL = 0x9 ++ _SIGBUS = 0xa ++ _SIGSEGV = 0xb ++ _SIGSYS = 0xc ++ _SIGPIPE = 0xd ++ _SIGALRM = 0xe ++ _SIGTERM = 0xf ++ _SIGURG = 0x10 ++ _SIGSTOP = 0x11 ++ _SIGTSTP = 0x12 ++ _SIGCONT = 0x13 ++ _SIGCHLD = 0x14 ++ _SIGTTIN = 0x15 ++ _SIGTTOU = 0x16 ++ _SIGIO = 0x17 ++ _SIGXCPU = 0x18 ++ _SIGXFSZ = 0x19 ++ _SIGVTALRM = 0x1a ++ _SIGPROF = 0x1b ++ _SIGWINCH = 0x1c ++ _SIGINFO = 0x1d ++ _SIGUSR1 = 0x1e ++ _SIGUSR2 = 0x1f ++ ++ _FPE_INTDIV = 0x1 ++ _FPE_INTOVF = 0x2 ++ _FPE_FLTDIV = 0x3 ++ _FPE_FLTOVF = 0x4 ++ _FPE_FLTUND = 0x5 ++ _FPE_FLTRES = 0x6 ++ _FPE_FLTINV = 0x7 ++ _FPE_FLTSUB = 0x8 ++ ++ _BUS_ADRALN = 0x1 ++ _BUS_ADRERR = 0x2 ++ _BUS_OBJERR = 0x3 ++ ++ _SEGV_MAPERR = 0x1 ++ _SEGV_ACCERR = 0x2 ++ ++ _ITIMER_REAL = 0x0 ++ _ITIMER_VIRTUAL = 0x1 ++ _ITIMER_PROF = 0x2 ++ ++ _EV_ADD = 0x1 ++ _EV_DELETE = 0x2 ++ _EV_CLEAR = 0x20 ++ _EV_ERROR = 0x4000 ++ _EV_EOF = 0x8000 ++ _EVFILT_READ = -0x1 ++ _EVFILT_WRITE = -0x2 ++) ++ ++type tforkt struct { ++ tf_tcb unsafe.Pointer ++ tf_tid *int32 ++ tf_stack uintptr ++} ++ ++type sigcontext struct { ++ __sc_unused int32 ++ sc_mask int32 ++ sc_ra uintptr ++ sc_sp uintptr ++ sc_gp uintptr ++ sc_tp uintptr ++ sc_t [7]uintptr ++ sc_s [12]uintptr ++ sc_a [8]uintptr ++ sc_sepc uintptr ++ sc_f [32]uintptr ++ sc_fcsr uintptr ++ sc_cookie int64 ++} ++ ++type siginfo struct { ++ si_signo int32 ++ si_code int32 ++ si_errno int32 ++ pad_cgo_0 [4]byte ++ _data [120]byte ++} ++ ++type stackt struct { ++ ss_sp uintptr ++ ss_size uintptr ++ ss_flags int32 ++ pad_cgo_0 [4]byte ++} ++ ++type timespec struct { ++ tv_sec int64 ++ tv_nsec int64 ++} ++ ++//go:nosplit ++func (ts *timespec) setNsec(ns int64) { ++ ts.tv_sec = ns / 1e9 ++ ts.tv_nsec = ns % 1e9 ++} ++ ++type timeval struct { ++ tv_sec int64 ++ tv_usec int64 ++} ++ ++func (tv *timeval) set_usec(x int32) { ++ tv.tv_usec = int64(x) ++} ++ ++type itimerval struct { ++ it_interval timeval ++ it_value timeval ++} ++ ++type keventt struct { ++ ident uint64 ++ filter int16 ++ flags uint16 ++ fflags uint32 ++ data int64 ++ udata *byte ++} ++ ++type pthread uintptr ++type pthreadattr uintptr ++type pthreadcond uintptr ++type pthreadcondattr uintptr ++type pthreadmutex uintptr ++type pthreadmutexattr uintptr diff --git a/lang/go/patches/patch-src_runtime_rt0_openbsd_riscv64_s b/lang/go/patches/patch-src_runtime_rt0_openbsd_riscv64_s new file mode 100644 index 000000000000..870f2c0f4ddf --- /dev/null +++ b/lang/go/patches/patch-src_runtime_rt0_openbsd_riscv64_s @@ -0,0 +1,18 @@ +Index: src/runtime/rt0_openbsd_riscv64.s +--- src/runtime/rt0_openbsd_riscv64.s.orig ++++ src/runtime/rt0_openbsd_riscv64.s +@@ -0,0 +1,14 @@ ++// Copyright 2022 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. ++ ++#include "textflag.h" ++ ++TEXT _rt0_riscv64_openbsd(SB),NOSPLIT|NOFRAME,$0 ++ MOV 0(X2), A0 // argc ++ ADD $8, X2, A1 // argv ++ JMP main(SB) ++ ++TEXT main(SB),NOSPLIT|NOFRAME,$0 ++ MOV $runtime·rt0_go(SB), T0 ++ JALR ZERO, T0 diff --git a/lang/go/patches/patch-src_runtime_signal_openbsd_riscv64_go b/lang/go/patches/patch-src_runtime_signal_openbsd_riscv64_go new file mode 100644 index 000000000000..1699d09584e1 --- /dev/null +++ b/lang/go/patches/patch-src_runtime_signal_openbsd_riscv64_go @@ -0,0 +1,76 @@ +Index: src/runtime/signal_openbsd_riscv64.go +--- src/runtime/signal_openbsd_riscv64.go.orig ++++ src/runtime/signal_openbsd_riscv64.go +@@ -0,0 +1,72 @@ ++// Copyright 2022 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 runtime ++ ++import ( ++ "internal/goarch" ++ "unsafe" ++) ++ ++type sigctxt struct { ++ info *siginfo ++ ctxt unsafe.Pointer ++} ++ ++//go:nosplit ++//go:nowritebarrierrec ++func (c *sigctxt) regs() *sigcontext { ++ return (*sigcontext)(c.ctxt) ++} ++ ++func (c *sigctxt) ra() uint64 { return uint64(c.regs().sc_ra) } ++func (c *sigctxt) sp() uint64 { return uint64(c.regs().sc_sp) } ++func (c *sigctxt) gp() uint64 { return uint64(c.regs().sc_gp) } ++func (c *sigctxt) tp() uint64 { return uint64(c.regs().sc_tp) } ++func (c *sigctxt) t0() uint64 { return uint64(c.regs().sc_t[0]) } ++func (c *sigctxt) t1() uint64 { return uint64(c.regs().sc_t[1]) } ++func (c *sigctxt) t2() uint64 { return uint64(c.regs().sc_t[2]) } ++func (c *sigctxt) s0() uint64 { return uint64(c.regs().sc_s[0]) } ++func (c *sigctxt) s1() uint64 { return uint64(c.regs().sc_s[1]) } ++func (c *sigctxt) a0() uint64 { return uint64(c.regs().sc_a[0]) } ++func (c *sigctxt) a1() uint64 { return uint64(c.regs().sc_a[1]) } ++func (c *sigctxt) a2() uint64 { return uint64(c.regs().sc_a[2]) } ++func (c *sigctxt) a3() uint64 { return uint64(c.regs().sc_a[3]) } ++func (c *sigctxt) a4() uint64 { return uint64(c.regs().sc_a[4]) } ++func (c *sigctxt) a5() uint64 { return uint64(c.regs().sc_a[5]) } ++func (c *sigctxt) a6() uint64 { return uint64(c.regs().sc_a[6]) } ++func (c *sigctxt) a7() uint64 { return uint64(c.regs().sc_a[7]) } ++func (c *sigctxt) s2() uint64 { return uint64(c.regs().sc_s[2]) } ++func (c *sigctxt) s3() uint64 { return uint64(c.regs().sc_s[3]) } ++func (c *sigctxt) s4() uint64 { return uint64(c.regs().sc_s[4]) } ++func (c *sigctxt) s5() uint64 { return uint64(c.regs().sc_s[5]) } ++func (c *sigctxt) s6() uint64 { return uint64(c.regs().sc_s[6]) } ++func (c *sigctxt) s7() uint64 { return uint64(c.regs().sc_s[7]) } ++func (c *sigctxt) s8() uint64 { return uint64(c.regs().sc_s[8]) } ++func (c *sigctxt) s9() uint64 { return uint64(c.regs().sc_s[9]) } ++func (c *sigctxt) s10() uint64 { return uint64(c.regs().sc_s[10]) } ++func (c *sigctxt) s11() uint64 { return uint64(c.regs().sc_s[11]) } ++func (c *sigctxt) t3() uint64 { return uint64(c.regs().sc_t[3]) } ++func (c *sigctxt) t4() uint64 { return uint64(c.regs().sc_t[4]) } ++func (c *sigctxt) t5() uint64 { return uint64(c.regs().sc_t[5]) } ++func (c *sigctxt) t6() uint64 { return uint64(c.regs().sc_t[6]) } ++ ++//go:nosplit ++//go:nowritebarrierrec ++func (c *sigctxt) pc() uint64 { return uint64(c.regs().sc_sepc) } ++ ++func (c *sigctxt) sigcode() uint64 { return uint64(c.info.si_code) } ++func (c *sigctxt) sigaddr() uint64 { ++ return *(*uint64)(add(unsafe.Pointer(c.info), 2*goarch.PtrSize)) ++} ++ ++func (c *sigctxt) set_pc(x uint64) { c.regs().sc_sepc = uintptr(x) } ++func (c *sigctxt) set_ra(x uint64) { c.regs().sc_ra = uintptr(x) } ++func (c *sigctxt) set_sp(x uint64) { c.regs().sc_sp = uintptr(x) } ++func (c *sigctxt) set_gp(x uint64) { c.regs().sc_gp = uintptr(x) } ++ ++func (c *sigctxt) set_sigcode(x uint32) { c.info.si_code = int32(x) } ++func (c *sigctxt) set_sigaddr(x uint64) { ++ *(*uintptr)(add(unsafe.Pointer(c.info), 2*goarch.PtrSize)) = uintptr(x) ++} diff --git a/lang/go/patches/patch-src_runtime_signal_riscv64_go b/lang/go/patches/patch-src_runtime_signal_riscv64_go new file mode 100644 index 000000000000..04bdb2b98435 --- /dev/null +++ b/lang/go/patches/patch-src_runtime_signal_riscv64_go @@ -0,0 +1,12 @@ +Index: src/runtime/signal_riscv64.go +--- src/runtime/signal_riscv64.go.orig ++++ src/runtime/signal_riscv64.go +@@ -2,7 +2,7 @@ + // Use of this source code is governed by a BSD-style + // license that can be found in the LICENSE file. + +-//go:build linux && riscv64 ++//go:build linux || openbsd + + package runtime + diff --git a/lang/go/patches/patch-src_runtime_stubs_riscv64_go b/lang/go/patches/patch-src_runtime_stubs_riscv64_go new file mode 100644 index 000000000000..3d5bc6ed2ad3 --- /dev/null +++ b/lang/go/patches/patch-src_runtime_stubs_riscv64_go @@ -0,0 +1,18 @@ +Index: src/runtime/stubs_riscv64.go +--- src/runtime/stubs_riscv64.go.orig ++++ src/runtime/stubs_riscv64.go +@@ -4,9 +4,14 @@ + + package runtime + ++import "unsafe" ++ + // Called from assembly only; declared for go vet. + func load_g() + func save_g() ++ ++//go:noescape ++func asmcgocall_no_g(fn, arg unsafe.Pointer) + + // Used by reflectcall and the reflect package. + // diff --git a/lang/go/patches/patch-src_runtime_sys_openbsd_riscv64_s b/lang/go/patches/patch-src_runtime_sys_openbsd_riscv64_s new file mode 100644 index 000000000000..e74745cf6d68 --- /dev/null +++ b/lang/go/patches/patch-src_runtime_sys_openbsd_riscv64_s @@ -0,0 +1,734 @@ +Index: src/runtime/sys_openbsd_riscv64.s +--- src/runtime/sys_openbsd_riscv64.s.orig ++++ src/runtime/sys_openbsd_riscv64.s +@@ -0,0 +1,730 @@ ++// Copyright 2020 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. ++// ++// System calls and other sys.stuff for mips64, OpenBSD ++// System calls are implemented in libc/libpthread, this file ++// contains trampolines that convert from Go to C calling convention. ++// Some direct system call implementations currently remain. ++// ++ ++#include "go_asm.h" ++#include "go_tls.h" ++#include "textflag.h" ++ ++#define CLOCK_REALTIME $0 ++#define CLOCK_MONOTONIC $3 ++ ++// mstart_stub is the first function executed on a new thread started by pthread_create. ++// It just does some low-level setup and then calls mstart. ++// Note: called with the C calling convention. ++TEXT runtime·mstart_stub(SB),NOSPLIT,$200 ++ // X10 points to the m. ++ // We are already on m's g0 stack. ++ ++ // Save callee-save registers (X8, X9, X18..X27, F8, F9, F18..F27) ++ MOV X8, (1*8)(X2) ++ MOV X9, (2*8)(X2) ++ MOV X18, (3*8)(X2) ++ MOV X19, (4*8)(X2) ++ MOV X20, (5*8)(X2) ++ MOV X21, (6*8)(X2) ++ MOV X22, (7*8)(X2) ++ MOV X23, (8*8)(X2) ++ MOV X24, (9*8)(X2) ++ MOV X25, (10*8)(X2) ++ MOV X26, (11*8)(X2) ++ MOV g, (12*8)(X2) ++ MOVF F8, (13*8)(X2) ++ MOVF F9, (14*8)(X2) ++ MOVF F18, (15*8)(X2) ++ MOVF F19, (16*8)(X2) ++ MOVF F20, (17*8)(X2) ++ MOVF F21, (18*8)(X2) ++ MOVF F22, (19*8)(X2) ++ MOVF F23, (20*8)(X2) ++ MOVF F24, (21*8)(X2) ++ MOVF F25, (22*8)(X2) ++ MOVF F26, (23*8)(X2) ++ MOVF F27, (24*8)(X2) ++ ++ MOV m_g0(X10), g ++ CALL runtime·save_g(SB) ++ ++ CALL runtime·mstart(SB) ++ ++ // Restore callee-save registers. ++ MOV (1*8)(X2), X8 ++ MOV (2*8)(X2), X9 ++ MOV (3*8)(X2), X18 ++ MOV (4*8)(X2), X19 ++ MOV (5*8)(X2), X20 ++ MOV (6*8)(X2), X21 ++ MOV (7*8)(X2), X22 ++ MOV (8*8)(X2), X23 ++ MOV (9*8)(X2), X24 ++ MOV (10*8)(X2), X25 ++ MOV (11*8)(X2), X26 ++ MOV (12*8)(X2), g ++ MOVF (13*8)(X2), F8 ++ MOVF (14*8)(X2), F9 ++ MOVF (15*8)(X2), F18 ++ MOVF (16*8)(X2), F19 ++ MOVF (17*8)(X2), F20 ++ MOVF (18*8)(X2), F21 ++ MOVF (19*8)(X2), F22 ++ MOVF (20*8)(X2), F23 ++ MOVF (21*8)(X2), F24 ++ MOVF (22*8)(X2), F25 ++ MOVF (23*8)(X2), F26 ++ MOVF (24*8)(X2), F27 ++ ++ // Go is all done with this OS thread. ++ // Tell pthread everything is ok (we never join with this thread, so ++ // the value here doesn't really matter). ++ MOV $0, X10 ++ ++ RET ++ ++TEXT runtime·sigfwd(SB),NOSPLIT,$0-32 ++ MOVW sig+8(FP), X10 ++ MOV info+16(FP), X11 ++ MOV ctx+24(FP), X12 ++ MOV fn+0(FP), X5 ++ JALR X1, X5 ++ RET ++ ++TEXT runtime·sigtramp(SB),NOSPLIT|TOPFRAME,$224 ++ // Save callee-save registers (X8, X9, X18..X27, F8, F9, F18..F27) ++ MOV X8, (4*8)(X2) ++ MOV X9, (5*8)(X2) ++ MOV X18, (6*8)(X2) ++ MOV X19, (7*8)(X2) ++ MOV X20, (8*8)(X2) ++ MOV X21, (9*8)(X2) ++ MOV X22, (10*8)(X2) ++ MOV X23, (11*8)(X2) ++ MOV X24, (12*8)(X2) ++ MOV X25, (13*8)(X2) ++ MOV X26, (14*8)(X2) ++ MOV g, (15*8)(X2) ++ MOVF F8, (16*8)(X2) ++ MOVF F9, (17*8)(X2) ++ MOVF F18, (18*8)(X2) ++ MOVF F19, (19*8)(X2) ++ MOVF F20, (20*8)(X2) ++ MOVF F21, (21*8)(X2) ++ MOVF F22, (22*8)(X2) ++ MOVF F23, (23*8)(X2) ++ MOVF F24, (24*8)(X2) ++ MOVF F25, (25*8)(X2) ++ MOVF F26, (26*8)(X2) ++ MOVF F27, (27*8)(X2) ++ ++ // this might be called in external code context, ++ // where g is not set. ++ CALL runtime·load_g(SB) ++ ++ MOVW X10, 8(X2) ++ MOV X11, 16(X2) ++ MOV X12, 24(X2) ++ MOV $runtime·sigtrampgo(SB), X5 ++ JALR X1, X5 ++ ++ // Restore callee-save registers. ++ MOV (4*8)(X2), X8 ++ MOV (5*8)(X2), X9 ++ MOV (6*8)(X2), X18 ++ MOV (7*8)(X2), X19 ++ MOV (8*8)(X2), X20 ++ MOV (9*8)(X2), X21 ++ MOV (10*8)(X2), X22 ++ MOV (11*8)(X2), X23 ++ MOV (12*8)(X2), X24 ++ MOV (13*8)(X2), X25 ++ MOV (14*8)(X2), X26 ++ MOV (15*8)(X2), g ++ MOVF (16*8)(X2), F8 ++ MOVF (17*8)(X2), F9 ++ MOVF (18*8)(X2), F18 ++ MOVF (19*8)(X2), F19 ++ MOVF (20*8)(X2), F20 ++ MOVF (21*8)(X2), F21 ++ MOVF (22*8)(X2), F22 ++ MOVF (23*8)(X2), F23 ++ MOVF (24*8)(X2), F24 ++ MOVF (25*8)(X2), F25 ++ MOVF (26*8)(X2), F26 ++ MOVF (27*8)(X2), F27 ++ ++ RET ++ ++// ++// These trampolines help convert from Go calling convention to C calling convention. ++// They should be called with asmcgocall. ++// A pointer to the arguments is passed in R0. ++// A single int32 result is returned in R0. ++// (For more results, make an args/results structure.) ++TEXT runtime·pthread_attr_init_trampoline(SB),NOSPLIT,$8 ++ MOV 0(X10), X10 // arg 1 - attr ++ CALL libc_pthread_attr_init(SB) ++ RET ++ ++TEXT runtime·pthread_attr_destroy_trampoline(SB),NOSPLIT,$8 ++ MOV 0(X10), X10 // arg 1 - attr ++ CALL libc_pthread_attr_destroy(SB) ++ RET ++ ++TEXT runtime·pthread_attr_getstacksize_trampoline(SB),NOSPLIT,$8 ++ MOV 8(X10), X11 // arg 2 - size ++ MOV 0(X10), X10 // arg 1 - attr ++ CALL libc_pthread_attr_getstacksize(SB) ++ RET ++ ++TEXT runtime·pthread_attr_setdetachstate_trampoline(SB),NOSPLIT,$8 ++ MOV 8(X10), X11 // arg 2 - state ++ MOV 0(X10), X10 // arg 1 - attr ++ CALL libc_pthread_attr_setdetachstate(SB) ++ RET ++ ++TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$8 ++ MOV 0(X10), X11 // arg 2 - attr ++ MOV 8(X10), X12 // arg 3 - start ++ MOV 16(X10), X13 // arg 4 - arg ++ ADD $-16, X2 ++ MOV X2, X10 // arg 1 - &threadid (discard) ++ CALL libc_pthread_create(SB) ++ ADD $16, X2 ++ RET ++ ++TEXT runtime·thrkill_trampoline(SB),NOSPLIT,$8 ++ MOV 8(X10), X11 // arg 2 - signal ++ MOV $0, X12 // arg 3 - tcb ++ MOVW 0(X10), X10 // arg 1 - tid ++ CALL libc_thrkill(SB) ++ RET ++ ++TEXT runtime·thrsleep_trampoline(SB),NOSPLIT,$8 ++ MOVW 8(X10), X11 // arg 2 - clock_id ++ MOV 16(X10), X12 // arg 3 - abstime ++ MOV 24(X10), X13 // arg 4 - lock ++ MOV 32(X10), X14 // arg 5 - abort ++ MOV 0(X10), X10 // arg 1 - id ++ CALL libc_thrsleep(SB) ++ RET ++ ++TEXT runtime·thrwakeup_trampoline(SB),NOSPLIT,$8 ++ MOVW 8(X10), X11 // arg 2 - count ++ MOV 0(X10), X10 // arg 1 - id ++ CALL libc_thrwakeup(SB) ++ RET ++ ++TEXT runtime·exit_trampoline(SB),NOSPLIT,$8 ++ MOVW 0(X10), X10 // arg 1 - status ++ CALL libc_exit(SB) ++ MOV $0, X5 // crash on failure ++ MOV X5, (X5) ++ RET ++ ++TEXT runtime·getthrid_trampoline(SB),NOSPLIT,$8 ++ MOV X10, X9 // pointer to args ++ CALL libc_getthrid(SB) ++ MOVW X10, 0(X9) // return value ++ RET ++ ++TEXT runtime·raiseproc_trampoline(SB),NOSPLIT,$8 ++ MOV X10, X9 // pointer to args ++ CALL libc_getpid(SB) // arg 1 - pid (result in X10) ++ MOVW 0(X9), X11 // arg 2 - signal ++ CALL libc_kill(SB) ++ RET ++ ++TEXT runtime·sched_yield_trampoline(SB),NOSPLIT,$8 ++ CALL libc_sched_yield(SB) ++ RET ++ ++TEXT runtime·mmap_trampoline(SB),NOSPLIT,$8 ++ MOV X10, X9 // pointer to args ++ MOV 0(X9), X10 // arg 1 - addr ++ MOV 8(X9), X11 // arg 2 - len ++ MOVW 16(X9), X12 // arg 3 - prot ++ MOVW 20(X9), X13 // arg 4 - flags ++ MOVW 24(X9), X14 // arg 5 - fid ++ MOVW 28(X9), X15 // arg 6 - offset ++ CALL libc_mmap(SB) ++ MOV $0, X5 ++ MOV $-1, X6 ++ BNE X6, X10, noerr ++ CALL libc_errno(SB) ++ MOVW (X10), X5 // errno ++ MOV $0, X10 ++noerr: ++ MOV X10, 32(X9) ++ MOV X5, 40(X9) ++ RET ++ ++TEXT runtime·munmap_trampoline(SB),NOSPLIT,$8 ++ MOV 8(X10), X11 // arg 2 - len ++ MOV 0(X10), X10 // arg 1 - addr ++ CALL libc_munmap(SB) ++ MOV $-1, X5 ++ BNE X5, X10, 3(PC) ++ MOV $0, X5 // crash on failure ++ MOV X5, (X5) ++ RET ++ ++TEXT runtime·madvise_trampoline(SB),NOSPLIT,$8 ++ MOV 8(X10), X11 // arg 2 - len ++ MOVW 16(X10), X12 // arg 3 - advice ++ MOV 0(X10), X10 // arg 1 - addr ++ CALL libc_madvise(SB) ++ // ignore failure - maybe pages are locked ++ RET ++ ++TEXT runtime·open_trampoline(SB),NOSPLIT,$8 ++ MOVW 8(X10), X11 // arg 2 - flags ++ MOVW 12(X10), X12 // arg 3 - mode ++ MOV 0(X10), X10 // arg 1 - path ++ MOV $0, X13 // varargs ++ CALL libc_open(SB) ++ RET ++ ++TEXT runtime·close_trampoline(SB),NOSPLIT,$8 ++ MOVW 0(X10), X10 // arg 1 - fd ++ CALL libc_close(SB) ++ RET ++ ++TEXT runtime·read_trampoline(SB),NOSPLIT,$8 ++ MOV 8(X10), X11 // arg 2 - buf ++ MOVW 16(X10), X12 // arg 3 - count ++ MOVW 0(X10), X10 // arg 1 - fd (int32 from read) ++ CALL libc_read(SB) ++ MOV $-1, X5 ++ BNE X5, X10, noerr ++ CALL libc_errno(SB) ++ MOVW (X10), X10 // errno ++ NEG X10 // caller expects negative errno ++noerr: ++ RET ++ ++TEXT runtime·write_trampoline(SB),NOSPLIT,$8 ++ MOV 8(X10), X11 // arg 2 - buf ++ MOVW 16(X10), X12 // arg 3 - count ++ MOV 0(X10), X10 // arg 1 - fd (uintptr from write1) ++ CALL libc_write(SB) ++ MOV $-1, X5 ++ BNE X5, X10, noerr ++ CALL libc_errno(SB) ++ MOVW (X10), X10 // errno ++ NEG X10 // caller expects negative errno ++noerr: ++ RET ++ ++TEXT runtime·pipe2_trampoline(SB),NOSPLIT,$8 ++ MOVW 8(X10), X11 // arg 2 - flags ++ MOV 0(X10), X10 // arg 1 - filedes ++ CALL libc_pipe2(SB) ++ MOV $-1, X5 ++ BNE X5, X10, noerr ++ CALL libc_errno(SB) ++ MOVW (X10), X10 // errno ++ NEG X10 // caller expects negative errno ++noerr: ++ RET ++ ++TEXT runtime·setitimer_trampoline(SB),NOSPLIT,$8 ++ MOV 8(X10), X11 // arg 2 - new ++ MOV 16(X10), X12 // arg 3 - old ++ MOVW 0(X10), X10 // arg 1 - which ++ CALL libc_setitimer(SB) ++ RET ++ ++TEXT runtime·usleep_trampoline(SB),NOSPLIT,$8 ++ MOVW 0(X10), X10 // arg 1 - usec ++ CALL libc_usleep(SB) ++ RET ++ ++TEXT runtime·sysctl_trampoline(SB),NOSPLIT,$8 ++ MOVW 8(X10), X11 // arg 2 - miblen ++ MOV 16(X10), X12 // arg 3 - out ++ MOV 24(X10), X13 // arg 4 - size ++ MOV 32(X10), X14 // arg 5 - dst ++ MOV 40(X10), X15 // arg 6 - ndst ++ MOV 0(X10), X10 // arg 1 - mib ++ CALL libc_sysctl(SB) ++ RET ++ ++TEXT runtime·kqueue_trampoline(SB),NOSPLIT,$8 ++ CALL libc_kqueue(SB) ++ RET ++ ++TEXT runtime·kevent_trampoline(SB),NOSPLIT,$8 ++ MOV 8(X10), X11 // arg 2 - keventt ++ MOVW 16(X10), X12 // arg 3 - nch ++ MOV 24(X10), X13 // arg 4 - ev ++ MOVW 32(X10), X14 // arg 5 - nev ++ MOV 40(X10), X15 // arg 6 - ts ++ MOVW 0(X10), X10 // arg 1 - kq ++ CALL libc_kevent(SB) ++ MOV $-1, X5 ++ BNE X5, X10, noerr ++ CALL libc_errno(SB) ++ MOVW (X10), X10 // errno ++ NEG X10 // caller expects negative errno ++noerr: ++ RET ++ ++TEXT runtime·clock_gettime_trampoline(SB),NOSPLIT,$8 ++ MOV 8(X10), X11 // arg 2 - tp ++ MOVW 0(X10), X10 // arg 1 - clock_id ++ CALL libc_clock_gettime(SB) ++ MOV $-1, X5 ++ BNE X5, X10, 3(PC) ++ MOV $0, X5 // crash on failure ++ MOV X5, (X5) ++ RET ++ ++TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$8 ++ MOVW 4(X10), X11 // arg 2 - cmd ++ MOVW 8(X10), X12 // arg 3 - arg ++ MOVW 0(X10), X10 // arg 1 - fd ++ MOV $0, X13 // vararg ++ CALL libc_fcntl(SB) ++ RET ++ ++TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$8 ++ MOV 8(X10), X11 // arg 2 - new ++ MOV 16(X10), X12 // arg 3 - old ++ MOVW 0(X10), X10 // arg 1 - sig ++ CALL libc_sigaction(SB) ++ MOV $-1, X5 ++ BNE X5, X10, 3(PC) ++ MOV $0, X5 // crash on failure ++ MOV X5, (X5) ++ RET ++ ++TEXT runtime·sigprocmask_trampoline(SB),NOSPLIT,$8 ++ MOV 8(X10), X11 // arg 2 - new ++ MOV 16(X10), X12 // arg 3 - old ++ MOVW 0(X10), X10 // arg 1 - how ++ CALL libc_pthread_sigmask(SB) ++ MOV $-1, X5 ++ BNE X5, X10, 3(PC) ++ MOV $0, X5 // crash on failure ++ MOV X5, (X5) ++ RET ++ ++TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$8 ++ MOV 8(X10), X11 // arg 2 - old ++ MOV 0(X10), X10 // arg 1 - new ++ CALL libc_sigaltstack(SB) ++ MOV $-1, X5 ++ BNE X5, X10, 3(PC) ++ MOV $0, X5 // crash on failure ++ MOV X5, (X5) ++ RET ++ ++// syscall calls a function in libc on behalf of the syscall package. ++// syscall takes a pointer to a struct like: ++// struct { ++// fn uintptr ++// a1 uintptr ++// a2 uintptr ++// a3 uintptr ++// r1 uintptr ++// r2 uintptr ++// err uintptr ++// } ++// syscall must be called on the g0 stack with the ++// C calling convention (use libcCall). ++// ++// syscall expects a 32-bit result and tests for 32-bit -1 ++// to decide there was an error. ++TEXT runtime·syscall(SB),NOSPLIT,$8 ++ MOV X10, X9 // pointer to args ++ ++ MOV (0*8)(X9), X5 // fn ++ MOV (1*8)(X9), X10 // a1 ++ MOV (2*8)(X9), X11 // a2 ++ MOV (3*8)(X9), X12 // a3 ++ MOV $0, X13 // vararg ++ ++ JALR X1, X5 ++ ++ MOV X10, (4*8)(X9) // r1 ++ MOV X11, (5*8)(X9) // r2 ++ ++ // Standard libc functions return -1 on error ++ // and set errno. ++ MOV $-1, X5 ++ BNE X5, X10, ok ++ ++ // Get error code from libc. ++ CALL libc_errno(SB) ++ MOVW (X10), X10 ++ MOV X10, (6*8)(X9) // err ++ ++ok: ++ RET ++ ++// syscallX calls a function in libc on behalf of the syscall package. ++// syscallX takes a pointer to a struct like: ++// struct { ++// fn uintptr ++// a1 uintptr ++// a2 uintptr ++// a3 uintptr ++// r1 uintptr ++// r2 uintptr ++// err uintptr ++// } ++// syscallX must be called on the g0 stack with the ++// C calling convention (use libcCall). ++// ++// syscallX is like syscall but expects a 64-bit result ++// and tests for 64-bit -1 to decide there was an error. ++TEXT runtime·syscallX(SB),NOSPLIT,$8 ++ MOV X10, X9 // pointer to args ++ ++ MOV (0*8)(X9), X5 // fn ++ MOV (1*8)(X9), X10 // a1 ++ MOV (2*8)(X9), X11 // a2 ++ MOV (3*8)(X9), X12 // a3 ++ MOV $0, X13 // vararg ++ ++ JALR X1, X5 ++ ++ MOV X10, (4*8)(X9) // r1 ++ MOV X11, (5*8)(X9) // r2 ++ ++ // Standard libc functions return -1 on error ++ // and set errno. ++ MOV $-1, X5 ++ BNE X5, X10, ok ++ ++ // Get error code from libc. ++ CALL libc_errno(SB) ++ MOVW (X10), X10 ++ MOV X10, (6*8)(X9) // err ++ ++ok: ++ RET ++ ++// syscall6 calls a function in libc on behalf of the syscall package. ++// syscall6 takes a pointer to a struct like: ++// struct { ++// fn uintptr ++// a1 uintptr ++// a2 uintptr ++// a3 uintptr ++// a4 uintptr ++// a5 uintptr ++// a6 uintptr ++// r1 uintptr ++// r2 uintptr ++// err uintptr ++// } ++// syscall6 must be called on the g0 stack with the ++// C calling convention (use libcCall). ++// ++// syscall6 expects a 32-bit result and tests for 32-bit -1 ++// to decide there was an error. ++TEXT runtime·syscall6(SB),NOSPLIT,$8 ++ MOV X10, X9 // pointer to args ++ ++ MOV (0*8)(X9), X5 // fn ++ MOV (1*8)(X9), X10 // a1 ++ MOV (2*8)(X9), X11 // a2 ++ MOV (3*8)(X9), X12 // a3 ++ MOV (4*8)(X9), X13 // a4 ++ MOV (5*8)(X9), X14 // a5 ++ MOV (6*8)(X9), X15 // a6 ++ MOV $0, X16 // vararg ++ ++ JALR X1, X5 ++ ++ MOV X10, (7*8)(X9) // r1 ++ MOV X11, (8*8)(X9) // r2 ++ ++ // Standard libc functions return -1 on error ++ // and set errno. ++ MOV $-1, X5 ++ BNE X5, X10, ok ++ ++ // Get error code from libc. ++ CALL libc_errno(SB) ++ MOVW (X10), X10 ++ MOV X10, (9*8)(X9) // err ++ ++ok: ++ RET ++ ++// syscall6X calls a function in libc on behalf of the syscall package. ++// syscall6X takes a pointer to a struct like: ++// struct { ++// fn uintptr ++// a1 uintptr ++// a2 uintptr ++// a3 uintptr ++// a4 uintptr ++// a5 uintptr ++// a6 uintptr ++// r1 uintptr ++// r2 uintptr ++// err uintptr ++// } ++// syscall6X must be called on the g0 stack with the ++// C calling convention (use libcCall). ++// ++// syscall6X is like syscall6 but expects a 64-bit result ++// and tests for 64-bit -1 to decide there was an error. ++TEXT runtime·syscall6X(SB),NOSPLIT,$8 ++ MOV X10, X9 // pointer to args ++ ++ MOV (0*8)(X9), X5 // fn ++ MOV (1*8)(X9), X10 // a1 ++ MOV (2*8)(X9), X11 // a2 ++ MOV (3*8)(X9), X12 // a3 ++ MOV (4*8)(X9), X13 // a4 ++ MOV (5*8)(X9), X14 // a5 ++ MOV (6*8)(X9), X15 // a6 ++ MOV $0, X16 // vararg ++ ++ JALR X1, X5 ++ ++ MOV X10, (7*8)(X9) // r1 ++ MOV X11, (8*8)(X9) // r2 ++ ++ // Standard libc functions return -1 on error ++ // and set errno. ++ MOV $-1, X5 ++ BNE X5, X10, ok ++ ++ // Get error code from libc. ++ CALL libc_errno(SB) ++ MOVW (X10), X10 ++ MOV X10, (9*8)(X9) // err ++ ++ok: ++ RET ++ ++// syscall10 calls a function in libc on behalf of the syscall package. ++// syscall10 takes a pointer to a struct like: ++// struct { ++// fn uintptr ++// a1 uintptr ++// a2 uintptr ++// a3 uintptr ++// a4 uintptr ++// a5 uintptr ++// a6 uintptr ++// a7 uintptr ++// a8 uintptr ++// a9 uintptr ++// a10 uintptr ++// r1 uintptr ++// r2 uintptr ++// err uintptr ++// } ++// syscall10 must be called on the g0 stack with the ++// C calling convention (use libcCall). ++// ++// The openbsd/mips64 kernel only accepts eight syscall arguments, except ++// for SYS_syscall, where an additional argument can be passed on the stack. ++TEXT runtime·syscall10(SB),NOSPLIT,$8 ++ MOV X10, X9 // pointer to args ++ ++ ADD $-16, X2 ++ ++ MOV (0*8)(X9), X5 // fn ++ MOV (1*8)(X9), X10 // a1 ++ MOV (2*8)(X9), X11 // a2 ++ MOV (3*8)(X9), X12 // a3 ++ MOV (4*8)(X9), X13 // a4 ++ MOV (5*8)(X9), X14 // a5 ++ MOV (6*8)(X9), X15 // a6 ++ MOV (7*8)(X9), X16 // a7 ++ MOV (8*8)(X9), X17 // a8 ++ MOV (9*8)(X9), X18 ++ MOV X18, 0(X2) // a9 ++ ++ JALR X1, X5 ++ ++ MOV X10, (11*8)(X9) // r1 ++ MOV X11, (12*8)(X9) // r2 ++ ++ // Standard libc functions return -1 on error ++ // and set errno. ++ MOV $-1, X5 ++ BNE X5, X10, ok ++ ++ // Get error code from libc. ++ CALL libc_errno(SB) ++ MOVW (X10), X10 ++ MOV X10, (13*8)(X9) // err ++ ++ok: ++ ADD $16, X2 ++ RET ++ ++// syscall10X calls a function in libc on behalf of the syscall package. ++// syscall10X takes a pointer to a struct like: ++// struct { ++// fn uintptr ++// a1 uintptr ++// a2 uintptr ++// a3 uintptr ++// a4 uintptr ++// a5 uintptr ++// a6 uintptr ++// a7 uintptr ++// a8 uintptr ++// a9 uintptr ++// a10 uintptr ++// r1 uintptr ++// r2 uintptr ++// err uintptr ++// } ++// syscall10X must be called on the g0 stack with the ++// C calling convention (use libcCall). ++// ++// syscall10X is like syscall10 but expects a 64-bit result ++// and tests for 64-bit -1 to decide there was an error. ++// ++// The openbsd/mips64 kernel only accepts eight syscall arguments, except ++// for SYS_syscall, where an additional argument can be passed on the stack. ++TEXT runtime·syscall10X(SB),NOSPLIT,$8 ++ MOV X10, X9 // pointer to args ++ ++ ADD $-16, X2 ++ ++ MOV (0*8)(X9), X5 // fn ++ MOV (1*8)(X9), X10 // a1 ++ MOV (2*8)(X9), X11 // a2 ++ MOV (3*8)(X9), X12 // a3 ++ MOV (4*8)(X9), X13 // a4 ++ MOV (5*8)(X9), X14 // a5 ++ MOV (6*8)(X9), X15 // a6 ++ MOV (7*8)(X9), X16 // a7 ++ MOV (8*8)(X9), X17 // a8 ++ MOV (9*8)(X9), X18 ++ MOV X18, 0(X2) // a9 ++ ++ JALR X1, X5 ++ ++ MOV X10, (11*8)(X9) // r1 ++ MOV X11, (12*8)(X9) // r2 ++ ++ // Standard libc functions return -1 on error ++ // and set errno. ++ MOV $-1, X5 ++ BNE X5, X10, ok ++ ++ // Get error code from libc. ++ CALL libc_errno(SB) ++ MOVW (X10), X10 ++ MOV X10, (13*8)(X9) // err ++ ++ok: ++ ADD $16, X2 ++ RET diff --git a/lang/go/patches/patch-src_runtime_tls_riscv64_s b/lang/go/patches/patch-src_runtime_tls_riscv64_s new file mode 100644 index 000000000000..427c3af832a8 --- /dev/null +++ b/lang/go/patches/patch-src_runtime_tls_riscv64_s @@ -0,0 +1,29 @@ +Index: src/runtime/tls_riscv64.s +--- src/runtime/tls_riscv64.s.orig ++++ src/runtime/tls_riscv64.s +@@ -11,20 +11,16 @@ + // + // NOTE: mcall() assumes this clobbers only X31 (REG_TMP). + TEXT runtime·save_g(SB),NOSPLIT|NOFRAME,$0-0 ++#ifndef GOOS_openbsd + MOVB runtime·iscgo(SB), X31 +- BEQ X0, X31, nocgo +- +- MOV runtime·tls_g(SB), X31 +- ADD TP, X31 // add offset to thread pointer (X4) +- MOV g, (X31) +- ++ BEQZ X31, nocgo ++#endif ++ MOV g, runtime·tls_g(SB) + nocgo: + RET + + TEXT runtime·load_g(SB),NOSPLIT|NOFRAME,$0-0 +- MOV runtime·tls_g(SB), X31 +- ADD TP, X31 // add offset to thread pointer (X4) +- MOV (X31), g ++ MOV runtime·tls_g(SB), g + RET + + GLOBL runtime·tls_g(SB), TLSBSS, $8 diff --git a/lang/go/patches/patch-src_syscall_asm_openbsd_riscv64_s b/lang/go/patches/patch-src_syscall_asm_openbsd_riscv64_s new file mode 100644 index 000000000000..230dcf36c817 --- /dev/null +++ b/lang/go/patches/patch-src_syscall_asm_openbsd_riscv64_s @@ -0,0 +1,36 @@ +Index: src/syscall/asm_openbsd_riscv64.s +--- src/syscall/asm_openbsd_riscv64.s.orig ++++ src/syscall/asm_openbsd_riscv64.s +@@ -0,0 +1,32 @@ ++// Copyright 2019 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. ++ ++#include "textflag.h" ++ ++// ++// System call support for RISCV64, OpenBSD ++// ++ ++// Provide these function names via assembly so they are provided as ABI0, ++// rather than ABIInternal. ++ ++// func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) ++TEXT ·Syscall(SB),NOSPLIT,$0-56 ++ JMP ·syscallInternal(SB) ++ ++// func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) ++TEXT ·Syscall6(SB),NOSPLIT,$0-80 ++ JMP ·syscall6Internal(SB) ++ ++// func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) ++TEXT ·RawSyscall(SB),NOSPLIT,$0-56 ++ JMP ·rawSyscallInternal(SB) ++ ++// func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) ++TEXT ·RawSyscall6(SB),NOSPLIT,$0-80 ++ JMP ·rawSyscall6Internal(SB) ++ ++// func Syscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno) ++TEXT ·Syscall9(SB),NOSPLIT,$0-104 ++ JMP ·syscall9Internal(SB) diff --git a/lang/go/patches/patch-src_syscall_mkall_sh b/lang/go/patches/patch-src_syscall_mkall_sh index 1ea20550db77..e4a881b3848e 100644 --- a/lang/go/patches/patch-src_syscall_mkall_sh +++ b/lang/go/patches/patch-src_syscall_mkall_sh @@ -1,7 +1,7 @@ Index: src/syscall/mkall.sh --- src/syscall/mkall.sh.orig +++ src/syscall/mkall.sh -@@ -337,15 +337,16 @@ openbsd_arm64) +@@ -337,15 +337,28 @@ openbsd_arm64) mkasm="go run mkasm.go" ;; openbsd_mips64) @@ -16,6 +16,18 @@ Index: src/syscall/mkall.sh # Let the type of C char be signed to make the bare syscall # API consistent between platforms. mktypes="GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char" ++ mkasm="go run mkasm.go" ++ ;; ++openbsd_riscv64) ++ GOOSARCH_in="syscall_openbsd_libc.go syscall_openbsd_$GOARCH.go" ++ mkerrors="$mkerrors -m64" ++ mksyscall="./mksyscall.pl -openbsd -libc" ++ mksysctl="./mksysctl_openbsd.pl" ++ zsysctl="zsysctl_openbsd.go" ++ mksysnum="curl -s 'http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master' | ./mksysnum_openbsd.pl" ++ # Let the type of C char be signed to make the bare syscall ++ # API consistent between platforms. ++ mktypes="GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char" + mkasm="go run mkasm.go" ;; plan9_386) diff --git a/lang/go/patches/patch-src_syscall_syscall_openbsd_riscv64_go b/lang/go/patches/patch-src_syscall_syscall_openbsd_riscv64_go new file mode 100644 index 000000000000..4def3d5031e8 --- /dev/null +++ b/lang/go/patches/patch-src_syscall_syscall_openbsd_riscv64_go @@ -0,0 +1,42 @@ +Index: src/syscall/syscall_openbsd_riscv64.go +--- src/syscall/syscall_openbsd_riscv64.go.orig ++++ src/syscall/syscall_openbsd_riscv64.go +@@ -0,0 +1,38 @@ ++// Copyright 2019 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 ++ ++func setTimespec(sec, nsec int64) Timespec { ++ return Timespec{Sec: sec, Nsec: nsec} ++} ++ ++func setTimeval(sec, usec int64) Timeval { ++ return Timeval{Sec: sec, Usec: usec} ++} ++ ++func SetKevent(k *Kevent_t, fd, mode, flags int) { ++ k.Ident = uint64(fd) ++ k.Filter = int16(mode) ++ k.Flags = uint16(flags) ++} ++ ++func (iov *Iovec) SetLen(length int) { ++ iov.Len = uint64(length) ++} ++ ++func (msghdr *Msghdr) SetControllen(length int) { ++ msghdr.Controllen = uint32(length) ++} ++ ++func (cmsg *Cmsghdr) SetLen(length int) { ++ cmsg.Len = uint32(length) ++} ++ ++// RTM_LOCK only exists in OpenBSD 6.3 and earlier. ++const RTM_LOCK = 0x8 ++ ++// SYS___SYSCTL only exists in OpenBSD 5.8 and earlier, when it was ++// was renamed to SYS_SYSCTL. ++const SYS___SYSCTL = SYS_SYSCTL diff --git a/lang/go/patches/patch-src_syscall_zerrors_openbsd_riscv64_go b/lang/go/patches/patch-src_syscall_zerrors_openbsd_riscv64_go new file mode 100644 index 000000000000..88c0dbecb3e3 --- /dev/null +++ b/lang/go/patches/patch-src_syscall_zerrors_openbsd_riscv64_go @@ -0,0 +1,1697 @@ +Index: src/syscall/zerrors_openbsd_riscv64.go +--- src/syscall/zerrors_openbsd_riscv64.go.orig ++++ src/syscall/zerrors_openbsd_riscv64.go +@@ -0,0 +1,1693 @@ ++// mkerrors.sh -m64 ++// Code generated by the command above; DO NOT EDIT. ++ ++// Code generated by cmd/cgo -godefs; DO NOT EDIT. ++// cgo -godefs -- -m64 _const.go ++ ++package syscall ++ ++const ( ++ AF_APPLETALK = 0x10 ++ AF_BLUETOOTH = 0x20 ++ AF_CCITT = 0xa ++ AF_CHAOS = 0x5 ++ AF_CNT = 0x15 ++ AF_COIP = 0x14 ++ AF_DATAKIT = 0x9 ++ AF_DECnet = 0xc ++ AF_DLI = 0xd ++ AF_E164 = 0x1a ++ AF_ECMA = 0x8 ++ AF_ENCAP = 0x1c ++ AF_HYLINK = 0xf ++ AF_IMPLINK = 0x3 ++ AF_INET = 0x2 ++ AF_INET6 = 0x18 ++ AF_IPX = 0x17 ++ AF_ISDN = 0x1a ++ AF_ISO = 0x7 ++ AF_KEY = 0x1e ++ AF_LAT = 0xe ++ AF_LINK = 0x12 ++ AF_LOCAL = 0x1 ++ AF_MAX = 0x24 ++ AF_MPLS = 0x21 ++ AF_NATM = 0x1b ++ AF_NS = 0x6 ++ AF_OSI = 0x7 ++ AF_PUP = 0x4 ++ AF_ROUTE = 0x11 ++ AF_SIP = 0x1d ++ AF_SNA = 0xb ++ AF_UNIX = 0x1 ++ AF_UNSPEC = 0x0 ++ ARPHRD_ETHER = 0x1 ++ ARPHRD_FRELAY = 0xf ++ ARPHRD_IEEE1394 = 0x18 ++ ARPHRD_IEEE802 = 0x6 ++ B0 = 0x0 ++ B110 = 0x6e ++ B115200 = 0x1c200 ++ B1200 = 0x4b0 ++ B134 = 0x86 ++ B14400 = 0x3840 ++ B150 = 0x96 ++ B1800 = 0x708 ++ B19200 = 0x4b00 ++ B200 = 0xc8 ++ B230400 = 0x38400 ++ B2400 = 0x960 ++ B28800 = 0x7080 ++ B300 = 0x12c ++ B38400 = 0x9600 ++ B4800 = 0x12c0 ++ B50 = 0x32 ++ B57600 = 0xe100 ++ B600 = 0x258 ++ B7200 = 0x1c20 ++ B75 = 0x4b ++ B76800 = 0x12c00 ++ B9600 = 0x2580 ++ BIOCFLUSH = 0x20004268 ++ BIOCGBLEN = 0x40044266 ++ BIOCGDIRFILT = 0x4004427c ++ BIOCGDLT = 0x4004426a ++ BIOCGDLTLIST = 0xc010427b ++ BIOCGETIF = 0x4020426b ++ BIOCGFILDROP = 0x40044278 ++ BIOCGHDRCMPLT = 0x40044274 ++ BIOCGRSIG = 0x40044273 ++ BIOCGRTIMEOUT = 0x4010426e ++ BIOCGSTATS = 0x4008426f ++ BIOCIMMEDIATE = 0x80044270 ++ BIOCLOCK = 0x20004276 ++ BIOCPROMISC = 0x20004269 ++ BIOCSBLEN = 0xc0044266 ++ BIOCSDIRFILT = 0x8004427d ++ BIOCSDLT = 0x8004427a ++ BIOCSETF = 0x80104267 ++ BIOCSETIF = 0x8020426c ++ BIOCSETWF = 0x80104277 ++ BIOCSFILDROP = 0x80044279 ++ BIOCSHDRCMPLT = 0x80044275 ++ BIOCSRSIG = 0x80044272 ++ BIOCSRTIMEOUT = 0x8010426d ++ BIOCVERSION = 0x40044271 ++ BPF_A = 0x10 ++ BPF_ABS = 0x20 ++ BPF_ADD = 0x0 ++ BPF_ALIGNMENT = 0x4 ++ BPF_ALU = 0x4 ++ BPF_AND = 0x50 ++ BPF_B = 0x10 ++ BPF_DIRECTION_IN = 0x1 ++ BPF_DIRECTION_OUT = 0x2 ++ BPF_DIV = 0x30 ++ BPF_FILDROP_CAPTURE = 0x1 ++ BPF_FILDROP_DROP = 0x2 ++ BPF_FILDROP_PASS = 0x0 ++ BPF_F_DIR_IN = 0x10 ++ BPF_F_DIR_MASK = 0x30 ++ BPF_F_DIR_OUT = 0x20 ++ BPF_F_DIR_SHIFT = 0x4 ++ BPF_F_FLOWID = 0x8 ++ BPF_F_PRI_MASK = 0x7 ++ BPF_H = 0x8 ++ BPF_IMM = 0x0 ++ BPF_IND = 0x40 ++ BPF_JA = 0x0 ++ BPF_JEQ = 0x10 ++ BPF_JGE = 0x30 ++ BPF_JGT = 0x20 ++ BPF_JMP = 0x5 ++ BPF_JSET = 0x40 ++ BPF_K = 0x0 ++ BPF_LD = 0x0 ++ BPF_LDX = 0x1 ++ BPF_LEN = 0x80 ++ BPF_LSH = 0x60 ++ BPF_MAJOR_VERSION = 0x1 ++ BPF_MAXBUFSIZE = 0x200000 ++ BPF_MAXINSNS = 0x200 ++ BPF_MEM = 0x60 ++ BPF_MEMWORDS = 0x10 ++ BPF_MINBUFSIZE = 0x20 ++ BPF_MINOR_VERSION = 0x1 ++ BPF_MISC = 0x7 ++ BPF_MSH = 0xa0 ++ BPF_MUL = 0x20 ++ BPF_NEG = 0x80 ++ BPF_OR = 0x40 ++ BPF_RELEASE = 0x30bb6 ++ BPF_RET = 0x6 ++ BPF_RND = 0xc0 ++ BPF_RSH = 0x70 ++ BPF_ST = 0x2 ++ BPF_STX = 0x3 ++ BPF_SUB = 0x10 ++ BPF_TAX = 0x0 ++ BPF_TXA = 0x80 ++ BPF_W = 0x0 ++ BPF_X = 0x8 ++ BRKINT = 0x2 ++ CFLUSH = 0xf ++ CLOCAL = 0x8000 ++ CREAD = 0x800 ++ CS5 = 0x0 ++ CS6 = 0x100 ++ CS7 = 0x200 ++ CS8 = 0x300 ++ CSIZE = 0x300 ++ CSTART = 0x11 ++ CSTATUS = 0xff ++ CSTOP = 0x13 ++ CSTOPB = 0x400 ++ CSUSP = 0x1a ++ CTL_MAXNAME = 0xc ++ CTL_NET = 0x4 ++ DIOCOSFPFLUSH = 0x2000444e ++ DLT_ARCNET = 0x7 ++ DLT_ATM_RFC1483 = 0xb ++ DLT_AX25 = 0x3 ++ DLT_CHAOS = 0x5 ++ DLT_C_HDLC = 0x68 ++ DLT_EN10MB = 0x1 ++ DLT_EN3MB = 0x2 ++ DLT_ENC = 0xd ++ DLT_FDDI = 0xa ++ DLT_IEEE802 = 0x6 ++ DLT_IEEE802_11 = 0x69 ++ DLT_IEEE802_11_RADIO = 0x7f ++ DLT_LOOP = 0xc ++ DLT_MPLS = 0xdb ++ DLT_NULL = 0x0 ++ DLT_OPENFLOW = 0x10b ++ DLT_PFLOG = 0x75 ++ DLT_PFSYNC = 0x12 ++ DLT_PPP = 0x9 ++ DLT_PPP_BSDOS = 0x10 ++ DLT_PPP_ETHER = 0x33 ++ DLT_PPP_SERIAL = 0x32 ++ DLT_PRONET = 0x4 ++ DLT_RAW = 0xe ++ DLT_SLIP = 0x8 ++ DLT_SLIP_BSDOS = 0xf ++ DLT_USBPCAP = 0xf9 ++ DLT_USER0 = 0x93 ++ DLT_USER1 = 0x94 ++ DLT_USER10 = 0x9d ++ DLT_USER11 = 0x9e ++ DLT_USER12 = 0x9f ++ DLT_USER13 = 0xa0 ++ DLT_USER14 = 0xa1 ++ DLT_USER15 = 0xa2 ++ DLT_USER2 = 0x95 ++ DLT_USER3 = 0x96 ++ DLT_USER4 = 0x97 ++ DLT_USER5 = 0x98 ++ DLT_USER6 = 0x99 ++ DLT_USER7 = 0x9a ++ DLT_USER8 = 0x9b ++ DLT_USER9 = 0x9c ++ DT_BLK = 0x6 ++ DT_CHR = 0x2 ++ DT_DIR = 0x4 ++ DT_FIFO = 0x1 ++ DT_LNK = 0xa ++ DT_REG = 0x8 ++ DT_SOCK = 0xc ++ DT_UNKNOWN = 0x0 ++ ECHO = 0x8 ++ ECHOCTL = 0x40 ++ ECHOE = 0x2 ++ ECHOK = 0x4 ++ ECHOKE = 0x1 ++ ECHONL = 0x10 ++ ECHOPRT = 0x20 ++ EMT_TAGOVF = 0x1 ++ EMUL_ENABLED = 0x1 ++ EMUL_NATIVE = 0x2 ++ ENDRUNDISC = 0x9 ++ ETH64_8021_RSVD_MASK = 0xfffffffffff0 ++ ETH64_8021_RSVD_PREFIX = 0x180c2000000 ++ ETHERMIN = 0x2e ++ ETHERMTU = 0x5dc ++ ETHERTYPE_8023 = 0x4 ++ ETHERTYPE_AARP = 0x80f3 ++ ETHERTYPE_ACCTON = 0x8390 ++ ETHERTYPE_AEONIC = 0x8036 ++ ETHERTYPE_ALPHA = 0x814a ++ ETHERTYPE_AMBER = 0x6008 ++ ETHERTYPE_AMOEBA = 0x8145 ++ ETHERTYPE_AOE = 0x88a2 ++ ETHERTYPE_APOLLO = 0x80f7 ++ ETHERTYPE_APOLLODOMAIN = 0x8019 ++ ETHERTYPE_APPLETALK = 0x809b ++ ETHERTYPE_APPLITEK = 0x80c7 ++ ETHERTYPE_ARGONAUT = 0x803a ++ ETHERTYPE_ARP = 0x806 ++ ETHERTYPE_AT = 0x809b ++ ETHERTYPE_ATALK = 0x809b ++ ETHERTYPE_ATOMIC = 0x86df ++ ETHERTYPE_ATT = 0x8069 ++ ETHERTYPE_ATTSTANFORD = 0x8008 ++ ETHERTYPE_AUTOPHON = 0x806a ++ ETHERTYPE_AXIS = 0x8856 ++ ETHERTYPE_BCLOOP = 0x9003 ++ ETHERTYPE_BOFL = 0x8102 ++ ETHERTYPE_CABLETRON = 0x7034 ++ ETHERTYPE_CHAOS = 0x804 ++ ETHERTYPE_COMDESIGN = 0x806c ++ ETHERTYPE_COMPUGRAPHIC = 0x806d ++ ETHERTYPE_COUNTERPOINT = 0x8062 ++ ETHERTYPE_CRONUS = 0x8004 ++ ETHERTYPE_CRONUSVLN = 0x8003 ++ ETHERTYPE_DCA = 0x1234 ++ ETHERTYPE_DDE = 0x807b ++ ETHERTYPE_DEBNI = 0xaaaa ++ ETHERTYPE_DECAM = 0x8048 ++ ETHERTYPE_DECCUST = 0x6006 ++ ETHERTYPE_DECDIAG = 0x6005 ++ ETHERTYPE_DECDNS = 0x803c ++ ETHERTYPE_DECDTS = 0x803e ++ ETHERTYPE_DECEXPER = 0x6000 ++ ETHERTYPE_DECLAST = 0x8041 ++ ETHERTYPE_DECLTM = 0x803f ++ ETHERTYPE_DECMUMPS = 0x6009 ++ ETHERTYPE_DECNETBIOS = 0x8040 ++ ETHERTYPE_DELTACON = 0x86de ++ ETHERTYPE_DIDDLE = 0x4321 ++ ETHERTYPE_DLOG1 = 0x660 ++ ETHERTYPE_DLOG2 = 0x661 ++ ETHERTYPE_DN = 0x6003 ++ ETHERTYPE_DOGFIGHT = 0x1989 ++ ETHERTYPE_DSMD = 0x8039 ++ ETHERTYPE_EAPOL = 0x888e ++ ETHERTYPE_ECMA = 0x803 ++ ETHERTYPE_ENCRYPT = 0x803d ++ ETHERTYPE_ES = 0x805d ++ ETHERTYPE_EXCELAN = 0x8010 ++ ETHERTYPE_EXPERDATA = 0x8049 ++ ETHERTYPE_FLIP = 0x8146 ++ ETHERTYPE_FLOWCONTROL = 0x8808 ++ ETHERTYPE_FRARP = 0x808 ++ ETHERTYPE_GENDYN = 0x8068 ++ ETHERTYPE_HAYES = 0x8130 ++ ETHERTYPE_HIPPI_FP = 0x8180 ++ ETHERTYPE_HITACHI = 0x8820 ++ ETHERTYPE_HP = 0x8005 ++ ETHERTYPE_IEEEPUP = 0xa00 ++ ETHERTYPE_IEEEPUPAT = 0xa01 ++ ETHERTYPE_IMLBL = 0x4c42 ++ ETHERTYPE_IMLBLDIAG = 0x424c ++ ETHERTYPE_IP = 0x800 ++ ETHERTYPE_IPAS = 0x876c ++ ETHERTYPE_IPV6 = 0x86dd ++ ETHERTYPE_IPX = 0x8137 ++ ETHERTYPE_IPXNEW = 0x8037 ++ ETHERTYPE_KALPANA = 0x8582 ++ ETHERTYPE_LANBRIDGE = 0x8038 ++ ETHERTYPE_LANPROBE = 0x8888 ++ ETHERTYPE_LAT = 0x6004 ++ ETHERTYPE_LBACK = 0x9000 ++ ETHERTYPE_LITTLE = 0x8060 ++ ETHERTYPE_LLDP = 0x88cc ++ ETHERTYPE_LOGICRAFT = 0x8148 ++ ETHERTYPE_LOOPBACK = 0x9000 ++ ETHERTYPE_MACSEC = 0x88e5 ++ ETHERTYPE_MATRA = 0x807a ++ ETHERTYPE_MAX = 0xffff ++ ETHERTYPE_MERIT = 0x807c ++ ETHERTYPE_MICP = 0x873a ++ ETHERTYPE_MOPDL = 0x6001 ++ ETHERTYPE_MOPRC = 0x6002 ++ ETHERTYPE_MOTOROLA = 0x818d ++ ETHERTYPE_MPLS = 0x8847 ++ ETHERTYPE_MPLS_MCAST = 0x8848 ++ ETHERTYPE_MUMPS = 0x813f ++ ETHERTYPE_NBPCC = 0x3c04 ++ ETHERTYPE_NBPCLAIM = 0x3c09 ++ ETHERTYPE_NBPCLREQ = 0x3c05 ++ ETHERTYPE_NBPCLRSP = 0x3c06 ++ ETHERTYPE_NBPCREQ = 0x3c02 ++ ETHERTYPE_NBPCRSP = 0x3c03 ++ ETHERTYPE_NBPDG = 0x3c07 ++ ETHERTYPE_NBPDGB = 0x3c08 ++ ETHERTYPE_NBPDLTE = 0x3c0a ++ ETHERTYPE_NBPRAR = 0x3c0c ++ ETHERTYPE_NBPRAS = 0x3c0b ++ ETHERTYPE_NBPRST = 0x3c0d ++ ETHERTYPE_NBPSCD = 0x3c01 ++ ETHERTYPE_NBPVCD = 0x3c00 ++ ETHERTYPE_NBS = 0x802 ++ ETHERTYPE_NCD = 0x8149 ++ ETHERTYPE_NESTAR = 0x8006 ++ ETHERTYPE_NETBEUI = 0x8191 ++ ETHERTYPE_NHRP = 0x2001 ++ ETHERTYPE_NOVELL = 0x8138 ++ ETHERTYPE_NS = 0x600 ++ ETHERTYPE_NSAT = 0x601 ++ ETHERTYPE_NSCOMPAT = 0x807 ++ ETHERTYPE_NSH = 0x984f ++ ETHERTYPE_NTRAILER = 0x10 ++ ETHERTYPE_OS9 = 0x7007 ++ ETHERTYPE_OS9NET = 0x7009 ++ ETHERTYPE_PACER = 0x80c6 ++ ETHERTYPE_PBB = 0x88e7 ++ ETHERTYPE_PCS = 0x4242 ++ ETHERTYPE_PLANNING = 0x8044 ++ ETHERTYPE_PPP = 0x880b ++ ETHERTYPE_PPPOE = 0x8864 ++ ETHERTYPE_PPPOEDISC = 0x8863 ++ ETHERTYPE_PRIMENTS = 0x7031 ++ ETHERTYPE_PUP = 0x200 ++ ETHERTYPE_PUPAT = 0x200 ++ ETHERTYPE_QINQ = 0x88a8 ++ ETHERTYPE_RACAL = 0x7030 ++ ETHERTYPE_RATIONAL = 0x8150 ++ ETHERTYPE_RAWFR = 0x6559 ++ ETHERTYPE_RCL = 0x1995 ++ ETHERTYPE_RDP = 0x8739 ++ ETHERTYPE_RETIX = 0x80f2 ++ ETHERTYPE_REVARP = 0x8035 ++ ETHERTYPE_SCA = 0x6007 ++ ETHERTYPE_SECTRA = 0x86db ++ ETHERTYPE_SECUREDATA = 0x876d ++ ETHERTYPE_SGITW = 0x817e ++ ETHERTYPE_SG_BOUNCE = 0x8016 ++ ETHERTYPE_SG_DIAG = 0x8013 ++ ETHERTYPE_SG_NETGAMES = 0x8014 ++ ETHERTYPE_SG_RESV = 0x8015 ++ ETHERTYPE_SIMNET = 0x5208 ++ ETHERTYPE_SLOW = 0x8809 ++ ETHERTYPE_SNA = 0x80d5 ++ ETHERTYPE_SNMP = 0x814c ++ ETHERTYPE_SONIX = 0xfaf5 ++ ETHERTYPE_SPIDER = 0x809f ++ ETHERTYPE_SPRITE = 0x500 ++ ETHERTYPE_STP = 0x8181 ++ ETHERTYPE_TALARIS = 0x812b ++ ETHERTYPE_TALARISMC = 0x852b ++ ETHERTYPE_TCPCOMP = 0x876b ++ ETHERTYPE_TCPSM = 0x9002 ++ ETHERTYPE_TEC = 0x814f ++ ETHERTYPE_TIGAN = 0x802f ++ ETHERTYPE_TRAIL = 0x1000 ++ ETHERTYPE_TRANSETHER = 0x6558 ++ ETHERTYPE_TYMSHARE = 0x802e ++ ETHERTYPE_UBBST = 0x7005 ++ ETHERTYPE_UBDEBUG = 0x900 ++ ETHERTYPE_UBDIAGLOOP = 0x7002 ++ ETHERTYPE_UBDL = 0x7000 ++ ETHERTYPE_UBNIU = 0x7001 ++ ETHERTYPE_UBNMC = 0x7003 ++ ETHERTYPE_VALID = 0x1600 ++ ETHERTYPE_VARIAN = 0x80dd ++ ETHERTYPE_VAXELN = 0x803b ++ ETHERTYPE_VEECO = 0x8067 ++ ETHERTYPE_VEXP = 0x805b ++ ETHERTYPE_VGLAB = 0x8131 ++ ETHERTYPE_VINES = 0xbad ++ ETHERTYPE_VINESECHO = 0xbaf ++ ETHERTYPE_VINESLOOP = 0xbae ++ ETHERTYPE_VITAL = 0xff00 ++ ETHERTYPE_VLAN = 0x8100 ++ ETHERTYPE_VLTLMAN = 0x8080 ++ ETHERTYPE_VPROD = 0x805c ++ ETHERTYPE_VURESERVED = 0x8147 ++ ETHERTYPE_WATERLOO = 0x8130 ++ ETHERTYPE_WELLFLEET = 0x8103 ++ ETHERTYPE_X25 = 0x805 ++ ETHERTYPE_X75 = 0x801 ++ ETHERTYPE_XNSSM = 0x9001 ++ ETHERTYPE_XTP = 0x817d ++ ETHER_ADDR_LEN = 0x6 ++ ETHER_ALIGN = 0x2 ++ ETHER_CRC_LEN = 0x4 ++ ETHER_CRC_POLY_BE = 0x4c11db6 ++ ETHER_CRC_POLY_LE = 0xedb88320 ++ ETHER_HDR_LEN = 0xe ++ ETHER_MAX_DIX_LEN = 0x600 ++ ETHER_MAX_HARDMTU_LEN = 0xff9b ++ ETHER_MAX_LEN = 0x5ee ++ ETHER_MIN_LEN = 0x40 ++ ETHER_TYPE_LEN = 0x2 ++ ETHER_VLAN_ENCAP_LEN = 0x4 ++ EVFILT_AIO = -0x3 ++ EVFILT_DEVICE = -0x8 ++ EVFILT_EXCEPT = -0x9 ++ EVFILT_PROC = -0x5 ++ EVFILT_READ = -0x1 ++ EVFILT_SIGNAL = -0x6 ++ EVFILT_SYSCOUNT = 0x9 ++ EVFILT_TIMER = -0x7 ++ EVFILT_VNODE = -0x4 ++ EVFILT_WRITE = -0x2 ++ EVL_ENCAPLEN = 0x4 ++ EVL_PRIO_BITS = 0xd ++ EVL_PRIO_MAX = 0x7 ++ EVL_VLID_MASK = 0xfff ++ EVL_VLID_MAX = 0xffe ++ EVL_VLID_MIN = 0x1 ++ EVL_VLID_NULL = 0x0 ++ EV_ADD = 0x1 ++ EV_CLEAR = 0x20 ++ EV_DELETE = 0x2 ++ EV_DISABLE = 0x8 ++ EV_DISPATCH = 0x80 ++ EV_ENABLE = 0x4 ++ EV_EOF = 0x8000 ++ EV_ERROR = 0x4000 ++ EV_FLAG1 = 0x2000 ++ EV_ONESHOT = 0x10 ++ EV_RECEIPT = 0x40 ++ EV_SYSFLAGS = 0xf800 ++ EXTA = 0x4b00 ++ EXTB = 0x9600 ++ EXTPROC = 0x800 ++ FD_CLOEXEC = 0x1 ++ FD_SETSIZE = 0x400 ++ FLUSHO = 0x800000 ++ F_DUPFD = 0x0 ++ F_DUPFD_CLOEXEC = 0xa ++ F_GETFD = 0x1 ++ F_GETFL = 0x3 ++ F_GETLK = 0x7 ++ F_GETOWN = 0x5 ++ F_ISATTY = 0xb ++ F_RDLCK = 0x1 ++ F_SETFD = 0x2 ++ F_SETFL = 0x4 ++ F_SETLK = 0x8 ++ F_SETLKW = 0x9 ++ F_SETOWN = 0x6 ++ F_UNLCK = 0x2 ++ F_WRLCK = 0x3 ++ HUPCL = 0x4000 ++ ICANON = 0x100 ++ ICMP6_FILTER = 0x12 ++ ICRNL = 0x100 ++ IEXTEN = 0x400 ++ IFAN_ARRIVAL = 0x0 ++ IFAN_DEPARTURE = 0x1 ++ IFF_ALLMULTI = 0x200 ++ IFF_BROADCAST = 0x2 ++ IFF_CANTCHANGE = 0x8e52 ++ IFF_DEBUG = 0x4 ++ IFF_LINK0 = 0x1000 ++ IFF_LINK1 = 0x2000 ++ IFF_LINK2 = 0x4000 ++ IFF_LOOPBACK = 0x8 ++ IFF_MULTICAST = 0x8000 ++ IFF_NOARP = 0x80 ++ IFF_OACTIVE = 0x400 ++ IFF_POINTOPOINT = 0x10 ++ IFF_PROMISC = 0x100 ++ IFF_RUNNING = 0x40 ++ IFF_SIMPLEX = 0x800 ++ IFF_STATICARP = 0x20 ++ IFF_UP = 0x1 ++ IFNAMSIZ = 0x10 ++ IFT_1822 = 0x2 ++ IFT_A12MPPSWITCH = 0x82 ++ IFT_AAL2 = 0xbb ++ IFT_AAL5 = 0x31 ++ IFT_ADSL = 0x5e ++ IFT_AFLANE8023 = 0x3b ++ IFT_AFLANE8025 = 0x3c ++ IFT_ARAP = 0x58 ++ IFT_ARCNET = 0x23 ++ IFT_ARCNETPLUS = 0x24 ++ IFT_ASYNC = 0x54 ++ IFT_ATM = 0x25 ++ IFT_ATMDXI = 0x69 ++ IFT_ATMFUNI = 0x6a ++ IFT_ATMIMA = 0x6b ++ IFT_ATMLOGICAL = 0x50 ++ IFT_ATMRADIO = 0xbd ++ IFT_ATMSUBINTERFACE = 0x86 ++ IFT_ATMVCIENDPT = 0xc2 ++ IFT_ATMVIRTUAL = 0x95 ++ IFT_BGPPOLICYACCOUNTING = 0xa2 ++ IFT_BLUETOOTH = 0xf8 ++ IFT_BRIDGE = 0xd1 ++ IFT_BSC = 0x53 ++ IFT_CARP = 0xf7 ++ IFT_CCTEMUL = 0x3d ++ IFT_CEPT = 0x13 ++ IFT_CES = 0x85 ++ IFT_CHANNEL = 0x46 ++ IFT_CNR = 0x55 ++ IFT_COFFEE = 0x84 ++ IFT_COMPOSITELINK = 0x9b ++ IFT_DCN = 0x8d ++ IFT_DIGITALPOWERLINE = 0x8a ++ IFT_DIGITALWRAPPEROVERHEADCHANNEL = 0xba ++ IFT_DLSW = 0x4a ++ IFT_DOCSCABLEDOWNSTREAM = 0x80 ++ IFT_DOCSCABLEMACLAYER = 0x7f ++ IFT_DOCSCABLEUPSTREAM = 0x81 ++ IFT_DOCSCABLEUPSTREAMCHANNEL = 0xcd ++ IFT_DS0 = 0x51 ++ IFT_DS0BUNDLE = 0x52 ++ IFT_DS1FDL = 0xaa ++ IFT_DS3 = 0x1e ++ IFT_DTM = 0x8c ++ IFT_DUMMY = 0xf1 ++ IFT_DVBASILN = 0xac ++ IFT_DVBASIOUT = 0xad ++ IFT_DVBRCCDOWNSTREAM = 0x93 ++ IFT_DVBRCCMACLAYER = 0x92 ++ IFT_DVBRCCUPSTREAM = 0x94 ++ IFT_ECONET = 0xce ++ IFT_ENC = 0xf4 ++ IFT_EON = 0x19 ++ IFT_EPLRS = 0x57 ++ IFT_ESCON = 0x49 ++ IFT_ETHER = 0x6 ++ IFT_FAITH = 0xf3 ++ IFT_FAST = 0x7d ++ IFT_FASTETHER = 0x3e ++ IFT_FASTETHERFX = 0x45 ++ IFT_FDDI = 0xf ++ IFT_FIBRECHANNEL = 0x38 ++ IFT_FRAMERELAYINTERCONNECT = 0x3a ++ IFT_FRAMERELAYMPI = 0x5c ++ IFT_FRDLCIENDPT = 0xc1 ++ IFT_FRELAY = 0x20 ++ IFT_FRELAYDCE = 0x2c ++ IFT_FRF16MFRBUNDLE = 0xa3 ++ IFT_FRFORWARD = 0x9e ++ IFT_G703AT2MB = 0x43 ++ IFT_G703AT64K = 0x42 ++ IFT_GIF = 0xf0 ++ IFT_GIGABITETHERNET = 0x75 ++ IFT_GR303IDT = 0xb2 ++ IFT_GR303RDT = 0xb1 ++ IFT_H323GATEKEEPER = 0xa4 ++ IFT_H323PROXY = 0xa5 ++ IFT_HDH1822 = 0x3 ++ IFT_HDLC = 0x76 ++ IFT_HDSL2 = 0xa8 ++ IFT_HIPERLAN2 = 0xb7 ++ IFT_HIPPI = 0x2f ++ IFT_HIPPIINTERFACE = 0x39 ++ IFT_HOSTPAD = 0x5a ++ IFT_HSSI = 0x2e ++ IFT_HY = 0xe ++ IFT_IBM370PARCHAN = 0x48 ++ IFT_IDSL = 0x9a ++ IFT_IEEE1394 = 0x90 ++ IFT_IEEE80211 = 0x47 ++ IFT_IEEE80212 = 0x37 ++ IFT_IEEE8023ADLAG = 0xa1 ++ IFT_IFGSN = 0x91 ++ IFT_IMT = 0xbe ++ IFT_INFINIBAND = 0xc7 ++ IFT_INTERLEAVE = 0x7c ++ IFT_IP = 0x7e ++ IFT_IPFORWARD = 0x8e ++ IFT_IPOVERATM = 0x72 ++ IFT_IPOVERCDLC = 0x6d ++ IFT_IPOVERCLAW = 0x6e ++ IFT_IPSWITCH = 0x4e ++ IFT_ISDN = 0x3f ++ IFT_ISDNBASIC = 0x14 ++ IFT_ISDNPRIMARY = 0x15 ++ IFT_ISDNS = 0x4b ++ IFT_ISDNU = 0x4c ++ IFT_ISO88022LLC = 0x29 ++ IFT_ISO88023 = 0x7 ++ IFT_ISO88024 = 0x8 ++ IFT_ISO88025 = 0x9 ++ IFT_ISO88025CRFPINT = 0x62 ++ IFT_ISO88025DTR = 0x56 ++ IFT_ISO88025FIBER = 0x73 ++ IFT_ISO88026 = 0xa ++ IFT_ISUP = 0xb3 ++ IFT_L2VLAN = 0x87 ++ IFT_L3IPVLAN = 0x88 ++ IFT_L3IPXVLAN = 0x89 ++ IFT_LAPB = 0x10 ++ IFT_LAPD = 0x4d ++ IFT_LAPF = 0x77 ++ IFT_LINEGROUP = 0xd2 ++ IFT_LOCALTALK = 0x2a ++ IFT_LOOP = 0x18 ++ IFT_MBIM = 0xfa ++ IFT_MEDIAMAILOVERIP = 0x8b ++ IFT_MFSIGLINK = 0xa7 ++ IFT_MIOX25 = 0x26 ++ IFT_MODEM = 0x30 ++ IFT_MPC = 0x71 ++ IFT_MPLS = 0xa6 ++ IFT_MPLSTUNNEL = 0x96 ++ IFT_MSDSL = 0x8f ++ IFT_MVL = 0xbf ++ IFT_MYRINET = 0x63 ++ IFT_NFAS = 0xaf ++ IFT_NSIP = 0x1b ++ IFT_OPTICALCHANNEL = 0xc3 ++ IFT_OPTICALTRANSPORT = 0xc4 ++ IFT_OTHER = 0x1 ++ IFT_P10 = 0xc ++ IFT_P80 = 0xd ++ IFT_PARA = 0x22 ++ IFT_PFLOG = 0xf5 ++ IFT_PFLOW = 0xf9 ++ IFT_PFSYNC = 0xf6 ++ IFT_PLC = 0xae ++ IFT_PON155 = 0xcf ++ IFT_PON622 = 0xd0 ++ IFT_POS = 0xab ++ IFT_PPP = 0x17 ++ IFT_PPPMULTILINKBUNDLE = 0x6c ++ IFT_PROPATM = 0xc5 ++ IFT_PROPBWAP2MP = 0xb8 ++ IFT_PROPCNLS = 0x59 ++ IFT_PROPDOCSWIRELESSDOWNSTREAM = 0xb5 ++ IFT_PROPDOCSWIRELESSMACLAYER = 0xb4 ++ IFT_PROPDOCSWIRELESSUPSTREAM = 0xb6 ++ IFT_PROPMUX = 0x36 ++ IFT_PROPVIRTUAL = 0x35 ++ IFT_PROPWIRELESSP2P = 0x9d ++ IFT_PTPSERIAL = 0x16 ++ IFT_PVC = 0xf2 ++ IFT_Q2931 = 0xc9 ++ IFT_QLLC = 0x44 ++ IFT_RADIOMAC = 0xbc ++ IFT_RADSL = 0x5f ++ IFT_REACHDSL = 0xc0 ++ IFT_RFC1483 = 0x9f ++ IFT_RS232 = 0x21 ++ IFT_RSRB = 0x4f ++ IFT_SDLC = 0x11 ++ IFT_SDSL = 0x60 ++ IFT_SHDSL = 0xa9 ++ IFT_SIP = 0x1f ++ IFT_SIPSIG = 0xcc ++ IFT_SIPTG = 0xcb ++ IFT_SLIP = 0x1c ++ IFT_SMDSDXI = 0x2b ++ IFT_SMDSICIP = 0x34 ++ IFT_SONET = 0x27 ++ IFT_SONETOVERHEADCHANNEL = 0xb9 ++ IFT_SONETPATH = 0x32 ++ IFT_SONETVT = 0x33 ++ IFT_SRP = 0x97 ++ IFT_SS7SIGLINK = 0x9c ++ IFT_STACKTOSTACK = 0x6f ++ IFT_STARLAN = 0xb ++ IFT_T1 = 0x12 ++ IFT_TDLC = 0x74 ++ IFT_TELINK = 0xc8 ++ IFT_TERMPAD = 0x5b ++ IFT_TR008 = 0xb0 ++ IFT_TRANSPHDLC = 0x7b ++ IFT_TUNNEL = 0x83 ++ IFT_ULTRA = 0x1d ++ IFT_USB = 0xa0 ++ IFT_V11 = 0x40 ++ IFT_V35 = 0x2d ++ IFT_V36 = 0x41 ++ IFT_V37 = 0x78 ++ IFT_VDSL = 0x61 ++ IFT_VIRTUALIPADDRESS = 0x70 ++ IFT_VIRTUALTG = 0xca ++ IFT_VOICEDID = 0xd5 ++ IFT_VOICEEM = 0x64 ++ IFT_VOICEEMFGD = 0xd3 ++ IFT_VOICEENCAP = 0x67 ++ IFT_VOICEFGDEANA = 0xd4 ++ IFT_VOICEFXO = 0x65 ++ IFT_VOICEFXS = 0x66 ++ IFT_VOICEOVERATM = 0x98 ++ IFT_VOICEOVERCABLE = 0xc6 ++ IFT_VOICEOVERFRAMERELAY = 0x99 ++ IFT_VOICEOVERIP = 0x68 ++ IFT_WIREGUARD = 0xfb ++ IFT_X213 = 0x5d ++ IFT_X25 = 0x5 ++ IFT_X25DDN = 0x4 ++ IFT_X25HUNTGROUP = 0x7a ++ IFT_X25MLP = 0x79 ++ IFT_X25PLE = 0x28 ++ IFT_XETHER = 0x1a ++ IGNBRK = 0x1 ++ IGNCR = 0x80 ++ IGNPAR = 0x4 ++ IMAXBEL = 0x2000 ++ INLCR = 0x40 ++ INPCK = 0x10 ++ IN_CLASSA_HOST = 0xffffff ++ IN_CLASSA_MAX = 0x80 ++ IN_CLASSA_NET = 0xff000000 ++ IN_CLASSA_NSHIFT = 0x18 ++ IN_CLASSB_HOST = 0xffff ++ IN_CLASSB_MAX = 0x10000 ++ IN_CLASSB_NET = 0xffff0000 ++ IN_CLASSB_NSHIFT = 0x10 ++ IN_CLASSC_HOST = 0xff ++ IN_CLASSC_NET = 0xffffff00 ++ IN_CLASSC_NSHIFT = 0x8 ++ IN_CLASSD_HOST = 0xfffffff ++ IN_CLASSD_NET = 0xf0000000 ++ IN_CLASSD_NSHIFT = 0x1c ++ IN_LOOPBACKNET = 0x7f ++ IN_RFC3021_HOST = 0x1 ++ IN_RFC3021_NET = 0xfffffffe ++ IN_RFC3021_NSHIFT = 0x1f ++ IPPROTO_AH = 0x33 ++ IPPROTO_CARP = 0x70 ++ IPPROTO_DIVERT = 0x102 ++ IPPROTO_DONE = 0x101 ++ IPPROTO_DSTOPTS = 0x3c ++ IPPROTO_EGP = 0x8 ++ IPPROTO_ENCAP = 0x62 ++ IPPROTO_EON = 0x50 ++ IPPROTO_ESP = 0x32 ++ IPPROTO_ETHERIP = 0x61 ++ IPPROTO_FRAGMENT = 0x2c ++ IPPROTO_GGP = 0x3 ++ IPPROTO_GRE = 0x2f ++ IPPROTO_HOPOPTS = 0x0 ++ IPPROTO_ICMP = 0x1 ++ IPPROTO_ICMPV6 = 0x3a ++ IPPROTO_IDP = 0x16 ++ IPPROTO_IGMP = 0x2 ++ IPPROTO_IP = 0x0 ++ IPPROTO_IPCOMP = 0x6c ++ IPPROTO_IPIP = 0x4 ++ IPPROTO_IPV4 = 0x4 ++ IPPROTO_IPV6 = 0x29 ++ IPPROTO_MAX = 0x100 ++ IPPROTO_MAXID = 0x103 ++ IPPROTO_MOBILE = 0x37 ++ IPPROTO_MPLS = 0x89 ++ IPPROTO_NONE = 0x3b ++ IPPROTO_PFSYNC = 0xf0 ++ IPPROTO_PIM = 0x67 ++ IPPROTO_PUP = 0xc ++ IPPROTO_RAW = 0xff ++ IPPROTO_ROUTING = 0x2b ++ IPPROTO_RSVP = 0x2e ++ IPPROTO_SCTP = 0x84 ++ IPPROTO_TCP = 0x6 ++ IPPROTO_TP = 0x1d ++ IPPROTO_UDP = 0x11 ++ IPPROTO_UDPLITE = 0x88 ++ IPV6_AUTH_LEVEL = 0x35 ++ IPV6_AUTOFLOWLABEL = 0x3b ++ IPV6_CHECKSUM = 0x1a ++ IPV6_DEFAULT_MULTICAST_HOPS = 0x1 ++ IPV6_DEFAULT_MULTICAST_LOOP = 0x1 ++ IPV6_DEFHLIM = 0x40 ++ IPV6_DONTFRAG = 0x3e ++ IPV6_DSTOPTS = 0x32 ++ IPV6_ESP_NETWORK_LEVEL = 0x37 ++ IPV6_ESP_TRANS_LEVEL = 0x36 ++ IPV6_FAITH = 0x1d ++ IPV6_FLOWINFO_MASK = 0xffffff0f ++ IPV6_FLOWLABEL_MASK = 0xffff0f00 ++ IPV6_FRAGTTL = 0x78 ++ IPV6_HLIMDEC = 0x1 ++ IPV6_HOPLIMIT = 0x2f ++ IPV6_HOPOPTS = 0x31 ++ IPV6_IPCOMP_LEVEL = 0x3c ++ IPV6_JOIN_GROUP = 0xc ++ IPV6_LEAVE_GROUP = 0xd ++ IPV6_MAXHLIM = 0xff ++ IPV6_MAXPACKET = 0xffff ++ IPV6_MINHOPCOUNT = 0x41 ++ IPV6_MMTU = 0x500 ++ IPV6_MULTICAST_HOPS = 0xa ++ IPV6_MULTICAST_IF = 0x9 ++ IPV6_MULTICAST_LOOP = 0xb ++ IPV6_NEXTHOP = 0x30 ++ IPV6_OPTIONS = 0x1 ++ IPV6_PATHMTU = 0x2c ++ IPV6_PIPEX = 0x3f ++ IPV6_PKTINFO = 0x2e ++ IPV6_PORTRANGE = 0xe ++ IPV6_PORTRANGE_DEFAULT = 0x0 ++ IPV6_PORTRANGE_HIGH = 0x1 ++ IPV6_PORTRANGE_LOW = 0x2 ++ IPV6_RECVDSTOPTS = 0x28 ++ IPV6_RECVDSTPORT = 0x40 ++ IPV6_RECVHOPLIMIT = 0x25 ++ IPV6_RECVHOPOPTS = 0x27 ++ IPV6_RECVPATHMTU = 0x2b ++ IPV6_RECVPKTINFO = 0x24 ++ IPV6_RECVRTHDR = 0x26 ++ IPV6_RECVTCLASS = 0x39 ++ IPV6_RTABLE = 0x1021 ++ IPV6_RTHDR = 0x33 ++ IPV6_RTHDRDSTOPTS = 0x23 ++ IPV6_RTHDR_LOOSE = 0x0 ++ IPV6_RTHDR_STRICT = 0x1 ++ IPV6_RTHDR_TYPE_0 = 0x0 ++ IPV6_SOCKOPT_RESERVED1 = 0x3 ++ IPV6_TCLASS = 0x3d ++ IPV6_UNICAST_HOPS = 0x4 ++ IPV6_USE_MIN_MTU = 0x2a ++ IPV6_V6ONLY = 0x1b ++ IPV6_VERSION = 0x60 ++ IPV6_VERSION_MASK = 0xf0 ++ IP_ADD_MEMBERSHIP = 0xc ++ IP_AUTH_LEVEL = 0x14 ++ IP_DEFAULT_MULTICAST_LOOP = 0x1 ++ IP_DEFAULT_MULTICAST_TTL = 0x1 ++ IP_DF = 0x4000 ++ IP_DROP_MEMBERSHIP = 0xd ++ IP_ESP_NETWORK_LEVEL = 0x16 ++ IP_ESP_TRANS_LEVEL = 0x15 ++ IP_HDRINCL = 0x2 ++ IP_IPCOMP_LEVEL = 0x1d ++ IP_IPDEFTTL = 0x25 ++ IP_IPSECFLOWINFO = 0x24 ++ IP_IPSEC_LOCAL_AUTH = 0x1b ++ IP_IPSEC_LOCAL_CRED = 0x19 ++ IP_IPSEC_LOCAL_ID = 0x17 ++ IP_IPSEC_REMOTE_AUTH = 0x1c ++ IP_IPSEC_REMOTE_CRED = 0x1a ++ IP_IPSEC_REMOTE_ID = 0x18 ++ IP_MAXPACKET = 0xffff ++ IP_MAX_MEMBERSHIPS = 0xfff ++ IP_MF = 0x2000 ++ IP_MINTTL = 0x20 ++ IP_MIN_MEMBERSHIPS = 0xf ++ IP_MSS = 0x240 ++ IP_MULTICAST_IF = 0x9 ++ IP_MULTICAST_LOOP = 0xb ++ IP_MULTICAST_TTL = 0xa ++ IP_OFFMASK = 0x1fff ++ IP_OPTIONS = 0x1 ++ IP_PIPEX = 0x22 ++ IP_PORTRANGE = 0x13 ++ IP_PORTRANGE_DEFAULT = 0x0 ++ IP_PORTRANGE_HIGH = 0x1 ++ IP_PORTRANGE_LOW = 0x2 ++ IP_RECVDSTADDR = 0x7 ++ IP_RECVDSTPORT = 0x21 ++ IP_RECVIF = 0x1e ++ IP_RECVOPTS = 0x5 ++ IP_RECVRETOPTS = 0x6 ++ IP_RECVRTABLE = 0x23 ++ IP_RECVTTL = 0x1f ++ IP_RETOPTS = 0x8 ++ IP_RF = 0x8000 ++ IP_RTABLE = 0x1021 ++ IP_SENDSRCADDR = 0x7 ++ IP_TOS = 0x3 ++ IP_TTL = 0x4 ++ ISIG = 0x80 ++ ISTRIP = 0x20 ++ IXANY = 0x800 ++ IXOFF = 0x400 ++ IXON = 0x200 ++ LCNT_OVERLOAD_FLUSH = 0x6 ++ LOCK_EX = 0x2 ++ LOCK_NB = 0x4 ++ LOCK_SH = 0x1 ++ LOCK_UN = 0x8 ++ MADV_DONTNEED = 0x4 ++ MADV_FREE = 0x6 ++ MADV_NORMAL = 0x0 ++ MADV_RANDOM = 0x1 ++ MADV_SEQUENTIAL = 0x2 ++ MADV_SPACEAVAIL = 0x5 ++ MADV_WILLNEED = 0x3 ++ MAP_ANON = 0x1000 ++ MAP_ANONYMOUS = 0x1000 ++ MAP_CONCEAL = 0x8000 ++ MAP_COPY = 0x2 ++ MAP_FILE = 0x0 ++ MAP_FIXED = 0x10 ++ MAP_FLAGMASK = 0xfff7 ++ MAP_HASSEMAPHORE = 0x0 ++ MAP_INHERIT = 0x0 ++ MAP_INHERIT_COPY = 0x1 ++ MAP_INHERIT_NONE = 0x2 ++ MAP_INHERIT_SHARE = 0x0 ++ MAP_INHERIT_ZERO = 0x3 ++ MAP_NOEXTEND = 0x0 ++ MAP_NORESERVE = 0x0 ++ MAP_PRIVATE = 0x2 ++ MAP_RENAME = 0x0 ++ MAP_SHARED = 0x1 ++ MAP_STACK = 0x4000 ++ MAP_TRYFIXED = 0x0 ++ MCL_CURRENT = 0x1 ++ MCL_FUTURE = 0x2 ++ MSG_BCAST = 0x100 ++ MSG_CMSG_CLOEXEC = 0x800 ++ MSG_CTRUNC = 0x20 ++ MSG_DONTROUTE = 0x4 ++ MSG_DONTWAIT = 0x80 ++ MSG_EOR = 0x8 ++ MSG_MCAST = 0x200 ++ MSG_NOSIGNAL = 0x400 ++ MSG_OOB = 0x1 ++ MSG_PEEK = 0x2 ++ MSG_TRUNC = 0x10 ++ MSG_WAITALL = 0x40 ++ MS_ASYNC = 0x1 ++ MS_INVALIDATE = 0x4 ++ MS_SYNC = 0x2 ++ NAME_MAX = 0xff ++ NET_RT_DUMP = 0x1 ++ NET_RT_FLAGS = 0x2 ++ NET_RT_IFLIST = 0x3 ++ NET_RT_IFNAMES = 0x6 ++ NET_RT_MAXID = 0x8 ++ NET_RT_SOURCE = 0x7 ++ NET_RT_STATS = 0x4 ++ NET_RT_TABLE = 0x5 ++ NOFLSH = 0x80000000 ++ NOTE_ATTRIB = 0x8 ++ NOTE_CHANGE = 0x1 ++ NOTE_CHILD = 0x4 ++ NOTE_DELETE = 0x1 ++ NOTE_EOF = 0x2 ++ NOTE_EXEC = 0x20000000 ++ NOTE_EXIT = 0x80000000 ++ NOTE_EXTEND = 0x4 ++ NOTE_FORK = 0x40000000 ++ NOTE_LINK = 0x10 ++ NOTE_LOWAT = 0x1 ++ NOTE_OOB = 0x4 ++ NOTE_PCTRLMASK = 0xf0000000 ++ NOTE_PDATAMASK = 0xfffff ++ NOTE_RENAME = 0x20 ++ NOTE_REVOKE = 0x40 ++ NOTE_TRACK = 0x1 ++ NOTE_TRACKERR = 0x2 ++ NOTE_TRUNCATE = 0x80 ++ NOTE_WRITE = 0x2 ++ OCRNL = 0x10 ++ ONLCR = 0x2 ++ ONLRET = 0x80 ++ ONOCR = 0x40 ++ ONOEOT = 0x8 ++ OPOST = 0x1 ++ O_ACCMODE = 0x3 ++ O_APPEND = 0x8 ++ O_ASYNC = 0x40 ++ O_CLOEXEC = 0x10000 ++ O_CREAT = 0x200 ++ O_DIRECTORY = 0x20000 ++ O_DSYNC = 0x80 ++ O_EXCL = 0x800 ++ O_EXLOCK = 0x20 ++ O_FSYNC = 0x80 ++ O_NDELAY = 0x4 ++ O_NOCTTY = 0x8000 ++ O_NOFOLLOW = 0x100 ++ O_NONBLOCK = 0x4 ++ O_RDONLY = 0x0 ++ O_RDWR = 0x2 ++ O_RSYNC = 0x80 ++ O_SHLOCK = 0x10 ++ O_SYNC = 0x80 ++ O_TRUNC = 0x400 ++ O_WRONLY = 0x1 ++ PARENB = 0x1000 ++ PARMRK = 0x8 ++ PARODD = 0x2000 ++ PENDIN = 0x20000000 ++ PF_FLUSH = 0x1 ++ PRIO_PGRP = 0x1 ++ PRIO_PROCESS = 0x0 ++ PRIO_USER = 0x2 ++ PROT_EXEC = 0x4 ++ PROT_NONE = 0x0 ++ PROT_READ = 0x1 ++ PROT_WRITE = 0x2 ++ RLIMIT_CORE = 0x4 ++ RLIMIT_CPU = 0x0 ++ RLIMIT_DATA = 0x2 ++ RLIMIT_FSIZE = 0x1 ++ RLIMIT_NOFILE = 0x8 ++ RLIMIT_STACK = 0x3 ++ RLIM_INFINITY = 0x7fffffffffffffff ++ RTAX_AUTHOR = 0x6 ++ RTAX_BFD = 0xb ++ RTAX_BRD = 0x7 ++ RTAX_DNS = 0xc ++ RTAX_DST = 0x0 ++ RTAX_GATEWAY = 0x1 ++ RTAX_GENMASK = 0x3 ++ RTAX_IFA = 0x5 ++ RTAX_IFP = 0x4 ++ RTAX_LABEL = 0xa ++ RTAX_MAX = 0xf ++ RTAX_NETMASK = 0x2 ++ RTAX_SEARCH = 0xe ++ RTAX_SRC = 0x8 ++ RTAX_SRCMASK = 0x9 ++ RTAX_STATIC = 0xd ++ RTA_AUTHOR = 0x40 ++ RTA_BFD = 0x800 ++ RTA_BRD = 0x80 ++ RTA_DNS = 0x1000 ++ RTA_DST = 0x1 ++ RTA_GATEWAY = 0x2 ++ RTA_GENMASK = 0x8 ++ RTA_IFA = 0x20 ++ RTA_IFP = 0x10 ++ RTA_LABEL = 0x400 ++ RTA_NETMASK = 0x4 ++ RTA_SEARCH = 0x4000 ++ RTA_SRC = 0x100 ++ RTA_SRCMASK = 0x200 ++ RTA_STATIC = 0x2000 ++ RTF_ANNOUNCE = 0x4000 ++ RTF_BFD = 0x1000000 ++ RTF_BLACKHOLE = 0x1000 ++ RTF_BROADCAST = 0x400000 ++ RTF_CACHED = 0x20000 ++ RTF_CLONED = 0x10000 ++ RTF_CLONING = 0x100 ++ RTF_CONNECTED = 0x800000 ++ RTF_DONE = 0x40 ++ RTF_DYNAMIC = 0x10 ++ RTF_FMASK = 0x110fc08 ++ RTF_GATEWAY = 0x2 ++ RTF_HOST = 0x4 ++ RTF_LLINFO = 0x400 ++ RTF_LOCAL = 0x200000 ++ RTF_MODIFIED = 0x20 ++ RTF_MPATH = 0x40000 ++ RTF_MPLS = 0x100000 ++ RTF_MULTICAST = 0x200 ++ RTF_PERMANENT_ARP = 0x2000 ++ RTF_PROTO1 = 0x8000 ++ RTF_PROTO2 = 0x4000 ++ RTF_PROTO3 = 0x2000 ++ RTF_REJECT = 0x8 ++ RTF_STATIC = 0x800 ++ RTF_UP = 0x1 ++ RTF_USETRAILERS = 0x8000 ++ RTM_80211INFO = 0x15 ++ RTM_ADD = 0x1 ++ RTM_BFD = 0x12 ++ RTM_CHANGE = 0x3 ++ RTM_CHGADDRATTR = 0x14 ++ RTM_DELADDR = 0xd ++ RTM_DELETE = 0x2 ++ RTM_DESYNC = 0x10 ++ RTM_GET = 0x4 ++ RTM_IFANNOUNCE = 0xf ++ RTM_IFINFO = 0xe ++ RTM_INVALIDATE = 0x11 ++ RTM_LOSING = 0x5 ++ RTM_MAXSIZE = 0x800 ++ RTM_MISS = 0x7 ++ RTM_NEWADDR = 0xc ++ RTM_PROPOSAL = 0x13 ++ RTM_REDIRECT = 0x6 ++ RTM_RESOLVE = 0xb ++ RTM_SOURCE = 0x16 ++ RTM_VERSION = 0x5 ++ RTV_EXPIRE = 0x4 ++ RTV_HOPCOUNT = 0x2 ++ RTV_MTU = 0x1 ++ RTV_RPIPE = 0x8 ++ RTV_RTT = 0x40 ++ RTV_RTTVAR = 0x80 ++ RTV_SPIPE = 0x10 ++ RTV_SSTHRESH = 0x20 ++ RT_TABLEID_BITS = 0x8 ++ RT_TABLEID_MASK = 0xff ++ RT_TABLEID_MAX = 0xff ++ RUSAGE_CHILDREN = -0x1 ++ RUSAGE_SELF = 0x0 ++ RUSAGE_THREAD = 0x1 ++ SCM_RIGHTS = 0x1 ++ SCM_TIMESTAMP = 0x4 ++ SHUT_RD = 0x0 ++ SHUT_RDWR = 0x2 ++ SHUT_WR = 0x1 ++ SIOCADDMULTI = 0x80206931 ++ SIOCAIFADDR = 0x8040691a ++ SIOCAIFGROUP = 0x80286987 ++ SIOCATMARK = 0x40047307 ++ SIOCBRDGADD = 0x8060693c ++ SIOCBRDGADDL = 0x80606949 ++ SIOCBRDGADDS = 0x80606941 ++ SIOCBRDGARL = 0x808c694d ++ SIOCBRDGDADDR = 0x81286947 ++ SIOCBRDGDEL = 0x8060693d ++ SIOCBRDGDELS = 0x80606942 ++ SIOCBRDGFLUSH = 0x80606948 ++ SIOCBRDGFRL = 0x808c694e ++ SIOCBRDGGCACHE = 0xc0146941 ++ SIOCBRDGGFD = 0xc0146952 ++ SIOCBRDGGHT = 0xc0146951 ++ SIOCBRDGGIFFLGS = 0xc060693e ++ SIOCBRDGGMA = 0xc0146953 ++ SIOCBRDGGPARAM = 0xc0406958 ++ SIOCBRDGGPRI = 0xc0146950 ++ SIOCBRDGGRL = 0xc030694f ++ SIOCBRDGGTO = 0xc0146946 ++ SIOCBRDGIFS = 0xc0606942 ++ SIOCBRDGRTS = 0xc0206943 ++ SIOCBRDGSADDR = 0xc1286944 ++ SIOCBRDGSCACHE = 0x80146940 ++ SIOCBRDGSFD = 0x80146952 ++ SIOCBRDGSHT = 0x80146951 ++ SIOCBRDGSIFCOST = 0x80606955 ++ SIOCBRDGSIFFLGS = 0x8060693f ++ SIOCBRDGSIFPRIO = 0x80606954 ++ SIOCBRDGSIFPROT = 0x8060694a ++ SIOCBRDGSMA = 0x80146953 ++ SIOCBRDGSPRI = 0x80146950 ++ SIOCBRDGSPROTO = 0x8014695a ++ SIOCBRDGSTO = 0x80146945 ++ SIOCBRDGSTXHC = 0x80146959 ++ SIOCDELLABEL = 0x80206997 ++ SIOCDELMULTI = 0x80206932 ++ SIOCDIFADDR = 0x80206919 ++ SIOCDIFGROUP = 0x80286989 ++ SIOCDIFPARENT = 0x802069b4 ++ SIOCDIFPHYADDR = 0x80206949 ++ SIOCDPWE3NEIGHBOR = 0x802069de ++ SIOCDVNETID = 0x802069af ++ SIOCGETKALIVE = 0xc01869a4 ++ SIOCGETLABEL = 0x8020699a ++ SIOCGETMPWCFG = 0xc02069ae ++ SIOCGETPFLOW = 0xc02069fe ++ SIOCGETPFSYNC = 0xc02069f8 ++ SIOCGETSGCNT = 0xc0207534 ++ SIOCGETVIFCNT = 0xc0287533 ++ SIOCGETVLAN = 0xc0206990 ++ SIOCGIFADDR = 0xc0206921 ++ SIOCGIFBRDADDR = 0xc0206923 ++ SIOCGIFCONF = 0xc0106924 ++ SIOCGIFDATA = 0xc020691b ++ SIOCGIFDESCR = 0xc0206981 ++ SIOCGIFDSTADDR = 0xc0206922 ++ SIOCGIFFLAGS = 0xc0206911 ++ SIOCGIFGATTR = 0xc028698b ++ SIOCGIFGENERIC = 0xc020693a ++ SIOCGIFGLIST = 0xc028698d ++ SIOCGIFGMEMB = 0xc028698a ++ SIOCGIFGROUP = 0xc0286988 ++ SIOCGIFHARDMTU = 0xc02069a5 ++ SIOCGIFLLPRIO = 0xc02069b6 ++ SIOCGIFMEDIA = 0xc0406938 ++ SIOCGIFMETRIC = 0xc0206917 ++ SIOCGIFMTU = 0xc020697e ++ SIOCGIFNETMASK = 0xc0206925 ++ SIOCGIFPAIR = 0xc02069b1 ++ SIOCGIFPARENT = 0xc02069b3 ++ SIOCGIFPRIORITY = 0xc020699c ++ SIOCGIFRDOMAIN = 0xc02069a0 ++ SIOCGIFRTLABEL = 0xc0206983 ++ SIOCGIFRXR = 0x802069aa ++ SIOCGIFSFFPAGE = 0xc1126939 ++ SIOCGIFXFLAGS = 0xc020699e ++ SIOCGLIFPHYADDR = 0xc218694b ++ SIOCGLIFPHYDF = 0xc02069c2 ++ SIOCGLIFPHYECN = 0xc02069c8 ++ SIOCGLIFPHYRTABLE = 0xc02069a2 ++ SIOCGLIFPHYTTL = 0xc02069a9 ++ SIOCGPGRP = 0x40047309 ++ SIOCGPWE3 = 0xc0206998 ++ SIOCGPWE3CTRLWORD = 0xc02069dc ++ SIOCGPWE3FAT = 0xc02069dd ++ SIOCGPWE3NEIGHBOR = 0xc21869de ++ SIOCGRXHPRIO = 0xc02069db ++ SIOCGSPPPPARAMS = 0xc0206994 ++ SIOCGTXHPRIO = 0xc02069c6 ++ SIOCGUMBINFO = 0xc02069be ++ SIOCGUMBPARAM = 0xc02069c0 ++ SIOCGVH = 0xc02069f6 ++ SIOCGVNETFLOWID = 0xc02069c4 ++ SIOCGVNETID = 0xc02069a7 ++ SIOCIFAFATTACH = 0x801169ab ++ SIOCIFAFDETACH = 0x801169ac ++ SIOCIFCREATE = 0x8020697a ++ SIOCIFDESTROY = 0x80206979 ++ SIOCIFGCLONERS = 0xc0106978 ++ SIOCSETKALIVE = 0x801869a3 ++ SIOCSETLABEL = 0x80206999 ++ SIOCSETMPWCFG = 0x802069ad ++ SIOCSETPFLOW = 0x802069fd ++ SIOCSETPFSYNC = 0x802069f7 ++ SIOCSETVLAN = 0x8020698f ++ SIOCSIFADDR = 0x8020690c ++ SIOCSIFBRDADDR = 0x80206913 ++ SIOCSIFDESCR = 0x80206980 ++ SIOCSIFDSTADDR = 0x8020690e ++ SIOCSIFFLAGS = 0x80206910 ++ SIOCSIFGATTR = 0x8028698c ++ SIOCSIFGENERIC = 0x80206939 ++ SIOCSIFLLADDR = 0x8020691f ++ SIOCSIFLLPRIO = 0x802069b5 ++ SIOCSIFMEDIA = 0xc0206937 ++ SIOCSIFMETRIC = 0x80206918 ++ SIOCSIFMTU = 0x8020697f ++ SIOCSIFNETMASK = 0x80206916 ++ SIOCSIFPAIR = 0x802069b0 ++ SIOCSIFPARENT = 0x802069b2 ++ SIOCSIFPRIORITY = 0x8020699b ++ SIOCSIFRDOMAIN = 0x8020699f ++ SIOCSIFRTLABEL = 0x80206982 ++ SIOCSIFXFLAGS = 0x8020699d ++ SIOCSLIFPHYADDR = 0x8218694a ++ SIOCSLIFPHYDF = 0x802069c1 ++ SIOCSLIFPHYECN = 0x802069c7 ++ SIOCSLIFPHYRTABLE = 0x802069a1 ++ SIOCSLIFPHYTTL = 0x802069a8 ++ SIOCSPGRP = 0x80047308 ++ SIOCSPWE3CTRLWORD = 0x802069dc ++ SIOCSPWE3FAT = 0x802069dd ++ SIOCSPWE3NEIGHBOR = 0x821869de ++ SIOCSRXHPRIO = 0x802069db ++ SIOCSSPPPPARAMS = 0x80206993 ++ SIOCSTXHPRIO = 0x802069c5 ++ SIOCSUMBPARAM = 0x802069bf ++ SIOCSVH = 0xc02069f5 ++ SIOCSVNETFLOWID = 0x802069c3 ++ SIOCSVNETID = 0x802069a6 ++ SOCK_CLOEXEC = 0x8000 ++ SOCK_DGRAM = 0x2 ++ SOCK_DNS = 0x1000 ++ SOCK_NONBLOCK = 0x4000 ++ SOCK_RAW = 0x3 ++ SOCK_RDM = 0x4 ++ SOCK_SEQPACKET = 0x5 ++ SOCK_STREAM = 0x1 ++ SOL_SOCKET = 0xffff ++ SOMAXCONN = 0x80 ++ SO_ACCEPTCONN = 0x2 ++ SO_BINDANY = 0x1000 ++ SO_BROADCAST = 0x20 ++ SO_DEBUG = 0x1 ++ SO_DOMAIN = 0x1024 ++ SO_DONTROUTE = 0x10 ++ SO_ERROR = 0x1007 ++ SO_KEEPALIVE = 0x8 ++ SO_LINGER = 0x80 ++ SO_NETPROC = 0x1020 ++ SO_OOBINLINE = 0x100 ++ SO_PEERCRED = 0x1022 ++ SO_PROTOCOL = 0x1025 ++ SO_RCVBUF = 0x1002 ++ SO_RCVLOWAT = 0x1004 ++ SO_RCVTIMEO = 0x1006 ++ SO_REUSEADDR = 0x4 ++ SO_REUSEPORT = 0x200 ++ SO_RTABLE = 0x1021 ++ SO_SNDBUF = 0x1001 ++ SO_SNDLOWAT = 0x1003 ++ SO_SNDTIMEO = 0x1005 ++ SO_SPLICE = 0x1023 ++ SO_TIMESTAMP = 0x800 ++ SO_TYPE = 0x1008 ++ SO_USELOOPBACK = 0x40 ++ SO_ZEROIZE = 0x2000 ++ TCIFLUSH = 0x1 ++ TCIOFLUSH = 0x3 ++ TCOFLUSH = 0x2 ++ TCP_INFO = 0x9 ++ TCP_MAXSEG = 0x2 ++ TCP_MAXWIN = 0xffff ++ TCP_MAX_SACK = 0x3 ++ TCP_MAX_WINSHIFT = 0xe ++ TCP_MD5SIG = 0x4 ++ TCP_MSS = 0x200 ++ TCP_NODELAY = 0x1 ++ TCP_NOPUSH = 0x10 ++ TCP_SACKHOLE_LIMIT = 0x80 ++ TCP_SACK_ENABLE = 0x8 ++ TCSAFLUSH = 0x2 ++ TIOCCBRK = 0x2000747a ++ TIOCCDTR = 0x20007478 ++ TIOCCHKVERAUTH = 0x2000741e ++ TIOCCLRVERAUTH = 0x2000741d ++ TIOCCONS = 0x80047462 ++ TIOCDRAIN = 0x2000745e ++ TIOCEXCL = 0x2000740d ++ TIOCEXT = 0x80047460 ++ TIOCFLAG_CLOCAL = 0x2 ++ TIOCFLAG_CRTSCTS = 0x4 ++ TIOCFLAG_MDMBUF = 0x8 ++ TIOCFLAG_PPS = 0x10 ++ TIOCFLAG_SOFTCAR = 0x1 ++ TIOCFLUSH = 0x80047410 ++ TIOCGETA = 0x402c7413 ++ TIOCGETD = 0x4004741a ++ TIOCGFLAGS = 0x4004745d ++ TIOCGPGRP = 0x40047477 ++ TIOCGSID = 0x40047463 ++ TIOCGTSTAMP = 0x4010745b ++ TIOCGWINSZ = 0x40087468 ++ TIOCMBIC = 0x8004746b ++ TIOCMBIS = 0x8004746c ++ TIOCMGET = 0x4004746a ++ TIOCMODG = 0x4004746a ++ TIOCMODS = 0x8004746d ++ TIOCMSET = 0x8004746d ++ TIOCM_CAR = 0x40 ++ TIOCM_CD = 0x40 ++ TIOCM_CTS = 0x20 ++ TIOCM_DSR = 0x100 ++ TIOCM_DTR = 0x2 ++ TIOCM_LE = 0x1 ++ TIOCM_RI = 0x80 ++ TIOCM_RNG = 0x80 ++ TIOCM_RTS = 0x4 ++ TIOCM_SR = 0x10 ++ TIOCM_ST = 0x8 ++ TIOCNOTTY = 0x20007471 ++ TIOCNXCL = 0x2000740e ++ TIOCOUTQ = 0x40047473 ++ TIOCPKT = 0x80047470 ++ TIOCPKT_DATA = 0x0 ++ TIOCPKT_DOSTOP = 0x20 ++ TIOCPKT_FLUSHREAD = 0x1 ++ TIOCPKT_FLUSHWRITE = 0x2 ++ TIOCPKT_IOCTL = 0x40 ++ TIOCPKT_NOSTOP = 0x10 ++ TIOCPKT_START = 0x8 ++ TIOCPKT_STOP = 0x4 ++ TIOCREMOTE = 0x80047469 ++ TIOCSBRK = 0x2000747b ++ TIOCSCTTY = 0x20007461 ++ TIOCSDTR = 0x20007479 ++ TIOCSETA = 0x802c7414 ++ TIOCSETAF = 0x802c7416 ++ TIOCSETAW = 0x802c7415 ++ TIOCSETD = 0x8004741b ++ TIOCSETVERAUTH = 0x8004741c ++ TIOCSFLAGS = 0x8004745c ++ TIOCSIG = 0x8004745f ++ TIOCSPGRP = 0x80047476 ++ TIOCSTART = 0x2000746e ++ TIOCSTAT = 0x20007465 ++ TIOCSTOP = 0x2000746f ++ TIOCSTSTAMP = 0x8008745a ++ TIOCSWINSZ = 0x80087467 ++ TIOCUCNTL = 0x80047466 ++ TIOCUCNTL_CBRK = 0x7a ++ TIOCUCNTL_SBRK = 0x7b ++ TOSTOP = 0x400000 ++ VDISCARD = 0xf ++ VDSUSP = 0xb ++ VEOF = 0x0 ++ VEOL = 0x1 ++ VEOL2 = 0x2 ++ VERASE = 0x3 ++ VINTR = 0x8 ++ VKILL = 0x5 ++ VLNEXT = 0xe ++ VMIN = 0x10 ++ VQUIT = 0x9 ++ VREPRINT = 0x6 ++ VSTART = 0xc ++ VSTATUS = 0x12 ++ VSTOP = 0xd ++ VSUSP = 0xa ++ VTIME = 0x11 ++ VWERASE = 0x4 ++ WALTSIG = 0x4 ++ WCONTINUED = 0x8 ++ WCOREFLAG = 0x80 ++ WNOHANG = 0x1 ++ WUNTRACED = 0x2 ++) ++ ++// Errors ++const ( ++ E2BIG = Errno(0x7) ++ EACCES = Errno(0xd) ++ EADDRINUSE = Errno(0x30) ++ EADDRNOTAVAIL = Errno(0x31) ++ EAFNOSUPPORT = Errno(0x2f) ++ EAGAIN = Errno(0x23) ++ EALREADY = Errno(0x25) ++ EAUTH = Errno(0x50) ++ EBADF = Errno(0x9) ++ EBADMSG = Errno(0x5c) ++ EBADRPC = Errno(0x48) ++ EBUSY = Errno(0x10) ++ ECANCELED = Errno(0x58) ++ ECHILD = Errno(0xa) ++ ECONNABORTED = Errno(0x35) ++ ECONNREFUSED = Errno(0x3d) ++ ECONNRESET = Errno(0x36) ++ EDEADLK = Errno(0xb) ++ EDESTADDRREQ = Errno(0x27) ++ EDOM = Errno(0x21) ++ EDQUOT = Errno(0x45) ++ EEXIST = Errno(0x11) ++ EFAULT = Errno(0xe) ++ EFBIG = Errno(0x1b) ++ EFTYPE = Errno(0x4f) ++ EHOSTDOWN = Errno(0x40) ++ EHOSTUNREACH = Errno(0x41) ++ EIDRM = Errno(0x59) ++ EILSEQ = Errno(0x54) ++ EINPROGRESS = Errno(0x24) ++ EINTR = Errno(0x4) ++ EINVAL = Errno(0x16) ++ EIO = Errno(0x5) ++ EIPSEC = Errno(0x52) ++ EISCONN = Errno(0x38) ++ EISDIR = Errno(0x15) ++ ELAST = Errno(0x5f) ++ ELOOP = Errno(0x3e) ++ EMEDIUMTYPE = Errno(0x56) ++ EMFILE = Errno(0x18) ++ EMLINK = Errno(0x1f) ++ EMSGSIZE = Errno(0x28) ++ ENAMETOOLONG = Errno(0x3f) ++ ENEEDAUTH = Errno(0x51) ++ ENETDOWN = Errno(0x32) ++ ENETRESET = Errno(0x34) ++ ENETUNREACH = Errno(0x33) ++ ENFILE = Errno(0x17) ++ ENOATTR = Errno(0x53) ++ ENOBUFS = Errno(0x37) ++ ENODEV = Errno(0x13) ++ ENOENT = Errno(0x2) ++ ENOEXEC = Errno(0x8) ++ ENOLCK = Errno(0x4d) ++ ENOMEDIUM = Errno(0x55) ++ ENOMEM = Errno(0xc) ++ ENOMSG = Errno(0x5a) ++ ENOPROTOOPT = Errno(0x2a) ++ ENOSPC = Errno(0x1c) ++ ENOSYS = Errno(0x4e) ++ ENOTBLK = Errno(0xf) ++ ENOTCONN = Errno(0x39) ++ ENOTDIR = Errno(0x14) ++ ENOTEMPTY = Errno(0x42) ++ ENOTRECOVERABLE = Errno(0x5d) ++ ENOTSOCK = Errno(0x26) ++ ENOTSUP = Errno(0x5b) ++ ENOTTY = Errno(0x19) ++ ENXIO = Errno(0x6) ++ EOPNOTSUPP = Errno(0x2d) ++ EOVERFLOW = Errno(0x57) ++ EOWNERDEAD = Errno(0x5e) ++ EPERM = Errno(0x1) ++ EPFNOSUPPORT = Errno(0x2e) ++ EPIPE = Errno(0x20) ++ EPROCLIM = Errno(0x43) ++ EPROCUNAVAIL = Errno(0x4c) ++ EPROGMISMATCH = Errno(0x4b) ++ EPROGUNAVAIL = Errno(0x4a) ++ EPROTO = Errno(0x5f) ++ EPROTONOSUPPORT = Errno(0x2b) ++ EPROTOTYPE = Errno(0x29) ++ ERANGE = Errno(0x22) ++ EREMOTE = Errno(0x47) ++ EROFS = Errno(0x1e) ++ ERPCMISMATCH = Errno(0x49) ++ ESHUTDOWN = Errno(0x3a) ++ ESOCKTNOSUPPORT = Errno(0x2c) ++ ESPIPE = Errno(0x1d) ++ ESRCH = Errno(0x3) ++ ESTALE = Errno(0x46) ++ ETIMEDOUT = Errno(0x3c) ++ ETOOMANYREFS = Errno(0x3b) ++ ETXTBSY = Errno(0x1a) ++ EUSERS = Errno(0x44) ++ EWOULDBLOCK = Errno(0x23) ++ EXDEV = Errno(0x12) ++) ++ ++// Signals ++const ( ++ SIGABRT = Signal(0x6) ++ SIGALRM = Signal(0xe) ++ SIGBUS = Signal(0xa) ++ SIGCHLD = Signal(0x14) ++ SIGCONT = Signal(0x13) ++ SIGEMT = Signal(0x7) ++ SIGFPE = Signal(0x8) ++ SIGHUP = Signal(0x1) ++ SIGILL = Signal(0x4) ++ SIGINFO = Signal(0x1d) ++ SIGINT = Signal(0x2) ++ SIGIO = Signal(0x17) ++ SIGIOT = Signal(0x6) ++ SIGKILL = Signal(0x9) ++ SIGPIPE = Signal(0xd) ++ SIGPROF = Signal(0x1b) ++ SIGQUIT = Signal(0x3) ++ SIGSEGV = Signal(0xb) ++ SIGSTOP = Signal(0x11) ++ SIGSYS = Signal(0xc) ++ SIGTERM = Signal(0xf) ++ SIGTHR = Signal(0x20) ++ SIGTRAP = Signal(0x5) ++ SIGTSTP = Signal(0x12) ++ SIGTTIN = Signal(0x15) ++ SIGTTOU = Signal(0x16) ++ SIGURG = Signal(0x10) ++ SIGUSR1 = Signal(0x1e) ++ SIGUSR2 = Signal(0x1f) ++ SIGVTALRM = Signal(0x1a) ++ SIGWINCH = Signal(0x1c) ++ SIGXCPU = Signal(0x18) ++ SIGXFSZ = Signal(0x19) ++) ++ ++// Error table ++var errors = [...]string{ ++ 1: "operation not permitted", ++ 2: "no such file or directory", ++ 3: "no such process", ++ 4: "interrupted system call", ++ 5: "input/output error", ++ 6: "device not configured", ++ 7: "argument list too long", ++ 8: "exec format error", ++ 9: "bad file descriptor", ++ 10: "no child processes", ++ 11: "resource deadlock avoided", ++ 12: "cannot allocate memory", ++ 13: "permission denied", ++ 14: "bad address", ++ 15: "block device required", ++ 16: "device busy", ++ 17: "file exists", ++ 18: "cross-device link", ++ 19: "operation not supported by device", ++ 20: "not a directory", ++ 21: "is a directory", ++ 22: "invalid argument", ++ 23: "too many open files in system", ++ 24: "too many open files", ++ 25: "inappropriate ioctl for device", ++ 26: "text file busy", ++ 27: "file too large", ++ 28: "no space left on device", ++ 29: "illegal seek", ++ 30: "read-only file system", ++ 31: "too many links", ++ 32: "broken pipe", ++ 33: "numerical argument out of domain", ++ 34: "result too large", ++ 35: "resource temporarily unavailable", ++ 36: "operation now in progress", ++ 37: "operation already in progress", ++ 38: "socket operation on non-socket", ++ 39: "destination address required", ++ 40: "message too long", ++ 41: "protocol wrong type for socket", ++ 42: "protocol not available", ++ 43: "protocol not supported", ++ 44: "socket type not supported", ++ 45: "operation not supported", ++ 46: "protocol family not supported", ++ 47: "address family not supported by protocol family", ++ 48: "address already in use", ++ 49: "can't assign requested address", ++ 50: "network is down", ++ 51: "network is unreachable", ++ 52: "network dropped connection on reset", ++ 53: "software caused connection abort", ++ 54: "connection reset by peer", ++ 55: "no buffer space available", ++ 56: "socket is already connected", ++ 57: "socket is not connected", ++ 58: "can't send after socket shutdown", ++ 59: "too many references: can't splice", ++ 60: "operation timed out", ++ 61: "connection refused", ++ 62: "too many levels of symbolic links", ++ 63: "file name too long", ++ 64: "host is down", ++ 65: "no route to host", ++ 66: "directory not empty", ++ 67: "too many processes", ++ 68: "too many users", ++ 69: "disk quota exceeded", ++ 70: "stale NFS file handle", ++ 71: "too many levels of remote in path", ++ 72: "RPC struct is bad", ++ 73: "RPC version wrong", ++ 74: "RPC program not available", ++ 75: "program version wrong", ++ 76: "bad procedure for program", ++ 77: "no locks available", ++ 78: "function not implemented", ++ 79: "inappropriate file type or format", ++ 80: "authentication error", ++ 81: "need authenticator", ++ 82: "IPsec processing failure", ++ 83: "attribute not found", ++ 84: "illegal byte sequence", ++ 85: "no medium found", ++ 86: "wrong medium type", ++ 87: "value too large to be stored in data type", ++ 88: "operation canceled", ++ 89: "identifier removed", ++ 90: "no message of desired type", ++ 91: "not supported", ++ 92: "bad message", ++ 93: "state not recoverable", ++ 94: "previous owner died", ++ 95: "protocol error", ++} ++ ++// Signal table ++var signals = [...]string{ ++ 1: "hangup", ++ 2: "interrupt", ++ 3: "quit", ++ 4: "illegal instruction", ++ 5: "trace/BPT trap", ++ 6: "abort trap", ++ 7: "EMT trap", ++ 8: "floating point exception", ++ 9: "killed", ++ 10: "bus error", ++ 11: "segmentation fault", ++ 12: "bad system call", ++ 13: "broken pipe", ++ 14: "alarm clock", ++ 15: "terminated", ++ 16: "urgent I/O condition", ++ 17: "suspended (signal)", ++ 18: "suspended", ++ 19: "continued", ++ 20: "child exited", ++ 21: "stopped (tty input)", ++ 22: "stopped (tty output)", ++ 23: "I/O possible", ++ 24: "cputime limit exceeded", ++ 25: "filesize limit exceeded", ++ 26: "virtual timer expired", ++ 27: "profiling timer expired", ++ 28: "window size changes", ++ 29: "information request", ++ 30: "user defined signal 1", ++ 31: "user defined signal 2", ++ 32: "thread AST", ++} diff --git a/lang/go/patches/patch-src_syscall_zsyscall_openbsd_riscv64_go b/lang/go/patches/patch-src_syscall_zsyscall_openbsd_riscv64_go new file mode 100644 index 000000000000..9ccbafec3537 --- /dev/null +++ b/lang/go/patches/patch-src_syscall_zsyscall_openbsd_riscv64_go @@ -0,0 +1,1915 @@ +Index: src/syscall/zsyscall_openbsd_riscv64.go +--- src/syscall/zsyscall_openbsd_riscv64.go.orig ++++ src/syscall/zsyscall_openbsd_riscv64.go +@@ -0,0 +1,1911 @@ ++// mksyscall.pl -openbsd -libc -tags openbsd,riscv64 syscall_bsd.go syscall_openbsd.go syscall_openbsd_libc.go syscall_openbsd_riscv64.go ++// Code generated by the command above; DO NOT EDIT. ++ ++//go:build openbsd && riscv64 ++ ++package syscall ++ ++import "unsafe" ++import "internal/abi" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func getgroups(ngid int, gid *_Gid_t) (n int, err error) { ++ r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_getgroups_trampoline() ++ ++//go:cgo_import_dynamic libc_getgroups getgroups "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func setgroups(ngid int, gid *_Gid_t) (err error) { ++ _, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_setgroups_trampoline() ++ ++//go:cgo_import_dynamic libc_setgroups setgroups "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) { ++ r0, _, e1 := syscall6(abi.FuncPCABI0(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0) ++ wpid = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_wait4_trampoline() ++ ++//go:cgo_import_dynamic libc_wait4 wait4 "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) { ++ r0, _, e1 := syscall(abi.FuncPCABI0(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_accept_trampoline() ++ ++//go:cgo_import_dynamic libc_accept accept "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_bind_trampoline() ++ ++//go:cgo_import_dynamic libc_bind bind "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_connect_trampoline() ++ ++//go:cgo_import_dynamic libc_connect connect "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func socket(domain int, typ int, proto int) (fd int, err error) { ++ r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto)) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_socket_trampoline() ++ ++//go:cgo_import_dynamic libc_socket socket "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { ++ _, _, e1 := syscall6(abi.FuncPCABI0(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_getsockopt_trampoline() ++ ++//go:cgo_import_dynamic libc_getsockopt getsockopt "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) { ++ _, _, e1 := syscall6(abi.FuncPCABI0(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_setsockopt_trampoline() ++ ++//go:cgo_import_dynamic libc_setsockopt setsockopt "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) { ++ _, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_getpeername_trampoline() ++ ++//go:cgo_import_dynamic libc_getpeername getpeername "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) { ++ _, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_getsockname_trampoline() ++ ++//go:cgo_import_dynamic libc_getsockname getsockname "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Shutdown(s int, how int) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_shutdown_trampoline() ++ ++//go:cgo_import_dynamic libc_shutdown shutdown "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) { ++ _, _, e1 := rawSyscall6(abi.FuncPCABI0(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_socketpair_trampoline() ++ ++//go:cgo_import_dynamic libc_socketpair socketpair "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(p) > 0 { ++ _p0 = unsafe.Pointer(&p[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := syscall6(abi.FuncPCABI0(libc_recvfrom_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen))) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_recvfrom_trampoline() ++ ++//go:cgo_import_dynamic libc_recvfrom recvfrom "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) { ++ var _p0 unsafe.Pointer ++ if len(buf) > 0 { ++ _p0 = unsafe.Pointer(&buf[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := syscall6(abi.FuncPCABI0(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_sendto_trampoline() ++ ++//go:cgo_import_dynamic libc_sendto sendto "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { ++ r0, _, e1 := syscall(abi.FuncPCABI0(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_recvmsg_trampoline() ++ ++//go:cgo_import_dynamic libc_recvmsg recvmsg "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { ++ r0, _, e1 := syscall(abi.FuncPCABI0(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_sendmsg_trampoline() ++ ++//go:cgo_import_dynamic libc_sendmsg sendmsg "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) { ++ r0, _, e1 := syscall6(abi.FuncPCABI0(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout))) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_kevent_trampoline() ++ ++//go:cgo_import_dynamic libc_kevent kevent "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func utimes(path string, timeval *[2]Timeval) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_utimes_trampoline() ++ ++//go:cgo_import_dynamic libc_utimes utimes "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func futimes(fd int, timeval *[2]Timeval) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_futimes_trampoline() ++ ++//go:cgo_import_dynamic libc_futimes futimes "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func fcntl(fd int, cmd int, arg int) (val int, err error) { ++ r0, _, e1 := syscall(abi.FuncPCABI0(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg)) ++ val = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_fcntl_trampoline() ++ ++//go:cgo_import_dynamic libc_fcntl fcntl "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func pipe2(p *[2]_C_int, flags int) (err error) { ++ _, _, e1 := rawSyscall(abi.FuncPCABI0(libc_pipe2_trampoline), uintptr(unsafe.Pointer(p)), uintptr(flags), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_pipe2_trampoline() ++ ++//go:cgo_import_dynamic libc_pipe2 pipe2 "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func accept4(fd int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (nfd int, err error) { ++ r0, _, e1 := syscall6(abi.FuncPCABI0(libc_accept4_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0) ++ nfd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_accept4_trampoline() ++ ++//go:cgo_import_dynamic libc_accept4 accept4 "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func getdents(fd int, buf []byte) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(buf) > 0 { ++ _p0 = unsafe.Pointer(&buf[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := syscall(abi.FuncPCABI0(libc_getdents_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(buf))) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_getdents_trampoline() ++ ++//go:cgo_import_dynamic libc_getdents getdents "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Access(path string, mode uint32) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_access_trampoline() ++ ++//go:cgo_import_dynamic libc_access access "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Adjtime(delta *Timeval, olddelta *Timeval) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_adjtime_trampoline() ++ ++//go:cgo_import_dynamic libc_adjtime adjtime "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Chdir(path string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_chdir_trampoline() ++ ++//go:cgo_import_dynamic libc_chdir chdir "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Chflags(path string, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_chflags_trampoline() ++ ++//go:cgo_import_dynamic libc_chflags chflags "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Chmod(path string, mode uint32) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_chmod_trampoline() ++ ++//go:cgo_import_dynamic libc_chmod chmod "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Chown(path string, uid int, gid int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_chown_trampoline() ++ ++//go:cgo_import_dynamic libc_chown chown "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Chroot(path string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_chroot_trampoline() ++ ++//go:cgo_import_dynamic libc_chroot chroot "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Close(fd int) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_close_trampoline), uintptr(fd), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_close_trampoline() ++ ++//go:cgo_import_dynamic libc_close close "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Dup(fd int) (nfd int, err error) { ++ r0, _, e1 := syscall(abi.FuncPCABI0(libc_dup_trampoline), uintptr(fd), 0, 0) ++ nfd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_dup_trampoline() ++ ++//go:cgo_import_dynamic libc_dup dup "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Dup2(from int, to int) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_dup2_trampoline), uintptr(from), uintptr(to), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_dup2_trampoline() ++ ++//go:cgo_import_dynamic libc_dup2 dup2 "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func dup3(from int, to int, flags int) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_dup3_trampoline), uintptr(from), uintptr(to), uintptr(flags)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_dup3_trampoline() ++ ++//go:cgo_import_dynamic libc_dup3 dup3 "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fchdir(fd int) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_fchdir_trampoline), uintptr(fd), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_fchdir_trampoline() ++ ++//go:cgo_import_dynamic libc_fchdir fchdir "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fchflags(fd int, flags int) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_fchflags_trampoline() ++ ++//go:cgo_import_dynamic libc_fchflags fchflags "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fchmod(fd int, mode uint32) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_fchmod_trampoline() ++ ++//go:cgo_import_dynamic libc_fchmod fchmod "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fchown(fd int, uid int, gid int) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_fchown_trampoline() ++ ++//go:cgo_import_dynamic libc_fchown fchown "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Flock(fd int, how int) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_flock_trampoline), uintptr(fd), uintptr(how), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_flock_trampoline() ++ ++//go:cgo_import_dynamic libc_flock flock "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fpathconf(fd int, name int) (val int, err error) { ++ r0, _, e1 := syscall(abi.FuncPCABI0(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0) ++ val = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_fpathconf_trampoline() ++ ++//go:cgo_import_dynamic libc_fpathconf fpathconf "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fstat(fd int, stat *Stat_t) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_fstat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_fstat_trampoline() ++ ++//go:cgo_import_dynamic libc_fstat fstat "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fstatfs(fd int, stat *Statfs_t) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_fstatfs_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_fstatfs_trampoline() ++ ++//go:cgo_import_dynamic libc_fstatfs fstatfs "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fsync(fd int) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_fsync_trampoline), uintptr(fd), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_fsync_trampoline() ++ ++//go:cgo_import_dynamic libc_fsync fsync "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Ftruncate(fd int, length int64) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_ftruncate_trampoline() ++ ++//go:cgo_import_dynamic libc_ftruncate ftruncate "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getegid() (egid int) { ++ r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getegid_trampoline), 0, 0, 0) ++ egid = int(r0) ++ return ++} ++ ++func libc_getegid_trampoline() ++ ++//go:cgo_import_dynamic libc_getegid getegid "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Geteuid() (uid int) { ++ r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_geteuid_trampoline), 0, 0, 0) ++ uid = int(r0) ++ return ++} ++ ++func libc_geteuid_trampoline() ++ ++//go:cgo_import_dynamic libc_geteuid geteuid "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getgid() (gid int) { ++ r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getgid_trampoline), 0, 0, 0) ++ gid = int(r0) ++ return ++} ++ ++func libc_getgid_trampoline() ++ ++//go:cgo_import_dynamic libc_getgid getgid "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getpgid(pid int) (pgid int, err error) { ++ r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getpgid_trampoline), uintptr(pid), 0, 0) ++ pgid = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_getpgid_trampoline() ++ ++//go:cgo_import_dynamic libc_getpgid getpgid "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getpgrp() (pgrp int) { ++ r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getpgrp_trampoline), 0, 0, 0) ++ pgrp = int(r0) ++ return ++} ++ ++func libc_getpgrp_trampoline() ++ ++//go:cgo_import_dynamic libc_getpgrp getpgrp "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getpid() (pid int) { ++ r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getpid_trampoline), 0, 0, 0) ++ pid = int(r0) ++ return ++} ++ ++func libc_getpid_trampoline() ++ ++//go:cgo_import_dynamic libc_getpid getpid "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getppid() (ppid int) { ++ r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getppid_trampoline), 0, 0, 0) ++ ppid = int(r0) ++ return ++} ++ ++func libc_getppid_trampoline() ++ ++//go:cgo_import_dynamic libc_getppid getppid "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getpriority(which int, who int) (prio int, err error) { ++ r0, _, e1 := syscall(abi.FuncPCABI0(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0) ++ prio = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_getpriority_trampoline() ++ ++//go:cgo_import_dynamic libc_getpriority getpriority "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getrlimit(which int, lim *Rlimit) (err error) { ++ _, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_getrlimit_trampoline() ++ ++//go:cgo_import_dynamic libc_getrlimit getrlimit "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getrusage(who int, rusage *Rusage) (err error) { ++ _, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_getrusage_trampoline() ++ ++//go:cgo_import_dynamic libc_getrusage getrusage "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getsid(pid int) (sid int, err error) { ++ r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getsid_trampoline), uintptr(pid), 0, 0) ++ sid = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_getsid_trampoline() ++ ++//go:cgo_import_dynamic libc_getsid getsid "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Gettimeofday(tv *Timeval) (err error) { ++ _, _, e1 := rawSyscall(abi.FuncPCABI0(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tv)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_gettimeofday_trampoline() ++ ++//go:cgo_import_dynamic libc_gettimeofday gettimeofday "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getuid() (uid int) { ++ r0, _, _ := rawSyscall(abi.FuncPCABI0(libc_getuid_trampoline), 0, 0, 0) ++ uid = int(r0) ++ return ++} ++ ++func libc_getuid_trampoline() ++ ++//go:cgo_import_dynamic libc_getuid getuid "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Issetugid() (tainted bool) { ++ r0, _, _ := syscall(abi.FuncPCABI0(libc_issetugid_trampoline), 0, 0, 0) ++ tainted = bool(r0 != 0) ++ return ++} ++ ++func libc_issetugid_trampoline() ++ ++//go:cgo_import_dynamic libc_issetugid issetugid "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Kill(pid int, signum Signal) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_kill_trampoline), uintptr(pid), uintptr(signum), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_kill_trampoline() ++ ++//go:cgo_import_dynamic libc_kill kill "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Kqueue() (fd int, err error) { ++ r0, _, e1 := syscall(abi.FuncPCABI0(libc_kqueue_trampoline), 0, 0, 0) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_kqueue_trampoline() ++ ++//go:cgo_import_dynamic libc_kqueue kqueue "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Lchown(path string, uid int, gid int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_lchown_trampoline() ++ ++//go:cgo_import_dynamic libc_lchown lchown "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Link(path string, link string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(link) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_link_trampoline() ++ ++//go:cgo_import_dynamic libc_link link "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Listen(s int, backlog int) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_listen_trampoline() ++ ++//go:cgo_import_dynamic libc_listen listen "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Lstat(path string, stat *Stat_t) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_lstat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_lstat_trampoline() ++ ++//go:cgo_import_dynamic libc_lstat lstat "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Mkdir(path string, mode uint32) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_mkdir_trampoline() ++ ++//go:cgo_import_dynamic libc_mkdir mkdir "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Mkfifo(path string, mode uint32) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_mkfifo_trampoline() ++ ++//go:cgo_import_dynamic libc_mkfifo mkfifo "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Mknod(path string, mode uint32, dev int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_mknod_trampoline() ++ ++//go:cgo_import_dynamic libc_mknod mknod "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Nanosleep(time *Timespec, leftover *Timespec) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_nanosleep_trampoline), uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_nanosleep_trampoline() ++ ++//go:cgo_import_dynamic libc_nanosleep nanosleep "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Open(path string, mode int, perm uint32) (fd int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ r0, _, e1 := syscall(abi.FuncPCABI0(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm)) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_open_trampoline() ++ ++//go:cgo_import_dynamic libc_open open "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Pathconf(path string, name int) (val int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ r0, _, e1 := syscall(abi.FuncPCABI0(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0) ++ val = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_pathconf_trampoline() ++ ++//go:cgo_import_dynamic libc_pathconf pathconf "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func pread(fd int, p []byte, offset int64) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(p) > 0 { ++ _p0 = unsafe.Pointer(&p[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := syscall6(abi.FuncPCABI0(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_pread_trampoline() ++ ++//go:cgo_import_dynamic libc_pread pread "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func pwrite(fd int, p []byte, offset int64) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(p) > 0 { ++ _p0 = unsafe.Pointer(&p[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := syscall6(abi.FuncPCABI0(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_pwrite_trampoline() ++ ++//go:cgo_import_dynamic libc_pwrite pwrite "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func read(fd int, p []byte) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(p) > 0 { ++ _p0 = unsafe.Pointer(&p[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := syscall(abi.FuncPCABI0(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p))) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_read_trampoline() ++ ++//go:cgo_import_dynamic libc_read read "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Readlink(path string, buf []byte) (n int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 unsafe.Pointer ++ if len(buf) > 0 { ++ _p1 = unsafe.Pointer(&buf[0]) ++ } else { ++ _p1 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := syscall(abi.FuncPCABI0(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf))) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_readlink_trampoline() ++ ++//go:cgo_import_dynamic libc_readlink readlink "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Rename(from string, to string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(from) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(to) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_rename_trampoline() ++ ++//go:cgo_import_dynamic libc_rename rename "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Revoke(path string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_revoke_trampoline() ++ ++//go:cgo_import_dynamic libc_revoke revoke "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Rmdir(path string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_rmdir_trampoline() ++ ++//go:cgo_import_dynamic libc_rmdir rmdir "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error) { ++ _, _, e1 := syscall6(abi.FuncPCABI0(libc_select_trampoline), uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_select_trampoline() ++ ++//go:cgo_import_dynamic libc_select select "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setegid(egid int) (err error) { ++ _, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setegid_trampoline), uintptr(egid), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_setegid_trampoline() ++ ++//go:cgo_import_dynamic libc_setegid setegid "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Seteuid(euid int) (err error) { ++ _, _, e1 := rawSyscall(abi.FuncPCABI0(libc_seteuid_trampoline), uintptr(euid), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_seteuid_trampoline() ++ ++//go:cgo_import_dynamic libc_seteuid seteuid "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setgid(gid int) (err error) { ++ _, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setgid_trampoline), uintptr(gid), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_setgid_trampoline() ++ ++//go:cgo_import_dynamic libc_setgid setgid "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setlogin(name string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(name) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_setlogin_trampoline() ++ ++//go:cgo_import_dynamic libc_setlogin setlogin "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setpgid(pid int, pgid int) (err error) { ++ _, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_setpgid_trampoline() ++ ++//go:cgo_import_dynamic libc_setpgid setpgid "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setpriority(which int, who int, prio int) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_setpriority_trampoline() ++ ++//go:cgo_import_dynamic libc_setpriority setpriority "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setregid(rgid int, egid int) (err error) { ++ _, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_setregid_trampoline() ++ ++//go:cgo_import_dynamic libc_setregid setregid "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setreuid(ruid int, euid int) (err error) { ++ _, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_setreuid_trampoline() ++ ++//go:cgo_import_dynamic libc_setreuid setreuid "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setrlimit(which int, lim *Rlimit) (err error) { ++ _, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_setrlimit_trampoline() ++ ++//go:cgo_import_dynamic libc_setrlimit setrlimit "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setsid() (pid int, err error) { ++ r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setsid_trampoline), 0, 0, 0) ++ pid = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_setsid_trampoline() ++ ++//go:cgo_import_dynamic libc_setsid setsid "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Settimeofday(tp *Timeval) (err error) { ++ _, _, e1 := rawSyscall(abi.FuncPCABI0(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_settimeofday_trampoline() ++ ++//go:cgo_import_dynamic libc_settimeofday settimeofday "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setuid(uid int) (err error) { ++ _, _, e1 := rawSyscall(abi.FuncPCABI0(libc_setuid_trampoline), uintptr(uid), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_setuid_trampoline() ++ ++//go:cgo_import_dynamic libc_setuid setuid "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Stat(path string, stat *Stat_t) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_stat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_stat_trampoline() ++ ++//go:cgo_import_dynamic libc_stat stat "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Statfs(path string, stat *Statfs_t) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_statfs_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_statfs_trampoline() ++ ++//go:cgo_import_dynamic libc_statfs statfs "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Symlink(path string, link string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(link) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_symlink_trampoline() ++ ++//go:cgo_import_dynamic libc_symlink symlink "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Sync() (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_sync_trampoline), 0, 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_sync_trampoline() ++ ++//go:cgo_import_dynamic libc_sync sync "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Truncate(path string, length int64) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_truncate_trampoline() ++ ++//go:cgo_import_dynamic libc_truncate truncate "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Umask(newmask int) (oldmask int) { ++ r0, _, _ := syscall(abi.FuncPCABI0(libc_umask_trampoline), uintptr(newmask), 0, 0) ++ oldmask = int(r0) ++ return ++} ++ ++func libc_umask_trampoline() ++ ++//go:cgo_import_dynamic libc_umask umask "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Unlink(path string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_unlink_trampoline() ++ ++//go:cgo_import_dynamic libc_unlink unlink "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Unmount(path string, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_unmount_trampoline() ++ ++//go:cgo_import_dynamic libc_unmount unmount "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func write(fd int, p []byte) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(p) > 0 { ++ _p0 = unsafe.Pointer(&p[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := syscall(abi.FuncPCABI0(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p))) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_write_trampoline() ++ ++//go:cgo_import_dynamic libc_write write "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) { ++ r0, _, e1 := syscall6X(abi.FuncPCABI0(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos)) ++ ret = uintptr(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_mmap_trampoline() ++ ++//go:cgo_import_dynamic libc_mmap mmap "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func munmap(addr uintptr, length uintptr) (err error) { ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_munmap_trampoline() ++ ++//go:cgo_import_dynamic libc_munmap munmap "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func utimensat(dirfd int, path string, times *[2]Timespec, flag int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall6(abi.FuncPCABI0(libc_utimensat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flag), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_utimensat_trampoline() ++ ++//go:cgo_import_dynamic libc_utimensat utimensat "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func directSyscall(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr) (ret uintptr, err error) { ++ r0, _, e1 := syscall6X(abi.FuncPCABI0(libc_syscall_trampoline), uintptr(trap), uintptr(a1), uintptr(a2), uintptr(a3), uintptr(a4), uintptr(a5)) ++ ret = uintptr(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_syscall_trampoline() ++ ++//go:cgo_import_dynamic libc_syscall syscall "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func readlen(fd int, buf *byte, nbuf int) (n int, err error) { ++ r0, _, e1 := syscall(abi.FuncPCABI0(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf)) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func writelen(fd int, buf *byte, nbuf int) (n int, err error) { ++ r0, _, e1 := syscall(abi.FuncPCABI0(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf)) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Seek(fd int, offset int64, whence int) (newoffset int64, err error) { ++ r0, _, e1 := syscallX(abi.FuncPCABI0(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(whence)) ++ newoffset = int64(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_lseek_trampoline() ++ ++//go:cgo_import_dynamic libc_lseek lseek "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func getcwd(buf []byte) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(buf) > 0 { ++ _p0 = unsafe.Pointer(&buf[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := syscall(abi.FuncPCABI0(libc_getcwd_trampoline), uintptr(_p0), uintptr(len(buf)), 0) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_getcwd_trampoline() ++ ++//go:cgo_import_dynamic libc_getcwd getcwd "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) { ++ var _p0 unsafe.Pointer ++ if len(mib) > 0 { ++ _p0 = unsafe.Pointer(&mib[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := syscall6(abi.FuncPCABI0(libc_sysctl_trampoline), uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_sysctl_trampoline() ++ ++//go:cgo_import_dynamic libc_sysctl sysctl "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func fork() (pid int, err error) { ++ r0, _, e1 := rawSyscall(abi.FuncPCABI0(libc_fork_trampoline), 0, 0, 0) ++ pid = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_fork_trampoline() ++ ++//go:cgo_import_dynamic libc_fork fork "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func ioctl(fd int, req int, arg int) (err error) { ++ _, _, e1 := rawSyscall(abi.FuncPCABI0(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_ioctl_trampoline() ++ ++//go:cgo_import_dynamic libc_ioctl ioctl "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func execve(path *byte, argv **byte, envp **byte) (err error) { ++ _, _, e1 := rawSyscall(abi.FuncPCABI0(libc_execve_trampoline), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(argv)), uintptr(unsafe.Pointer(envp))) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_execve_trampoline() ++ ++//go:cgo_import_dynamic libc_execve execve "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func exit(res int) (err error) { ++ _, _, e1 := rawSyscall(abi.FuncPCABI0(libc_exit_trampoline), uintptr(res), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_exit_trampoline() ++ ++//go:cgo_import_dynamic libc_exit exit "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++//go:nosplit ++func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) { ++ _, _, e1 := syscall6(abi.FuncPCABI0(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_ptrace_trampoline() ++ ++//go:cgo_import_dynamic libc_ptrace ptrace "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func getentropy(p []byte) (err error) { ++ var _p0 unsafe.Pointer ++ if len(p) > 0 { ++ _p0 = unsafe.Pointer(&p[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := rawSyscall(abi.FuncPCABI0(libc_getentropy_trampoline), uintptr(_p0), uintptr(len(p)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_getentropy_trampoline() ++ ++//go:cgo_import_dynamic libc_getentropy getentropy "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func fstatat(fd int, path string, stat *Stat_t, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall6(abi.FuncPCABI0(libc_fstatat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_fstatat_trampoline() ++ ++//go:cgo_import_dynamic libc_fstatat fstatat "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func fcntlPtr(fd int, cmd int, arg unsafe.Pointer) (val int, err error) { ++ r0, _, e1 := syscall(abi.FuncPCABI0(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg)) ++ val = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func unlinkat(fd int, path string, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := syscall(abi.FuncPCABI0(libc_unlinkat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_unlinkat_trampoline() ++ ++//go:cgo_import_dynamic libc_unlinkat unlinkat "libc.so" ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func openat(fd int, path string, flags int, perm uint32) (fdret int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ r0, _, e1 := syscall6(abi.FuncPCABI0(libc_openat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(perm), 0, 0) ++ fdret = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++func libc_openat_trampoline() ++ ++//go:cgo_import_dynamic libc_openat openat "libc.so" diff --git a/lang/go/patches/patch-src_syscall_zsyscall_openbsd_riscv64_s b/lang/go/patches/patch-src_syscall_zsyscall_openbsd_riscv64_s new file mode 100644 index 000000000000..a3487ed0f87a --- /dev/null +++ b/lang/go/patches/patch-src_syscall_zsyscall_openbsd_riscv64_s @@ -0,0 +1,239 @@ +Index: src/syscall/zsyscall_openbsd_riscv64.s +--- src/syscall/zsyscall_openbsd_riscv64.s.orig ++++ src/syscall/zsyscall_openbsd_riscv64.s +@@ -0,0 +1,235 @@ ++// go run mkasm.go openbsd riscv64 ++// Code generated by the command above; DO NOT EDIT. ++#include "textflag.h" ++TEXT ·libc_getgroups_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_getgroups(SB) ++TEXT ·libc_setgroups_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_setgroups(SB) ++TEXT ·libc_wait4_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_wait4(SB) ++TEXT ·libc_accept_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_accept(SB) ++TEXT ·libc_bind_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_bind(SB) ++TEXT ·libc_connect_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_connect(SB) ++TEXT ·libc_socket_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_socket(SB) ++TEXT ·libc_getsockopt_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_getsockopt(SB) ++TEXT ·libc_setsockopt_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_setsockopt(SB) ++TEXT ·libc_getpeername_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_getpeername(SB) ++TEXT ·libc_getsockname_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_getsockname(SB) ++TEXT ·libc_shutdown_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_shutdown(SB) ++TEXT ·libc_socketpair_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_socketpair(SB) ++TEXT ·libc_recvfrom_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_recvfrom(SB) ++TEXT ·libc_sendto_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_sendto(SB) ++TEXT ·libc_recvmsg_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_recvmsg(SB) ++TEXT ·libc_sendmsg_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_sendmsg(SB) ++TEXT ·libc_kevent_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_kevent(SB) ++TEXT ·libc_utimes_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_utimes(SB) ++TEXT ·libc_futimes_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_futimes(SB) ++TEXT ·libc_fcntl_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_fcntl(SB) ++TEXT ·libc_pipe2_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_pipe2(SB) ++TEXT ·libc_accept4_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_accept4(SB) ++TEXT ·libc_getdents_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_getdents(SB) ++TEXT ·libc_access_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_access(SB) ++TEXT ·libc_adjtime_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_adjtime(SB) ++TEXT ·libc_chdir_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_chdir(SB) ++TEXT ·libc_chflags_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_chflags(SB) ++TEXT ·libc_chmod_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_chmod(SB) ++TEXT ·libc_chown_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_chown(SB) ++TEXT ·libc_chroot_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_chroot(SB) ++TEXT ·libc_close_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_close(SB) ++TEXT ·libc_dup_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_dup(SB) ++TEXT ·libc_dup2_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_dup2(SB) ++TEXT ·libc_dup3_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_dup3(SB) ++TEXT ·libc_fchdir_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_fchdir(SB) ++TEXT ·libc_fchflags_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_fchflags(SB) ++TEXT ·libc_fchmod_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_fchmod(SB) ++TEXT ·libc_fchown_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_fchown(SB) ++TEXT ·libc_flock_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_flock(SB) ++TEXT ·libc_fpathconf_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_fpathconf(SB) ++TEXT ·libc_fstat_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_fstat(SB) ++TEXT ·libc_fstatfs_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_fstatfs(SB) ++TEXT ·libc_fsync_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_fsync(SB) ++TEXT ·libc_ftruncate_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_ftruncate(SB) ++TEXT ·libc_getegid_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_getegid(SB) ++TEXT ·libc_geteuid_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_geteuid(SB) ++TEXT ·libc_getgid_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_getgid(SB) ++TEXT ·libc_getpgid_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_getpgid(SB) ++TEXT ·libc_getpgrp_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_getpgrp(SB) ++TEXT ·libc_getpid_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_getpid(SB) ++TEXT ·libc_getppid_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_getppid(SB) ++TEXT ·libc_getpriority_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_getpriority(SB) ++TEXT ·libc_getrlimit_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_getrlimit(SB) ++TEXT ·libc_getrusage_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_getrusage(SB) ++TEXT ·libc_getsid_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_getsid(SB) ++TEXT ·libc_gettimeofday_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_gettimeofday(SB) ++TEXT ·libc_getuid_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_getuid(SB) ++TEXT ·libc_issetugid_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_issetugid(SB) ++TEXT ·libc_kill_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_kill(SB) ++TEXT ·libc_kqueue_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_kqueue(SB) ++TEXT ·libc_lchown_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_lchown(SB) ++TEXT ·libc_link_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_link(SB) ++TEXT ·libc_listen_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_listen(SB) ++TEXT ·libc_lstat_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_lstat(SB) ++TEXT ·libc_mkdir_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_mkdir(SB) ++TEXT ·libc_mkfifo_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_mkfifo(SB) ++TEXT ·libc_mknod_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_mknod(SB) ++TEXT ·libc_nanosleep_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_nanosleep(SB) ++TEXT ·libc_open_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_open(SB) ++TEXT ·libc_pathconf_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_pathconf(SB) ++TEXT ·libc_pread_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_pread(SB) ++TEXT ·libc_pwrite_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_pwrite(SB) ++TEXT ·libc_read_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_read(SB) ++TEXT ·libc_readlink_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_readlink(SB) ++TEXT ·libc_rename_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_rename(SB) ++TEXT ·libc_revoke_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_revoke(SB) ++TEXT ·libc_rmdir_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_rmdir(SB) ++TEXT ·libc_select_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_select(SB) ++TEXT ·libc_setegid_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_setegid(SB) ++TEXT ·libc_seteuid_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_seteuid(SB) ++TEXT ·libc_setgid_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_setgid(SB) ++TEXT ·libc_setlogin_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_setlogin(SB) ++TEXT ·libc_setpgid_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_setpgid(SB) ++TEXT ·libc_setpriority_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_setpriority(SB) ++TEXT ·libc_setregid_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_setregid(SB) ++TEXT ·libc_setreuid_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_setreuid(SB) ++TEXT ·libc_setrlimit_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_setrlimit(SB) ++TEXT ·libc_setsid_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_setsid(SB) ++TEXT ·libc_settimeofday_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_settimeofday(SB) ++TEXT ·libc_setuid_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_setuid(SB) ++TEXT ·libc_stat_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_stat(SB) ++TEXT ·libc_statfs_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_statfs(SB) ++TEXT ·libc_symlink_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_symlink(SB) ++TEXT ·libc_sync_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_sync(SB) ++TEXT ·libc_truncate_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_truncate(SB) ++TEXT ·libc_umask_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_umask(SB) ++TEXT ·libc_unlink_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_unlink(SB) ++TEXT ·libc_unmount_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_unmount(SB) ++TEXT ·libc_write_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_write(SB) ++TEXT ·libc_mmap_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_mmap(SB) ++TEXT ·libc_munmap_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_munmap(SB) ++TEXT ·libc_utimensat_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_utimensat(SB) ++TEXT ·libc_syscall_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_syscall(SB) ++TEXT ·libc_lseek_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_lseek(SB) ++TEXT ·libc_getcwd_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_getcwd(SB) ++TEXT ·libc_sysctl_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_sysctl(SB) ++TEXT ·libc_fork_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_fork(SB) ++TEXT ·libc_ioctl_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_ioctl(SB) ++TEXT ·libc_execve_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_execve(SB) ++TEXT ·libc_exit_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_exit(SB) ++TEXT ·libc_ptrace_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_ptrace(SB) ++TEXT ·libc_getentropy_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_getentropy(SB) ++TEXT ·libc_fstatat_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_fstatat(SB) ++TEXT ·libc_unlinkat_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_unlinkat(SB) ++TEXT ·libc_openat_trampoline(SB),NOSPLIT,$0-0 ++ JMP libc_openat(SB) diff --git a/lang/go/patches/patch-src_syscall_zsysctl_openbsd_go b/lang/go/patches/patch-src_syscall_zsysctl_openbsd_go new file mode 100644 index 000000000000..4b5e9691f5f9 --- /dev/null +++ b/lang/go/patches/patch-src_syscall_zsysctl_openbsd_go @@ -0,0 +1,204 @@ +Index: src/syscall/zsysctl_openbsd.go +--- src/syscall/zsysctl_openbsd.go.orig ++++ src/syscall/zsysctl_openbsd.go +@@ -14,6 +14,7 @@ var sysctlMib = []mibentry{ + {"ddb.max_line", []_C_int{9, 3}}, + {"ddb.max_width", []_C_int{9, 2}}, + {"ddb.panic", []_C_int{9, 5}}, ++ {"ddb.profile", []_C_int{9, 9}}, + {"ddb.radix", []_C_int{9, 1}}, + {"ddb.tab_stop_width", []_C_int{9, 4}}, + {"ddb.trigger", []_C_int{9, 8}}, +@@ -28,30 +29,39 @@ var sysctlMib = []mibentry{ + {"hw.model", []_C_int{6, 2}}, + {"hw.ncpu", []_C_int{6, 3}}, + {"hw.ncpufound", []_C_int{6, 21}}, ++ {"hw.ncpuonline", []_C_int{6, 25}}, + {"hw.pagesize", []_C_int{6, 7}}, ++ {"hw.perfpolicy", []_C_int{6, 23}}, + {"hw.physmem", []_C_int{6, 19}}, ++ {"hw.power", []_C_int{6, 26}}, + {"hw.product", []_C_int{6, 15}}, + {"hw.serialno", []_C_int{6, 17}}, + {"hw.setperf", []_C_int{6, 13}}, ++ {"hw.smt", []_C_int{6, 24}}, + {"hw.usermem", []_C_int{6, 20}}, + {"hw.uuid", []_C_int{6, 18}}, + {"hw.vendor", []_C_int{6, 14}}, + {"hw.version", []_C_int{6, 16}}, +- {"kern.arandom", []_C_int{1, 37}}, ++ {"kern.allowdt", []_C_int{1, 65}}, ++ {"kern.allowkmem", []_C_int{1, 52}}, + {"kern.argmax", []_C_int{1, 8}}, ++ {"kern.audio", []_C_int{1, 84}}, + {"kern.boottime", []_C_int{1, 21}}, + {"kern.bufcachepercent", []_C_int{1, 72}}, + {"kern.ccpu", []_C_int{1, 45}}, + {"kern.clockrate", []_C_int{1, 12}}, ++ {"kern.consbuf", []_C_int{1, 83}}, ++ {"kern.consbufsize", []_C_int{1, 82}}, + {"kern.consdev", []_C_int{1, 75}}, + {"kern.cp_time", []_C_int{1, 40}}, + {"kern.cp_time2", []_C_int{1, 71}}, +- {"kern.cryptodevallowsoft", []_C_int{1, 53}}, ++ {"kern.cpustats", []_C_int{1, 85}}, + {"kern.domainname", []_C_int{1, 22}}, + {"kern.file", []_C_int{1, 73}}, + {"kern.forkstat", []_C_int{1, 42}}, + {"kern.fscale", []_C_int{1, 46}}, + {"kern.fsync", []_C_int{1, 33}}, ++ {"kern.global_ptrace", []_C_int{1, 81}}, + {"kern.hostid", []_C_int{1, 11}}, + {"kern.hostname", []_C_int{1, 10}}, + {"kern.intrcnt.nintrcnt", []_C_int{1, 63, 1}}, +@@ -81,10 +91,10 @@ var sysctlMib = []mibentry{ + {"kern.osrevision", []_C_int{1, 3}}, + {"kern.ostype", []_C_int{1, 1}}, + {"kern.osversion", []_C_int{1, 27}}, ++ {"kern.pfstatus", []_C_int{1, 86}}, + {"kern.pool_debug", []_C_int{1, 77}}, + {"kern.posix1version", []_C_int{1, 17}}, + {"kern.proc", []_C_int{1, 66}}, +- {"kern.random", []_C_int{1, 31}}, + {"kern.rawpartition", []_C_int{1, 24}}, + {"kern.saved_ids", []_C_int{1, 20}}, + {"kern.securelevel", []_C_int{1, 9}}, +@@ -102,21 +112,20 @@ var sysctlMib = []mibentry{ + {"kern.timecounter.hardware", []_C_int{1, 69, 3}}, + {"kern.timecounter.tick", []_C_int{1, 69, 1}}, + {"kern.timecounter.timestepwarnings", []_C_int{1, 69, 2}}, +- {"kern.tty.maxptys", []_C_int{1, 44, 6}}, +- {"kern.tty.nptys", []_C_int{1, 44, 7}}, ++ {"kern.timeout_stats", []_C_int{1, 87}}, + {"kern.tty.tk_cancc", []_C_int{1, 44, 4}}, + {"kern.tty.tk_nin", []_C_int{1, 44, 1}}, + {"kern.tty.tk_nout", []_C_int{1, 44, 2}}, + {"kern.tty.tk_rawcc", []_C_int{1, 44, 3}}, + {"kern.tty.ttyinfo", []_C_int{1, 44, 5}}, + {"kern.ttycount", []_C_int{1, 57}}, +- {"kern.userasymcrypto", []_C_int{1, 60}}, +- {"kern.usercrypto", []_C_int{1, 52}}, +- {"kern.usermount", []_C_int{1, 30}}, ++ {"kern.utc_offset", []_C_int{1, 88}}, + {"kern.version", []_C_int{1, 4}}, +- {"kern.vnode", []_C_int{1, 13}}, ++ {"kern.video", []_C_int{1, 89}}, + {"kern.watchdog.auto", []_C_int{1, 64, 2}}, + {"kern.watchdog.period", []_C_int{1, 64, 1}}, ++ {"kern.witnesswatch", []_C_int{1, 53}}, ++ {"kern.wxabort", []_C_int{1, 74}}, + {"net.bpf.bufsize", []_C_int{4, 31, 1}}, + {"net.bpf.maxbufsize", []_C_int{4, 31, 2}}, + {"net.inet.ah.enable", []_C_int{4, 2, 51, 1}}, +@@ -144,7 +153,9 @@ var sysctlMib = []mibentry{ + {"net.inet.icmp.stats", []_C_int{4, 2, 1, 7}}, + {"net.inet.icmp.tstamprepl", []_C_int{4, 2, 1, 6}}, + {"net.inet.igmp.stats", []_C_int{4, 2, 2, 1}}, ++ {"net.inet.ip.arpdown", []_C_int{4, 2, 0, 40}}, + {"net.inet.ip.arpqueued", []_C_int{4, 2, 0, 36}}, ++ {"net.inet.ip.arptimeout", []_C_int{4, 2, 0, 39}}, + {"net.inet.ip.encdebug", []_C_int{4, 2, 0, 12}}, + {"net.inet.ip.forwarding", []_C_int{4, 2, 0, 1}}, + {"net.inet.ip.ifq.congestion", []_C_int{4, 2, 0, 30, 4}}, +@@ -153,8 +164,10 @@ var sysctlMib = []mibentry{ + {"net.inet.ip.ifq.maxlen", []_C_int{4, 2, 0, 30, 2}}, + {"net.inet.ip.maxqueue", []_C_int{4, 2, 0, 11}}, + {"net.inet.ip.mforwarding", []_C_int{4, 2, 0, 31}}, ++ {"net.inet.ip.mrtmfc", []_C_int{4, 2, 0, 37}}, + {"net.inet.ip.mrtproto", []_C_int{4, 2, 0, 34}}, + {"net.inet.ip.mrtstats", []_C_int{4, 2, 0, 35}}, ++ {"net.inet.ip.mrtvif", []_C_int{4, 2, 0, 38}}, + {"net.inet.ip.mtu", []_C_int{4, 2, 0, 4}}, + {"net.inet.ip.mtudisc", []_C_int{4, 2, 0, 27}}, + {"net.inet.ip.mtudisctimeout", []_C_int{4, 2, 0, 28}}, +@@ -171,9 +184,7 @@ var sysctlMib = []mibentry{ + {"net.inet.ipcomp.stats", []_C_int{4, 2, 108, 2}}, + {"net.inet.ipip.allow", []_C_int{4, 2, 4, 1}}, + {"net.inet.ipip.stats", []_C_int{4, 2, 4, 2}}, +- {"net.inet.mobileip.allow", []_C_int{4, 2, 55, 1}}, + {"net.inet.pfsync.stats", []_C_int{4, 2, 240, 1}}, +- {"net.inet.pim.stats", []_C_int{4, 2, 103, 1}}, + {"net.inet.tcp.ackonpush", []_C_int{4, 2, 6, 13}}, + {"net.inet.tcp.always_keepalive", []_C_int{4, 2, 6, 22}}, + {"net.inet.tcp.baddynamic", []_C_int{4, 2, 6, 6}}, +@@ -187,6 +198,7 @@ var sysctlMib = []mibentry{ + {"net.inet.tcp.reasslimit", []_C_int{4, 2, 6, 18}}, + {"net.inet.tcp.rfc1323", []_C_int{4, 2, 6, 1}}, + {"net.inet.tcp.rfc3390", []_C_int{4, 2, 6, 17}}, ++ {"net.inet.tcp.rootonly", []_C_int{4, 2, 6, 24}}, + {"net.inet.tcp.rstppslimit", []_C_int{4, 2, 6, 12}}, + {"net.inet.tcp.sack", []_C_int{4, 2, 6, 10}}, + {"net.inet.tcp.sackholelimit", []_C_int{4, 2, 6, 20}}, +@@ -194,9 +206,12 @@ var sysctlMib = []mibentry{ + {"net.inet.tcp.stats", []_C_int{4, 2, 6, 21}}, + {"net.inet.tcp.synbucketlimit", []_C_int{4, 2, 6, 16}}, + {"net.inet.tcp.syncachelimit", []_C_int{4, 2, 6, 15}}, ++ {"net.inet.tcp.synhashsize", []_C_int{4, 2, 6, 25}}, ++ {"net.inet.tcp.synuselimit", []_C_int{4, 2, 6, 23}}, + {"net.inet.udp.baddynamic", []_C_int{4, 2, 17, 2}}, + {"net.inet.udp.checksum", []_C_int{4, 2, 17, 1}}, + {"net.inet.udp.recvspace", []_C_int{4, 2, 17, 3}}, ++ {"net.inet.udp.rootonly", []_C_int{4, 2, 17, 6}}, + {"net.inet.udp.sendspace", []_C_int{4, 2, 17, 4}}, + {"net.inet.udp.stats", []_C_int{4, 2, 17, 5}}, + {"net.inet6.divert.recvspace", []_C_int{4, 24, 86, 1}}, +@@ -209,13 +224,8 @@ var sysctlMib = []mibentry{ + {"net.inet6.icmp6.nd6_delay", []_C_int{4, 24, 30, 8}}, + {"net.inet6.icmp6.nd6_maxnudhint", []_C_int{4, 24, 30, 15}}, + {"net.inet6.icmp6.nd6_mmaxtries", []_C_int{4, 24, 30, 10}}, +- {"net.inet6.icmp6.nd6_prune", []_C_int{4, 24, 30, 6}}, + {"net.inet6.icmp6.nd6_umaxtries", []_C_int{4, 24, 30, 9}}, +- {"net.inet6.icmp6.nd6_useloopback", []_C_int{4, 24, 30, 11}}, +- {"net.inet6.icmp6.nodeinfo", []_C_int{4, 24, 30, 13}}, +- {"net.inet6.icmp6.rediraccept", []_C_int{4, 24, 30, 2}}, + {"net.inet6.icmp6.redirtimeout", []_C_int{4, 24, 30, 3}}, +- {"net.inet6.ip6.accept_rtadv", []_C_int{4, 24, 17, 12}}, + {"net.inet6.ip6.auto_flowlabel", []_C_int{4, 24, 17, 17}}, + {"net.inet6.ip6.dad_count", []_C_int{4, 24, 17, 16}}, + {"net.inet6.ip6.dad_pending", []_C_int{4, 24, 17, 49}}, +@@ -228,20 +238,19 @@ var sysctlMib = []mibentry{ + {"net.inet6.ip6.maxdynroutes", []_C_int{4, 24, 17, 48}}, + {"net.inet6.ip6.maxfragpackets", []_C_int{4, 24, 17, 9}}, + {"net.inet6.ip6.maxfrags", []_C_int{4, 24, 17, 41}}, +- {"net.inet6.ip6.maxifdefrouters", []_C_int{4, 24, 17, 47}}, +- {"net.inet6.ip6.maxifprefixes", []_C_int{4, 24, 17, 46}}, + {"net.inet6.ip6.mforwarding", []_C_int{4, 24, 17, 42}}, ++ {"net.inet6.ip6.mrtmfc", []_C_int{4, 24, 17, 53}}, ++ {"net.inet6.ip6.mrtmif", []_C_int{4, 24, 17, 52}}, + {"net.inet6.ip6.mrtproto", []_C_int{4, 24, 17, 8}}, + {"net.inet6.ip6.mtudisctimeout", []_C_int{4, 24, 17, 50}}, + {"net.inet6.ip6.multicast_mtudisc", []_C_int{4, 24, 17, 44}}, + {"net.inet6.ip6.multipath", []_C_int{4, 24, 17, 43}}, + {"net.inet6.ip6.neighborgcthresh", []_C_int{4, 24, 17, 45}}, + {"net.inet6.ip6.redirect", []_C_int{4, 24, 17, 2}}, +- {"net.inet6.ip6.rr_prune", []_C_int{4, 24, 17, 22}}, ++ {"net.inet6.ip6.soiikey", []_C_int{4, 24, 17, 54}}, + {"net.inet6.ip6.sourcecheck", []_C_int{4, 24, 17, 10}}, + {"net.inet6.ip6.sourcecheck_logint", []_C_int{4, 24, 17, 11}}, + {"net.inet6.ip6.use_deprecated", []_C_int{4, 24, 17, 21}}, +- {"net.inet6.ip6.v6only", []_C_int{4, 24, 17, 24}}, + {"net.key.sadb_dump", []_C_int{4, 30, 1}}, + {"net.key.spd_dump", []_C_int{4, 30, 2}}, + {"net.mpls.ifq.congestion", []_C_int{4, 33, 3, 4}}, +@@ -250,21 +259,7 @@ var sysctlMib = []mibentry{ + {"net.mpls.ifq.maxlen", []_C_int{4, 33, 3, 2}}, + {"net.mpls.mapttl_ip", []_C_int{4, 33, 5}}, + {"net.mpls.mapttl_ip6", []_C_int{4, 33, 6}}, +- {"net.mpls.maxloop_inkernel", []_C_int{4, 33, 4}}, + {"net.mpls.ttl", []_C_int{4, 33, 2}}, + {"net.pflow.stats", []_C_int{4, 34, 1}}, + {"net.pipex.enable", []_C_int{4, 35, 1}}, +- {"vm.anonmin", []_C_int{2, 7}}, +- {"vm.loadavg", []_C_int{2, 2}}, +- {"vm.maxslp", []_C_int{2, 10}}, +- {"vm.nkmempages", []_C_int{2, 6}}, +- {"vm.psstrings", []_C_int{2, 3}}, +- {"vm.swapencrypt.enable", []_C_int{2, 5, 0}}, +- {"vm.swapencrypt.keyscreated", []_C_int{2, 5, 1}}, +- {"vm.swapencrypt.keysdeleted", []_C_int{2, 5, 2}}, +- {"vm.uspace", []_C_int{2, 11}}, +- {"vm.uvmexp", []_C_int{2, 4}}, +- {"vm.vmmeter", []_C_int{2, 1}}, +- {"vm.vnodemin", []_C_int{2, 9}}, +- {"vm.vtextmin", []_C_int{2, 8}}, + } diff --git a/lang/go/patches/patch-src_syscall_zsysnum_openbsd_riscv64_go b/lang/go/patches/patch-src_syscall_zsysnum_openbsd_riscv64_go new file mode 100644 index 000000000000..fd8ea49b82cf --- /dev/null +++ b/lang/go/patches/patch-src_syscall_zsysnum_openbsd_riscv64_go @@ -0,0 +1,232 @@ +Index: src/syscall/zsysnum_openbsd_riscv64.go +--- src/syscall/zsysnum_openbsd_riscv64.go.orig ++++ src/syscall/zsysnum_openbsd_riscv64.go +@@ -0,0 +1,228 @@ ++// mksysnum_openbsd.pl ++// Code generated by the command above; DO NOT EDIT. ++ ++package syscall ++ ++const ( ++ SYS_EXIT = 1 // { void sys_exit(int rval); } ++ SYS_FORK = 2 // { int sys_fork(void); } ++ SYS_READ = 3 // { ssize_t sys_read(int fd, void *buf, size_t nbyte); } ++ SYS_WRITE = 4 // { ssize_t sys_write(int fd, const void *buf, \ ++ SYS_OPEN = 5 // { int sys_open(const char *path, \ ++ SYS_CLOSE = 6 // { int sys_close(int fd); } ++ SYS_GETENTROPY = 7 // { int sys_getentropy(void *buf, size_t nbyte); } ++ SYS___TFORK = 8 // { int sys___tfork(const struct __tfork *param, \ ++ SYS_LINK = 9 // { int sys_link(const char *path, const char *link); } ++ SYS_UNLINK = 10 // { int sys_unlink(const char *path); } ++ SYS_WAIT4 = 11 // { pid_t sys_wait4(pid_t pid, int *status, \ ++ SYS_CHDIR = 12 // { int sys_chdir(const char *path); } ++ SYS_FCHDIR = 13 // { int sys_fchdir(int fd); } ++ SYS_MKNOD = 14 // { int sys_mknod(const char *path, mode_t mode, \ ++ SYS_CHMOD = 15 // { int sys_chmod(const char *path, mode_t mode); } ++ SYS_CHOWN = 16 // { int sys_chown(const char *path, uid_t uid, \ ++ SYS_OBREAK = 17 // { int sys_obreak(char *nsize); } break ++ SYS_GETDTABLECOUNT = 18 // { int sys_getdtablecount(void); } ++ SYS_GETRUSAGE = 19 // { int sys_getrusage(int who, \ ++ SYS_GETPID = 20 // { pid_t sys_getpid(void); } ++ SYS_MOUNT = 21 // { int sys_mount(const char *type, const char *path, \ ++ SYS_UNMOUNT = 22 // { int sys_unmount(const char *path, int flags); } ++ SYS_SETUID = 23 // { int sys_setuid(uid_t uid); } ++ SYS_GETUID = 24 // { uid_t sys_getuid(void); } ++ SYS_GETEUID = 25 // { uid_t sys_geteuid(void); } ++ SYS_PTRACE = 26 // { int sys_ptrace(int req, pid_t pid, caddr_t addr, \ ++ SYS_RECVMSG = 27 // { ssize_t sys_recvmsg(int s, struct msghdr *msg, \ ++ SYS_SENDMSG = 28 // { ssize_t sys_sendmsg(int s, \ ++ SYS_RECVFROM = 29 // { ssize_t sys_recvfrom(int s, void *buf, size_t len, \ ++ SYS_ACCEPT = 30 // { int sys_accept(int s, struct sockaddr *name, \ ++ SYS_GETPEERNAME = 31 // { int sys_getpeername(int fdes, struct sockaddr *asa, \ ++ SYS_GETSOCKNAME = 32 // { int sys_getsockname(int fdes, struct sockaddr *asa, \ ++ SYS_ACCESS = 33 // { int sys_access(const char *path, int amode); } ++ SYS_CHFLAGS = 34 // { int sys_chflags(const char *path, u_int flags); } ++ SYS_FCHFLAGS = 35 // { int sys_fchflags(int fd, u_int flags); } ++ SYS_SYNC = 36 // { void sys_sync(void); } ++ SYS_MSYSCALL = 37 // { int sys_msyscall(void *addr, size_t len); } ++ SYS_STAT = 38 // { int sys_stat(const char *path, struct stat *ub); } ++ SYS_GETPPID = 39 // { pid_t sys_getppid(void); } ++ SYS_LSTAT = 40 // { int sys_lstat(const char *path, struct stat *ub); } ++ SYS_DUP = 41 // { int sys_dup(int fd); } ++ SYS_FSTATAT = 42 // { int sys_fstatat(int fd, const char *path, \ ++ SYS_GETEGID = 43 // { gid_t sys_getegid(void); } ++ SYS_PROFIL = 44 // { int sys_profil(caddr_t samples, size_t size, \ ++ SYS_KTRACE = 45 // { int sys_ktrace(const char *fname, int ops, \ ++ SYS_SIGACTION = 46 // { int sys_sigaction(int signum, \ ++ SYS_GETGID = 47 // { gid_t sys_getgid(void); } ++ SYS_SIGPROCMASK = 48 // { int sys_sigprocmask(int how, sigset_t mask); } ++ SYS_MMAP = 49 // { void *sys_mmap(void *addr, size_t len, int prot, \ ++ SYS_SETLOGIN = 50 // { int sys_setlogin(const char *namebuf); } ++ SYS_ACCT = 51 // { int sys_acct(const char *path); } ++ SYS_SIGPENDING = 52 // { int sys_sigpending(void); } ++ SYS_FSTAT = 53 // { int sys_fstat(int fd, struct stat *sb); } ++ SYS_IOCTL = 54 // { int sys_ioctl(int fd, \ ++ SYS_REBOOT = 55 // { int sys_reboot(int opt); } ++ SYS_REVOKE = 56 // { int sys_revoke(const char *path); } ++ SYS_SYMLINK = 57 // { int sys_symlink(const char *path, \ ++ SYS_READLINK = 58 // { ssize_t sys_readlink(const char *path, \ ++ SYS_EXECVE = 59 // { int sys_execve(const char *path, \ ++ SYS_UMASK = 60 // { mode_t sys_umask(mode_t newmask); } ++ SYS_CHROOT = 61 // { int sys_chroot(const char *path); } ++ SYS_GETFSSTAT = 62 // { int sys_getfsstat(struct statfs *buf, size_t bufsize, \ ++ SYS_STATFS = 63 // { int sys_statfs(const char *path, \ ++ SYS_FSTATFS = 64 // { int sys_fstatfs(int fd, struct statfs *buf); } ++ SYS_FHSTATFS = 65 // { int sys_fhstatfs(const fhandle_t *fhp, \ ++ SYS_VFORK = 66 // { int sys_vfork(void); } ++ SYS_GETTIMEOFDAY = 67 // { int sys_gettimeofday(struct timeval *tp, \ ++ SYS_SETTIMEOFDAY = 68 // { int sys_settimeofday(const struct timeval *tv, \ ++ SYS_SETITIMER = 69 // { int sys_setitimer(int which, \ ++ SYS_GETITIMER = 70 // { int sys_getitimer(int which, \ ++ SYS_SELECT = 71 // { int sys_select(int nd, fd_set *in, fd_set *ou, \ ++ SYS_KEVENT = 72 // { int sys_kevent(int fd, \ ++ SYS_MUNMAP = 73 // { int sys_munmap(void *addr, size_t len); } ++ SYS_MPROTECT = 74 // { int sys_mprotect(void *addr, size_t len, \ ++ SYS_MADVISE = 75 // { int sys_madvise(void *addr, size_t len, \ ++ SYS_UTIMES = 76 // { int sys_utimes(const char *path, \ ++ SYS_FUTIMES = 77 // { int sys_futimes(int fd, \ ++ SYS_MQUERY = 78 // { void *sys_mquery(void *addr, size_t len, int prot, \ ++ SYS_GETGROUPS = 79 // { int sys_getgroups(int gidsetsize, \ ++ SYS_SETGROUPS = 80 // { int sys_setgroups(int gidsetsize, \ ++ SYS_GETPGRP = 81 // { int sys_getpgrp(void); } ++ SYS_SETPGID = 82 // { int sys_setpgid(pid_t pid, pid_t pgid); } ++ SYS_FUTEX = 83 // { int sys_futex(uint32_t *f, int op, int val, \ ++ SYS_UTIMENSAT = 84 // { int sys_utimensat(int fd, const char *path, \ ++ SYS_FUTIMENS = 85 // { int sys_futimens(int fd, \ ++ SYS_KBIND = 86 // { int sys_kbind(const struct __kbind *param, \ ++ SYS_CLOCK_GETTIME = 87 // { int sys_clock_gettime(clockid_t clock_id, \ ++ SYS_CLOCK_SETTIME = 88 // { int sys_clock_settime(clockid_t clock_id, \ ++ SYS_CLOCK_GETRES = 89 // { int sys_clock_getres(clockid_t clock_id, \ ++ SYS_DUP2 = 90 // { int sys_dup2(int from, int to); } ++ SYS_NANOSLEEP = 91 // { int sys_nanosleep(const struct timespec *rqtp, \ ++ SYS_FCNTL = 92 // { int sys_fcntl(int fd, int cmd, ... void *arg); } ++ SYS_ACCEPT4 = 93 // { int sys_accept4(int s, struct sockaddr *name, \ ++ SYS___THRSLEEP = 94 // { int sys___thrsleep(const volatile void *ident, \ ++ SYS_FSYNC = 95 // { int sys_fsync(int fd); } ++ SYS_SETPRIORITY = 96 // { int sys_setpriority(int which, id_t who, int prio); } ++ SYS_SOCKET = 97 // { int sys_socket(int domain, int type, int protocol); } ++ SYS_CONNECT = 98 // { int sys_connect(int s, const struct sockaddr *name, \ ++ SYS_GETDENTS = 99 // { int sys_getdents(int fd, void *buf, size_t buflen); } ++ SYS_GETPRIORITY = 100 // { int sys_getpriority(int which, id_t who); } ++ SYS_PIPE2 = 101 // { int sys_pipe2(int *fdp, int flags); } ++ SYS_DUP3 = 102 // { int sys_dup3(int from, int to, int flags); } ++ SYS_SIGRETURN = 103 // { int sys_sigreturn(struct sigcontext *sigcntxp); } ++ SYS_BIND = 104 // { int sys_bind(int s, const struct sockaddr *name, \ ++ SYS_SETSOCKOPT = 105 // { int sys_setsockopt(int s, int level, int name, \ ++ SYS_LISTEN = 106 // { int sys_listen(int s, int backlog); } ++ SYS_CHFLAGSAT = 107 // { int sys_chflagsat(int fd, const char *path, \ ++ SYS_PLEDGE = 108 // { int sys_pledge(const char *promises, \ ++ SYS_PPOLL = 109 // { int sys_ppoll(struct pollfd *fds, \ ++ SYS_PSELECT = 110 // { int sys_pselect(int nd, fd_set *in, fd_set *ou, \ ++ SYS_SIGSUSPEND = 111 // { int sys_sigsuspend(int mask); } ++ SYS_SENDSYSLOG = 112 // { int sys_sendsyslog(const char *buf, size_t nbyte, \ ++ SYS_UNVEIL = 114 // { int sys_unveil(const char *path, \ ++ SYS___REALPATH = 115 // { int sys___realpath(const char *pathname, \ ++ SYS_GETSOCKOPT = 118 // { int sys_getsockopt(int s, int level, int name, \ ++ SYS_THRKILL = 119 // { int sys_thrkill(pid_t tid, int signum, void *tcb); } ++ SYS_READV = 120 // { ssize_t sys_readv(int fd, \ ++ SYS_WRITEV = 121 // { ssize_t sys_writev(int fd, \ ++ SYS_KILL = 122 // { int sys_kill(int pid, int signum); } ++ SYS_FCHOWN = 123 // { int sys_fchown(int fd, uid_t uid, gid_t gid); } ++ SYS_FCHMOD = 124 // { int sys_fchmod(int fd, mode_t mode); } ++ SYS_SETREUID = 126 // { int sys_setreuid(uid_t ruid, uid_t euid); } ++ SYS_SETREGID = 127 // { int sys_setregid(gid_t rgid, gid_t egid); } ++ SYS_RENAME = 128 // { int sys_rename(const char *from, const char *to); } ++ SYS_FLOCK = 131 // { int sys_flock(int fd, int how); } ++ SYS_MKFIFO = 132 // { int sys_mkfifo(const char *path, mode_t mode); } ++ SYS_SENDTO = 133 // { ssize_t sys_sendto(int s, const void *buf, \ ++ SYS_SHUTDOWN = 134 // { int sys_shutdown(int s, int how); } ++ SYS_SOCKETPAIR = 135 // { int sys_socketpair(int domain, int type, \ ++ SYS_MKDIR = 136 // { int sys_mkdir(const char *path, mode_t mode); } ++ SYS_RMDIR = 137 // { int sys_rmdir(const char *path); } ++ SYS_ADJTIME = 140 // { int sys_adjtime(const struct timeval *delta, \ ++ SYS_GETLOGIN_R = 141 // { int sys_getlogin_r(char *namebuf, u_int namelen); } ++ SYS_SETSID = 147 // { int sys_setsid(void); } ++ SYS_QUOTACTL = 148 // { int sys_quotactl(const char *path, int cmd, \ ++ SYS_YPCONNECT = 150 // { int sys_ypconnect(int type); } ++ SYS_NFSSVC = 155 // { int sys_nfssvc(int flag, void *argp); } ++ SYS_GETFH = 161 // { int sys_getfh(const char *fname, fhandle_t *fhp); } ++ SYS___TMPFD = 164 // { int sys___tmpfd(int flags); } ++ SYS_SYSARCH = 165 // { int sys_sysarch(int op, void *parms); } ++ SYS_LSEEK = 166 // { off_t sys_lseek(int fd, off_t offset, int whence); } ++ SYS_TRUNCATE = 167 // { int sys_truncate(const char *path, off_t length); } ++ SYS_FTRUNCATE = 168 // { int sys_ftruncate(int fd, off_t length); } ++ SYS_PREAD = 169 // { ssize_t sys_pread(int fd, void *buf, \ ++ SYS_PWRITE = 170 // { ssize_t sys_pwrite(int fd, const void *buf, \ ++ SYS_PREADV = 171 // { ssize_t sys_preadv(int fd, \ ++ SYS_PWRITEV = 172 // { ssize_t sys_pwritev(int fd, \ ++ SYS_PAD_PREAD = 173 // { ssize_t sys_pad_pread(int fd, void *buf, \ ++ SYS_PAD_PWRITE = 174 // { ssize_t sys_pad_pwrite(int fd, const void *buf, \ ++ SYS_SETGID = 181 // { int sys_setgid(gid_t gid); } ++ SYS_SETEGID = 182 // { int sys_setegid(gid_t egid); } ++ SYS_SETEUID = 183 // { int sys_seteuid(uid_t euid); } ++ SYS_PATHCONF = 191 // { long sys_pathconf(const char *path, int name); } ++ SYS_FPATHCONF = 192 // { long sys_fpathconf(int fd, int name); } ++ SYS_SWAPCTL = 193 // { int sys_swapctl(int cmd, const void *arg, int misc); } ++ SYS_GETRLIMIT = 194 // { int sys_getrlimit(int which, \ ++ SYS_SETRLIMIT = 195 // { int sys_setrlimit(int which, \ ++ SYS_PAD_MMAP = 197 // { void *sys_pad_mmap(void *addr, size_t len, int prot, \ ++ SYS_PAD_LSEEK = 199 // { off_t sys_pad_lseek(int fd, int pad, off_t offset, \ ++ SYS_PAD_TRUNCATE = 200 // { int sys_pad_truncate(const char *path, int pad, \ ++ SYS_PAD_FTRUNCATE = 201 // { int sys_pad_ftruncate(int fd, int pad, off_t length); } ++ SYS_SYSCTL = 202 // { int sys_sysctl(const int *name, u_int namelen, \ ++ SYS_MLOCK = 203 // { int sys_mlock(const void *addr, size_t len); } ++ SYS_MUNLOCK = 204 // { int sys_munlock(const void *addr, size_t len); } ++ SYS_GETPGID = 207 // { pid_t sys_getpgid(pid_t pid); } ++ SYS_UTRACE = 209 // { int sys_utrace(const char *label, const void *addr, \ ++ SYS_SEMGET = 221 // { int sys_semget(key_t key, int nsems, int semflg); } ++ SYS_MSGGET = 225 // { int sys_msgget(key_t key, int msgflg); } ++ SYS_MSGSND = 226 // { int sys_msgsnd(int msqid, const void *msgp, size_t msgsz, \ ++ SYS_MSGRCV = 227 // { int sys_msgrcv(int msqid, void *msgp, size_t msgsz, \ ++ SYS_SHMAT = 228 // { void *sys_shmat(int shmid, const void *shmaddr, \ ++ SYS_SHMDT = 230 // { int sys_shmdt(const void *shmaddr); } ++ SYS_MINHERIT = 250 // { int sys_minherit(void *addr, size_t len, \ ++ SYS_POLL = 252 // { int sys_poll(struct pollfd *fds, \ ++ SYS_ISSETUGID = 253 // { int sys_issetugid(void); } ++ SYS_LCHOWN = 254 // { int sys_lchown(const char *path, uid_t uid, gid_t gid); } ++ SYS_GETSID = 255 // { pid_t sys_getsid(pid_t pid); } ++ SYS_MSYNC = 256 // { int sys_msync(void *addr, size_t len, int flags); } ++ SYS_PIPE = 263 // { int sys_pipe(int *fdp); } ++ SYS_FHOPEN = 264 // { int sys_fhopen(const fhandle_t *fhp, int flags); } ++ SYS_PAD_PREADV = 267 // { ssize_t sys_pad_preadv(int fd, \ ++ SYS_PAD_PWRITEV = 268 // { ssize_t sys_pad_pwritev(int fd, \ ++ SYS_KQUEUE = 269 // { int sys_kqueue(void); } ++ SYS_MLOCKALL = 271 // { int sys_mlockall(int flags); } ++ SYS_MUNLOCKALL = 272 // { int sys_munlockall(void); } ++ SYS_GETRESUID = 281 // { int sys_getresuid(uid_t *ruid, uid_t *euid, \ ++ SYS_SETRESUID = 282 // { int sys_setresuid(uid_t ruid, uid_t euid, \ ++ SYS_GETRESGID = 283 // { int sys_getresgid(gid_t *rgid, gid_t *egid, \ ++ SYS_SETRESGID = 284 // { int sys_setresgid(gid_t rgid, gid_t egid, \ ++ SYS_PAD_MQUERY = 286 // { void *sys_pad_mquery(void *addr, size_t len, \ ++ SYS_CLOSEFROM = 287 // { int sys_closefrom(int fd); } ++ SYS_SIGALTSTACK = 288 // { int sys_sigaltstack(const struct sigaltstack *nss, \ ++ SYS_SHMGET = 289 // { int sys_shmget(key_t key, size_t size, int shmflg); } ++ SYS_SEMOP = 290 // { int sys_semop(int semid, struct sembuf *sops, \ ++ SYS_FHSTAT = 294 // { int sys_fhstat(const fhandle_t *fhp, \ ++ SYS___SEMCTL = 295 // { int sys___semctl(int semid, int semnum, int cmd, \ ++ SYS_SHMCTL = 296 // { int sys_shmctl(int shmid, int cmd, \ ++ SYS_MSGCTL = 297 // { int sys_msgctl(int msqid, int cmd, \ ++ SYS_SCHED_YIELD = 298 // { int sys_sched_yield(void); } ++ SYS_GETTHRID = 299 // { pid_t sys_getthrid(void); } ++ SYS___THRWAKEUP = 301 // { int sys___thrwakeup(const volatile void *ident, \ ++ SYS___THREXIT = 302 // { void sys___threxit(pid_t *notdead); } ++ SYS___THRSIGDIVERT = 303 // { int sys___thrsigdivert(sigset_t sigmask, \ ++ SYS___GETCWD = 304 // { int sys___getcwd(char *buf, size_t len); } ++ SYS_ADJFREQ = 305 // { int sys_adjfreq(const int64_t *freq, \ ++ SYS_SETRTABLE = 310 // { int sys_setrtable(int rtableid); } ++ SYS_GETRTABLE = 311 // { int sys_getrtable(void); } ++ SYS_FACCESSAT = 313 // { int sys_faccessat(int fd, const char *path, \ ++ SYS_FCHMODAT = 314 // { int sys_fchmodat(int fd, const char *path, \ ++ SYS_FCHOWNAT = 315 // { int sys_fchownat(int fd, const char *path, \ ++ SYS_LINKAT = 317 // { int sys_linkat(int fd1, const char *path1, int fd2, \ ++ SYS_MKDIRAT = 318 // { int sys_mkdirat(int fd, const char *path, \ ++ SYS_MKFIFOAT = 319 // { int sys_mkfifoat(int fd, const char *path, \ ++ SYS_MKNODAT = 320 // { int sys_mknodat(int fd, const char *path, \ ++ SYS_OPENAT = 321 // { int sys_openat(int fd, const char *path, int flags, \ ++ SYS_READLINKAT = 322 // { ssize_t sys_readlinkat(int fd, const char *path, \ ++ SYS_RENAMEAT = 323 // { int sys_renameat(int fromfd, const char *from, \ ++ SYS_SYMLINKAT = 324 // { int sys_symlinkat(const char *path, int fd, \ ++ SYS_UNLINKAT = 325 // { int sys_unlinkat(int fd, const char *path, \ ++ SYS___SET_TCB = 329 // { void sys___set_tcb(void *tcb); } ++ SYS___GET_TCB = 330 // { void *sys___get_tcb(void); } ++) diff --git a/lang/go/patches/patch-src_syscall_ztypes_openbsd_riscv64_go b/lang/go/patches/patch-src_syscall_ztypes_openbsd_riscv64_go new file mode 100644 index 000000000000..df0cfaa8c0a6 --- /dev/null +++ b/lang/go/patches/patch-src_syscall_ztypes_openbsd_riscv64_go @@ -0,0 +1,450 @@ +Index: src/syscall/ztypes_openbsd_riscv64.go +--- src/syscall/ztypes_openbsd_riscv64.go.orig ++++ src/syscall/ztypes_openbsd_riscv64.go +@@ -0,0 +1,446 @@ ++// Code generated by cmd/cgo -godefs; DO NOT EDIT. ++// cgo -godefs -- -fsigned-char types_openbsd.go ++ ++package syscall ++ ++const ( ++ sizeofPtr = 0x8 ++ sizeofShort = 0x2 ++ sizeofInt = 0x4 ++ sizeofLong = 0x8 ++ sizeofLongLong = 0x8 ++) ++ ++type ( ++ _C_short int16 ++ _C_int int32 ++ _C_long int64 ++ _C_long_long int64 ++) ++ ++type Timespec struct { ++ Sec int64 ++ Nsec int64 ++} ++ ++type Timeval struct { ++ Sec int64 ++ Usec int64 ++} ++ ++type Rusage struct { ++ Utime Timeval ++ Stime Timeval ++ Maxrss int64 ++ Ixrss int64 ++ Idrss int64 ++ Isrss int64 ++ Minflt int64 ++ Majflt int64 ++ Nswap int64 ++ Inblock int64 ++ Oublock int64 ++ Msgsnd int64 ++ Msgrcv int64 ++ Nsignals int64 ++ Nvcsw int64 ++ Nivcsw int64 ++} ++ ++type Rlimit struct { ++ Cur uint64 ++ Max uint64 ++} ++ ++type _Gid_t uint32 ++ ++const ( ++ S_IFMT = 0xf000 ++ S_IFIFO = 0x1000 ++ S_IFCHR = 0x2000 ++ S_IFDIR = 0x4000 ++ S_IFBLK = 0x6000 ++ S_IFREG = 0x8000 ++ S_IFLNK = 0xa000 ++ S_IFSOCK = 0xc000 ++ S_ISUID = 0x800 ++ S_ISGID = 0x400 ++ S_ISVTX = 0x200 ++ S_IRUSR = 0x100 ++ S_IWUSR = 0x80 ++ S_IXUSR = 0x40 ++ S_IRWXG = 0x38 ++ S_IRWXO = 0x7 ++) ++ ++type Stat_t struct { ++ Mode uint32 ++ Dev int32 ++ Ino uint64 ++ Nlink uint32 ++ Uid uint32 ++ Gid uint32 ++ Rdev int32 ++ Atim Timespec ++ Mtim Timespec ++ Ctim Timespec ++ Size int64 ++ Blocks int64 ++ Blksize int32 ++ Flags uint32 ++ Gen uint32 ++ X__st_birthtim Timespec ++} ++ ++type Statfs_t struct { ++ F_flags uint32 ++ F_bsize uint32 ++ F_iosize uint32 ++ F_blocks uint64 ++ F_bfree uint64 ++ F_bavail int64 ++ F_files uint64 ++ F_ffree uint64 ++ F_favail int64 ++ F_syncwrites uint64 ++ F_syncreads uint64 ++ F_asyncwrites uint64 ++ F_asyncreads uint64 ++ F_fsid Fsid ++ F_namemax uint32 ++ F_owner uint32 ++ F_ctime uint64 ++ F_fstypename [16]int8 ++ F_mntonname [90]int8 ++ F_mntfromname [90]int8 ++ F_mntfromspec [90]int8 ++ Pad_cgo_0 [2]byte ++ Mount_info [160]byte ++} ++ ++type Flock_t struct { ++ Start int64 ++ Len int64 ++ Pid int32 ++ Type int16 ++ Whence int16 ++} ++ ++type Dirent struct { ++ Fileno uint64 ++ Off int64 ++ Reclen uint16 ++ Type uint8 ++ Namlen uint8 ++ X__d_padding [4]uint8 ++ Name [256]int8 ++} ++ ++type Fsid struct { ++ Val [2]int32 ++} ++ ++const ( ++ pathMax = 0x400 ++) ++ ++type RawSockaddrInet4 struct { ++ Len uint8 ++ Family uint8 ++ Port uint16 ++ Addr [4]byte /* in_addr */ ++ Zero [8]int8 ++} ++ ++type RawSockaddrInet6 struct { ++ Len uint8 ++ Family uint8 ++ Port uint16 ++ Flowinfo uint32 ++ Addr [16]byte /* in6_addr */ ++ Scope_id uint32 ++} ++ ++type RawSockaddrUnix struct { ++ Len uint8 ++ Family uint8 ++ Path [104]int8 ++} ++ ++type RawSockaddrDatalink struct { ++ Len uint8 ++ Family uint8 ++ Index uint16 ++ Type uint8 ++ Nlen uint8 ++ Alen uint8 ++ Slen uint8 ++ Data [24]int8 ++} ++ ++type RawSockaddr struct { ++ Len uint8 ++ Family uint8 ++ Data [14]int8 ++} ++ ++type RawSockaddrAny struct { ++ Addr RawSockaddr ++ Pad [92]int8 ++} ++ ++type _Socklen uint32 ++ ++type Linger struct { ++ Onoff int32 ++ Linger int32 ++} ++ ++type Iovec struct { ++ Base *byte ++ Len uint64 ++} ++ ++type IPMreq struct { ++ Multiaddr [4]byte /* in_addr */ ++ Interface [4]byte /* in_addr */ ++} ++ ++type IPv6Mreq struct { ++ Multiaddr [16]byte /* in6_addr */ ++ Interface uint32 ++} ++ ++type Msghdr struct { ++ Name *byte ++ Namelen uint32 ++ Iov *Iovec ++ Iovlen uint32 ++ Control *byte ++ Controllen uint32 ++ Flags int32 ++} ++ ++type Cmsghdr struct { ++ Len uint32 ++ Level int32 ++ Type int32 ++} ++ ++type Inet6Pktinfo struct { ++ Addr [16]byte /* in6_addr */ ++ Ifindex uint32 ++} ++ ++type IPv6MTUInfo struct { ++ Addr RawSockaddrInet6 ++ Mtu uint32 ++} ++ ++type ICMPv6Filter struct { ++ Filt [8]uint32 ++} ++ ++const ( ++ SizeofSockaddrInet4 = 0x10 ++ SizeofSockaddrInet6 = 0x1c ++ SizeofSockaddrAny = 0x6c ++ SizeofSockaddrUnix = 0x6a ++ SizeofSockaddrDatalink = 0x20 ++ SizeofLinger = 0x8 ++ SizeofIPMreq = 0x8 ++ SizeofIPv6Mreq = 0x14 ++ SizeofMsghdr = 0x30 ++ SizeofCmsghdr = 0xc ++ SizeofInet6Pktinfo = 0x14 ++ SizeofIPv6MTUInfo = 0x20 ++ SizeofICMPv6Filter = 0x20 ++) ++ ++const ( ++ PTRACE_TRACEME = 0x0 ++ PTRACE_CONT = 0x7 ++ PTRACE_KILL = 0x8 ++) ++ ++type Kevent_t struct { ++ Ident uint64 ++ Filter int16 ++ Flags uint16 ++ Fflags uint32 ++ Data int64 ++ Udata *byte ++} ++ ++type FdSet struct { ++ Bits [32]uint32 ++} ++ ++const ( ++ SizeofIfMsghdr = 0xa8 ++ SizeofIfData = 0x90 ++ SizeofIfaMsghdr = 0x18 ++ SizeofIfAnnounceMsghdr = 0x1a ++ SizeofRtMsghdr = 0x60 ++ SizeofRtMetrics = 0x38 ++) ++ ++type IfMsghdr struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Hdrlen uint16 ++ Index uint16 ++ Tableid uint16 ++ Pad1 uint8 ++ Pad2 uint8 ++ Addrs int32 ++ Flags int32 ++ Xflags int32 ++ Data IfData ++} ++ ++type IfData struct { ++ Type uint8 ++ Addrlen uint8 ++ Hdrlen uint8 ++ Link_state uint8 ++ Mtu uint32 ++ Metric uint32 ++ Rdomain uint32 ++ Baudrate uint64 ++ Ipackets uint64 ++ Ierrors uint64 ++ Opackets uint64 ++ Oerrors uint64 ++ Collisions uint64 ++ Ibytes uint64 ++ Obytes uint64 ++ Imcasts uint64 ++ Omcasts uint64 ++ Iqdrops uint64 ++ Oqdrops uint64 ++ Noproto uint64 ++ Capabilities uint32 ++ Lastchange Timeval ++} ++ ++type IfaMsghdr struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Hdrlen uint16 ++ Index uint16 ++ Tableid uint16 ++ Pad1 uint8 ++ Pad2 uint8 ++ Addrs int32 ++ Flags int32 ++ Metric int32 ++} ++ ++type IfAnnounceMsghdr struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Hdrlen uint16 ++ Index uint16 ++ What uint16 ++ Name [16]int8 ++} ++ ++type RtMsghdr struct { ++ Msglen uint16 ++ Version uint8 ++ Type uint8 ++ Hdrlen uint16 ++ Index uint16 ++ Tableid uint16 ++ Priority uint8 ++ Mpls uint8 ++ Addrs int32 ++ Flags int32 ++ Fmask int32 ++ Pid int32 ++ Seq int32 ++ Errno int32 ++ Inits uint32 ++ Rmx RtMetrics ++} ++ ++type RtMetrics struct { ++ Pksent uint64 ++ Expire int64 ++ Locks uint32 ++ Mtu uint32 ++ Refcnt uint32 ++ Hopcount uint32 ++ Recvpipe uint32 ++ Sendpipe uint32 ++ Ssthresh uint32 ++ Rtt uint32 ++ Rttvar uint32 ++ Pad uint32 ++} ++ ++type Mclpool struct{} ++ ++const ( ++ SizeofBpfVersion = 0x4 ++ SizeofBpfStat = 0x8 ++ SizeofBpfProgram = 0x10 ++ SizeofBpfInsn = 0x8 ++ SizeofBpfHdr = 0x18 ++) ++ ++type BpfVersion struct { ++ Major uint16 ++ Minor uint16 ++} ++ ++type BpfStat struct { ++ Recv uint32 ++ Drop uint32 ++} ++ ++type BpfProgram struct { ++ Len uint32 ++ Insns *BpfInsn ++} ++ ++type BpfInsn struct { ++ Code uint16 ++ Jt uint8 ++ Jf uint8 ++ K uint32 ++} ++ ++type BpfHdr struct { ++ Tstamp BpfTimeval ++ Caplen uint32 ++ Datalen uint32 ++ Hdrlen uint16 ++ Ifidx uint16 ++ Flowid uint16 ++ Flags uint8 ++ Drops uint8 ++} ++ ++type BpfTimeval struct { ++ Sec uint32 ++ Usec uint32 ++} ++ ++const ( ++ _AT_FDCWD = -0x64 ++) ++ ++type Termios struct { ++ Iflag uint32 ++ Oflag uint32 ++ Cflag uint32 ++ Lflag uint32 ++ Cc [20]uint8 ++ Ispeed int32 ++ Ospeed int32 ++} diff --git a/lang/go/patches/patch-src_vendor_golang_org_x_sys_cpu_cpu_other_riscv64_go b/lang/go/patches/patch-src_vendor_golang_org_x_sys_cpu_cpu_other_riscv64_go new file mode 100644 index 000000000000..b510b183a339 --- /dev/null +++ b/lang/go/patches/patch-src_vendor_golang_org_x_sys_cpu_cpu_other_riscv64_go @@ -0,0 +1,16 @@ +Index: src/vendor/golang.org/x/sys/cpu/cpu_other_riscv64.go +--- src/vendor/golang.org/x/sys/cpu/cpu_other_riscv64.go.orig ++++ src/vendor/golang.org/x/sys/cpu/cpu_other_riscv64.go +@@ -0,0 +1,12 @@ ++// Copyright 2022 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. ++ ++//go:build !linux && riscv64 ++// +build !linux,riscv64 ++ ++package cpu ++ ++func archInit() { ++ Initialized = true ++} diff --git a/lang/go/pkg/PLIST b/lang/go/pkg/PLIST index 512b07ac42c2..03c6efd2cb83 100644 --- a/lang/go/pkg/PLIST +++ b/lang/go/pkg/PLIST @@ -4440,6 +4440,7 @@ go/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s go/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_riscv64.s go/src/cmd/vendor/golang.org/x/sys/unix/asm_linux_s390x.s go/src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_mips64.s +go/src/cmd/vendor/golang.org/x/sys/unix/asm_openbsd_riscv64.s go/src/cmd/vendor/golang.org/x/sys/unix/asm_solaris_amd64.s go/src/cmd/vendor/golang.org/x/sys/unix/asm_zos_s390x.s go/src/cmd/vendor/golang.org/x/sys/unix/bluetooth_linux.go @@ -4540,6 +4541,7 @@ go/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_amd64.go go/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_arm.go go/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_arm64.go go/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_mips64.go +go/src/cmd/vendor/golang.org/x/sys/unix/syscall_openbsd_riscv64.go go/src/cmd/vendor/golang.org/x/sys/unix/syscall_solaris.go go/src/cmd/vendor/golang.org/x/sys/unix/syscall_solaris_amd64.go go/src/cmd/vendor/golang.org/x/sys/unix/syscall_unix.go @@ -4586,6 +4588,7 @@ go/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_amd64.go go/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_arm.go go/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_arm64.go go/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_mips64.go +go/src/cmd/vendor/golang.org/x/sys/unix/zerrors_openbsd_riscv64.go go/src/cmd/vendor/golang.org/x/sys/unix/zerrors_solaris_amd64.go go/src/cmd/vendor/golang.org/x/sys/unix/zerrors_zos_s390x.go go/src/cmd/vendor/golang.org/x/sys/unix/zptrace_armnn_linux.go @@ -4636,6 +4639,7 @@ go/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_amd64.go go/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm.go go/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_arm64.go go/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_mips64.go +go/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_openbsd_riscv64.go go/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go go/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_zos_s390x.go go/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_386.go @@ -4643,6 +4647,7 @@ go/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_amd64.go go/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_arm.go go/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_arm64.go go/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_mips64.go +go/src/cmd/vendor/golang.org/x/sys/unix/zsysctl_openbsd_riscv64.go go/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_amd64.go go/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_darwin_arm64.go go/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_dragonfly_amd64.go @@ -4674,6 +4679,7 @@ go/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_amd64.go go/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_arm.go go/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_arm64.go go/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_mips64.go +go/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_openbsd_riscv64.go go/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go go/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc.go go/src/cmd/vendor/golang.org/x/sys/unix/ztypes_aix_ppc64.go @@ -4710,6 +4716,7 @@ go/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_amd64.go go/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm.go go/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_arm64.go go/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_mips64.go +go/src/cmd/vendor/golang.org/x/sys/unix/ztypes_openbsd_riscv64.go go/src/cmd/vendor/golang.org/x/sys/unix/ztypes_solaris_amd64.go go/src/cmd/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go go/src/cmd/vendor/golang.org/x/sys/windows/ @@ -8509,6 +8516,7 @@ go/src/runtime/cgo/gcc_openbsd_amd64.c go/src/runtime/cgo/gcc_openbsd_arm.c go/src/runtime/cgo/gcc_openbsd_arm64.c go/src/runtime/cgo/gcc_openbsd_mips64.c +go/src/runtime/cgo/gcc_openbsd_riscv64.c go/src/runtime/cgo/gcc_ppc64x.c go/src/runtime/cgo/gcc_riscv64.S go/src/runtime/cgo/gcc_s390x.S @@ -8625,6 +8633,7 @@ go/src/runtime/defs_openbsd_amd64.go go/src/runtime/defs_openbsd_arm.go go/src/runtime/defs_openbsd_arm64.go go/src/runtime/defs_openbsd_mips64.go +go/src/runtime/defs_openbsd_riscv64.go go/src/runtime/defs_plan9_386.go go/src/runtime/defs_plan9_amd64.go go/src/runtime/defs_plan9_arm.go @@ -9065,6 +9074,7 @@ go/src/runtime/rt0_openbsd_amd64.s go/src/runtime/rt0_openbsd_arm.s go/src/runtime/rt0_openbsd_arm64.s go/src/runtime/rt0_openbsd_mips64.s +go/src/runtime/rt0_openbsd_riscv64.s go/src/runtime/rt0_plan9_386.s go/src/runtime/rt0_plan9_amd64.s go/src/runtime/rt0_plan9_arm.s @@ -9130,6 +9140,7 @@ go/src/runtime/signal_openbsd_amd64.go go/src/runtime/signal_openbsd_arm.go go/src/runtime/signal_openbsd_arm64.go go/src/runtime/signal_openbsd_mips64.go +go/src/runtime/signal_openbsd_riscv64.go go/src/runtime/signal_plan9.go go/src/runtime/signal_ppc64x.go go/src/runtime/signal_riscv64.go @@ -9212,6 +9223,7 @@ go/src/runtime/sys_openbsd_amd64.s go/src/runtime/sys_openbsd_arm.s go/src/runtime/sys_openbsd_arm64.s go/src/runtime/sys_openbsd_mips64.s +go/src/runtime/sys_openbsd_riscv64.s go/src/runtime/sys_plan9_386.s go/src/runtime/sys_plan9_amd64.s go/src/runtime/sys_plan9_arm.s @@ -9516,6 +9528,7 @@ go/src/syscall/asm_openbsd_amd64.s go/src/syscall/asm_openbsd_arm.s go/src/syscall/asm_openbsd_arm64.s go/src/syscall/asm_openbsd_mips64.s +go/src/syscall/asm_openbsd_riscv64.s go/src/syscall/asm_plan9_386.s go/src/syscall/asm_plan9_amd64.s go/src/syscall/asm_plan9_arm.s @@ -9650,6 +9663,7 @@ go/src/syscall/syscall_openbsd_arm.go go/src/syscall/syscall_openbsd_arm64.go go/src/syscall/syscall_openbsd_libc.go go/src/syscall/syscall_openbsd_mips64.go +go/src/syscall/syscall_openbsd_riscv64.go go/src/syscall/syscall_plan9.go go/src/syscall/syscall_plan9_test.go go/src/syscall/syscall_ptrace_test.go @@ -9708,6 +9722,7 @@ go/src/syscall/zerrors_openbsd_amd64.go go/src/syscall/zerrors_openbsd_arm.go go/src/syscall/zerrors_openbsd_arm64.go go/src/syscall/zerrors_openbsd_mips64.go +go/src/syscall/zerrors_openbsd_riscv64.go go/src/syscall/zerrors_solaris_amd64.go go/src/syscall/zerrors_windows.go go/src/syscall/zsyscall_aix_ppc64.go @@ -9747,6 +9762,8 @@ go/src/syscall/zsyscall_openbsd_arm64.go go/src/syscall/zsyscall_openbsd_arm64.s go/src/syscall/zsyscall_openbsd_mips64.go go/src/syscall/zsyscall_openbsd_mips64.s +go/src/syscall/zsyscall_openbsd_riscv64.go +go/src/syscall/zsyscall_openbsd_riscv64.s go/src/syscall/zsyscall_plan9_386.go go/src/syscall/zsyscall_plan9_amd64.go go/src/syscall/zsyscall_plan9_arm.go @@ -9782,6 +9799,7 @@ go/src/syscall/zsysnum_openbsd_amd64.go go/src/syscall/zsysnum_openbsd_arm.go go/src/syscall/zsysnum_openbsd_arm64.go go/src/syscall/zsysnum_openbsd_mips64.go +go/src/syscall/zsysnum_openbsd_riscv64.go go/src/syscall/zsysnum_plan9.go go/src/syscall/zsysnum_solaris_amd64.go go/src/syscall/ztypes_aix_ppc64.go @@ -9814,6 +9832,7 @@ go/src/syscall/ztypes_openbsd_amd64.go go/src/syscall/ztypes_openbsd_arm.go go/src/syscall/ztypes_openbsd_arm64.go go/src/syscall/ztypes_openbsd_mips64.go +go/src/syscall/ztypes_openbsd_riscv64.go go/src/syscall/ztypes_solaris_amd64.go go/src/testdata/ go/src/testdata/Isaac.Newton-Opticks.txt @@ -10130,6 +10149,7 @@ go/src/vendor/golang.org/x/sys/cpu/cpu_netbsd_arm64.go go/src/vendor/golang.org/x/sys/cpu/cpu_other_arm.go go/src/vendor/golang.org/x/sys/cpu/cpu_other_arm64.go go/src/vendor/golang.org/x/sys/cpu/cpu_other_mips64x.go +go/src/vendor/golang.org/x/sys/cpu/cpu_other_riscv64.go go/src/vendor/golang.org/x/sys/cpu/cpu_ppc64x.go go/src/vendor/golang.org/x/sys/cpu/cpu_riscv64.go go/src/vendor/golang.org/x/sys/cpu/cpu_s390x.go