diff --git a/golang.spec b/golang.spec index c13d992f149e63d62d4b2b2c84adc4e535861d54..cb94d347dbbfbf3ebe387cb9913853de13a0a6d2 100644 --- a/golang.spec +++ b/golang.spec @@ -66,7 +66,7 @@ Name: golang Version: 1.17.3 -Release: 14 +Release: 15 Summary: The Go Programming Language License: BSD and Public Domain URL: https://golang.org/ @@ -432,6 +432,25 @@ fi %files devel -f go-tests.list -f go-misc.list -f go-src.list %changelog +* Sta Mar 18 2023 huangqiqi - 1.17.3-15 +- runtime: implement undefined reference funcs & remove atomic prefix +- support --buildmode=shared for loong64 +- support --buildmode=plugin for loong64 +- enable test for buildmode=share&plugin +- Revert "cmd/compile: remove atomic Cas Xchg and Xadd intrinsics on loong64" +- net: disable TestLookupDotsWithRemoteSource and TestLookupGoogleSRV +- cmd/compile: sign-extend the 2nd argument of the AtomicCas32 op on loong64 +- syscall: update linux/loong64 kernel ABI, emulate fstatat with statx +- cmd/internal/obj/loong64: add the PCALAU12I instruction for reloc use +- cmd/{asm,link}/loong64: switch to LoongArch ELF psABI v2 relocs +- cmd/link, cmd/internal: in shared mode, change to use IE mode to access TLS variables +- enable c-archive test on linux/loong64 +- runtime: no need to save these registers in load_g&save_g +- cmd/internal/obj/loong64: add support for movgr2cf and movcf2gr instructions +- runtime: save and restore fcc registers in async preempt on loong64 +- cmd,cmd/vendor: pick up updates for golang.org/x/arch/loong64 +- cmd/internal/objfile: add loong64 disassembler support + * Fri Jan 20 2023 hanchao - 1.17.3-14 - Type:CVE - CVE:CVE-2022-23806,CVE-2022-23773,CVE-2022-24921,CVE-2021-44716,CVE-2022-23772,CVE-2022-41717 diff --git a/loongarch64.conf b/loongarch64.conf index bd53f855f7a41903ff339243bd011094c35cdffa..82b0ed3fe2e2514bc4f419d972d71e94e8a6ebb2 100644 --- a/loongarch64.conf +++ b/loongarch64.conf @@ -80,3 +80,20 @@ 0080-cmd-link-detect-glibc-vs-musl-ldso-at-link-time.patch 0081-runtime-mark-morestack_noctxt-SPWRITE-for-linux-loon.patch 0082-cmd-compile-cmd-dist-cmd-go-enable-pie-buildmode-for.patch +0083-runtime-implement-undefined-reference-funcs-remove-a.patch +0084-support-buildmode-shared-for-loong64.patch +0085-support-buildmode-plugin-for-loong64.patch +0086-enable-test-for-buildmode-share-plugin.patch +0087-Revert-cmd-compile-remove-atomic-Cas-Xchg-and-Xadd-i.patch +0088-net-disable-TestLookupDotsWithRemoteSource-and-TestL.patch +0089-cmd-compile-sign-extend-the-2nd-argument-of-the-Atom.patch +0090-syscall-update-linux-loong64-kernel-ABI-emulate-fsta.patch +0091-cmd-internal-obj-loong64-add-the-PCALAU12I-instructi.patch +0092-cmd-asm-link-loong64-switch-to-LoongArch-ELF-psABI-v.patch +0093-cmd-link-cmd-internal-in-shared-mode-change-to-use-I.patch +0094-enable-c-archive-test-on-linux-loong64.patch +0095-runtime-no-need-to-save-these-registers-in-load_g-sa.patch +0096-cmd-internal-obj-loong64-add-support-for-movgr2cf-an.patch +0097-runtime-save-and-restore-fcc-registers-in-async-pree.patch +0098-cmd-cmd-vendor-pick-up-updates-for-golang.org-x-arch.patch +0099-cmd-internal-objfile-add-loong64-disassembler-suppor.patch diff --git a/loongarch64/0083-runtime-implement-undefined-reference-funcs-remove-a.patch b/loongarch64/0083-runtime-implement-undefined-reference-funcs-remove-a.patch new file mode 100644 index 0000000000000000000000000000000000000000..f6fdc9e24b9c38374ef7e27050cd4cd40a190e66 --- /dev/null +++ b/loongarch64/0083-runtime-implement-undefined-reference-funcs-remove-a.patch @@ -0,0 +1,101 @@ +From 448bdb469b4dfa1d0f9a7882aaed2276976ff716 Mon Sep 17 00:00:00 2001 +From: limeidan +Date: Thu, 1 Dec 2022 17:44:42 +0800 +Subject: [PATCH 02/18] runtime: implement undefined reference funcs & remove + atomic prefix + +Change-Id: Idbcbdbf5dcc3c9586d79ca10d48b47dcbb9f5ab6 +--- + src/runtime/asm_loong64.s | 10 +++++++ + src/runtime/internal/atomic/atomic_loong64.s | 28 ++++++++++++++++++-- + src/runtime/sys_linux_loong64.s | 3 +++ + 3 files changed, 39 insertions(+), 2 deletions(-) + +diff --git a/src/runtime/asm_loong64.s b/src/runtime/asm_loong64.s +index abc065b03b..604bc43c33 100644 +--- a/src/runtime/asm_loong64.s ++++ b/src/runtime/asm_loong64.s +@@ -642,6 +642,16 @@ TEXT runtime·goexit(SB),NOSPLIT|NOFRAME|TOPFRAME,$0-0 + // traceback from goexit1 must hit code range of goexit + NOR R0, R0 // NOP + ++TEXT runtime·addmoduledata(SB),NOSPLIT,$0-0 ++ ADDV $-16, R3 ++ MOVV R30, 8(R3) ++ MOVV runtime·lastmoduledatap(SB), R5 ++ MOVV R4, moduledata_next(R5) ++ MOVV R4, runtime·lastmoduledatap(SB) ++ MOVV 8(R3), R30 ++ ADDV $16, R3 ++ RET ++ + TEXT ·checkASM(SB),NOSPLIT,$0-1 + MOVW $1, R19 + MOVB R19, ret+0(FP) +diff --git a/src/runtime/internal/atomic/atomic_loong64.s b/src/runtime/internal/atomic/atomic_loong64.s +index fef7931968..9a457ad529 100644 +--- a/src/runtime/internal/atomic/atomic_loong64.s ++++ b/src/runtime/internal/atomic/atomic_loong64.s +@@ -78,12 +78,36 @@ TEXT ·Storeuintptr(SB), NOSPLIT, $0-16 + TEXT ·Xadduintptr(SB), NOSPLIT, $0-24 + JMP ·Xadd64(SB) + ++TEXT ·Casint64(SB), NOSPLIT, $0-25 ++ JMP ·Cas64(SB) ++ ++TEXT ·Casint32(SB), NOSPLIT, $0-17 ++ JMP ·Cas(SB) ++ ++TEXT ·Loadint32(SB), NOSPLIT, $0-12 ++ JMP ·Load(SB) ++ ++TEXT ·Storeint32(SB), NOSPLIT, $0-12 ++ JMP ·Store(SB) ++ ++TEXT ·Storeint64(SB), NOSPLIT, $0-16 ++ JMP ·Store64(SB) ++ ++TEXT ·Xchgint64(SB), NOSPLIT, $0-24 ++ JMP ·Xchg64(SB) ++ ++TEXT ·Xchgint32(SB), NOSPLIT, $0-20 ++ JMP ·Xchg(SB) ++ + TEXT ·Loadint64(SB), NOSPLIT, $0-16 + JMP ·Load64(SB) + + TEXT ·Xaddint64(SB), NOSPLIT, $0-24 + JMP ·Xadd64(SB) + ++TEXT ·Xaddint32(SB), NOSPLIT, $0-20 ++ JMP ·Xadd(SB) ++ + // bool casp(void **val, void *old, void *new) + // Atomically: + // if(*val == old){ +@@ -294,9 +318,9 @@ TEXT ·Loadp(SB),NOSPLIT|NOFRAME,$0-16 + + // uint32 runtime∕internal∕atomic·LoadAcq(uint32 volatile* ptr) + TEXT ·LoadAcq(SB),NOSPLIT|NOFRAME,$0-12 +- JMP atomic·Load(SB) ++ JMP ·Load(SB) + + // uintptr ·LoadAcquintptr(uintptr volatile* ptr) + TEXT ·LoadAcquintptr(SB),NOSPLIT|NOFRAME,$0-16 +- JMP atomic·Load64(SB) ++ JMP ·Load64(SB) + +diff --git a/src/runtime/sys_linux_loong64.s b/src/runtime/sys_linux_loong64.s +index f062cdec3f..7872604d8b 100644 +--- a/src/runtime/sys_linux_loong64.s ++++ b/src/runtime/sys_linux_loong64.s +@@ -677,3 +677,6 @@ TEXT runtime·socket(SB),$0-20 + MOVV R0, 2(R0) // unimplemented, only needed for android; declared in stubs_linux.go + MOVW R0, ret+16(FP) // for vet + RET ++ ++TEXT runtime·sigreturn(SB),NOSPLIT,$0-0 ++ RET +-- +2.38.0 + diff --git a/loongarch64/0084-support-buildmode-shared-for-loong64.patch b/loongarch64/0084-support-buildmode-shared-for-loong64.patch new file mode 100644 index 0000000000000000000000000000000000000000..54b1ef82416486bbf02793d6ca9bbd542d7f8576 --- /dev/null +++ b/loongarch64/0084-support-buildmode-shared-for-loong64.patch @@ -0,0 +1,292 @@ +From 0e045450dcf86db2354f015f18def9ae04d76633 Mon Sep 17 00:00:00 2001 +From: limeidan +Date: Thu, 1 Dec 2022 17:45:39 +0800 +Subject: [PATCH 03/18] support --buildmode=shared for loong64 + +Change-Id: I73cf079aedcd2d601c0a91f199e8520520a28e91 +--- + src/cmd/compile/internal/ssa/regalloc.go | 2 + + src/cmd/internal/obj/loong64/a.out.go | 2 +- + src/cmd/internal/obj/loong64/asm.go | 38 ++++---- + src/cmd/internal/obj/loong64/cnames.go | 2 +- + src/cmd/internal/obj/loong64/obj.go | 116 +++++++++++++++++++++++ + src/cmd/internal/sys/supported.go | 2 +- + src/cmd/link/internal/ld/config.go | 2 +- + 7 files changed, 141 insertions(+), 23 deletions(-) + +diff --git a/src/cmd/compile/internal/ssa/regalloc.go b/src/cmd/compile/internal/ssa/regalloc.go +index 3b90b8769c..639ee9f117 100644 +--- a/src/cmd/compile/internal/ssa/regalloc.go ++++ b/src/cmd/compile/internal/ssa/regalloc.go +@@ -624,6 +624,8 @@ func (s *regAllocState) init(f *Func) { + s.allocatable &^= 1 << 15 // R15 + case "arm": + s.allocatable &^= 1 << 9 // R9 ++ case "loong64": ++ // nothing to do + case "ppc64le": // R2 already reserved. + // nothing to do + case "arm64": +diff --git a/src/cmd/internal/obj/loong64/a.out.go b/src/cmd/internal/obj/loong64/a.out.go +index 4fb4c91eea..63ee0ab44a 100644 +--- a/src/cmd/internal/obj/loong64/a.out.go ++++ b/src/cmd/internal/obj/loong64/a.out.go +@@ -225,9 +225,9 @@ const ( + C_LOREG + C_GOK + C_ADDR +- C_GOTADDR + C_TLS_LE + C_TLS_GD ++ C_GOTADDR + C_TEXTSIZE + + C_NCLASS // must be the last +diff --git a/src/cmd/internal/obj/loong64/asm.go b/src/cmd/internal/obj/loong64/asm.go +index 0d40ec1f39..c583e4d368 100644 +--- a/src/cmd/internal/obj/loong64/asm.go ++++ b/src/cmd/internal/obj/loong64/asm.go +@@ -270,8 +270,6 @@ var optab = []Optab{ + {AJMP, C_NONE, C_NONE, C_ZOREG, 18, 4, REGZERO, 0, 0}, // jirl r0, rj, 0 + {AJAL, C_NONE, C_NONE, C_ZOREG, 18, 4, REGLINK, 0, 0}, // jirl r1, rj, 0 + +- {AMOVV, C_GOTADDR, C_NONE, C_REG, 63, 12, 0, sys.Loong64, 0}, +- + {AMOVW, C_SEXT, C_NONE, C_FREG, 27, 4, 0, sys.Loong64, 0}, + {AMOVF, C_SEXT, C_NONE, C_FREG, 27, 4, 0, sys.Loong64, 0}, + {AMOVD, C_SEXT, C_NONE, C_FREG, 27, 4, 0, sys.Loong64, 0}, +@@ -340,6 +338,8 @@ var optab = []Optab{ + {AMOVBU, C_TLS_GD, C_NONE, C_REG, 57, 24, 0, sys.Loong64, 0}, + {AMOVWU, C_TLS_GD, C_NONE, C_REG, 57, 24, 0, sys.Loong64, 0}, + ++ {AMOVV, C_GOTADDR, C_NONE, C_REG, 63, 8, 0, sys.Loong64, 0}, ++ + {AWORD, C_LCON, C_NONE, C_NONE, 40, 4, 0, 0, 0}, + {AWORD, C_DCON, C_NONE, C_NONE, 61, 4, 0, 0, 0}, + +@@ -567,9 +567,6 @@ func (c *ctxt0) aclass(a *obj.Addr) int { + } + return C_LEXT + +- case obj.NAME_GOTREF: +- return C_GOTADDR +- + case obj.NAME_AUTO: + if a.Reg == REGSP { + // unset base register for better printing, since +@@ -603,6 +600,9 @@ func (c *ctxt0) aclass(a *obj.Addr) int { + return C_SOREG + } + return C_LOREG ++ ++ case obj.NAME_GOTREF: ++ return C_GOTADDR + } + + return C_GOK +@@ -1699,20 +1699,20 @@ func (c *ctxt0) asmout(p *obj.Prog, o *Optab, out []uint32) { + o1 = OP_RR(c.oprr(p.As), uint32(p.From.Reg), uint32(p.To.Reg)) + + case 63: // mov sym@GOT, r ==> pcaddu12i + ld.d +- o1 = OP_IR(c.opir(APCADDU12I), uint32(0), uint32(REGTMP)) +- rel := obj.Addrel(c.cursym) +- rel.Off = int32(c.pc) +- rel.Siz = 4 +- rel.Sym = p.From.Sym +- rel.Type = objabi.R_LOONG64_GOTPCREL_HI +- rel.Add = 0x0 +- o2 = OP_12IRR(c.opirr(-p.As), uint32(0), uint32(REGTMP), uint32(p.To.Reg)) +- rel2 := obj.Addrel(c.cursym) +- rel2.Off = int32(c.pc+4) +- rel2.Siz = 4 +- rel2.Sym = p.From.Sym +- rel2.Type = objabi.R_LOONG64_GOTPCREL_LO +- rel2.Add = 0x0 ++ o1 = OP_IR(c.opir(APCADDU12I), uint32(0), uint32(p.To.Reg)) ++ rel := obj.Addrel(c.cursym) ++ rel.Off = int32(c.pc) ++ rel.Siz = 4 ++ rel.Sym = p.From.Sym ++ rel.Type = objabi.R_LOONG64_GOTPCREL_HI ++ rel.Add = 0x0 ++ o2 = OP_12IRR(c.opirr(-p.As), uint32(0), uint32(p.To.Reg), uint32(p.To.Reg)) ++ rel2 := obj.Addrel(c.cursym) ++ rel2.Off = int32(c.pc + 4) ++ rel2.Siz = 4 ++ rel2.Sym = p.From.Sym ++ rel2.Type = objabi.R_LOONG64_GOTPCREL_LO ++ rel2.Add = 0x0 + } + + out[0] = o1 +diff --git a/src/cmd/internal/obj/loong64/cnames.go b/src/cmd/internal/obj/loong64/cnames.go +index c594ac97a3..b0b4f78c72 100644 +--- a/src/cmd/internal/obj/loong64/cnames.go ++++ b/src/cmd/internal/obj/loong64/cnames.go +@@ -37,9 +37,9 @@ var cnames0 = []string{ + "LOREG", + "GOK", + "ADDR", +- "GOTADDR", + "TLS_LE", + "TLS_GD", ++ "GOTADDR", + "TEXTSIZE", + "NCLASS", + } +diff --git a/src/cmd/internal/obj/loong64/obj.go b/src/cmd/internal/obj/loong64/obj.go +index 0f39c666a3..5bad29c049 100644 +--- a/src/cmd/internal/obj/loong64/obj.go ++++ b/src/cmd/internal/obj/loong64/obj.go +@@ -84,6 +84,122 @@ func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) { + p.As = AADDVU + } + } ++ ++ if ctxt.Flag_dynlink { ++ rewriteToUseGot(ctxt, p, newprog) ++ } ++} ++ ++func rewriteToUseGot(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) { ++ // ADUFFxxx $offset ++ // becomes ++ // MOVV runtime.duffxxx@GOT, REGTMP ++ // ADD $offset, REGTMP ++ // JAL REGTMP ++ if p.As == obj.ADUFFCOPY || p.As == obj.ADUFFZERO { ++ var sym *obj.LSym ++ if p.As == obj.ADUFFZERO { ++ sym = ctxt.Lookup("runtime.duffzero") ++ } else { ++ sym = ctxt.Lookup("runtime.duffcopy") ++ } ++ offset := p.To.Offset ++ p.As = AMOVV ++ p.From.Type = obj.TYPE_MEM ++ p.From.Sym = sym ++ p.From.Name = obj.NAME_GOTREF ++ p.To.Type = obj.TYPE_REG ++ p.To.Reg = REGTMP ++ p.To.Name = obj.NAME_NONE ++ p.To.Offset = 0 ++ p.To.Sym = nil ++ p1 := obj.Appendp(p, newprog) ++ p1.As = AADDV ++ p1.From.Type = obj.TYPE_CONST ++ p1.From.Offset = offset ++ p1.To.Type = obj.TYPE_REG ++ p1.To.Reg = REGTMP ++ p2 := obj.Appendp(p1, newprog) ++ p2.As = AJAL ++ p2.To.Type = obj.TYPE_MEM ++ p2.To.Reg = REGTMP ++ } ++ ++ // We only care about global data: NAME_EXTERN means a global ++ // symbol in the Go sense, and p.Sym.Local is true for a few ++ // internally defined symbols. ++ if p.From.Type == obj.TYPE_ADDR && p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local() { ++ // MOVV $sym, Rx becomes MOVV sym@GOT, Rx ++ // MOVV $sym+, Rx becomes MOVV sym@GOT, Rx; ADD , Rx ++ if p.As != AMOVV { ++ ctxt.Diag("do not know how to handle TYPE_ADDR in %v with -shared", p) ++ } ++ if p.To.Type != obj.TYPE_REG { ++ ctxt.Diag("do not know how to handle LEAQ-type insn to non-register in %v with -shared", p) ++ } ++ p.From.Type = obj.TYPE_MEM ++ p.From.Name = obj.NAME_GOTREF ++ if p.From.Offset != 0 { ++ q := obj.Appendp(p, newprog) ++ q.As = AADDV ++ q.From.Type = obj.TYPE_CONST ++ q.From.Offset = p.From.Offset ++ q.To = p.To ++ p.From.Offset = 0 ++ } ++ } ++ if p.GetFrom3() != nil && p.GetFrom3().Name == obj.NAME_EXTERN { ++ ctxt.Diag("don't know how to handle %v with -shared", p) ++ } ++ ++ var source *obj.Addr ++ // MOVx sym, Ry becomes MOVV sym@GOT, REGTMP; MOVx (REGTMP), Ry ++ // MOVx Ry, sym becomes MOVV sym@GOT, REGTMP; MOVx Ry, (REGTMP) ++ // An addition may be inserted between the two MOVs if there is an offset. ++ if p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local() { ++ if p.To.Name == obj.NAME_EXTERN && !p.To.Sym.Local() { ++ ctxt.Diag("cannot handle NAME_EXTERN on both sides in %v with -shared", p) ++ } ++ source = &p.From ++ } else if p.To.Name == obj.NAME_EXTERN && !p.To.Sym.Local() { ++ source = &p.To ++ } else { ++ return ++ } ++ if p.As == obj.ATEXT || p.As == obj.AFUNCDATA || p.As == obj.ACALL || p.As == obj.ARET || p.As == obj.AJMP { ++ return ++ } ++ if source.Sym.Type == objabi.STLSBSS { ++ return ++ } ++ if source.Type != obj.TYPE_MEM { ++ ctxt.Diag("don't know how to handle %v with -shared", p) ++ } ++ p1 := obj.Appendp(p, newprog) ++ p2 := obj.Appendp(p1, newprog) ++ p1.As = AMOVV ++ p1.From.Type = obj.TYPE_MEM ++ p1.From.Sym = source.Sym ++ p1.From.Name = obj.NAME_GOTREF ++ p1.To.Type = obj.TYPE_REG ++ p1.To.Reg = REGTMP ++ ++ p2.As = p.As ++ p2.From = p.From ++ p2.To = p.To ++ if p.From.Name == obj.NAME_EXTERN { ++ p2.From.Reg = REGTMP ++ p2.From.Name = obj.NAME_NONE ++ p2.From.Sym = nil ++ } else if p.To.Name == obj.NAME_EXTERN { ++ p2.To.Reg = REGTMP ++ p2.To.Name = obj.NAME_NONE ++ p2.To.Sym = nil ++ } else { ++ return ++ } ++ obj.Nopout(p) ++ + } + + func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) { +diff --git a/src/cmd/internal/sys/supported.go b/src/cmd/internal/sys/supported.go +index 0626ce27eb..53f488f73b 100644 +--- a/src/cmd/internal/sys/supported.go ++++ b/src/cmd/internal/sys/supported.go +@@ -100,7 +100,7 @@ func BuildModeSupported(compiler, buildmode, goos, goarch string) bool { + + case "shared": + switch platform { +- case "linux/386", "linux/amd64", "linux/arm", "linux/arm64", "linux/ppc64le", "linux/s390x": ++ case "linux/386", "linux/amd64", "linux/arm", "linux/arm64", "linux/loong64", "linux/ppc64le", "linux/s390x": + return true + } + return false +diff --git a/src/cmd/link/internal/ld/config.go b/src/cmd/link/internal/ld/config.go +index 09e032b012..4a82a3abff 100644 +--- a/src/cmd/link/internal/ld/config.go ++++ b/src/cmd/link/internal/ld/config.go +@@ -83,7 +83,7 @@ func (mode *BuildMode) Set(s string) error { + switch buildcfg.GOOS { + case "linux": + switch buildcfg.GOARCH { +- case "386", "amd64", "arm", "arm64", "ppc64le", "s390x": ++ case "386", "amd64", "arm", "arm64", "loong64", "ppc64le", "s390x": + default: + return badmode() + } +-- +2.38.0 + diff --git a/loongarch64/0085-support-buildmode-plugin-for-loong64.patch b/loongarch64/0085-support-buildmode-plugin-for-loong64.patch new file mode 100644 index 0000000000000000000000000000000000000000..3b735b55013ab0431cc871b839940ea0bff1a01b --- /dev/null +++ b/loongarch64/0085-support-buildmode-plugin-for-loong64.patch @@ -0,0 +1,86 @@ +From b9e58d4daf4c30c6565a069f22dc648433c2647f Mon Sep 17 00:00:00 2001 +From: limeidan +Date: Thu, 1 Dec 2022 19:44:20 +0800 +Subject: [PATCH 04/18] support --buildmode=plugin for loong64 + +Change-Id: Ie3f4770d732e13a9c6271ff79d5ea1233d89c116 +--- + src/cmd/internal/sys/supported.go | 2 +- + src/cmd/link/internal/ld/config.go | 2 +- + src/cmd/link/internal/loong64/asm.go | 34 +++++++++++++++++++++++++++- + 3 files changed, 35 insertions(+), 3 deletions(-) + +diff --git a/src/cmd/internal/sys/supported.go b/src/cmd/internal/sys/supported.go +index 53f488f73b..fcfc552cb6 100644 +--- a/src/cmd/internal/sys/supported.go ++++ b/src/cmd/internal/sys/supported.go +@@ -107,7 +107,7 @@ func BuildModeSupported(compiler, buildmode, goos, goarch string) bool { + + case "plugin": + switch platform { +- case "linux/amd64", "linux/arm", "linux/arm64", "linux/386", "linux/s390x", "linux/ppc64le", ++ case "linux/amd64", "linux/arm", "linux/arm64", "linux/loong64", "linux/386", "linux/s390x", "linux/ppc64le", + "android/amd64", "android/arm", "android/arm64", "android/386", + "darwin/amd64", "darwin/arm64", + "freebsd/amd64": +diff --git a/src/cmd/link/internal/ld/config.go b/src/cmd/link/internal/ld/config.go +index 4a82a3abff..29a8f8c692 100644 +--- a/src/cmd/link/internal/ld/config.go ++++ b/src/cmd/link/internal/ld/config.go +@@ -95,7 +95,7 @@ func (mode *BuildMode) Set(s string) error { + switch buildcfg.GOOS { + case "linux": + switch buildcfg.GOARCH { +- case "386", "amd64", "arm", "arm64", "s390x", "ppc64le": ++ case "386", "amd64", "arm", "arm64", "loong64", "s390x", "ppc64le": + default: + return badmode() + } +diff --git a/src/cmd/link/internal/loong64/asm.go b/src/cmd/link/internal/loong64/asm.go +index c45971d50d..8c65103872 100644 +--- a/src/cmd/link/internal/loong64/asm.go ++++ b/src/cmd/link/internal/loong64/asm.go +@@ -13,7 +13,39 @@ import ( + "debug/elf" + ) + +-func gentext(ctxt *ld.Link, ldr *loader.Loader) {} ++func gentext(ctxt *ld.Link, ldr *loader.Loader) { ++ initfunc, addmoduledata := ld.PrepareAddmoduledata(ctxt) ++ if initfunc == nil { ++ return ++ } ++ ++ o := func(op uint32) { ++ initfunc.AddUint32(ctxt.Arch, op) ++ } ++ ++ // 0: pcaddu12i r4, $0 ++ // 0: R_ADDRLOONG64U ++ // 4: addi.d r4, r4, $0 ++ // 4: R_ADDRLOONG64 ++ o(0x1c000004) ++ rel, _ := initfunc.AddRel(objabi.R_ADDRLOONG64U) ++ rel.SetOff(0) ++ rel.SetSiz(4) ++ rel.SetSym(ctxt.Moduledata) ++ o(0x02c00084) ++ rel2, _ := initfunc.AddRel(objabi.R_ADDRLOONG64) ++ rel2.SetOff(4) ++ rel2.SetSiz(4) ++ rel2.SetSym(ctxt.Moduledata) ++ ++ // 8: b $0 ++ // 8: R_CALLLOONG64 ++ o(0x50000000) ++ rel3, _ := initfunc.AddRel(objabi.R_CALLLOONG64) ++ rel3.SetOff(8) ++ rel3.SetSiz(4) ++ rel3.SetSym(addmoduledata) ++} + + func adddynrel(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, s loader.Sym, r loader.Reloc, rIdx int) bool { + return true +-- +2.38.0 + diff --git a/loongarch64/0086-enable-test-for-buildmode-share-plugin.patch b/loongarch64/0086-enable-test-for-buildmode-share-plugin.patch new file mode 100644 index 0000000000000000000000000000000000000000..75b72cd41113a2e8d3fdda2298a15bf7acd2d119 --- /dev/null +++ b/loongarch64/0086-enable-test-for-buildmode-share-plugin.patch @@ -0,0 +1,35 @@ +From 972ba9fc94149fa9328c8f12daf6a61783b308af Mon Sep 17 00:00:00 2001 +From: limeidan +Date: Thu, 1 Dec 2022 21:13:44 +0800 +Subject: [PATCH 05/18] enable test for buildmode=share&plugin + +Change-Id: Ic1e15ac5cfba087a162014d383ef8fd84b390839 +--- + src/cmd/dist/test.go | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go +index 070c0268ea..dc1b18906b 100644 +--- a/src/cmd/dist/test.go ++++ b/src/cmd/dist/test.go +@@ -1063,7 +1063,7 @@ func (t *tester) supportedBuildmode(mode string) bool { + return false + case "shared": + switch pair { +- case "linux-386", "linux-amd64", "linux-arm", "linux-arm64", "linux-ppc64le", "linux-s390x": ++ case "linux-386", "linux-amd64", "linux-arm", "linux-arm64", "linux-loong64", "linux-ppc64le", "linux-s390x": + return true + } + return false +@@ -1071,7 +1071,7 @@ func (t *tester) supportedBuildmode(mode string) bool { + // linux-arm64 is missing because it causes the external linker + // to crash, see https://golang.org/issue/17138 + switch pair { +- case "linux-386", "linux-amd64", "linux-arm", "linux-s390x", "linux-ppc64le": ++ case "linux-386", "linux-amd64", "linux-arm", "linux-loong64", "linux-s390x", "linux-ppc64le": + return true + case "darwin-amd64", "darwin-arm64": + return true +-- +2.38.0 + diff --git a/loongarch64/0087-Revert-cmd-compile-remove-atomic-Cas-Xchg-and-Xadd-i.patch b/loongarch64/0087-Revert-cmd-compile-remove-atomic-Cas-Xchg-and-Xadd-i.patch new file mode 100644 index 0000000000000000000000000000000000000000..4e6e6b5da0c9fe3b6977d14a32f39228debe8da4 --- /dev/null +++ b/loongarch64/0087-Revert-cmd-compile-remove-atomic-Cas-Xchg-and-Xadd-i.patch @@ -0,0 +1,70 @@ +From fb4393662cff11f7ee56adb323028381e8919084 Mon Sep 17 00:00:00 2001 +From: Guoqi Chen +Date: Fri, 16 Dec 2022 16:34:24 +0800 +Subject: [PATCH 06/18] Revert "cmd/compile: remove atomic Cas Xchg and Xadd + intrinsics on loong64" + +This reverts commit 8eac089cc04bb96752c3927425a45526f2181b0e. + +Change-Id: I2a1e8d5e4ac014ae804958c8c73f6e4e2cc8fc02 +--- + src/cmd/compile/internal/ssagen/ssa.go | 6 +++--- + test/inline_sync.go | 2 +- + test/intrinsic_atomic.go | 2 +- + 3 files changed, 5 insertions(+), 5 deletions(-) + +diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go +index 509773f0bb..487aded827 100644 +--- a/src/cmd/compile/internal/ssagen/ssa.go ++++ b/src/cmd/compile/internal/ssagen/ssa.go +@@ -3945,7 +3945,7 @@ func InitTables() { + s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v) + return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT32], v) + }, +- sys.AMD64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X) ++ sys.AMD64, sys.Loong64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X) + addF("runtime/internal/atomic", "Xchg64", + func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { + v := s.newValue3(ssa.OpAtomicExchange64, types.NewTuple(types.Types[types.TUINT64], types.TypeMem), args[0], args[1], s.mem()) +@@ -4010,7 +4010,7 @@ func InitTables() { + s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v) + return s.newValue1(ssa.OpSelect0, types.Types[types.TUINT32], v) + }, +- sys.AMD64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X) ++ sys.AMD64, sys.Loong64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X) + addF("runtime/internal/atomic", "Xadd64", + func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { + v := s.newValue3(ssa.OpAtomicAdd64, types.NewTuple(types.Types[types.TUINT64], types.TypeMem), args[0], args[1], s.mem()) +@@ -4032,7 +4032,7 @@ func InitTables() { + s.vars[memVar] = s.newValue1(ssa.OpSelect1, types.TypeMem, v) + return s.newValue1(ssa.OpSelect0, types.Types[types.TBOOL], v) + }, +- sys.AMD64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X) ++ sys.AMD64, sys.Loong64, sys.MIPS, sys.MIPS64, sys.PPC64, sys.RISCV64, sys.S390X) + addF("runtime/internal/atomic", "Cas64", + func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { + v := s.newValue4(ssa.OpAtomicCompareAndSwap64, types.NewTuple(types.Types[types.TBOOL], types.TypeMem), args[0], args[1], args[2], s.mem()) +diff --git a/test/inline_sync.go b/test/inline_sync.go +index de3934359d..30b436af41 100644 +--- a/test/inline_sync.go ++++ b/test/inline_sync.go +@@ -1,4 +1,4 @@ +-// +build !nacl,!386,!wasm,!arm,!gcflags_noopt,!loong64 ++// +build !nacl,!386,!wasm,!arm,!gcflags_noopt + // errorcheck -0 -m + + // Copyright 2019 The Go Authors. All rights reserved. +diff --git a/test/intrinsic_atomic.go b/test/intrinsic_atomic.go +index 61911b7a46..a1004c89d9 100644 +--- a/test/intrinsic_atomic.go ++++ b/test/intrinsic_atomic.go +@@ -1,5 +1,5 @@ + // errorcheck -0 -d=ssa/intrinsics/debug +-// +build amd64 arm64 mips mipsle mips64 mips64le ppc64 ppc64le riscv64 s390x ++// +build amd64 arm64 loong64 mips mipsle mips64 mips64le ppc64 ppc64le riscv64 s390x + + // Copyright 2016 The Go Authors. All rights reserved. + // Use of this source code is governed by a BSD-style +-- +2.38.0 + diff --git a/loongarch64/0088-net-disable-TestLookupDotsWithRemoteSource-and-TestL.patch b/loongarch64/0088-net-disable-TestLookupDotsWithRemoteSource-and-TestL.patch new file mode 100644 index 0000000000000000000000000000000000000000..c6a736b37b903a41f8f1b27082e7874469b54847 --- /dev/null +++ b/loongarch64/0088-net-disable-TestLookupDotsWithRemoteSource-and-TestL.patch @@ -0,0 +1,55 @@ +From c1831779e2b1c705366b8375b56c962ef6719dac Mon Sep 17 00:00:00 2001 +From: Michael Anthony Knyszek +Date: Fri, 11 Nov 2022 17:26:45 +0000 +Subject: [PATCH 07/18] net: disable TestLookupDotsWithRemoteSource and + TestLookupGoogleSRV + +These tests fail consistently due to a DNS change causing widespread +trybot outages. + +For #56707. +Fixes #56709. + +Change-Id: Iebdf91254a922a48880021198f0f12f6bc16b6e7 +Reviewed-on: https://go-review.googlesource.com/c/go/+/449640 +Reviewed-by: Carlos Amedee +Reviewed-by: Bryan Mills +Run-TryBot: Michael Knyszek +TryBot-Result: Gopher Robot +Reviewed-by: Damien Neil +(cherry picked from commit 97765249082b6835c77517a4e63bb38cfd6db97b) +Reviewed-on: https://go-review.googlesource.com/c/go/+/449505 +Reviewed-by: Ian Lance Taylor +--- + src/net/lookup_test.go | 8 ++++++++ + 1 file changed, 8 insertions(+) + +diff --git a/src/net/lookup_test.go b/src/net/lookup_test.go +index 3faaf00710..45237c9f47 100644 +--- a/src/net/lookup_test.go ++++ b/src/net/lookup_test.go +@@ -72,6 +72,10 @@ var lookupGoogleSRVTests = []struct { + var backoffDuration = [...]time.Duration{time.Second, 5 * time.Second, 30 * time.Second} + + func TestLookupGoogleSRV(t *testing.T) { ++ // TODO(mknyszek): Figure out next steps for this test. This is just ++ // a quick fix. ++ t.Skip("fails consistently due to an upstream DNS change; see #56707.") ++ + t.Parallel() + mustHaveExternalNetwork(t) + +@@ -629,6 +633,10 @@ func TestLookupDotsWithLocalSource(t *testing.T) { + } + + func TestLookupDotsWithRemoteSource(t *testing.T) { ++ // TODO(mknyszek): Figure out next steps for this test. This is just ++ // a quick fix. ++ t.Skip("fails consistently due to an upstream DNS change; see #56707.") ++ + if runtime.GOOS == "darwin" || runtime.GOOS == "ios" { + testenv.SkipFlaky(t, 27992) + } +-- +2.38.0 + diff --git a/loongarch64/0089-cmd-compile-sign-extend-the-2nd-argument-of-the-Atom.patch b/loongarch64/0089-cmd-compile-sign-extend-the-2nd-argument-of-the-Atom.patch new file mode 100644 index 0000000000000000000000000000000000000000..9d6b17c398dd339ed592de5a433ddbe78ff86065 --- /dev/null +++ b/loongarch64/0089-cmd-compile-sign-extend-the-2nd-argument-of-the-Atom.patch @@ -0,0 +1,164 @@ +From 30898c1aeba155c637cea659ffc2bf76d455baaf Mon Sep 17 00:00:00 2001 +From: Guoqi Chen +Date: Sat, 17 Dec 2022 14:19:36 +0800 +Subject: [PATCH 08/18] cmd/compile: sign-extend the 2nd argument of the + AtomicCas32 op on loong64 +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +The function AtomicCas32 is implemented using the LL-SC instruction pair on +loong64. However, the LL instruction on loong64 is sign-extended, so it is +necessary to sign-extend the second parameter "old" of the AtomicCas32, so +that the instruction BNE after LL can get the desired result. + +The function prototype of AtomicCas32 in golang: + func AtomicCas32(ptr *uint32, old, new uint32) bool + +When using an intrinsify implementation: + case 1: (*ptr) <= 0x80000000 && old < 0x80000000 + E.g: (*ptr) = 0x7FFFFFFF, old = Rarg1= 0x7FFFFFFF + + After run the instruction "LL (Rarg0), Rtmp": Rtmp = 0x7FFFFFFF + Rtmp ! = Rarg1(old) is false, the result we expect + + case 2: (*ptr) >= 0x80000000 && old >= 0x80000000 + E.g: (*ptr) = 0x80000000, old = Rarg1= 0x80000000 + + After run the instruction "LL (Rarg0), Rtmp": Rtmp = 0xFFFFFFFF_80000000 + Rtmp ! = Rarg1(old) is true, which we do not expect + +When using an non-intrinsify implementation: + Because Rarg1 is loaded from the stack using sign-extended instructions + ld.w, the situation described in Case 2 above does not occur + +Benchmarks on linux/loong64: +name old time/op new time/op delta +Cas 50.0ns ± 0% 50.1ns ± 0% ~ (p=1.000 n=1+1) +Cas64 50.0ns ± 0% 50.1ns ± 0% ~ (p=1.000 n=1+1) +Cas-4 56.0ns ± 0% 56.0ns ± 0% ~ (p=1.000 n=1+1) +Cas64-4 56.0ns ± 0% 56.0ns ± 0% ~ (p=1.000 n=1+1) + +Change-Id: I190a7fc648023b15fa392f7fdda5ac18c1561bac +--- + .../compile/internal/ssa/gen/LOONG64.rules | 3 +- + .../compile/internal/ssa/rewriteLOONG64.go | 24 ++++++++- + test/fixedbugs/issue57282.go | 50 +++++++++++++++++++ + 3 files changed, 74 insertions(+), 3 deletions(-) + create mode 100644 test/fixedbugs/issue57282.go + +diff --git a/src/cmd/compile/internal/ssa/gen/LOONG64.rules b/src/cmd/compile/internal/ssa/gen/LOONG64.rules +index 20664d33c5..f76bdeb618 100644 +--- a/src/cmd/compile/internal/ssa/gen/LOONG64.rules ++++ b/src/cmd/compile/internal/ssa/gen/LOONG64.rules +@@ -399,7 +399,8 @@ + + (AtomicAdd(32|64) ...) => (LoweredAtomicAdd(32|64) ...) + +-(AtomicCompareAndSwap(32|64) ...) => (LoweredAtomicCas(32|64) ...) ++(AtomicCompareAndSwap32 ptr old new mem) => (LoweredAtomicCas32 ptr (SignExt32to64 old) new mem) ++(AtomicCompareAndSwap64 ...) => (LoweredAtomicCas64 ...) + + // checks + (NilCheck ...) => (LoweredNilCheck ...) +diff --git a/src/cmd/compile/internal/ssa/rewriteLOONG64.go b/src/cmd/compile/internal/ssa/rewriteLOONG64.go +index daab2163a3..bfe28f541c 100644 +--- a/src/cmd/compile/internal/ssa/rewriteLOONG64.go ++++ b/src/cmd/compile/internal/ssa/rewriteLOONG64.go +@@ -52,8 +52,7 @@ func rewriteValueLOONG64(v *Value) bool { + v.Op = OpLOONG64LoweredAtomicAdd64 + return true + case OpAtomicCompareAndSwap32: +- v.Op = OpLOONG64LoweredAtomicCas32 +- return true ++ return rewriteValueLOONG64_OpAtomicCompareAndSwap32(v) + case OpAtomicCompareAndSwap64: + v.Op = OpLOONG64LoweredAtomicCas64 + return true +@@ -692,6 +691,27 @@ func rewriteValueLOONG64_OpAddr(v *Value) bool { + return true + } + } ++func rewriteValueLOONG64_OpAtomicCompareAndSwap32(v *Value) bool { ++ v_3 := v.Args[3] ++ v_2 := v.Args[2] ++ v_1 := v.Args[1] ++ v_0 := v.Args[0] ++ b := v.Block ++ typ := &b.Func.Config.Types ++ // match: (AtomicCompareAndSwap32 ptr old new mem) ++ // result: (LoweredAtomicCas32 ptr (SignExt32to64 old) new mem) ++ for { ++ ptr := v_0 ++ old := v_1 ++ new := v_2 ++ mem := v_3 ++ v.reset(OpLOONG64LoweredAtomicCas32) ++ v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64) ++ v0.AddArg(old) ++ v.AddArg4(ptr, v0, new, mem) ++ return true ++ } ++} + func rewriteValueLOONG64_OpAvg64u(v *Value) bool { + v_1 := v.Args[1] + v_0 := v.Args[0] +diff --git a/test/fixedbugs/issue57282.go b/test/fixedbugs/issue57282.go +new file mode 100644 +index 0000000000..a87206843c +--- /dev/null ++++ b/test/fixedbugs/issue57282.go +@@ -0,0 +1,50 @@ ++// run ++ ++// 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 loong64 ++ ++package main ++ ++import ( ++ "fmt" ++ . "sync/atomic" ++) ++ ++const ( ++ _magic = 0xfbcdefaf ++) ++ ++func main() { ++ var x struct { ++ before uint32 ++ i uint32 ++ after uint32 ++ ++ o uint32 ++ n uint32 ++ } ++ ++ x.before = _magic ++ x.after = _magic ++ ++ for t := uint32(0x7FFFFFF0); t < 0x80000003; t += 1 { ++ x.i = t + 0 ++ x.o = t + 0 ++ x.n = t + 1 ++ ++ if !CompareAndSwapUint32(&x.i, x.o, x.n) { ++ panic(fmt.Sprintf("should have swapped %#x %#x", x.o, x.n)) ++ } ++ ++ if x.i != x.n { ++ panic(fmt.Sprintf("wrong x.i after swap: x.i=%#x x.n=%#x", x.i, x.n)) ++ } ++ ++ if x.before != _magic || x.after != _magic { ++ panic(fmt.Sprintf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, _magic, _magic)) ++ } ++ } ++} +-- +2.38.0 + diff --git a/loongarch64/0090-syscall-update-linux-loong64-kernel-ABI-emulate-fsta.patch b/loongarch64/0090-syscall-update-linux-loong64-kernel-ABI-emulate-fsta.patch new file mode 100644 index 0000000000000000000000000000000000000000..4bdc64afda0b6df312eb811f17c1f9b3adba111b --- /dev/null +++ b/loongarch64/0090-syscall-update-linux-loong64-kernel-ABI-emulate-fsta.patch @@ -0,0 +1,3965 @@ +From a508e487a8bab0d6dc3f21f6e83adbd2e837942e Mon Sep 17 00:00:00 2001 +From: Guoqi Chen +Date: Thu, 9 Mar 2023 17:45:42 +0800 +Subject: [PATCH 09/18] syscall: update linux/loong64 kernel ABI, emulate + fstatat with statx + +The linux/loong64 kernel ABI has changed a little since the inception +of the Go port; most notably fstat and fstatat are being removed [1], +leaving only statx as the stat mechanism. Fortunately the structs are +easy enough to translate, and we now exclusively use statx across the +board on loong64 for best compatibility with past and future kernels +(due to the architecture's young age, statx is always available). + +In wiring up the statx calls, it turned out the linux/loong64 syscall +definitions were out-of-date, so the generation script received some +tweaking as well. + +Signed-off-by: Guoqi Chen +Change-Id: I79a9bed3005a9b39b958c06aa2b4af995cc17afe +--- + src/internal/syscall/unix/at.go | 16 - + src/internal/syscall/unix/at_fstatat.go | 29 + + src/internal/syscall/unix/at_statx.go | 16 + + .../syscall/unix/at_sysnum_fstatat_linux.go | 4 +- + src/syscall/mkerrors.sh | 1 + + src/syscall/syscall_linux_loong64.go | 63 +- + src/syscall/types_linux.go | 9 +- + src/syscall/zerrors_linux_loong64.go | 3445 +++++++++-------- + src/syscall/zsyscall_linux_loong64.go | 76 +- + src/syscall/zsysnum_linux_loong64.go | 3 +- + src/syscall/ztypes_linux_loong64.go | 48 +- + 11 files changed, 1979 insertions(+), 1731 deletions(-) + create mode 100644 src/internal/syscall/unix/at_fstatat.go + create mode 100644 src/internal/syscall/unix/at_statx.go + +diff --git a/src/internal/syscall/unix/at.go b/src/internal/syscall/unix/at.go +index 9b08864f7f..8045b459cd 100644 +--- a/src/internal/syscall/unix/at.go ++++ b/src/internal/syscall/unix/at.go +@@ -41,19 +41,3 @@ func Openat(dirfd int, path string, flags int, perm uint32) (int, error) { + + return int(fd), nil + } +- +-func Fstatat(dirfd int, path string, stat *syscall.Stat_t, flags int) error { +- var p *byte +- p, err := syscall.BytePtrFromString(path) +- if err != nil { +- return err +- } +- +- _, _, errno := syscall.Syscall6(fstatatTrap, uintptr(dirfd), uintptr(unsafe.Pointer(p)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0) +- if errno != 0 { +- return errno +- } +- +- return nil +- +-} +diff --git a/src/internal/syscall/unix/at_fstatat.go b/src/internal/syscall/unix/at_fstatat.go +new file mode 100644 +index 0000000000..4146b16d73 +--- /dev/null ++++ b/src/internal/syscall/unix/at_fstatat.go +@@ -0,0 +1,29 @@ ++// Copyright 2018 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 && !loong64) || openbsd || netbsd || dragonfly ++// +build linux,!loong64 openbsd netbsd dragonfly ++ ++package unix ++ ++import ( ++ "syscall" ++ "unsafe" ++) ++ ++func Fstatat(dirfd int, path string, stat *syscall.Stat_t, flags int) error { ++ var p *byte ++ p, err := syscall.BytePtrFromString(path) ++ if err != nil { ++ return err ++ } ++ ++ _, _, errno := syscall.Syscall6(fstatatTrap, uintptr(dirfd), uintptr(unsafe.Pointer(p)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0) ++ if errno != 0 { ++ return errno ++ } ++ ++ return nil ++ ++} +diff --git a/src/internal/syscall/unix/at_statx.go b/src/internal/syscall/unix/at_statx.go +new file mode 100644 +index 0000000000..8bc57b11e1 +--- /dev/null ++++ b/src/internal/syscall/unix/at_statx.go +@@ -0,0 +1,16 @@ ++// 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 && loong64 ++// +build linux,loong64 ++ ++package unix ++ ++import ( ++ "syscall" ++) ++ ++func Fstatat(dirfd int, path string, stat *syscall.Stat_t, flags int) error { ++ return syscall.Fstatat(dirfd, path, stat, flags) ++} +diff --git a/src/internal/syscall/unix/at_sysnum_fstatat_linux.go b/src/internal/syscall/unix/at_sysnum_fstatat_linux.go +index 5f7ea12e01..e53a2d1b75 100644 +--- a/src/internal/syscall/unix/at_sysnum_fstatat_linux.go ++++ b/src/internal/syscall/unix/at_sysnum_fstatat_linux.go +@@ -2,8 +2,8 @@ + // Use of this source code is governed by a BSD-style + // license that can be found in the LICENSE file. + +-//go:build arm64 || riscv64 || loong64 +-// +build arm64 riscv64 loong64 ++//go:build arm64 || riscv64 ++// +build arm64 riscv64 + + package unix + +diff --git a/src/syscall/mkerrors.sh b/src/syscall/mkerrors.sh +index fc86d8bd7e..92ab4c5f1e 100755 +--- a/src/syscall/mkerrors.sh ++++ b/src/syscall/mkerrors.sh +@@ -131,6 +131,7 @@ includes_Linux=' + #include + #include + #include ++#include + #include + #include + #include +diff --git a/src/syscall/syscall_linux_loong64.go b/src/syscall/syscall_linux_loong64.go +index 2bad1fcdf5..531201c0c1 100644 +--- a/src/syscall/syscall_linux_loong64.go ++++ b/src/syscall/syscall_linux_loong64.go +@@ -23,16 +23,12 @@ func EpollCreate(size int) (fd int, err error) { + + //sys EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) = SYS_EPOLL_PWAIT + //sys Fchown(fd int, uid int, gid int) (err error) +-//sys Fstat(fd int, stat *Stat_t) (err error) +-//sys Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) +-//sys fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) + //sys Fstatfs(fd int, buf *Statfs_t) (err error) + //sys Ftruncate(fd int, length int64) (err error) + //sysnb Getegid() (egid int) + //sysnb Geteuid() (euid int) + //sysnb Getgid() (gid int) + //sysnb Getuid() (uid int) +-//sysnb Getrlimit(resource int, rlim *Rlimit) (err error) + //sys Listen(s int, n int) (err error) + //sys Pread(fd int, p []byte, offset int64) (n int, err error) = SYS_PREAD64 + //sys Pwrite(fd int, p []byte, offset int64) (n int, err error) = SYS_PWRITE64 +@@ -41,12 +37,63 @@ func EpollCreate(size int) (fd int, err error) { + //sys sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) + //sys Setfsgid(gid int) (err error) + //sys Setfsuid(uid int) (err error) +-//sys Setrlimit(resource int, rlim *Rlimit) (err error) + //sys Shutdown(fd int, how int) (err error) + //sys Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int64, err error) ++//sys statx(dirfd int, path string, flags int, mask int, stat *statx_t) (err error) ++ ++// makedev makes C dev_t from major and minor numbers the glibc way: ++// 0xMMMM_MMMM 0xmmmm_mmmm -> 0xMMMM_Mmmm_mmmM_MMmm ++func makedev(major uint32, minor uint32) uint64 { ++ majorH := uint64(major >> 12) ++ majorL := uint64(major & 0xfff) ++ minorH := uint64(minor >> 8) ++ minorL := uint64(minor & 0xff) ++ return (majorH << 44) | (minorH << 20) | (majorL << 8) | minorL ++} ++ ++func timespecFromStatxTimestamp(x statxTimestamp) Timespec { ++ return Timespec{ ++ Sec: x.Sec, ++ Nsec: int64(x.Nsec), ++ } ++} ++ ++func fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) { ++ var r statx_t ++ // Do it the glibc way, add AT_NO_AUTOMOUNT. ++ if err = statx(dirfd, path, _AT_NO_AUTOMOUNT|flags, _STATX_BASIC_STATS, &r); err != nil { ++ return err ++ } ++ ++ stat.Dev = makedev(r.Dev_major, r.Dev_minor) ++ stat.Ino = r.Ino ++ stat.Mode = uint32(r.Mode) ++ stat.Nlink = r.Nlink ++ stat.Uid = r.Uid ++ stat.Gid = r.Gid ++ stat.Rdev = makedev(r.Rdev_major, r.Rdev_minor) ++ // hope we don't get to process files so large to overflow these size ++ // fields... ++ stat.Size = int64(r.Size) ++ stat.Blksize = int32(r.Blksize) ++ stat.Blocks = int64(r.Blocks) ++ stat.Atim = timespecFromStatxTimestamp(r.Atime) ++ stat.Mtim = timespecFromStatxTimestamp(r.Mtime) ++ stat.Ctim = timespecFromStatxTimestamp(r.Ctime) ++ ++ return nil ++} ++ ++func Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) { ++ return fstatat(fd, path, stat, flags) ++} ++ ++func Fstat(fd int, stat *Stat_t) (err error) { ++ return fstatat(fd, "", stat, _AT_EMPTY_PATH) ++} + + func Stat(path string, stat *Stat_t) (err error) { +- return Fstatat(_AT_FDCWD, path, stat, 0) ++ return fstatat(_AT_FDCWD, path, stat, 0) + } + + func Lchown(path string, uid int, gid int) (err error) { +@@ -54,7 +101,7 @@ func Lchown(path string, uid int, gid int) (err error) { + } + + func Lstat(path string, stat *Stat_t) (err error) { +- return Fstatat(_AT_FDCWD, path, stat, _AT_SYMLINK_NOFOLLOW) ++ return fstatat(_AT_FDCWD, path, stat, _AT_SYMLINK_NOFOLLOW) + } + + //sys Statfs(path string, buf *Statfs_t) (err error) +@@ -196,7 +243,6 @@ func Pipe(p []int) (err error) { + return + } + +- + //sysnb pipe2(p *[2]_C_int, flags int) (err error) + + func Pipe2(p []int, flags int) (err error) { +@@ -210,4 +256,3 @@ func Pipe2(p []int, flags int) (err error) { + p[1] = int(pp[1]) + return + } +- +diff --git a/src/syscall/types_linux.go b/src/syscall/types_linux.go +index 1ca8912b20..3184f0c0cc 100644 +--- a/src/syscall/types_linux.go ++++ b/src/syscall/types_linux.go +@@ -88,7 +88,7 @@ struct my_sockaddr_un { + + #ifdef __ARM_EABI__ + typedef struct user_regs PtraceRegs; +-#elif defined(__aarch64__) || defined(__loongarch64) ++#elif defined(__aarch64__) + typedef struct user_pt_regs PtraceRegs; + #elif defined(__powerpc64__) + typedef struct pt_regs PtraceRegs; +@@ -184,6 +184,10 @@ type _Gid_t C.gid_t + + type Stat_t C.struct_stat + ++type statxTimestamp C.struct_statx_timestamp ++ ++type statx_t C.struct_statx ++ + type Statfs_t C.struct_statfs + + type Dirent C.struct_dirent +@@ -417,6 +421,9 @@ const ( + _AT_REMOVEDIR = C.AT_REMOVEDIR + _AT_SYMLINK_NOFOLLOW = C.AT_SYMLINK_NOFOLLOW + _AT_EACCESS = C.AT_EACCESS ++ _AT_EMPTY_PATH = C.AT_EMPTY_PATH ++ _AT_NO_AUTOMOUNT = C.AT_NO_AUTOMOUNT ++ _STATX_BASIC_STATS = C.STATX_BASIC_STATS + ) + + type pollFd C.struct_pollfd +diff --git a/src/syscall/zerrors_linux_loong64.go b/src/syscall/zerrors_linux_loong64.go +index 1281e7d960..7e2850fd00 100644 +--- a/src/syscall/zerrors_linux_loong64.go ++++ b/src/syscall/zerrors_linux_loong64.go +@@ -7,1651 +7,1806 @@ + package syscall + + const ( +- AF_ALG = 0x26 +- AF_APPLETALK = 0x5 +- AF_ASH = 0x12 +- AF_ATMPVC = 0x8 +- AF_ATMSVC = 0x14 +- AF_AX25 = 0x3 +- AF_BLUETOOTH = 0x1f +- AF_BRIDGE = 0x7 +- AF_CAIF = 0x25 +- AF_CAN = 0x1d +- AF_DECnet = 0xc +- AF_ECONET = 0x13 +- AF_FILE = 0x1 +- AF_IB = 0x1b +- AF_IEEE802154 = 0x24 +- AF_INET = 0x2 +- AF_INET6 = 0xa +- AF_IPX = 0x4 +- AF_IRDA = 0x17 +- AF_ISDN = 0x22 +- AF_IUCV = 0x20 +- AF_KCM = 0x29 +- AF_KEY = 0xf +- AF_LLC = 0x1a +- AF_LOCAL = 0x1 +- AF_MAX = 0x2c +- AF_MPLS = 0x1c +- AF_NETBEUI = 0xd +- AF_NETLINK = 0x10 +- AF_NETROM = 0x6 +- AF_NFC = 0x27 +- AF_PACKET = 0x11 +- AF_PHONET = 0x23 +- AF_PPPOX = 0x18 +- AF_QIPCRTR = 0x2a +- AF_RDS = 0x15 +- AF_ROSE = 0xb +- AF_ROUTE = 0x10 +- AF_RXRPC = 0x21 +- AF_SECURITY = 0xe +- AF_SMC = 0x2b +- AF_SNA = 0x16 +- AF_TIPC = 0x1e +- AF_UNIX = 0x1 +- AF_UNSPEC = 0x0 +- AF_VSOCK = 0x28 +- AF_WANPIPE = 0x19 +- AF_X25 = 0x9 +- ARPHRD_6LOWPAN = 0x339 +- ARPHRD_ADAPT = 0x108 +- ARPHRD_APPLETLK = 0x8 +- ARPHRD_ARCNET = 0x7 +- ARPHRD_ASH = 0x30d +- ARPHRD_ATM = 0x13 +- ARPHRD_AX25 = 0x3 +- ARPHRD_BIF = 0x307 +- ARPHRD_CAIF = 0x336 +- ARPHRD_CAN = 0x118 +- ARPHRD_CHAOS = 0x5 +- ARPHRD_CISCO = 0x201 +- ARPHRD_CSLIP = 0x101 +- ARPHRD_CSLIP6 = 0x103 +- ARPHRD_DDCMP = 0x205 +- ARPHRD_DLCI = 0xf +- ARPHRD_ECONET = 0x30e +- ARPHRD_EETHER = 0x2 +- ARPHRD_ETHER = 0x1 +- ARPHRD_EUI64 = 0x1b +- ARPHRD_FCAL = 0x311 +- ARPHRD_FCFABRIC = 0x313 +- ARPHRD_FCPL = 0x312 +- ARPHRD_FCPP = 0x310 +- ARPHRD_FDDI = 0x306 +- ARPHRD_FRAD = 0x302 +- ARPHRD_HDLC = 0x201 +- ARPHRD_HIPPI = 0x30c +- ARPHRD_HWX25 = 0x110 +- ARPHRD_IEEE1394 = 0x18 +- ARPHRD_IEEE802 = 0x6 +- ARPHRD_IEEE80211 = 0x321 +- ARPHRD_IEEE80211_PRISM = 0x322 +- ARPHRD_IEEE80211_RADIOTAP = 0x323 +- ARPHRD_IEEE802154 = 0x324 +- ARPHRD_IEEE802154_MONITOR = 0x325 +- ARPHRD_IEEE802_TR = 0x320 +- ARPHRD_INFINIBAND = 0x20 +- ARPHRD_IP6GRE = 0x337 +- ARPHRD_IPDDP = 0x309 +- ARPHRD_IPGRE = 0x30a +- ARPHRD_IRDA = 0x30f +- ARPHRD_LAPB = 0x204 +- ARPHRD_LOCALTLK = 0x305 +- ARPHRD_LOOPBACK = 0x304 +- ARPHRD_METRICOM = 0x17 +- ARPHRD_NETLINK = 0x338 +- ARPHRD_NETROM = 0x0 +- ARPHRD_NONE = 0xfffe +- ARPHRD_PHONET = 0x334 +- ARPHRD_PHONET_PIPE = 0x335 +- ARPHRD_PIMREG = 0x30b +- ARPHRD_PPP = 0x200 +- ARPHRD_PRONET = 0x4 +- ARPHRD_RAWHDLC = 0x206 +- ARPHRD_RAWIP = 0x207 +- ARPHRD_ROSE = 0x10e +- ARPHRD_RSRVD = 0x104 +- ARPHRD_SIT = 0x308 +- ARPHRD_SKIP = 0x303 +- ARPHRD_SLIP = 0x100 +- ARPHRD_SLIP6 = 0x102 +- ARPHRD_TUNNEL = 0x300 +- ARPHRD_TUNNEL6 = 0x301 +- ARPHRD_VOID = 0xffff +- ARPHRD_VSOCKMON = 0x33a +- ARPHRD_X25 = 0x10f +- B0 = 0x0 +- B1000000 = 0x1008 +- B110 = 0x3 +- B115200 = 0x1002 +- B1152000 = 0x1009 +- B1200 = 0x9 +- B134 = 0x4 +- B150 = 0x5 +- B1500000 = 0x100a +- B1800 = 0xa +- B19200 = 0xe +- B200 = 0x6 +- B2000000 = 0x100b +- B230400 = 0x1003 +- B2400 = 0xb +- B2500000 = 0x100c +- B300 = 0x7 +- B3000000 = 0x100d +- B3500000 = 0x100e +- B38400 = 0xf +- B4000000 = 0x100f +- B460800 = 0x1004 +- B4800 = 0xc +- B50 = 0x1 +- B500000 = 0x1005 +- B57600 = 0x1001 +- B576000 = 0x1006 +- B600 = 0x8 +- B75 = 0x2 +- B921600 = 0x1007 +- B9600 = 0xd +- BPF_A = 0x10 +- BPF_ABS = 0x20 +- BPF_ADD = 0x0 +- BPF_ALU = 0x4 +- BPF_AND = 0x50 +- BPF_B = 0x10 +- BPF_DIV = 0x30 +- 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_LL_OFF = -0x200000 +- BPF_LSH = 0x60 +- BPF_MAJOR_VERSION = 0x1 +- BPF_MAXINSNS = 0x1000 +- BPF_MEM = 0x60 +- BPF_MEMWORDS = 0x10 +- BPF_MINOR_VERSION = 0x1 +- BPF_MISC = 0x7 +- BPF_MOD = 0x90 +- BPF_MSH = 0xa0 +- BPF_MUL = 0x20 +- BPF_NEG = 0x80 +- BPF_NET_OFF = -0x100000 +- BPF_OR = 0x40 +- 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 +- BPF_XOR = 0xa0 +- BRKINT = 0x2 +- CFLUSH = 0xf +- CLOCAL = 0x800 +- CLONE_CHILD_CLEARTID = 0x200000 +- CLONE_CHILD_SETTID = 0x1000000 +- CLONE_DETACHED = 0x400000 +- CLONE_FILES = 0x400 +- CLONE_FS = 0x200 +- CLONE_IO = 0x80000000 +- CLONE_NEWCGROUP = 0x2000000 +- CLONE_NEWIPC = 0x8000000 +- CLONE_NEWNET = 0x40000000 +- CLONE_NEWNS = 0x20000 +- CLONE_NEWPID = 0x20000000 +- CLONE_NEWUSER = 0x10000000 +- CLONE_NEWUTS = 0x4000000 +- CLONE_PARENT = 0x8000 +- CLONE_PARENT_SETTID = 0x100000 +- CLONE_PTRACE = 0x2000 +- CLONE_SETTLS = 0x80000 +- CLONE_SIGHAND = 0x800 +- CLONE_SYSVSEM = 0x40000 +- CLONE_THREAD = 0x10000 +- CLONE_UNTRACED = 0x800000 +- CLONE_VFORK = 0x4000 +- CLONE_VM = 0x100 +- CREAD = 0x80 +- CS5 = 0x0 +- CS6 = 0x10 +- CS7 = 0x20 +- CS8 = 0x30 +- CSIGNAL = 0xff +- CSIZE = 0x30 +- CSTART = 0x11 +- CSTATUS = 0x0 +- CSTOP = 0x13 +- CSTOPB = 0x40 +- CSUSP = 0x1a +- DT_BLK = 0x6 +- DT_CHR = 0x2 +- DT_DIR = 0x4 +- DT_FIFO = 0x1 +- DT_LNK = 0xa +- DT_REG = 0x8 +- DT_SOCK = 0xc +- DT_UNKNOWN = 0x0 +- DT_WHT = 0xe +- ECHO = 0x8 +- ECHOCTL = 0x200 +- ECHOE = 0x10 +- ECHOK = 0x20 +- ECHOKE = 0x800 +- ECHONL = 0x40 +- ECHOPRT = 0x400 +- ENCODING_DEFAULT = 0x0 +- ENCODING_FM_MARK = 0x3 +- ENCODING_FM_SPACE = 0x4 +- ENCODING_MANCHESTER = 0x5 +- ENCODING_NRZ = 0x1 +- ENCODING_NRZI = 0x2 +- EPOLLERR = 0x8 +- EPOLLET = 0x80000000 +- EPOLLEXCLUSIVE = 0x10000000 +- EPOLLHUP = 0x10 +- EPOLLIN = 0x1 +- EPOLLMSG = 0x400 +- EPOLLONESHOT = 0x40000000 +- EPOLLOUT = 0x4 +- EPOLLPRI = 0x2 +- EPOLLRDBAND = 0x80 +- EPOLLRDHUP = 0x2000 +- EPOLLRDNORM = 0x40 +- EPOLLWAKEUP = 0x20000000 +- EPOLLWRBAND = 0x200 +- EPOLLWRNORM = 0x100 +- EPOLL_CLOEXEC = 0x80000 +- EPOLL_CTL_ADD = 0x1 +- EPOLL_CTL_DEL = 0x2 +- EPOLL_CTL_MOD = 0x3 +- ETH_P_1588 = 0x88f7 +- ETH_P_8021AD = 0x88a8 +- ETH_P_8021AH = 0x88e7 +- ETH_P_8021Q = 0x8100 +- ETH_P_80221 = 0x8917 +- ETH_P_802_2 = 0x4 +- ETH_P_802_3 = 0x1 +- ETH_P_802_3_MIN = 0x600 +- ETH_P_802_EX1 = 0x88b5 +- ETH_P_AARP = 0x80f3 +- ETH_P_AF_IUCV = 0xfbfb +- ETH_P_ALL = 0x3 +- ETH_P_AOE = 0x88a2 +- ETH_P_ARCNET = 0x1a +- ETH_P_ARP = 0x806 +- ETH_P_ATALK = 0x809b +- ETH_P_ATMFATE = 0x8884 +- ETH_P_ATMMPOA = 0x884c +- ETH_P_AX25 = 0x2 +- ETH_P_BATMAN = 0x4305 +- ETH_P_BPQ = 0x8ff +- ETH_P_CAIF = 0xf7 +- ETH_P_CAN = 0xc +- ETH_P_CANFD = 0xd +- ETH_P_CONTROL = 0x16 +- ETH_P_CUST = 0x6006 +- ETH_P_DDCMP = 0x6 +- ETH_P_DEC = 0x6000 +- ETH_P_DIAG = 0x6005 +- ETH_P_DNA_DL = 0x6001 +- ETH_P_DNA_RC = 0x6002 +- ETH_P_DNA_RT = 0x6003 +- ETH_P_DSA = 0x1b +- ETH_P_ECONET = 0x18 +- ETH_P_EDSA = 0xdada +- ETH_P_ERSPAN = 0x88be +- ETH_P_ERSPAN2 = 0x22eb +- ETH_P_FCOE = 0x8906 +- ETH_P_FIP = 0x8914 +- ETH_P_HDLC = 0x19 +- ETH_P_HSR = 0x892f +- ETH_P_IBOE = 0x8915 +- ETH_P_IEEE802154 = 0xf6 +- ETH_P_IEEEPUP = 0xa00 +- ETH_P_IEEEPUPAT = 0xa01 +- ETH_P_IFE = 0xed3e +- ETH_P_IP = 0x800 +- ETH_P_IPV6 = 0x86dd +- ETH_P_IPX = 0x8137 +- ETH_P_IRDA = 0x17 +- ETH_P_LAT = 0x6004 +- ETH_P_LINK_CTL = 0x886c +- ETH_P_LOCALTALK = 0x9 +- ETH_P_LOOP = 0x60 +- ETH_P_LOOPBACK = 0x9000 +- ETH_P_MACSEC = 0x88e5 +- ETH_P_MAP = 0xf9 +- ETH_P_MOBITEX = 0x15 +- ETH_P_MPLS_MC = 0x8848 +- ETH_P_MPLS_UC = 0x8847 +- ETH_P_MVRP = 0x88f5 +- ETH_P_NCSI = 0x88f8 +- ETH_P_NSH = 0x894f +- ETH_P_PAE = 0x888e +- ETH_P_PAUSE = 0x8808 +- ETH_P_PHONET = 0xf5 +- ETH_P_PPPTALK = 0x10 +- ETH_P_PPP_DISC = 0x8863 +- ETH_P_PPP_MP = 0x8 +- ETH_P_PPP_SES = 0x8864 +- ETH_P_PREAUTH = 0x88c7 +- ETH_P_PRP = 0x88fb +- ETH_P_PUP = 0x200 +- ETH_P_PUPAT = 0x201 +- ETH_P_QINQ1 = 0x9100 +- ETH_P_QINQ2 = 0x9200 +- ETH_P_QINQ3 = 0x9300 +- ETH_P_RARP = 0x8035 +- ETH_P_SCA = 0x6007 +- ETH_P_SLOW = 0x8809 +- ETH_P_SNAP = 0x5 +- ETH_P_TDLS = 0x890d +- ETH_P_TEB = 0x6558 +- ETH_P_TIPC = 0x88ca +- ETH_P_TRAILER = 0x1c +- ETH_P_TR_802_2 = 0x11 +- ETH_P_TSN = 0x22f0 +- ETH_P_WAN_PPP = 0x7 +- ETH_P_WCCP = 0x883e +- ETH_P_X25 = 0x805 +- ETH_P_XDSA = 0xf8 +- EXTA = 0xe +- EXTB = 0xf +- EXTPROC = 0x10000 +- FD_CLOEXEC = 0x1 +- FD_SETSIZE = 0x400 +- FLUSHO = 0x1000 +- F_ADD_SEALS = 0x409 +- F_DUPFD = 0x0 +- F_DUPFD_CLOEXEC = 0x406 +- F_EXLCK = 0x4 +- F_GETFD = 0x1 +- F_GETFL = 0x3 +- F_GETLEASE = 0x401 +- F_GETLK = 0x5 +- F_GETLK64 = 0x5 +- F_GETOWN = 0x9 +- F_GETOWN_EX = 0x10 +- F_GETPIPE_SZ = 0x408 +- F_GETSIG = 0xb +- F_GET_FILE_RW_HINT = 0x40d +- F_GET_RW_HINT = 0x40b +- F_GET_SEALS = 0x40a +- F_LOCK = 0x1 +- F_NOTIFY = 0x402 +- F_OFD_GETLK = 0x24 +- F_OFD_SETLK = 0x25 +- F_OFD_SETLKW = 0x26 +- F_OK = 0x0 +- F_RDLCK = 0x0 +- F_SEAL_GROW = 0x4 +- F_SEAL_SEAL = 0x1 +- F_SEAL_SHRINK = 0x2 +- F_SEAL_WRITE = 0x8 +- F_SETFD = 0x2 +- F_SETFL = 0x4 +- F_SETLEASE = 0x400 +- F_SETLK = 0x6 +- F_SETLK64 = 0x6 +- F_SETLKW = 0x7 +- F_SETLKW64 = 0x7 +- F_SETOWN = 0x8 +- F_SETOWN_EX = 0xf +- F_SETPIPE_SZ = 0x407 +- F_SETSIG = 0xa +- F_SET_FILE_RW_HINT = 0x40e +- F_SET_RW_HINT = 0x40c +- F_SHLCK = 0x8 +- F_TEST = 0x3 +- F_TLOCK = 0x2 +- F_ULOCK = 0x0 +- F_UNLCK = 0x2 +- F_WRLCK = 0x1 +- HUPCL = 0x400 +- ICANON = 0x2 +- ICMPV6_FILTER = 0x1 +- ICRNL = 0x100 +- IEXTEN = 0x8000 +- IFA_F_DADFAILED = 0x8 +- IFA_F_DEPRECATED = 0x20 +- IFA_F_HOMEADDRESS = 0x10 +- IFA_F_MANAGETEMPADDR = 0x100 +- IFA_F_MCAUTOJOIN = 0x400 +- IFA_F_NODAD = 0x2 +- IFA_F_NOPREFIXROUTE = 0x200 +- IFA_F_OPTIMISTIC = 0x4 +- IFA_F_PERMANENT = 0x80 +- IFA_F_SECONDARY = 0x1 +- IFA_F_STABLE_PRIVACY = 0x800 +- IFA_F_TEMPORARY = 0x1 +- IFA_F_TENTATIVE = 0x40 +- IFA_MAX = 0x9 +- IFF_ALLMULTI = 0x200 +- IFF_ATTACH_QUEUE = 0x200 +- IFF_AUTOMEDIA = 0x4000 +- IFF_BROADCAST = 0x2 +- IFF_DEBUG = 0x4 +- IFF_DETACH_QUEUE = 0x400 +- IFF_DORMANT = 0x20000 +- IFF_DYNAMIC = 0x8000 +- IFF_ECHO = 0x40000 +- IFF_LOOPBACK = 0x8 +- IFF_LOWER_UP = 0x10000 +- IFF_MASTER = 0x400 +- IFF_MULTICAST = 0x1000 +- IFF_MULTI_QUEUE = 0x100 +- IFF_NAPI = 0x10 +- IFF_NAPI_FRAGS = 0x20 +- IFF_NOARP = 0x80 +- IFF_NOFILTER = 0x1000 +- IFF_NOTRAILERS = 0x20 +- IFF_NO_PI = 0x1000 +- IFF_ONE_QUEUE = 0x2000 +- IFF_PERSIST = 0x800 +- IFF_POINTOPOINT = 0x10 +- IFF_PORTSEL = 0x2000 +- IFF_PROMISC = 0x100 +- IFF_RUNNING = 0x40 +- IFF_SLAVE = 0x800 +- IFF_TAP = 0x2 +- IFF_TUN = 0x1 +- IFF_TUN_EXCL = 0x8000 +- IFF_UP = 0x1 +- IFF_VNET_HDR = 0x4000 +- IFF_VOLATILE = 0x70c5a +- IFNAMSIZ = 0x10 +- IGNBRK = 0x1 +- IGNCR = 0x80 +- IGNPAR = 0x4 +- IMAXBEL = 0x2000 +- INLCR = 0x40 +- INPCK = 0x10 +- IN_ACCESS = 0x1 +- IN_ALL_EVENTS = 0xfff +- IN_ATTRIB = 0x4 +- 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_CLOEXEC = 0x80000 +- IN_CLOSE = 0x18 +- IN_CLOSE_NOWRITE = 0x10 +- IN_CLOSE_WRITE = 0x8 +- IN_CREATE = 0x100 +- IN_DELETE = 0x200 +- IN_DELETE_SELF = 0x400 +- IN_DONT_FOLLOW = 0x2000000 +- IN_EXCL_UNLINK = 0x4000000 +- IN_IGNORED = 0x8000 +- IN_ISDIR = 0x40000000 +- IN_LOOPBACKNET = 0x7f +- IN_MASK_ADD = 0x20000000 +- IN_MODIFY = 0x2 +- IN_MOVE = 0xc0 +- IN_MOVED_FROM = 0x40 +- IN_MOVED_TO = 0x80 +- IN_MOVE_SELF = 0x800 +- IN_NONBLOCK = 0x800 +- IN_ONESHOT = 0x80000000 +- IN_ONLYDIR = 0x1000000 +- IN_OPEN = 0x20 +- IN_Q_OVERFLOW = 0x4000 +- IN_UNMOUNT = 0x2000 +- IPPROTO_AH = 0x33 +- IPPROTO_BEETPH = 0x5e +- IPPROTO_COMP = 0x6c +- IPPROTO_DCCP = 0x21 +- IPPROTO_DSTOPTS = 0x3c +- IPPROTO_EGP = 0x8 +- IPPROTO_ENCAP = 0x62 +- IPPROTO_ESP = 0x32 +- IPPROTO_FRAGMENT = 0x2c +- IPPROTO_GRE = 0x2f +- IPPROTO_HOPOPTS = 0x0 +- IPPROTO_ICMP = 0x1 +- IPPROTO_ICMPV6 = 0x3a +- IPPROTO_IDP = 0x16 +- IPPROTO_IGMP = 0x2 +- IPPROTO_IP = 0x0 +- IPPROTO_IPIP = 0x4 +- IPPROTO_IPV6 = 0x29 +- IPPROTO_MH = 0x87 +- IPPROTO_MPLS = 0x89 +- IPPROTO_MTP = 0x5c +- IPPROTO_NONE = 0x3b +- 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_2292DSTOPTS = 0x4 +- IPV6_2292HOPLIMIT = 0x8 +- IPV6_2292HOPOPTS = 0x3 +- IPV6_2292PKTINFO = 0x2 +- IPV6_2292PKTOPTIONS = 0x6 +- IPV6_2292RTHDR = 0x5 +- IPV6_ADDRFORM = 0x1 +- IPV6_ADDR_PREFERENCES = 0x48 +- IPV6_ADD_MEMBERSHIP = 0x14 +- IPV6_AUTHHDR = 0xa +- IPV6_AUTOFLOWLABEL = 0x46 +- IPV6_CHECKSUM = 0x7 +- IPV6_DONTFRAG = 0x3e +- IPV6_DROP_MEMBERSHIP = 0x15 +- IPV6_DSTOPTS = 0x3b +- IPV6_FREEBIND = 0x4e +- IPV6_HDRINCL = 0x24 +- IPV6_HOPLIMIT = 0x34 +- IPV6_HOPOPTS = 0x36 +- IPV6_IPSEC_POLICY = 0x22 +- IPV6_JOIN_ANYCAST = 0x1b +- IPV6_JOIN_GROUP = 0x14 +- IPV6_LEAVE_ANYCAST = 0x1c +- IPV6_LEAVE_GROUP = 0x15 +- IPV6_MINHOPCOUNT = 0x49 +- IPV6_MTU = 0x18 +- IPV6_MTU_DISCOVER = 0x17 +- IPV6_MULTICAST_HOPS = 0x12 +- IPV6_MULTICAST_IF = 0x11 +- IPV6_MULTICAST_LOOP = 0x13 +- IPV6_NEXTHOP = 0x9 +- IPV6_ORIGDSTADDR = 0x4a +- IPV6_PATHMTU = 0x3d +- IPV6_PKTINFO = 0x32 +- IPV6_PMTUDISC_DO = 0x2 +- IPV6_PMTUDISC_DONT = 0x0 +- IPV6_PMTUDISC_INTERFACE = 0x4 +- IPV6_PMTUDISC_OMIT = 0x5 +- IPV6_PMTUDISC_PROBE = 0x3 +- IPV6_PMTUDISC_WANT = 0x1 +- IPV6_RECVDSTOPTS = 0x3a +- IPV6_RECVERR = 0x19 +- IPV6_RECVFRAGSIZE = 0x4d +- IPV6_RECVHOPLIMIT = 0x33 +- IPV6_RECVHOPOPTS = 0x35 +- IPV6_RECVORIGDSTADDR = 0x4a +- IPV6_RECVPATHMTU = 0x3c +- IPV6_RECVPKTINFO = 0x31 +- IPV6_RECVRTHDR = 0x38 +- IPV6_RECVTCLASS = 0x42 +- IPV6_ROUTER_ALERT = 0x16 +- IPV6_RTHDR = 0x39 +- IPV6_RTHDRDSTOPTS = 0x37 +- IPV6_RTHDR_LOOSE = 0x0 +- IPV6_RTHDR_STRICT = 0x1 +- IPV6_RTHDR_TYPE_0 = 0x0 +- IPV6_RXDSTOPTS = 0x3b +- IPV6_RXHOPOPTS = 0x36 +- IPV6_TCLASS = 0x43 +- IPV6_TRANSPARENT = 0x4b +- IPV6_UNICAST_HOPS = 0x10 +- IPV6_UNICAST_IF = 0x4c +- IPV6_V6ONLY = 0x1a +- IPV6_XFRM_POLICY = 0x23 +- IP_ADD_MEMBERSHIP = 0x23 +- IP_ADD_SOURCE_MEMBERSHIP = 0x27 +- IP_BIND_ADDRESS_NO_PORT = 0x18 +- IP_BLOCK_SOURCE = 0x26 +- IP_CHECKSUM = 0x17 +- IP_DEFAULT_MULTICAST_LOOP = 0x1 +- IP_DEFAULT_MULTICAST_TTL = 0x1 +- IP_DF = 0x4000 +- IP_DROP_MEMBERSHIP = 0x24 +- IP_DROP_SOURCE_MEMBERSHIP = 0x28 +- IP_FREEBIND = 0xf +- IP_HDRINCL = 0x3 +- IP_IPSEC_POLICY = 0x10 +- IP_MAXPACKET = 0xffff +- IP_MAX_MEMBERSHIPS = 0x14 +- IP_MF = 0x2000 +- IP_MINTTL = 0x15 +- IP_MSFILTER = 0x29 +- IP_MSS = 0x240 +- IP_MTU = 0xe +- IP_MTU_DISCOVER = 0xa +- IP_MULTICAST_ALL = 0x31 +- IP_MULTICAST_IF = 0x20 +- IP_MULTICAST_LOOP = 0x22 +- IP_MULTICAST_TTL = 0x21 +- IP_NODEFRAG = 0x16 +- IP_OFFMASK = 0x1fff +- IP_OPTIONS = 0x4 +- IP_ORIGDSTADDR = 0x14 +- IP_PASSSEC = 0x12 +- IP_PKTINFO = 0x8 +- IP_PKTOPTIONS = 0x9 +- IP_PMTUDISC = 0xa +- IP_PMTUDISC_DO = 0x2 +- IP_PMTUDISC_DONT = 0x0 +- IP_PMTUDISC_INTERFACE = 0x4 +- IP_PMTUDISC_OMIT = 0x5 +- IP_PMTUDISC_PROBE = 0x3 +- IP_PMTUDISC_WANT = 0x1 +- IP_RECVERR = 0xb +- IP_RECVFRAGSIZE = 0x19 +- IP_RECVOPTS = 0x6 +- IP_RECVORIGDSTADDR = 0x14 +- IP_RECVRETOPTS = 0x7 +- IP_RECVTOS = 0xd +- IP_RECVTTL = 0xc +- IP_RETOPTS = 0x7 +- IP_RF = 0x8000 +- IP_ROUTER_ALERT = 0x5 +- IP_TOS = 0x1 +- IP_TRANSPARENT = 0x13 +- IP_TTL = 0x2 +- IP_UNBLOCK_SOURCE = 0x25 +- IP_UNICAST_IF = 0x32 +- IP_XFRM_POLICY = 0x11 +- ISIG = 0x1 +- ISTRIP = 0x20 +- IUTF8 = 0x4000 +- IXANY = 0x800 +- IXOFF = 0x1000 +- IXON = 0x400 +- LINUX_REBOOT_CMD_CAD_OFF = 0x0 +- LINUX_REBOOT_CMD_CAD_ON = 0x89abcdef +- LINUX_REBOOT_CMD_HALT = 0xcdef0123 +- LINUX_REBOOT_CMD_KEXEC = 0x45584543 +- LINUX_REBOOT_CMD_POWER_OFF = 0x4321fedc +- LINUX_REBOOT_CMD_RESTART = 0x1234567 +- LINUX_REBOOT_CMD_RESTART2 = 0xa1b2c3d4 +- LINUX_REBOOT_CMD_SW_SUSPEND = 0xd000fce2 +- LINUX_REBOOT_MAGIC1 = 0xfee1dead +- LINUX_REBOOT_MAGIC2 = 0x28121969 +- LOCK_EX = 0x2 +- LOCK_NB = 0x4 +- LOCK_SH = 0x1 +- LOCK_UN = 0x8 +- MADV_DODUMP = 0x11 +- MADV_DOFORK = 0xb +- MADV_DONTDUMP = 0x10 +- MADV_DONTFORK = 0xa +- MADV_DONTNEED = 0x4 +- MADV_FREE = 0x8 +- MADV_HUGEPAGE = 0xe +- MADV_HWPOISON = 0x64 +- MADV_KEEPONFORK = 0x13 +- MADV_MERGEABLE = 0xc +- MADV_NOHUGEPAGE = 0xf +- MADV_NORMAL = 0x0 +- MADV_RANDOM = 0x1 +- MADV_REMOVE = 0x9 +- MADV_SEQUENTIAL = 0x2 +- MADV_UNMERGEABLE = 0xd +- MADV_WILLNEED = 0x3 +- MADV_WIPEONFORK = 0x12 +- MAP_ANON = 0x20 +- MAP_ANONYMOUS = 0x20 +- MAP_DENYWRITE = 0x800 +- MAP_EXECUTABLE = 0x1000 +- MAP_FILE = 0x0 +- MAP_FIXED = 0x10 +- MAP_FIXED_NOREPLACE = 0x100000 +- MAP_GROWSDOWN = 0x100 +- MAP_HUGETLB = 0x40000 +- MAP_HUGE_MASK = 0x3f +- MAP_HUGE_SHIFT = 0x1a +- MAP_LOCKED = 0x2000 +- MAP_NONBLOCK = 0x10000 +- MAP_NORESERVE = 0x4000 +- MAP_POPULATE = 0x8000 +- MAP_PRIVATE = 0x2 +- MAP_SHARED = 0x1 +- MAP_SHARED_VALIDATE = 0x3 +- MAP_STACK = 0x20000 +- MAP_SYNC = 0x80000 +- MAP_TYPE = 0xf +- MCL_CURRENT = 0x1 +- MCL_FUTURE = 0x2 +- MCL_ONFAULT = 0x4 +- MNT_DETACH = 0x2 +- MNT_EXPIRE = 0x4 +- MNT_FORCE = 0x1 +- MSG_BATCH = 0x40000 +- MSG_CMSG_CLOEXEC = 0x40000000 +- MSG_CONFIRM = 0x800 +- MSG_CTRUNC = 0x8 +- MSG_DONTROUTE = 0x4 +- MSG_DONTWAIT = 0x40 +- MSG_EOR = 0x80 +- MSG_ERRQUEUE = 0x2000 +- MSG_FASTOPEN = 0x20000000 +- MSG_FIN = 0x200 +- MSG_MORE = 0x8000 +- MSG_NOSIGNAL = 0x4000 +- MSG_OOB = 0x1 +- MSG_PEEK = 0x2 +- MSG_PROXY = 0x10 +- MSG_RST = 0x1000 +- MSG_SYN = 0x400 +- MSG_TRUNC = 0x20 +- MSG_TRYHARD = 0x4 +- MSG_WAITALL = 0x100 +- MSG_WAITFORONE = 0x10000 +- MSG_ZEROCOPY = 0x4000000 +- MS_ACTIVE = 0x40000000 +- MS_ASYNC = 0x1 +- MS_BIND = 0x1000 +- MS_DIRSYNC = 0x80 +- MS_INVALIDATE = 0x2 +- MS_I_VERSION = 0x800000 +- MS_KERNMOUNT = 0x400000 +- MS_LAZYTIME = 0x2000000 +- MS_MANDLOCK = 0x40 +- MS_MGC_MSK = 0xffff0000 +- MS_MGC_VAL = 0xc0ed0000 +- MS_MOVE = 0x2000 +- MS_NOATIME = 0x400 +- MS_NODEV = 0x4 +- MS_NODIRATIME = 0x800 +- MS_NOEXEC = 0x8 +- MS_NOSUID = 0x2 +- MS_NOUSER = -0x80000000 +- MS_POSIXACL = 0x10000 +- MS_PRIVATE = 0x40000 +- MS_RDONLY = 0x1 +- MS_REC = 0x4000 +- MS_RELATIME = 0x200000 +- MS_REMOUNT = 0x20 +- MS_RMT_MASK = 0x2800051 +- MS_SHARED = 0x100000 +- MS_SILENT = 0x8000 +- MS_SLAVE = 0x80000 +- MS_STRICTATIME = 0x1000000 +- MS_SYNC = 0x4 +- MS_SYNCHRONOUS = 0x10 +- MS_UNBINDABLE = 0x20000 +- NAME_MAX = 0xff +- NETLINK_ADD_MEMBERSHIP = 0x1 +- NETLINK_AUDIT = 0x9 +- NETLINK_BROADCAST_ERROR = 0x4 +- NETLINK_CAP_ACK = 0xa +- NETLINK_CONNECTOR = 0xb +- NETLINK_CRYPTO = 0x15 +- NETLINK_DNRTMSG = 0xe +- NETLINK_DROP_MEMBERSHIP = 0x2 +- NETLINK_ECRYPTFS = 0x13 +- NETLINK_EXT_ACK = 0xb +- NETLINK_FIB_LOOKUP = 0xa +- NETLINK_FIREWALL = 0x3 +- NETLINK_GENERIC = 0x10 +- NETLINK_INET_DIAG = 0x4 +- NETLINK_IP6_FW = 0xd +- NETLINK_ISCSI = 0x8 +- NETLINK_KOBJECT_UEVENT = 0xf +- NETLINK_LISTEN_ALL_NSID = 0x8 +- NETLINK_LIST_MEMBERSHIPS = 0x9 +- NETLINK_NETFILTER = 0xc +- NETLINK_NFLOG = 0x5 +- NETLINK_NO_ENOBUFS = 0x5 +- NETLINK_PKTINFO = 0x3 +- NETLINK_RDMA = 0x14 +- NETLINK_ROUTE = 0x0 +- NETLINK_RX_RING = 0x6 +- NETLINK_SCSITRANSPORT = 0x12 +- NETLINK_SELINUX = 0x7 +- NETLINK_SMC = 0x16 +- NETLINK_SOCK_DIAG = 0x4 +- NETLINK_TX_RING = 0x7 +- NETLINK_UNUSED = 0x1 +- NETLINK_USERSOCK = 0x2 +- NETLINK_XFRM = 0x6 +- NLA_ALIGNTO = 0x4 +- NLA_F_NESTED = 0x8000 +- NLA_F_NET_BYTEORDER = 0x4000 +- NLA_HDRLEN = 0x4 +- NLMSG_ALIGNTO = 0x4 +- NLMSG_DONE = 0x3 +- NLMSG_ERROR = 0x2 +- NLMSG_HDRLEN = 0x10 +- NLMSG_MIN_TYPE = 0x10 +- NLMSG_NOOP = 0x1 +- NLMSG_OVERRUN = 0x4 +- NLM_F_ACK = 0x4 +- NLM_F_ACK_TLVS = 0x200 +- NLM_F_APPEND = 0x800 +- NLM_F_ATOMIC = 0x400 +- NLM_F_CAPPED = 0x100 +- NLM_F_CREATE = 0x400 +- NLM_F_DUMP = 0x300 +- NLM_F_DUMP_FILTERED = 0x20 +- NLM_F_DUMP_INTR = 0x10 +- NLM_F_ECHO = 0x8 +- NLM_F_EXCL = 0x200 +- NLM_F_MATCH = 0x200 +- NLM_F_MULTI = 0x2 +- NLM_F_NONREC = 0x100 +- NLM_F_REPLACE = 0x100 +- NLM_F_REQUEST = 0x1 +- NLM_F_ROOT = 0x100 +- NOFLSH = 0x80 +- OCRNL = 0x8 +- OFDEL = 0x80 +- OFILL = 0x40 +- ONLCR = 0x4 +- ONLRET = 0x20 +- ONOCR = 0x10 +- OPOST = 0x1 +- O_ACCMODE = 0x3 +- O_APPEND = 0x400 +- O_ASYNC = 0x2000 +- O_CLOEXEC = 0x80000 +- O_CREAT = 0x40 +- O_DIRECT = 0x4000 +- O_DIRECTORY = 0x10000 +- O_DSYNC = 0x1000 +- O_EXCL = 0x80 +- O_FSYNC = 0x101000 +- O_LARGEFILE = 0x0 +- O_NDELAY = 0x800 +- O_NOATIME = 0x40000 +- O_NOCTTY = 0x100 +- O_NOFOLLOW = 0x20000 +- O_NONBLOCK = 0x800 +- O_PATH = 0x200000 +- O_RDONLY = 0x0 +- O_RDWR = 0x2 +- O_RSYNC = 0x101000 +- O_SYNC = 0x101000 +- O_TMPFILE = 0x410000 +- O_TRUNC = 0x200 +- O_WRONLY = 0x1 +- PACKET_ADD_MEMBERSHIP = 0x1 +- PACKET_AUXDATA = 0x8 +- PACKET_BROADCAST = 0x1 +- PACKET_COPY_THRESH = 0x7 +- PACKET_DROP_MEMBERSHIP = 0x2 +- PACKET_FANOUT = 0x12 +- PACKET_FANOUT_CBPF = 0x6 +- PACKET_FANOUT_CPU = 0x2 +- PACKET_FANOUT_DATA = 0x16 +- PACKET_FANOUT_EBPF = 0x7 +- PACKET_FANOUT_FLAG_DEFRAG = 0x8000 +- PACKET_FANOUT_FLAG_ROLLOVER = 0x1000 +- PACKET_FANOUT_FLAG_UNIQUEID = 0x2000 +- PACKET_FANOUT_HASH = 0x0 +- PACKET_FANOUT_LB = 0x1 +- PACKET_FANOUT_QM = 0x5 +- PACKET_FANOUT_RND = 0x4 +- PACKET_FANOUT_ROLLOVER = 0x3 +- PACKET_FASTROUTE = 0x6 +- PACKET_HDRLEN = 0xb +- PACKET_HOST = 0x0 +- PACKET_KERNEL = 0x7 +- PACKET_LOOPBACK = 0x5 +- PACKET_LOSS = 0xe +- PACKET_MR_ALLMULTI = 0x2 +- PACKET_MR_MULTICAST = 0x0 +- PACKET_MR_PROMISC = 0x1 +- PACKET_MR_UNICAST = 0x3 +- PACKET_MULTICAST = 0x2 +- PACKET_ORIGDEV = 0x9 +- PACKET_OTHERHOST = 0x3 +- PACKET_OUTGOING = 0x4 +- PACKET_QDISC_BYPASS = 0x14 +- PACKET_RECV_OUTPUT = 0x3 +- PACKET_RESERVE = 0xc +- PACKET_ROLLOVER_STATS = 0x15 +- PACKET_RX_RING = 0x5 +- PACKET_STATISTICS = 0x6 +- PACKET_TIMESTAMP = 0x11 +- PACKET_TX_HAS_OFF = 0x13 +- PACKET_TX_RING = 0xd +- PACKET_TX_TIMESTAMP = 0x10 +- PACKET_USER = 0x6 +- PACKET_VERSION = 0xa +- PACKET_VNET_HDR = 0xf +- PARENB = 0x100 +- PARITY_CRC16_PR0 = 0x2 +- PARITY_CRC16_PR0_CCITT = 0x4 +- PARITY_CRC16_PR1 = 0x3 +- PARITY_CRC16_PR1_CCITT = 0x5 +- PARITY_CRC32_PR0_CCITT = 0x6 +- PARITY_CRC32_PR1_CCITT = 0x7 +- PARITY_DEFAULT = 0x0 +- PARITY_NONE = 0x1 +- PARMRK = 0x8 +- PARODD = 0x200 +- PENDIN = 0x4000 +- PRIO_PGRP = 0x1 +- PRIO_PROCESS = 0x0 +- PRIO_USER = 0x2 +- PROT_EXEC = 0x4 +- PROT_GROWSDOWN = 0x1000000 +- PROT_GROWSUP = 0x2000000 +- PROT_NONE = 0x0 +- PROT_READ = 0x1 +- PROT_WRITE = 0x2 +- PR_CAPBSET_DROP = 0x18 +- PR_CAPBSET_READ = 0x17 +- PR_CAP_AMBIENT = 0x2f +- PR_CAP_AMBIENT_CLEAR_ALL = 0x4 +- PR_CAP_AMBIENT_IS_SET = 0x1 +- PR_CAP_AMBIENT_LOWER = 0x3 +- PR_CAP_AMBIENT_RAISE = 0x2 +- PR_ENDIAN_BIG = 0x0 +- PR_ENDIAN_LITTLE = 0x1 +- PR_ENDIAN_PPC_LITTLE = 0x2 +- PR_FPEMU_NOPRINT = 0x1 +- PR_FPEMU_SIGFPE = 0x2 +- PR_FP_EXC_ASYNC = 0x2 +- PR_FP_EXC_DISABLED = 0x0 +- PR_FP_EXC_DIV = 0x10000 +- PR_FP_EXC_INV = 0x100000 +- PR_FP_EXC_NONRECOV = 0x1 +- PR_FP_EXC_OVF = 0x20000 +- PR_FP_EXC_PRECISE = 0x3 +- PR_FP_EXC_RES = 0x80000 +- PR_FP_EXC_SW_ENABLE = 0x80 +- PR_FP_EXC_UND = 0x40000 +- PR_FP_MODE_FR = 0x1 +- PR_FP_MODE_FRE = 0x2 +- PR_GET_CHILD_SUBREAPER = 0x25 +- PR_GET_DUMPABLE = 0x3 +- PR_GET_ENDIAN = 0x13 +- PR_GET_FPEMU = 0x9 +- PR_GET_FPEXC = 0xb +- PR_GET_FP_MODE = 0x2e +- PR_GET_KEEPCAPS = 0x7 +- PR_GET_NAME = 0x10 +- PR_GET_NO_NEW_PRIVS = 0x27 +- PR_GET_PDEATHSIG = 0x2 +- PR_GET_SECCOMP = 0x15 +- PR_GET_SECUREBITS = 0x1b +- PR_GET_SPECULATION_CTRL = 0x34 +- PR_GET_THP_DISABLE = 0x2a +- PR_GET_TID_ADDRESS = 0x28 +- PR_GET_TIMERSLACK = 0x1e +- PR_GET_TIMING = 0xd +- PR_GET_TSC = 0x19 +- PR_GET_UNALIGN = 0x5 +- PR_MCE_KILL = 0x21 +- PR_MCE_KILL_CLEAR = 0x0 +- PR_MCE_KILL_DEFAULT = 0x2 +- PR_MCE_KILL_EARLY = 0x1 +- PR_MCE_KILL_GET = 0x22 +- PR_MCE_KILL_LATE = 0x0 +- PR_MCE_KILL_SET = 0x1 +- PR_MPX_DISABLE_MANAGEMENT = 0x2c +- PR_MPX_ENABLE_MANAGEMENT = 0x2b +- PR_SET_CHILD_SUBREAPER = 0x24 +- PR_SET_DUMPABLE = 0x4 +- PR_SET_ENDIAN = 0x14 +- PR_SET_FPEMU = 0xa +- PR_SET_FPEXC = 0xc +- PR_SET_FP_MODE = 0x2d +- PR_SET_KEEPCAPS = 0x8 +- PR_SET_MM = 0x23 +- PR_SET_MM_ARG_END = 0x9 +- PR_SET_MM_ARG_START = 0x8 +- PR_SET_MM_AUXV = 0xc +- PR_SET_MM_BRK = 0x7 +- PR_SET_MM_END_CODE = 0x2 +- PR_SET_MM_END_DATA = 0x4 +- PR_SET_MM_ENV_END = 0xb +- PR_SET_MM_ENV_START = 0xa +- PR_SET_MM_EXE_FILE = 0xd +- PR_SET_MM_MAP = 0xe +- PR_SET_MM_MAP_SIZE = 0xf +- PR_SET_MM_START_BRK = 0x6 +- PR_SET_MM_START_CODE = 0x1 +- PR_SET_MM_START_DATA = 0x3 +- PR_SET_MM_START_STACK = 0x5 +- PR_SET_NAME = 0xf +- PR_SET_NO_NEW_PRIVS = 0x26 +- PR_SET_PDEATHSIG = 0x1 +- PR_SET_PTRACER = 0x59616d61 +- PR_SET_PTRACER_ANY = 0xffffffffffffffff +- PR_SET_SECCOMP = 0x16 +- PR_SET_SECUREBITS = 0x1c +- PR_SET_SPECULATION_CTRL = 0x35 +- PR_SET_THP_DISABLE = 0x29 +- PR_SET_TIMERSLACK = 0x1d +- PR_SET_TIMING = 0xe +- PR_SET_TSC = 0x1a +- PR_SET_UNALIGN = 0x6 +- PR_SPEC_DISABLE = 0x4 +- PR_SPEC_ENABLE = 0x2 +- PR_SPEC_FORCE_DISABLE = 0x8 +- PR_SPEC_INDIRECT_BRANCH = 0x1 +- PR_SPEC_NOT_AFFECTED = 0x0 +- PR_SPEC_PRCTL = 0x1 +- PR_SPEC_STORE_BYPASS = 0x0 +- PR_SVE_GET_VL = 0x33 +- PR_SVE_SET_VL = 0x32 +- PR_SVE_SET_VL_ONEXEC = 0x40000 +- PR_SVE_VL_INHERIT = 0x20000 +- PR_SVE_VL_LEN_MASK = 0xffff +- PR_TASK_PERF_EVENTS_DISABLE = 0x1f +- PR_TASK_PERF_EVENTS_ENABLE = 0x20 +- PR_TIMING_STATISTICAL = 0x0 +- PR_TIMING_TIMESTAMP = 0x1 +- PR_TSC_ENABLE = 0x1 +- PR_TSC_SIGSEGV = 0x2 +- PR_UNALIGN_NOPRINT = 0x1 +- PR_UNALIGN_SIGBUS = 0x2 +- PTRACE_ATTACH = 0x10 +- PTRACE_CONT = 0x7 +- PTRACE_DETACH = 0x11 +- PTRACE_EVENT_CLONE = 0x3 +- PTRACE_EVENT_EXEC = 0x4 +- PTRACE_EVENT_EXIT = 0x6 +- PTRACE_EVENT_FORK = 0x1 +- PTRACE_EVENT_SECCOMP = 0x7 +- PTRACE_EVENT_STOP = 0x80 +- PTRACE_EVENT_VFORK = 0x2 +- PTRACE_EVENT_VFORK_DONE = 0x5 +- PTRACE_GETEVENTMSG = 0x4201 +- PTRACE_GETREGS = 0xc +- PTRACE_GETREGSET = 0x4204 +- PTRACE_GETSIGINFO = 0x4202 +- PTRACE_GETSIGMASK = 0x420a +- PTRACE_INTERRUPT = 0x4207 +- PTRACE_KILL = 0x8 +- PTRACE_LISTEN = 0x4208 +- PTRACE_O_EXITKILL = 0x100000 +- PTRACE_O_MASK = 0x3000ff +- PTRACE_O_SUSPEND_SECCOMP = 0x200000 +- PTRACE_O_TRACECLONE = 0x8 +- PTRACE_O_TRACEEXEC = 0x10 +- PTRACE_O_TRACEEXIT = 0x40 +- PTRACE_O_TRACEFORK = 0x2 +- PTRACE_O_TRACESECCOMP = 0x80 +- PTRACE_O_TRACESYSGOOD = 0x1 +- PTRACE_O_TRACEVFORK = 0x4 +- PTRACE_O_TRACEVFORKDONE = 0x20 +- PTRACE_PEEKDATA = 0x2 +- PTRACE_PEEKSIGINFO = 0x4209 +- PTRACE_PEEKSIGINFO_SHARED = 0x1 +- PTRACE_PEEKTEXT = 0x1 +- PTRACE_PEEKUSR = 0x3 +- PTRACE_POKEDATA = 0x5 +- PTRACE_POKETEXT = 0x4 +- PTRACE_POKEUSR = 0x6 +- PTRACE_SECCOMP_GET_FILTER = 0x420c +- PTRACE_SECCOMP_GET_METADATA = 0x420d +- PTRACE_SEIZE = 0x4206 +- PTRACE_SETOPTIONS = 0x4200 +- PTRACE_SETREGS = 0xd +- PTRACE_SETREGSET = 0x4205 +- PTRACE_SETSIGINFO = 0x4203 +- PTRACE_SETSIGMASK = 0x420b +- PTRACE_SINGLESTEP = 0x9 +- PTRACE_SYSCALL = 0x18 +- PTRACE_TRACEME = 0x0 +- RLIMIT_AS = 0x9 +- RLIMIT_CORE = 0x4 +- RLIMIT_CPU = 0x0 +- RLIMIT_DATA = 0x2 +- RLIMIT_FSIZE = 0x1 +- RLIMIT_NOFILE = 0x7 +- RLIMIT_STACK = 0x3 +- RLIM_INFINITY = -0x1 +- RTAX_ADVMSS = 0x8 +- RTAX_CC_ALGO = 0x10 +- RTAX_CWND = 0x7 +- RTAX_FASTOPEN_NO_COOKIE = 0x11 +- RTAX_FEATURES = 0xc +- RTAX_FEATURE_ALLFRAG = 0x8 +- RTAX_FEATURE_ECN = 0x1 +- RTAX_FEATURE_MASK = 0xf +- RTAX_FEATURE_SACK = 0x2 +- RTAX_FEATURE_TIMESTAMP = 0x4 +- RTAX_HOPLIMIT = 0xa +- RTAX_INITCWND = 0xb +- RTAX_INITRWND = 0xe +- RTAX_LOCK = 0x1 +- RTAX_MAX = 0x11 +- RTAX_MTU = 0x2 +- RTAX_QUICKACK = 0xf +- RTAX_REORDERING = 0x9 +- RTAX_RTO_MIN = 0xd +- RTAX_RTT = 0x4 +- RTAX_RTTVAR = 0x5 +- RTAX_SSTHRESH = 0x6 +- RTAX_UNSPEC = 0x0 +- RTAX_WINDOW = 0x3 +- RTA_ALIGNTO = 0x4 +- RTA_MAX = 0x1d +- RTCF_DIRECTSRC = 0x4000000 +- RTCF_DOREDIRECT = 0x1000000 +- RTCF_LOG = 0x2000000 +- RTCF_MASQ = 0x400000 +- RTCF_NAT = 0x800000 +- RTCF_VALVE = 0x200000 +- RTF_ADDRCLASSMASK = 0xf8000000 +- RTF_ADDRCONF = 0x40000 +- RTF_ALLONLINK = 0x20000 +- RTF_BROADCAST = 0x10000000 +- RTF_CACHE = 0x1000000 +- RTF_DEFAULT = 0x10000 +- RTF_DYNAMIC = 0x10 +- RTF_FLOW = 0x2000000 +- RTF_GATEWAY = 0x2 +- RTF_HOST = 0x4 +- RTF_INTERFACE = 0x40000000 +- RTF_IRTT = 0x100 +- RTF_LINKRT = 0x100000 +- RTF_LOCAL = 0x80000000 +- RTF_MODIFIED = 0x20 +- RTF_MSS = 0x40 +- RTF_MTU = 0x40 +- RTF_MULTICAST = 0x20000000 +- RTF_NAT = 0x8000000 +- RTF_NOFORWARD = 0x1000 +- RTF_NONEXTHOP = 0x200000 +- RTF_NOPMTUDISC = 0x4000 +- RTF_POLICY = 0x4000000 +- RTF_REINSTATE = 0x8 +- RTF_REJECT = 0x200 +- RTF_STATIC = 0x400 +- RTF_THROW = 0x2000 +- RTF_UP = 0x1 +- RTF_WINDOW = 0x80 +- RTF_XRESOLVE = 0x800 +- RTM_BASE = 0x10 +- RTM_DELACTION = 0x31 +- RTM_DELADDR = 0x15 +- RTM_DELADDRLABEL = 0x49 +- RTM_DELCHAIN = 0x65 +- RTM_DELLINK = 0x11 +- RTM_DELMDB = 0x55 +- RTM_DELNEIGH = 0x1d +- RTM_DELNETCONF = 0x51 +- RTM_DELNSID = 0x59 +- RTM_DELQDISC = 0x25 +- RTM_DELROUTE = 0x19 +- RTM_DELRULE = 0x21 +- RTM_DELTCLASS = 0x29 +- RTM_DELTFILTER = 0x2d +- RTM_F_CLONED = 0x200 +- RTM_F_EQUALIZE = 0x400 +- RTM_F_FIB_MATCH = 0x2000 +- RTM_F_LOOKUP_TABLE = 0x1000 +- RTM_F_NOTIFY = 0x100 +- RTM_F_PREFIX = 0x800 +- RTM_GETACTION = 0x32 +- RTM_GETADDR = 0x16 +- RTM_GETADDRLABEL = 0x4a +- RTM_GETANYCAST = 0x3e +- RTM_GETCHAIN = 0x66 +- RTM_GETDCB = 0x4e +- RTM_GETLINK = 0x12 +- RTM_GETMDB = 0x56 +- RTM_GETMULTICAST = 0x3a +- RTM_GETNEIGH = 0x1e +- RTM_GETNEIGHTBL = 0x42 +- RTM_GETNETCONF = 0x52 +- RTM_GETNSID = 0x5a +- RTM_GETQDISC = 0x26 +- RTM_GETROUTE = 0x1a +- RTM_GETRULE = 0x22 +- RTM_GETSTATS = 0x5e +- RTM_GETTCLASS = 0x2a +- RTM_GETTFILTER = 0x2e +- RTM_MAX = 0x67 +- RTM_NEWACTION = 0x30 +- RTM_NEWADDR = 0x14 +- RTM_NEWADDRLABEL = 0x48 +- RTM_NEWCACHEREPORT = 0x60 +- RTM_NEWCHAIN = 0x64 +- RTM_NEWLINK = 0x10 +- RTM_NEWMDB = 0x54 +- RTM_NEWNDUSEROPT = 0x44 +- RTM_NEWNEIGH = 0x1c +- RTM_NEWNEIGHTBL = 0x40 +- RTM_NEWNETCONF = 0x50 +- RTM_NEWNSID = 0x58 +- RTM_NEWPREFIX = 0x34 +- RTM_NEWQDISC = 0x24 +- RTM_NEWROUTE = 0x18 +- RTM_NEWRULE = 0x20 +- RTM_NEWSTATS = 0x5c +- RTM_NEWTCLASS = 0x28 +- RTM_NEWTFILTER = 0x2c +- RTM_NR_FAMILIES = 0x16 +- RTM_NR_MSGTYPES = 0x58 +- RTM_SETDCB = 0x4f +- RTM_SETLINK = 0x13 +- RTM_SETNEIGHTBL = 0x43 +- RTNH_ALIGNTO = 0x4 +- RTNH_COMPARE_MASK = 0x19 +- RTNH_F_DEAD = 0x1 +- RTNH_F_LINKDOWN = 0x10 +- RTNH_F_OFFLOAD = 0x8 +- RTNH_F_ONLINK = 0x4 +- RTNH_F_PERVASIVE = 0x2 +- RTNH_F_UNRESOLVED = 0x20 +- RTN_MAX = 0xb +- RTPROT_BABEL = 0x2a +- RTPROT_BGP = 0xba +- RTPROT_BIRD = 0xc +- RTPROT_BOOT = 0x3 +- RTPROT_DHCP = 0x10 +- RTPROT_DNROUTED = 0xd +- RTPROT_EIGRP = 0xc0 +- RTPROT_GATED = 0x8 +- RTPROT_ISIS = 0xbb +- RTPROT_KERNEL = 0x2 +- RTPROT_MROUTED = 0x11 +- RTPROT_MRT = 0xa +- RTPROT_NTK = 0xf +- RTPROT_OSPF = 0xbc +- RTPROT_RA = 0x9 +- RTPROT_REDIRECT = 0x1 +- RTPROT_RIP = 0xbd +- RTPROT_STATIC = 0x4 +- RTPROT_UNSPEC = 0x0 +- RTPROT_XORP = 0xe +- RTPROT_ZEBRA = 0xb +- RT_CLASS_DEFAULT = 0xfd +- RT_CLASS_LOCAL = 0xff +- RT_CLASS_MAIN = 0xfe +- RT_CLASS_MAX = 0xff +- RT_CLASS_UNSPEC = 0x0 +- RUSAGE_CHILDREN = -0x1 +- RUSAGE_SELF = 0x0 +- RUSAGE_THREAD = 0x1 +- SCM_CREDENTIALS = 0x2 +- SCM_RIGHTS = 0x1 +- SCM_TIMESTAMP = 0x1d +- SCM_TIMESTAMPING = 0x25 +- SCM_TIMESTAMPING_OPT_STATS = 0x36 +- SCM_TIMESTAMPING_PKTINFO = 0x3a +- SCM_TIMESTAMPNS = 0x23 +- SCM_TXTIME = 0x3d +- SCM_WIFI_STATUS = 0x29 +- SHUT_RD = 0x0 +- SHUT_RDWR = 0x2 +- SHUT_WR = 0x1 +- SIOCADDDLCI = 0x8980 +- SIOCADDMULTI = 0x8931 +- SIOCADDRT = 0x890b +- SIOCATMARK = 0x8905 +- SIOCDARP = 0x8953 +- SIOCDELDLCI = 0x8981 +- SIOCDELMULTI = 0x8932 +- SIOCDELRT = 0x890c +- SIOCDEVPRIVATE = 0x89f0 +- SIOCDIFADDR = 0x8936 +- SIOCDRARP = 0x8960 +- SIOCGARP = 0x8954 +- SIOCGIFADDR = 0x8915 +- SIOCGIFBR = 0x8940 +- SIOCGIFBRDADDR = 0x8919 +- SIOCGIFCONF = 0x8912 +- SIOCGIFCOUNT = 0x8938 +- SIOCGIFDSTADDR = 0x8917 +- SIOCGIFENCAP = 0x8925 +- SIOCGIFFLAGS = 0x8913 +- SIOCGIFHWADDR = 0x8927 +- SIOCGIFINDEX = 0x8933 +- SIOCGIFMAP = 0x8970 +- SIOCGIFMEM = 0x891f +- SIOCGIFMETRIC = 0x891d +- SIOCGIFMTU = 0x8921 +- SIOCGIFNAME = 0x8910 +- SIOCGIFNETMASK = 0x891b +- SIOCGIFPFLAGS = 0x8935 +- SIOCGIFSLAVE = 0x8929 +- SIOCGIFTXQLEN = 0x8942 +- SIOCGPGRP = 0x8904 +- SIOCGRARP = 0x8961 +- SIOCGSTAMP = 0x8906 +- SIOCGSTAMPNS = 0x8907 +- SIOCPROTOPRIVATE = 0x89e0 +- SIOCRTMSG = 0x890d +- SIOCSARP = 0x8955 +- SIOCSIFADDR = 0x8916 +- SIOCSIFBR = 0x8941 +- SIOCSIFBRDADDR = 0x891a +- SIOCSIFDSTADDR = 0x8918 +- SIOCSIFENCAP = 0x8926 +- SIOCSIFFLAGS = 0x8914 +- SIOCSIFHWADDR = 0x8924 +- SIOCSIFHWBROADCAST = 0x8937 +- SIOCSIFLINK = 0x8911 +- SIOCSIFMAP = 0x8971 +- SIOCSIFMEM = 0x8920 +- SIOCSIFMETRIC = 0x891e +- SIOCSIFMTU = 0x8922 +- SIOCSIFNAME = 0x8923 +- SIOCSIFNETMASK = 0x891c +- SIOCSIFPFLAGS = 0x8934 +- SIOCSIFSLAVE = 0x8930 +- SIOCSIFTXQLEN = 0x8943 +- SIOCSPGRP = 0x8902 +- SIOCSRARP = 0x8962 +- SOCK_CLOEXEC = 0x80000 +- SOCK_DCCP = 0x6 +- SOCK_DGRAM = 0x2 +- SOCK_NONBLOCK = 0x800 +- SOCK_PACKET = 0xa +- SOCK_RAW = 0x3 +- SOCK_RDM = 0x4 +- SOCK_SEQPACKET = 0x5 +- SOCK_STREAM = 0x1 +- SOL_AAL = 0x109 +- SOL_ALG = 0x117 +- SOL_ATM = 0x108 +- SOL_BLUETOOTH = 0x112 +- SOL_CAIF = 0x116 +- SOL_DCCP = 0x10d +- SOL_DECNET = 0x105 +- SOL_ICMPV6 = 0x3a +- SOL_IP = 0x0 +- SOL_IPV6 = 0x29 +- SOL_IRDA = 0x10a +- SOL_IUCV = 0x115 +- SOL_KCM = 0x119 +- SOL_LLC = 0x10c +- SOL_NETBEUI = 0x10b +- SOL_NETLINK = 0x10e +- SOL_NFC = 0x118 +- SOL_PACKET = 0x107 +- SOL_PNPIPE = 0x113 +- SOL_PPPOL2TP = 0x111 +- SOL_RAW = 0xff +- SOL_RDS = 0x114 +- SOL_RXRPC = 0x110 +- SOL_SOCKET = 0x1 +- SOL_TCP = 0x6 +- SOL_TIPC = 0x10f +- SOL_TLS = 0x11a +- SOL_X25 = 0x106 +- SOMAXCONN = 0x80 +- SO_ACCEPTCONN = 0x1e +- SO_ATTACH_BPF = 0x32 +- SO_ATTACH_FILTER = 0x1a +- SO_ATTACH_REUSEPORT_CBPF = 0x33 +- SO_ATTACH_REUSEPORT_EBPF = 0x34 +- SO_BINDTODEVICE = 0x19 +- SO_BPF_EXTENSIONS = 0x30 +- SO_BROADCAST = 0x6 +- SO_BSDCOMPAT = 0xe +- SO_BUSY_POLL = 0x2e +- SO_CNX_ADVICE = 0x35 +- SO_COOKIE = 0x39 +- SO_DEBUG = 0x1 +- SO_DETACH_BPF = 0x1b +- SO_DETACH_FILTER = 0x1b +- SO_DOMAIN = 0x27 +- SO_DONTROUTE = 0x5 +- SO_ERROR = 0x4 +- SO_GET_FILTER = 0x1a +- SO_INCOMING_CPU = 0x31 +- SO_INCOMING_NAPI_ID = 0x38 +- SO_KEEPALIVE = 0x9 +- SO_LINGER = 0xd +- SO_LOCK_FILTER = 0x2c +- SO_MARK = 0x24 +- SO_MAX_PACING_RATE = 0x2f +- SO_MEMINFO = 0x37 +- SO_NOFCS = 0x2b +- SO_NO_CHECK = 0xb +- SO_OOBINLINE = 0xa +- SO_PASSCRED = 0x10 +- SO_PASSSEC = 0x22 +- SO_PEEK_OFF = 0x2a +- SO_PEERCRED = 0x11 +- SO_PEERGROUPS = 0x3b +- SO_PEERNAME = 0x1c +- SO_PEERSEC = 0x1f +- SO_PRIORITY = 0xc +- SO_PROTOCOL = 0x26 +- SO_RCVBUF = 0x8 +- SO_RCVBUFFORCE = 0x21 +- SO_RCVLOWAT = 0x12 +- SO_RCVTIMEO = 0x14 +- SO_REUSEADDR = 0x2 +- SO_REUSEPORT = 0xf +- SO_RXQ_OVFL = 0x28 +- SO_SECURITY_AUTHENTICATION = 0x16 +- SO_SECURITY_ENCRYPTION_NETWORK = 0x18 +- SO_SECURITY_ENCRYPTION_TRANSPORT = 0x17 +- SO_SELECT_ERR_QUEUE = 0x2d +- SO_SNDBUF = 0x7 +- SO_SNDBUFFORCE = 0x20 +- SO_SNDLOWAT = 0x13 +- SO_SNDTIMEO = 0x15 +- SO_TIMESTAMP = 0x1d +- SO_TIMESTAMPING = 0x25 +- SO_TIMESTAMPNS = 0x23 +- SO_TXTIME = 0x3d +- SO_TYPE = 0x3 +- SO_WIFI_STATUS = 0x29 +- SO_ZEROCOPY = 0x3c +- 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_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 +- TCFLSH = 0x540b +- TCIFLUSH = 0x0 +- TCIOFLUSH = 0x2 +- TCOFLUSH = 0x1 +- TCP_CC_INFO = 0x1a +- TCP_CONGESTION = 0xd +- TCP_COOKIE_IN_ALWAYS = 0x1 +- TCP_COOKIE_MAX = 0x10 +- TCP_COOKIE_MIN = 0x8 +- TCP_COOKIE_OUT_NEVER = 0x2 +- TCP_COOKIE_PAIR_SIZE = 0x20 +- TCP_COOKIE_TRANSACTIONS = 0xf +- TCP_CORK = 0x3 +- TCP_DEFER_ACCEPT = 0x9 +- TCP_FASTOPEN = 0x17 +- TCP_FASTOPEN_CONNECT = 0x1e +- TCP_FASTOPEN_KEY = 0x21 +- TCP_FASTOPEN_NO_COOKIE = 0x22 +- TCP_INFO = 0xb +- TCP_KEEPCNT = 0x6 +- TCP_KEEPIDLE = 0x4 +- TCP_KEEPINTVL = 0x5 +- TCP_LINGER2 = 0x8 +- TCP_MAXSEG = 0x2 +- TCP_MAXWIN = 0xffff +- TCP_MAX_WINSHIFT = 0xe +- TCP_MD5SIG = 0xe +- TCP_MD5SIG_EXT = 0x20 +- TCP_MD5SIG_FLAG_PREFIX = 0x1 +- TCP_MD5SIG_MAXKEYLEN = 0x50 +- TCP_MSS = 0x200 +- TCP_MSS_DEFAULT = 0x218 +- TCP_MSS_DESIRED = 0x4c4 +- TCP_NODELAY = 0x1 +- TCP_NOTSENT_LOWAT = 0x19 +- TCP_QUEUE_SEQ = 0x15 +- TCP_QUICKACK = 0xc +- TCP_REPAIR = 0x13 +- TCP_REPAIR_OPTIONS = 0x16 +- TCP_REPAIR_QUEUE = 0x14 +- TCP_REPAIR_WINDOW = 0x1d +- TCP_SAVED_SYN = 0x1c +- TCP_SAVE_SYN = 0x1b +- TCP_SYNCNT = 0x7 +- TCP_S_DATA_IN = 0x4 +- TCP_S_DATA_OUT = 0x8 +- TCP_THIN_DUPACK = 0x11 +- TCP_THIN_LINEAR_TIMEOUTS = 0x10 +- TCP_TIMESTAMP = 0x18 +- TCP_ULP = 0x1f +- TCP_USER_TIMEOUT = 0x12 +- TCP_WINDOW_CLAMP = 0xa +- TCSAFLUSH = 0x2 +- TIOCCBRK = 0x5428 +- TIOCCONS = 0x541d +- TIOCEXCL = 0x540c +- TIOCGDEV = 0x80045432 +- TIOCGETD = 0x5424 +- TIOCGEXCL = 0x80045440 +- TIOCGICOUNT = 0x545d +- TIOCGLCKTRMIOS = 0x5456 +- TIOCGPGRP = 0x540f +- TIOCGPKT = 0x80045438 +- TIOCGPTLCK = 0x80045439 +- TIOCGPTN = 0x80045430 +- TIOCGPTPEER = 0x5441 +- TIOCGRS485 = 0x542e +- TIOCGSERIAL = 0x541e +- TIOCGSID = 0x5429 +- TIOCGSOFTCAR = 0x5419 +- TIOCGWINSZ = 0x5413 +- TIOCINQ = 0x541b +- TIOCLINUX = 0x541c +- TIOCMBIC = 0x5417 +- TIOCMBIS = 0x5416 +- TIOCMGET = 0x5415 +- TIOCMIWAIT = 0x545c +- TIOCMSET = 0x5418 +- 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 = 0x5422 +- TIOCNXCL = 0x540d +- TIOCOUTQ = 0x5411 +- TIOCPKT = 0x5420 +- TIOCPKT_DATA = 0x0 +- TIOCPKT_DOSTOP = 0x20 +- TIOCPKT_FLUSHREAD = 0x1 +- TIOCPKT_FLUSHWRITE = 0x2 +- TIOCPKT_IOCTL = 0x40 +- TIOCPKT_NOSTOP = 0x10 +- TIOCPKT_START = 0x8 +- TIOCPKT_STOP = 0x4 +- TIOCSBRK = 0x5427 +- TIOCSCTTY = 0x540e +- TIOCSERCONFIG = 0x5453 +- TIOCSERGETLSR = 0x5459 +- TIOCSERGETMULTI = 0x545a +- TIOCSERGSTRUCT = 0x5458 +- TIOCSERGWILD = 0x5454 +- TIOCSERSETMULTI = 0x545b +- TIOCSERSWILD = 0x5455 +- TIOCSER_TEMT = 0x1 +- TIOCSETD = 0x5423 +- TIOCSIG = 0x40045436 +- TIOCSLCKTRMIOS = 0x5457 +- TIOCSPGRP = 0x5410 +- TIOCSPTLCK = 0x40045431 +- TIOCSRS485 = 0x542f +- TIOCSSERIAL = 0x541f +- TIOCSSOFTCAR = 0x541a +- TIOCSTI = 0x5412 +- TIOCSWINSZ = 0x5414 +- TIOCVHANGUP = 0x5437 +- TOSTOP = 0x100 +- TUNATTACHFILTER = 0x401054d5 +- TUNDETACHFILTER = 0x401054d6 +- TUNGETFEATURES = 0x800454cf +- TUNGETFILTER = 0x801054db +- TUNGETIFF = 0x800454d2 +- TUNGETSNDBUF = 0x800454d3 +- TUNGETVNETBE = 0x800454df +- TUNGETVNETHDRSZ = 0x800454d7 +- TUNGETVNETLE = 0x800454dd +- TUNSETDEBUG = 0x400454c9 +- TUNSETFILTEREBPF = 0x800454e1 +- TUNSETGROUP = 0x400454ce +- TUNSETIFF = 0x400454ca +- TUNSETIFINDEX = 0x400454da +- TUNSETLINK = 0x400454cd +- TUNSETNOCSUM = 0x400454c8 +- TUNSETOFFLOAD = 0x400454d0 +- TUNSETOWNER = 0x400454cc +- TUNSETPERSIST = 0x400454cb +- TUNSETQUEUE = 0x400454d9 +- TUNSETSNDBUF = 0x400454d4 +- TUNSETSTEERINGEBPF = 0x800454e0 +- TUNSETTXFILTER = 0x400454d1 +- TUNSETVNETBE = 0x400454de +- TUNSETVNETHDRSZ = 0x400454d8 +- TUNSETVNETLE = 0x400454dc +- VDISCARD = 0xd +- VEOF = 0x4 +- VEOL = 0xb +- VEOL2 = 0x10 +- VERASE = 0x2 +- VINTR = 0x0 +- VKILL = 0x3 +- VLNEXT = 0xf +- VMIN = 0x6 +- VQUIT = 0x1 +- VREPRINT = 0xc +- VSTART = 0x8 +- VSTOP = 0x9 +- VSUSP = 0xa +- VSWTC = 0x7 +- VT0 = 0x0 +- VT1 = 0x4000 +- VTDLY = 0x4000 +- VTIME = 0x5 +- VWERASE = 0xe +- WALL = 0x40000000 +- WCLONE = 0x80000000 +- WCONTINUED = 0x8 +- WEXITED = 0x4 +- WNOHANG = 0x1 +- WNOTHREAD = 0x20000000 +- WNOWAIT = 0x1000000 +- WORDSIZE = 0x40 +- WSTOPPED = 0x2 +- WUNTRACED = 0x2 ++ AF_ALG = 0x26 ++ AF_APPLETALK = 0x5 ++ AF_ASH = 0x12 ++ AF_ATMPVC = 0x8 ++ AF_ATMSVC = 0x14 ++ AF_AX25 = 0x3 ++ AF_BLUETOOTH = 0x1f ++ AF_BRIDGE = 0x7 ++ AF_CAIF = 0x25 ++ AF_CAN = 0x1d ++ AF_DECnet = 0xc ++ AF_ECONET = 0x13 ++ AF_FILE = 0x1 ++ AF_IB = 0x1b ++ AF_IEEE802154 = 0x24 ++ AF_INET = 0x2 ++ AF_INET6 = 0xa ++ AF_IPX = 0x4 ++ AF_IRDA = 0x17 ++ AF_ISDN = 0x22 ++ AF_IUCV = 0x20 ++ AF_KCM = 0x29 ++ AF_KEY = 0xf ++ AF_LLC = 0x1a ++ AF_LOCAL = 0x1 ++ AF_MAX = 0x2e ++ AF_MCTP = 0x2d ++ AF_MPLS = 0x1c ++ AF_NETBEUI = 0xd ++ AF_NETLINK = 0x10 ++ AF_NETROM = 0x6 ++ AF_NFC = 0x27 ++ AF_PACKET = 0x11 ++ AF_PHONET = 0x23 ++ AF_PPPOX = 0x18 ++ AF_QIPCRTR = 0x2a ++ AF_RDS = 0x15 ++ AF_ROSE = 0xb ++ AF_ROUTE = 0x10 ++ AF_RXRPC = 0x21 ++ AF_SECURITY = 0xe ++ AF_SMC = 0x2b ++ AF_SNA = 0x16 ++ AF_TIPC = 0x1e ++ AF_UNIX = 0x1 ++ AF_UNSPEC = 0x0 ++ AF_VSOCK = 0x28 ++ AF_WANPIPE = 0x19 ++ AF_X25 = 0x9 ++ AF_XDP = 0x2c ++ ARPHRD_6LOWPAN = 0x339 ++ ARPHRD_ADAPT = 0x108 ++ ARPHRD_APPLETLK = 0x8 ++ ARPHRD_ARCNET = 0x7 ++ ARPHRD_ASH = 0x30d ++ ARPHRD_ATM = 0x13 ++ ARPHRD_AX25 = 0x3 ++ ARPHRD_BIF = 0x307 ++ ARPHRD_CAIF = 0x336 ++ ARPHRD_CAN = 0x118 ++ ARPHRD_CHAOS = 0x5 ++ ARPHRD_CISCO = 0x201 ++ ARPHRD_CSLIP = 0x101 ++ ARPHRD_CSLIP6 = 0x103 ++ ARPHRD_DDCMP = 0x205 ++ ARPHRD_DLCI = 0xf ++ ARPHRD_ECONET = 0x30e ++ ARPHRD_EETHER = 0x2 ++ ARPHRD_ETHER = 0x1 ++ ARPHRD_EUI64 = 0x1b ++ ARPHRD_FCAL = 0x311 ++ ARPHRD_FCFABRIC = 0x313 ++ ARPHRD_FCPL = 0x312 ++ ARPHRD_FCPP = 0x310 ++ ARPHRD_FDDI = 0x306 ++ ARPHRD_FRAD = 0x302 ++ ARPHRD_HDLC = 0x201 ++ ARPHRD_HIPPI = 0x30c ++ ARPHRD_HWX25 = 0x110 ++ ARPHRD_IEEE1394 = 0x18 ++ ARPHRD_IEEE802 = 0x6 ++ ARPHRD_IEEE80211 = 0x321 ++ ARPHRD_IEEE80211_PRISM = 0x322 ++ ARPHRD_IEEE80211_RADIOTAP = 0x323 ++ ARPHRD_IEEE802154 = 0x324 ++ ARPHRD_IEEE802154_MONITOR = 0x325 ++ ARPHRD_IEEE802_TR = 0x320 ++ ARPHRD_INFINIBAND = 0x20 ++ ARPHRD_IP6GRE = 0x337 ++ ARPHRD_IPDDP = 0x309 ++ ARPHRD_IPGRE = 0x30a ++ ARPHRD_IRDA = 0x30f ++ ARPHRD_LAPB = 0x204 ++ ARPHRD_LOCALTLK = 0x305 ++ ARPHRD_LOOPBACK = 0x304 ++ ARPHRD_MCTP = 0x122 ++ ARPHRD_METRICOM = 0x17 ++ ARPHRD_NETLINK = 0x338 ++ ARPHRD_NETROM = 0x0 ++ ARPHRD_NONE = 0xfffe ++ ARPHRD_PHONET = 0x334 ++ ARPHRD_PHONET_PIPE = 0x335 ++ ARPHRD_PIMREG = 0x30b ++ ARPHRD_PPP = 0x200 ++ ARPHRD_PRONET = 0x4 ++ ARPHRD_RAWHDLC = 0x206 ++ ARPHRD_RAWIP = 0x207 ++ ARPHRD_ROSE = 0x10e ++ ARPHRD_RSRVD = 0x104 ++ ARPHRD_SIT = 0x308 ++ ARPHRD_SKIP = 0x303 ++ ARPHRD_SLIP = 0x100 ++ ARPHRD_SLIP6 = 0x102 ++ ARPHRD_TUNNEL = 0x300 ++ ARPHRD_TUNNEL6 = 0x301 ++ ARPHRD_VOID = 0xffff ++ ARPHRD_VSOCKMON = 0x33a ++ ARPHRD_X25 = 0x10f ++ B0 = 0x0 ++ B1000000 = 0x1008 ++ B110 = 0x3 ++ B115200 = 0x1002 ++ B1152000 = 0x1009 ++ B1200 = 0x9 ++ B134 = 0x4 ++ B150 = 0x5 ++ B1500000 = 0x100a ++ B1800 = 0xa ++ B19200 = 0xe ++ B200 = 0x6 ++ B2000000 = 0x100b ++ B230400 = 0x1003 ++ B2400 = 0xb ++ B2500000 = 0x100c ++ B300 = 0x7 ++ B3000000 = 0x100d ++ B3500000 = 0x100e ++ B38400 = 0xf ++ B4000000 = 0x100f ++ B460800 = 0x1004 ++ B4800 = 0xc ++ B50 = 0x1 ++ B500000 = 0x1005 ++ B57600 = 0x1001 ++ B576000 = 0x1006 ++ B600 = 0x8 ++ B75 = 0x2 ++ B921600 = 0x1007 ++ B9600 = 0xd ++ BPF_A = 0x10 ++ BPF_ABS = 0x20 ++ BPF_ADD = 0x0 ++ BPF_ALU = 0x4 ++ BPF_AND = 0x50 ++ BPF_B = 0x10 ++ BPF_DIV = 0x30 ++ 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_LL_OFF = -0x200000 ++ BPF_LSH = 0x60 ++ BPF_MAJOR_VERSION = 0x1 ++ BPF_MAXINSNS = 0x1000 ++ BPF_MEM = 0x60 ++ BPF_MEMWORDS = 0x10 ++ BPF_MINOR_VERSION = 0x1 ++ BPF_MISC = 0x7 ++ BPF_MOD = 0x90 ++ BPF_MSH = 0xa0 ++ BPF_MUL = 0x20 ++ BPF_NEG = 0x80 ++ BPF_NET_OFF = -0x100000 ++ BPF_OR = 0x40 ++ 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 ++ BPF_XOR = 0xa0 ++ BRKINT = 0x2 ++ CFLUSH = 0xf ++ CLOCAL = 0x800 ++ CLONE_ARGS_SIZE_VER0 = 0x40 ++ CLONE_ARGS_SIZE_VER1 = 0x50 ++ CLONE_ARGS_SIZE_VER2 = 0x58 ++ CLONE_CHILD_CLEARTID = 0x200000 ++ CLONE_CHILD_SETTID = 0x1000000 ++ CLONE_CLEAR_SIGHAND = 0x100000000 ++ CLONE_DETACHED = 0x400000 ++ CLONE_FILES = 0x400 ++ CLONE_FS = 0x200 ++ CLONE_INTO_CGROUP = 0x200000000 ++ CLONE_IO = 0x80000000 ++ CLONE_NEWCGROUP = 0x2000000 ++ CLONE_NEWIPC = 0x8000000 ++ CLONE_NEWNET = 0x40000000 ++ CLONE_NEWNS = 0x20000 ++ CLONE_NEWPID = 0x20000000 ++ CLONE_NEWTIME = 0x80 ++ CLONE_NEWUSER = 0x10000000 ++ CLONE_NEWUTS = 0x4000000 ++ CLONE_PARENT = 0x8000 ++ CLONE_PARENT_SETTID = 0x100000 ++ CLONE_PIDFD = 0x1000 ++ CLONE_PTRACE = 0x2000 ++ CLONE_SETTLS = 0x80000 ++ CLONE_SIGHAND = 0x800 ++ CLONE_SYSVSEM = 0x40000 ++ CLONE_THREAD = 0x10000 ++ CLONE_UNTRACED = 0x800000 ++ CLONE_VFORK = 0x4000 ++ CLONE_VM = 0x100 ++ CREAD = 0x80 ++ CS5 = 0x0 ++ CS6 = 0x10 ++ CS7 = 0x20 ++ CS8 = 0x30 ++ CSIGNAL = 0xff ++ CSIZE = 0x30 ++ CSTART = 0x11 ++ CSTATUS = 0x0 ++ CSTOP = 0x13 ++ CSTOPB = 0x40 ++ CSUSP = 0x1a ++ DT_BLK = 0x6 ++ DT_CHR = 0x2 ++ DT_DIR = 0x4 ++ DT_FIFO = 0x1 ++ DT_LNK = 0xa ++ DT_REG = 0x8 ++ DT_SOCK = 0xc ++ DT_UNKNOWN = 0x0 ++ DT_WHT = 0xe ++ ECHO = 0x8 ++ ECHOCTL = 0x200 ++ ECHOE = 0x10 ++ ECHOK = 0x20 ++ ECHOKE = 0x800 ++ ECHONL = 0x40 ++ ECHOPRT = 0x400 ++ ENCODING_DEFAULT = 0x0 ++ ENCODING_FM_MARK = 0x3 ++ ENCODING_FM_SPACE = 0x4 ++ ENCODING_MANCHESTER = 0x5 ++ ENCODING_NRZ = 0x1 ++ ENCODING_NRZI = 0x2 ++ EPOLLERR = 0x8 ++ EPOLLET = 0x80000000 ++ EPOLLEXCLUSIVE = 0x10000000 ++ EPOLLHUP = 0x10 ++ EPOLLIN = 0x1 ++ EPOLLMSG = 0x400 ++ EPOLLONESHOT = 0x40000000 ++ EPOLLOUT = 0x4 ++ EPOLLPRI = 0x2 ++ EPOLLRDBAND = 0x80 ++ EPOLLRDHUP = 0x2000 ++ EPOLLRDNORM = 0x40 ++ EPOLLWAKEUP = 0x20000000 ++ EPOLLWRBAND = 0x200 ++ EPOLLWRNORM = 0x100 ++ EPOLL_CLOEXEC = 0x80000 ++ EPOLL_CTL_ADD = 0x1 ++ EPOLL_CTL_DEL = 0x2 ++ EPOLL_CTL_MOD = 0x3 ++ ETH_P_1588 = 0x88f7 ++ ETH_P_8021AD = 0x88a8 ++ ETH_P_8021AH = 0x88e7 ++ ETH_P_8021Q = 0x8100 ++ ETH_P_80221 = 0x8917 ++ ETH_P_802_2 = 0x4 ++ ETH_P_802_3 = 0x1 ++ ETH_P_802_3_MIN = 0x600 ++ ETH_P_802_EX1 = 0x88b5 ++ ETH_P_AARP = 0x80f3 ++ ETH_P_AF_IUCV = 0xfbfb ++ ETH_P_ALL = 0x3 ++ ETH_P_AOE = 0x88a2 ++ ETH_P_ARCNET = 0x1a ++ ETH_P_ARP = 0x806 ++ ETH_P_ATALK = 0x809b ++ ETH_P_ATMFATE = 0x8884 ++ ETH_P_ATMMPOA = 0x884c ++ ETH_P_AX25 = 0x2 ++ ETH_P_BATMAN = 0x4305 ++ ETH_P_BPQ = 0x8ff ++ ETH_P_CAIF = 0xf7 ++ ETH_P_CAN = 0xc ++ ETH_P_CANFD = 0xd ++ ETH_P_CFM = 0x8902 ++ ETH_P_CONTROL = 0x16 ++ ETH_P_CUST = 0x6006 ++ ETH_P_DDCMP = 0x6 ++ ETH_P_DEC = 0x6000 ++ ETH_P_DIAG = 0x6005 ++ ETH_P_DNA_DL = 0x6001 ++ ETH_P_DNA_RC = 0x6002 ++ ETH_P_DNA_RT = 0x6003 ++ ETH_P_DSA = 0x1b ++ ETH_P_DSA_8021Q = 0xdadb ++ ETH_P_DSA_A5PSW = 0xe001 ++ ETH_P_ECONET = 0x18 ++ ETH_P_EDSA = 0xdada ++ ETH_P_ERSPAN = 0x88be ++ ETH_P_ERSPAN2 = 0x22eb ++ ETH_P_ETHERCAT = 0x88a4 ++ ETH_P_FCOE = 0x8906 ++ ETH_P_FIP = 0x8914 ++ ETH_P_HDLC = 0x19 ++ ETH_P_HSR = 0x892f ++ ETH_P_IBOE = 0x8915 ++ ETH_P_IEEE802154 = 0xf6 ++ ETH_P_IEEEPUP = 0xa00 ++ ETH_P_IEEEPUPAT = 0xa01 ++ ETH_P_IFE = 0xed3e ++ ETH_P_IP = 0x800 ++ ETH_P_IPV6 = 0x86dd ++ ETH_P_IPX = 0x8137 ++ ETH_P_IRDA = 0x17 ++ ETH_P_LAT = 0x6004 ++ ETH_P_LINK_CTL = 0x886c ++ ETH_P_LLDP = 0x88cc ++ ETH_P_LOCALTALK = 0x9 ++ ETH_P_LOOP = 0x60 ++ ETH_P_LOOPBACK = 0x9000 ++ ETH_P_MACSEC = 0x88e5 ++ ETH_P_MAP = 0xf9 ++ ETH_P_MCTP = 0xfa ++ ETH_P_MOBITEX = 0x15 ++ ETH_P_MPLS_MC = 0x8848 ++ ETH_P_MPLS_UC = 0x8847 ++ ETH_P_MRP = 0x88e3 ++ ETH_P_MVRP = 0x88f5 ++ ETH_P_NCSI = 0x88f8 ++ ETH_P_NSH = 0x894f ++ ETH_P_PAE = 0x888e ++ ETH_P_PAUSE = 0x8808 ++ ETH_P_PHONET = 0xf5 ++ ETH_P_PPPTALK = 0x10 ++ ETH_P_PPP_DISC = 0x8863 ++ ETH_P_PPP_MP = 0x8 ++ ETH_P_PPP_SES = 0x8864 ++ ETH_P_PREAUTH = 0x88c7 ++ ETH_P_PROFINET = 0x8892 ++ ETH_P_PRP = 0x88fb ++ ETH_P_PUP = 0x200 ++ ETH_P_PUPAT = 0x201 ++ ETH_P_QINQ1 = 0x9100 ++ ETH_P_QINQ2 = 0x9200 ++ ETH_P_QINQ3 = 0x9300 ++ ETH_P_RARP = 0x8035 ++ ETH_P_REALTEK = 0x8899 ++ ETH_P_SCA = 0x6007 ++ ETH_P_SLOW = 0x8809 ++ ETH_P_SNAP = 0x5 ++ ETH_P_TDLS = 0x890d ++ ETH_P_TEB = 0x6558 ++ ETH_P_TIPC = 0x88ca ++ ETH_P_TRAILER = 0x1c ++ ETH_P_TR_802_2 = 0x11 ++ ETH_P_TSN = 0x22f0 ++ ETH_P_WAN_PPP = 0x7 ++ ETH_P_WCCP = 0x883e ++ ETH_P_X25 = 0x805 ++ ETH_P_XDSA = 0xf8 ++ EXTA = 0xe ++ EXTB = 0xf ++ EXTPROC = 0x10000 ++ FD_CLOEXEC = 0x1 ++ FD_SETSIZE = 0x400 ++ FLUSHO = 0x1000 ++ F_ADD_SEALS = 0x409 ++ F_DUPFD = 0x0 ++ F_DUPFD_CLOEXEC = 0x406 ++ F_EXLCK = 0x4 ++ F_GETFD = 0x1 ++ F_GETFL = 0x3 ++ F_GETLEASE = 0x401 ++ F_GETLK = 0x5 ++ F_GETLK64 = 0x5 ++ F_GETOWN = 0x9 ++ F_GETOWN_EX = 0x10 ++ F_GETPIPE_SZ = 0x408 ++ F_GETSIG = 0xb ++ F_GET_FILE_RW_HINT = 0x40d ++ F_GET_RW_HINT = 0x40b ++ F_GET_SEALS = 0x40a ++ F_LOCK = 0x1 ++ F_NOTIFY = 0x402 ++ F_OFD_GETLK = 0x24 ++ F_OFD_SETLK = 0x25 ++ F_OFD_SETLKW = 0x26 ++ F_OK = 0x0 ++ F_RDLCK = 0x0 ++ F_SEAL_FUTURE_WRITE = 0x10 ++ F_SEAL_GROW = 0x4 ++ F_SEAL_SEAL = 0x1 ++ F_SEAL_SHRINK = 0x2 ++ F_SEAL_WRITE = 0x8 ++ F_SETFD = 0x2 ++ F_SETFL = 0x4 ++ F_SETLEASE = 0x400 ++ F_SETLK = 0x6 ++ F_SETLK64 = 0x6 ++ F_SETLKW = 0x7 ++ F_SETLKW64 = 0x7 ++ F_SETOWN = 0x8 ++ F_SETOWN_EX = 0xf ++ F_SETPIPE_SZ = 0x407 ++ F_SETSIG = 0xa ++ F_SET_FILE_RW_HINT = 0x40e ++ F_SET_RW_HINT = 0x40c ++ F_SHLCK = 0x8 ++ F_TEST = 0x3 ++ F_TLOCK = 0x2 ++ F_ULOCK = 0x0 ++ F_UNLCK = 0x2 ++ F_WRLCK = 0x1 ++ HUPCL = 0x400 ++ ICANON = 0x2 ++ ICMPV6_FILTER = 0x1 ++ ICRNL = 0x100 ++ IEXTEN = 0x8000 ++ IFA_F_DADFAILED = 0x8 ++ IFA_F_DEPRECATED = 0x20 ++ IFA_F_HOMEADDRESS = 0x10 ++ IFA_F_MANAGETEMPADDR = 0x100 ++ IFA_F_MCAUTOJOIN = 0x400 ++ IFA_F_NODAD = 0x2 ++ IFA_F_NOPREFIXROUTE = 0x200 ++ IFA_F_OPTIMISTIC = 0x4 ++ IFA_F_PERMANENT = 0x80 ++ IFA_F_SECONDARY = 0x1 ++ IFA_F_STABLE_PRIVACY = 0x800 ++ IFA_F_TEMPORARY = 0x1 ++ IFA_F_TENTATIVE = 0x40 ++ IFA_MAX = 0xb ++ IFF_ALLMULTI = 0x200 ++ IFF_ATTACH_QUEUE = 0x200 ++ IFF_AUTOMEDIA = 0x4000 ++ IFF_BROADCAST = 0x2 ++ IFF_DEBUG = 0x4 ++ IFF_DETACH_QUEUE = 0x400 ++ IFF_DORMANT = 0x20000 ++ IFF_DYNAMIC = 0x8000 ++ IFF_ECHO = 0x40000 ++ IFF_LOOPBACK = 0x8 ++ IFF_LOWER_UP = 0x10000 ++ IFF_MASTER = 0x400 ++ IFF_MULTICAST = 0x1000 ++ IFF_MULTI_QUEUE = 0x100 ++ IFF_NAPI = 0x10 ++ IFF_NAPI_FRAGS = 0x20 ++ IFF_NOARP = 0x80 ++ IFF_NOFILTER = 0x1000 ++ IFF_NOTRAILERS = 0x20 ++ IFF_NO_CARRIER = 0x40 ++ IFF_NO_PI = 0x1000 ++ IFF_ONE_QUEUE = 0x2000 ++ IFF_PERSIST = 0x800 ++ IFF_POINTOPOINT = 0x10 ++ IFF_PORTSEL = 0x2000 ++ IFF_PROMISC = 0x100 ++ IFF_RUNNING = 0x40 ++ IFF_SLAVE = 0x800 ++ IFF_TAP = 0x2 ++ IFF_TUN = 0x1 ++ IFF_TUN_EXCL = 0x8000 ++ IFF_UP = 0x1 ++ IFF_VNET_HDR = 0x4000 ++ IFF_VOLATILE = 0x70c5a ++ IFNAMSIZ = 0x10 ++ IGNBRK = 0x1 ++ IGNCR = 0x80 ++ IGNPAR = 0x4 ++ IMAXBEL = 0x2000 ++ INLCR = 0x40 ++ INPCK = 0x10 ++ IN_ACCESS = 0x1 ++ IN_ALL_EVENTS = 0xfff ++ IN_ATTRIB = 0x4 ++ 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_CLOEXEC = 0x80000 ++ IN_CLOSE = 0x18 ++ IN_CLOSE_NOWRITE = 0x10 ++ IN_CLOSE_WRITE = 0x8 ++ IN_CREATE = 0x100 ++ IN_DELETE = 0x200 ++ IN_DELETE_SELF = 0x400 ++ IN_DONT_FOLLOW = 0x2000000 ++ IN_EXCL_UNLINK = 0x4000000 ++ IN_IGNORED = 0x8000 ++ IN_ISDIR = 0x40000000 ++ IN_LOOPBACKNET = 0x7f ++ IN_MASK_ADD = 0x20000000 ++ IN_MASK_CREATE = 0x10000000 ++ IN_MODIFY = 0x2 ++ IN_MOVE = 0xc0 ++ IN_MOVED_FROM = 0x40 ++ IN_MOVED_TO = 0x80 ++ IN_MOVE_SELF = 0x800 ++ IN_NONBLOCK = 0x800 ++ IN_ONESHOT = 0x80000000 ++ IN_ONLYDIR = 0x1000000 ++ IN_OPEN = 0x20 ++ IN_Q_OVERFLOW = 0x4000 ++ IN_UNMOUNT = 0x2000 ++ IPPROTO_AH = 0x33 ++ IPPROTO_BEETPH = 0x5e ++ IPPROTO_COMP = 0x6c ++ IPPROTO_DCCP = 0x21 ++ IPPROTO_DSTOPTS = 0x3c ++ IPPROTO_EGP = 0x8 ++ IPPROTO_ENCAP = 0x62 ++ IPPROTO_ESP = 0x32 ++ IPPROTO_ETHERNET = 0x8f ++ IPPROTO_FRAGMENT = 0x2c ++ IPPROTO_GRE = 0x2f ++ IPPROTO_HOPOPTS = 0x0 ++ IPPROTO_ICMP = 0x1 ++ IPPROTO_ICMPV6 = 0x3a ++ IPPROTO_IDP = 0x16 ++ IPPROTO_IGMP = 0x2 ++ IPPROTO_IP = 0x0 ++ IPPROTO_IPIP = 0x4 ++ IPPROTO_IPV6 = 0x29 ++ IPPROTO_MH = 0x87 ++ IPPROTO_MPLS = 0x89 ++ IPPROTO_MPTCP = 0x106 ++ IPPROTO_MTP = 0x5c ++ IPPROTO_NONE = 0x3b ++ 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_2292DSTOPTS = 0x4 ++ IPV6_2292HOPLIMIT = 0x8 ++ IPV6_2292HOPOPTS = 0x3 ++ IPV6_2292PKTINFO = 0x2 ++ IPV6_2292PKTOPTIONS = 0x6 ++ IPV6_2292RTHDR = 0x5 ++ IPV6_ADDRFORM = 0x1 ++ IPV6_ADDR_PREFERENCES = 0x48 ++ IPV6_ADD_MEMBERSHIP = 0x14 ++ IPV6_AUTHHDR = 0xa ++ IPV6_AUTOFLOWLABEL = 0x46 ++ IPV6_CHECKSUM = 0x7 ++ IPV6_DONTFRAG = 0x3e ++ IPV6_DROP_MEMBERSHIP = 0x15 ++ IPV6_DSTOPTS = 0x3b ++ IPV6_FREEBIND = 0x4e ++ IPV6_HDRINCL = 0x24 ++ IPV6_HOPLIMIT = 0x34 ++ IPV6_HOPOPTS = 0x36 ++ IPV6_IPSEC_POLICY = 0x22 ++ IPV6_JOIN_ANYCAST = 0x1b ++ IPV6_JOIN_GROUP = 0x14 ++ IPV6_LEAVE_ANYCAST = 0x1c ++ IPV6_LEAVE_GROUP = 0x15 ++ IPV6_MINHOPCOUNT = 0x49 ++ IPV6_MTU = 0x18 ++ IPV6_MTU_DISCOVER = 0x17 ++ IPV6_MULTICAST_ALL = 0x1d ++ IPV6_MULTICAST_HOPS = 0x12 ++ IPV6_MULTICAST_IF = 0x11 ++ IPV6_MULTICAST_LOOP = 0x13 ++ IPV6_NEXTHOP = 0x9 ++ IPV6_ORIGDSTADDR = 0x4a ++ IPV6_PATHMTU = 0x3d ++ IPV6_PKTINFO = 0x32 ++ IPV6_PMTUDISC_DO = 0x2 ++ IPV6_PMTUDISC_DONT = 0x0 ++ IPV6_PMTUDISC_INTERFACE = 0x4 ++ IPV6_PMTUDISC_OMIT = 0x5 ++ IPV6_PMTUDISC_PROBE = 0x3 ++ IPV6_PMTUDISC_WANT = 0x1 ++ IPV6_RECVDSTOPTS = 0x3a ++ IPV6_RECVERR = 0x19 ++ IPV6_RECVERR_RFC4884 = 0x1f ++ IPV6_RECVFRAGSIZE = 0x4d ++ IPV6_RECVHOPLIMIT = 0x33 ++ IPV6_RECVHOPOPTS = 0x35 ++ IPV6_RECVORIGDSTADDR = 0x4a ++ IPV6_RECVPATHMTU = 0x3c ++ IPV6_RECVPKTINFO = 0x31 ++ IPV6_RECVRTHDR = 0x38 ++ IPV6_RECVTCLASS = 0x42 ++ IPV6_ROUTER_ALERT = 0x16 ++ IPV6_ROUTER_ALERT_ISOLATE = 0x1e ++ IPV6_RTHDR = 0x39 ++ IPV6_RTHDRDSTOPTS = 0x37 ++ IPV6_RTHDR_LOOSE = 0x0 ++ IPV6_RTHDR_STRICT = 0x1 ++ IPV6_RTHDR_TYPE_0 = 0x0 ++ IPV6_RXDSTOPTS = 0x3b ++ IPV6_RXHOPOPTS = 0x36 ++ IPV6_TCLASS = 0x43 ++ IPV6_TRANSPARENT = 0x4b ++ IPV6_UNICAST_HOPS = 0x10 ++ IPV6_UNICAST_IF = 0x4c ++ IPV6_V6ONLY = 0x1a ++ IPV6_XFRM_POLICY = 0x23 ++ IP_ADD_MEMBERSHIP = 0x23 ++ IP_ADD_SOURCE_MEMBERSHIP = 0x27 ++ IP_BIND_ADDRESS_NO_PORT = 0x18 ++ IP_BLOCK_SOURCE = 0x26 ++ IP_CHECKSUM = 0x17 ++ IP_DEFAULT_MULTICAST_LOOP = 0x1 ++ IP_DEFAULT_MULTICAST_TTL = 0x1 ++ IP_DF = 0x4000 ++ IP_DROP_MEMBERSHIP = 0x24 ++ IP_DROP_SOURCE_MEMBERSHIP = 0x28 ++ IP_FREEBIND = 0xf ++ IP_HDRINCL = 0x3 ++ IP_IPSEC_POLICY = 0x10 ++ IP_MAXPACKET = 0xffff ++ IP_MAX_MEMBERSHIPS = 0x14 ++ IP_MF = 0x2000 ++ IP_MINTTL = 0x15 ++ IP_MSFILTER = 0x29 ++ IP_MSS = 0x240 ++ IP_MTU = 0xe ++ IP_MTU_DISCOVER = 0xa ++ IP_MULTICAST_ALL = 0x31 ++ IP_MULTICAST_IF = 0x20 ++ IP_MULTICAST_LOOP = 0x22 ++ IP_MULTICAST_TTL = 0x21 ++ IP_NODEFRAG = 0x16 ++ IP_OFFMASK = 0x1fff ++ IP_OPTIONS = 0x4 ++ IP_ORIGDSTADDR = 0x14 ++ IP_PASSSEC = 0x12 ++ IP_PKTINFO = 0x8 ++ IP_PKTOPTIONS = 0x9 ++ IP_PMTUDISC = 0xa ++ IP_PMTUDISC_DO = 0x2 ++ IP_PMTUDISC_DONT = 0x0 ++ IP_PMTUDISC_INTERFACE = 0x4 ++ IP_PMTUDISC_OMIT = 0x5 ++ IP_PMTUDISC_PROBE = 0x3 ++ IP_PMTUDISC_WANT = 0x1 ++ IP_RECVERR = 0xb ++ IP_RECVERR_RFC4884 = 0x1a ++ IP_RECVFRAGSIZE = 0x19 ++ IP_RECVOPTS = 0x6 ++ IP_RECVORIGDSTADDR = 0x14 ++ IP_RECVRETOPTS = 0x7 ++ IP_RECVTOS = 0xd ++ IP_RECVTTL = 0xc ++ IP_RETOPTS = 0x7 ++ IP_RF = 0x8000 ++ IP_ROUTER_ALERT = 0x5 ++ IP_TOS = 0x1 ++ IP_TRANSPARENT = 0x13 ++ IP_TTL = 0x2 ++ IP_UNBLOCK_SOURCE = 0x25 ++ IP_UNICAST_IF = 0x32 ++ IP_XFRM_POLICY = 0x11 ++ ISIG = 0x1 ++ ISTRIP = 0x20 ++ IUTF8 = 0x4000 ++ IXANY = 0x800 ++ IXOFF = 0x1000 ++ IXON = 0x400 ++ LINUX_REBOOT_CMD_CAD_OFF = 0x0 ++ LINUX_REBOOT_CMD_CAD_ON = 0x89abcdef ++ LINUX_REBOOT_CMD_HALT = 0xcdef0123 ++ LINUX_REBOOT_CMD_KEXEC = 0x45584543 ++ LINUX_REBOOT_CMD_POWER_OFF = 0x4321fedc ++ LINUX_REBOOT_CMD_RESTART = 0x1234567 ++ LINUX_REBOOT_CMD_RESTART2 = 0xa1b2c3d4 ++ LINUX_REBOOT_CMD_SW_SUSPEND = 0xd000fce2 ++ LINUX_REBOOT_MAGIC1 = 0xfee1dead ++ LINUX_REBOOT_MAGIC2 = 0x28121969 ++ LOCK_EX = 0x2 ++ LOCK_NB = 0x4 ++ LOCK_SH = 0x1 ++ LOCK_UN = 0x8 ++ MADV_COLD = 0x14 ++ MADV_DODUMP = 0x11 ++ MADV_DOFORK = 0xb ++ MADV_DONTDUMP = 0x10 ++ MADV_DONTFORK = 0xa ++ MADV_DONTNEED = 0x4 ++ MADV_DONTNEED_LOCKED = 0x18 ++ MADV_FREE = 0x8 ++ MADV_HUGEPAGE = 0xe ++ MADV_HWPOISON = 0x64 ++ MADV_KEEPONFORK = 0x13 ++ MADV_MERGEABLE = 0xc ++ MADV_NOHUGEPAGE = 0xf ++ MADV_NORMAL = 0x0 ++ MADV_PAGEOUT = 0x15 ++ MADV_POPULATE_READ = 0x16 ++ MADV_POPULATE_WRITE = 0x17 ++ MADV_RANDOM = 0x1 ++ MADV_REMOVE = 0x9 ++ MADV_SEQUENTIAL = 0x2 ++ MADV_UNMERGEABLE = 0xd ++ MADV_WILLNEED = 0x3 ++ MADV_WIPEONFORK = 0x12 ++ MAP_ANON = 0x20 ++ MAP_ANONYMOUS = 0x20 ++ MAP_DENYWRITE = 0x800 ++ MAP_EXECUTABLE = 0x1000 ++ MAP_FILE = 0x0 ++ MAP_FIXED = 0x10 ++ MAP_FIXED_NOREPLACE = 0x100000 ++ MAP_GROWSDOWN = 0x100 ++ MAP_HUGETLB = 0x40000 ++ MAP_HUGE_MASK = 0x3f ++ MAP_HUGE_SHIFT = 0x1a ++ MAP_LOCKED = 0x2000 ++ MAP_NONBLOCK = 0x10000 ++ MAP_NORESERVE = 0x4000 ++ MAP_POPULATE = 0x8000 ++ MAP_PRIVATE = 0x2 ++ MAP_SHARED = 0x1 ++ MAP_SHARED_VALIDATE = 0x3 ++ MAP_STACK = 0x20000 ++ MAP_SYNC = 0x80000 ++ MAP_TYPE = 0xf ++ MCL_CURRENT = 0x1 ++ MCL_FUTURE = 0x2 ++ MCL_ONFAULT = 0x4 ++ MNT_DETACH = 0x2 ++ MNT_EXPIRE = 0x4 ++ MNT_FORCE = 0x1 ++ MSG_BATCH = 0x40000 ++ MSG_CMSG_CLOEXEC = 0x40000000 ++ MSG_CONFIRM = 0x800 ++ MSG_CTRUNC = 0x8 ++ MSG_DONTROUTE = 0x4 ++ MSG_DONTWAIT = 0x40 ++ MSG_EOR = 0x80 ++ MSG_ERRQUEUE = 0x2000 ++ MSG_FASTOPEN = 0x20000000 ++ MSG_FIN = 0x200 ++ MSG_MORE = 0x8000 ++ MSG_NOSIGNAL = 0x4000 ++ MSG_OOB = 0x1 ++ MSG_PEEK = 0x2 ++ MSG_PROXY = 0x10 ++ MSG_RST = 0x1000 ++ MSG_SYN = 0x400 ++ MSG_TRUNC = 0x20 ++ MSG_TRYHARD = 0x4 ++ MSG_WAITALL = 0x100 ++ MSG_WAITFORONE = 0x10000 ++ MSG_ZEROCOPY = 0x4000000 ++ MS_ACTIVE = 0x40000000 ++ MS_ASYNC = 0x1 ++ MS_BIND = 0x1000 ++ MS_BORN = 0x20000000 ++ MS_DIRSYNC = 0x80 ++ MS_INVALIDATE = 0x2 ++ MS_I_VERSION = 0x800000 ++ MS_KERNMOUNT = 0x400000 ++ MS_LAZYTIME = 0x2000000 ++ MS_MANDLOCK = 0x40 ++ MS_MGC_MSK = 0xffff0000 ++ MS_MGC_VAL = 0xc0ed0000 ++ MS_MOVE = 0x2000 ++ MS_NOATIME = 0x400 ++ MS_NODEV = 0x4 ++ MS_NODIRATIME = 0x800 ++ MS_NOEXEC = 0x8 ++ MS_NOREMOTELOCK = 0x8000000 ++ MS_NOSEC = 0x10000000 ++ MS_NOSUID = 0x2 ++ MS_NOSYMFOLLOW = 0x100 ++ MS_NOUSER = -0x80000000 ++ MS_POSIXACL = 0x10000 ++ MS_PRIVATE = 0x40000 ++ MS_RDONLY = 0x1 ++ MS_REC = 0x4000 ++ MS_RELATIME = 0x200000 ++ MS_REMOUNT = 0x20 ++ MS_RMT_MASK = 0x2800051 ++ MS_SHARED = 0x100000 ++ MS_SILENT = 0x8000 ++ MS_SLAVE = 0x80000 ++ MS_STRICTATIME = 0x1000000 ++ MS_SUBMOUNT = 0x4000000 ++ MS_SYNC = 0x4 ++ MS_SYNCHRONOUS = 0x10 ++ MS_UNBINDABLE = 0x20000 ++ MS_VERBOSE = 0x8000 ++ NAME_MAX = 0xff ++ NETLINK_ADD_MEMBERSHIP = 0x1 ++ NETLINK_AUDIT = 0x9 ++ NETLINK_BROADCAST_ERROR = 0x4 ++ NETLINK_CAP_ACK = 0xa ++ NETLINK_CONNECTOR = 0xb ++ NETLINK_CRYPTO = 0x15 ++ NETLINK_DNRTMSG = 0xe ++ NETLINK_DROP_MEMBERSHIP = 0x2 ++ NETLINK_ECRYPTFS = 0x13 ++ NETLINK_EXT_ACK = 0xb ++ NETLINK_FIB_LOOKUP = 0xa ++ NETLINK_FIREWALL = 0x3 ++ NETLINK_GENERIC = 0x10 ++ NETLINK_GET_STRICT_CHK = 0xc ++ NETLINK_INET_DIAG = 0x4 ++ NETLINK_IP6_FW = 0xd ++ NETLINK_ISCSI = 0x8 ++ NETLINK_KOBJECT_UEVENT = 0xf ++ NETLINK_LISTEN_ALL_NSID = 0x8 ++ NETLINK_LIST_MEMBERSHIPS = 0x9 ++ NETLINK_NETFILTER = 0xc ++ NETLINK_NFLOG = 0x5 ++ NETLINK_NO_ENOBUFS = 0x5 ++ NETLINK_PKTINFO = 0x3 ++ NETLINK_RDMA = 0x14 ++ NETLINK_ROUTE = 0x0 ++ NETLINK_RX_RING = 0x6 ++ NETLINK_SCSITRANSPORT = 0x12 ++ NETLINK_SELINUX = 0x7 ++ NETLINK_SMC = 0x16 ++ NETLINK_SOCK_DIAG = 0x4 ++ NETLINK_TX_RING = 0x7 ++ NETLINK_UNUSED = 0x1 ++ NETLINK_USERSOCK = 0x2 ++ NETLINK_XFRM = 0x6 ++ NLA_ALIGNTO = 0x4 ++ NLA_F_NESTED = 0x8000 ++ NLA_F_NET_BYTEORDER = 0x4000 ++ NLA_HDRLEN = 0x4 ++ NLMSG_ALIGNTO = 0x4 ++ NLMSG_DONE = 0x3 ++ NLMSG_ERROR = 0x2 ++ NLMSG_HDRLEN = 0x10 ++ NLMSG_MIN_TYPE = 0x10 ++ NLMSG_NOOP = 0x1 ++ NLMSG_OVERRUN = 0x4 ++ NLM_F_ACK = 0x4 ++ NLM_F_ACK_TLVS = 0x200 ++ NLM_F_APPEND = 0x800 ++ NLM_F_ATOMIC = 0x400 ++ NLM_F_BULK = 0x200 ++ NLM_F_CAPPED = 0x100 ++ NLM_F_CREATE = 0x400 ++ NLM_F_DUMP = 0x300 ++ NLM_F_DUMP_FILTERED = 0x20 ++ NLM_F_DUMP_INTR = 0x10 ++ NLM_F_ECHO = 0x8 ++ NLM_F_EXCL = 0x200 ++ NLM_F_MATCH = 0x200 ++ NLM_F_MULTI = 0x2 ++ NLM_F_NONREC = 0x100 ++ NLM_F_REPLACE = 0x100 ++ NLM_F_REQUEST = 0x1 ++ NLM_F_ROOT = 0x100 ++ NOFLSH = 0x80 ++ OCRNL = 0x8 ++ OFDEL = 0x80 ++ OFILL = 0x40 ++ ONLCR = 0x4 ++ ONLRET = 0x20 ++ ONOCR = 0x10 ++ OPOST = 0x1 ++ O_ACCMODE = 0x3 ++ O_APPEND = 0x400 ++ O_ASYNC = 0x2000 ++ O_CLOEXEC = 0x80000 ++ O_CREAT = 0x40 ++ O_DIRECT = 0x4000 ++ O_DIRECTORY = 0x10000 ++ O_DSYNC = 0x1000 ++ O_EXCL = 0x80 ++ O_FSYNC = 0x101000 ++ O_LARGEFILE = 0x0 ++ O_NDELAY = 0x800 ++ O_NOATIME = 0x40000 ++ O_NOCTTY = 0x100 ++ O_NOFOLLOW = 0x20000 ++ O_NONBLOCK = 0x800 ++ O_PATH = 0x200000 ++ O_RDONLY = 0x0 ++ O_RDWR = 0x2 ++ O_RSYNC = 0x101000 ++ O_SYNC = 0x101000 ++ O_TMPFILE = 0x410000 ++ O_TRUNC = 0x200 ++ O_WRONLY = 0x1 ++ PACKET_ADD_MEMBERSHIP = 0x1 ++ PACKET_AUXDATA = 0x8 ++ PACKET_BROADCAST = 0x1 ++ PACKET_COPY_THRESH = 0x7 ++ PACKET_DROP_MEMBERSHIP = 0x2 ++ PACKET_FANOUT = 0x12 ++ PACKET_FANOUT_CBPF = 0x6 ++ PACKET_FANOUT_CPU = 0x2 ++ PACKET_FANOUT_DATA = 0x16 ++ PACKET_FANOUT_EBPF = 0x7 ++ PACKET_FANOUT_FLAG_DEFRAG = 0x8000 ++ PACKET_FANOUT_FLAG_ROLLOVER = 0x1000 ++ PACKET_FANOUT_FLAG_UNIQUEID = 0x2000 ++ PACKET_FANOUT_HASH = 0x0 ++ PACKET_FANOUT_LB = 0x1 ++ PACKET_FANOUT_QM = 0x5 ++ PACKET_FANOUT_RND = 0x4 ++ PACKET_FANOUT_ROLLOVER = 0x3 ++ PACKET_FASTROUTE = 0x6 ++ PACKET_HDRLEN = 0xb ++ PACKET_HOST = 0x0 ++ PACKET_IGNORE_OUTGOING = 0x17 ++ PACKET_KERNEL = 0x7 ++ PACKET_LOOPBACK = 0x5 ++ PACKET_LOSS = 0xe ++ PACKET_MR_ALLMULTI = 0x2 ++ PACKET_MR_MULTICAST = 0x0 ++ PACKET_MR_PROMISC = 0x1 ++ PACKET_MR_UNICAST = 0x3 ++ PACKET_MULTICAST = 0x2 ++ PACKET_ORIGDEV = 0x9 ++ PACKET_OTHERHOST = 0x3 ++ PACKET_OUTGOING = 0x4 ++ PACKET_QDISC_BYPASS = 0x14 ++ PACKET_RECV_OUTPUT = 0x3 ++ PACKET_RESERVE = 0xc ++ PACKET_ROLLOVER_STATS = 0x15 ++ PACKET_RX_RING = 0x5 ++ PACKET_STATISTICS = 0x6 ++ PACKET_TIMESTAMP = 0x11 ++ PACKET_TX_HAS_OFF = 0x13 ++ PACKET_TX_RING = 0xd ++ PACKET_TX_TIMESTAMP = 0x10 ++ PACKET_USER = 0x6 ++ PACKET_VERSION = 0xa ++ PACKET_VNET_HDR = 0xf ++ PARENB = 0x100 ++ PARITY_CRC16_PR0 = 0x2 ++ PARITY_CRC16_PR0_CCITT = 0x4 ++ PARITY_CRC16_PR1 = 0x3 ++ PARITY_CRC16_PR1_CCITT = 0x5 ++ PARITY_CRC32_PR0_CCITT = 0x6 ++ PARITY_CRC32_PR1_CCITT = 0x7 ++ PARITY_DEFAULT = 0x0 ++ PARITY_NONE = 0x1 ++ PARMRK = 0x8 ++ PARODD = 0x200 ++ PENDIN = 0x4000 ++ PRIO_PGRP = 0x1 ++ PRIO_PROCESS = 0x0 ++ PRIO_USER = 0x2 ++ PROT_EXEC = 0x4 ++ PROT_GROWSDOWN = 0x1000000 ++ PROT_GROWSUP = 0x2000000 ++ PROT_NONE = 0x0 ++ PROT_READ = 0x1 ++ PROT_WRITE = 0x2 ++ PR_CAPBSET_DROP = 0x18 ++ PR_CAPBSET_READ = 0x17 ++ PR_CAP_AMBIENT = 0x2f ++ PR_CAP_AMBIENT_CLEAR_ALL = 0x4 ++ PR_CAP_AMBIENT_IS_SET = 0x1 ++ PR_CAP_AMBIENT_LOWER = 0x3 ++ PR_CAP_AMBIENT_RAISE = 0x2 ++ PR_ENDIAN_BIG = 0x0 ++ PR_ENDIAN_LITTLE = 0x1 ++ PR_ENDIAN_PPC_LITTLE = 0x2 ++ PR_FPEMU_NOPRINT = 0x1 ++ PR_FPEMU_SIGFPE = 0x2 ++ PR_FP_EXC_ASYNC = 0x2 ++ PR_FP_EXC_DISABLED = 0x0 ++ PR_FP_EXC_DIV = 0x10000 ++ PR_FP_EXC_INV = 0x100000 ++ PR_FP_EXC_NONRECOV = 0x1 ++ PR_FP_EXC_OVF = 0x20000 ++ PR_FP_EXC_PRECISE = 0x3 ++ PR_FP_EXC_RES = 0x80000 ++ PR_FP_EXC_SW_ENABLE = 0x80 ++ PR_FP_EXC_UND = 0x40000 ++ PR_FP_MODE_FR = 0x1 ++ PR_FP_MODE_FRE = 0x2 ++ PR_GET_CHILD_SUBREAPER = 0x25 ++ PR_GET_DUMPABLE = 0x3 ++ PR_GET_ENDIAN = 0x13 ++ PR_GET_FPEMU = 0x9 ++ PR_GET_FPEXC = 0xb ++ PR_GET_FP_MODE = 0x2e ++ PR_GET_IO_FLUSHER = 0x3a ++ PR_GET_KEEPCAPS = 0x7 ++ PR_GET_NAME = 0x10 ++ PR_GET_NO_NEW_PRIVS = 0x27 ++ PR_GET_PDEATHSIG = 0x2 ++ PR_GET_SECCOMP = 0x15 ++ PR_GET_SECUREBITS = 0x1b ++ PR_GET_SPECULATION_CTRL = 0x34 ++ PR_GET_TAGGED_ADDR_CTRL = 0x38 ++ PR_GET_THP_DISABLE = 0x2a ++ PR_GET_TID_ADDRESS = 0x28 ++ PR_GET_TIMERSLACK = 0x1e ++ PR_GET_TIMING = 0xd ++ PR_GET_TSC = 0x19 ++ PR_GET_UNALIGN = 0x5 ++ PR_MCE_KILL = 0x21 ++ PR_MCE_KILL_CLEAR = 0x0 ++ PR_MCE_KILL_DEFAULT = 0x2 ++ PR_MCE_KILL_EARLY = 0x1 ++ PR_MCE_KILL_GET = 0x22 ++ PR_MCE_KILL_LATE = 0x0 ++ PR_MCE_KILL_SET = 0x1 ++ PR_MPX_DISABLE_MANAGEMENT = 0x2c ++ PR_MPX_ENABLE_MANAGEMENT = 0x2b ++ PR_MTE_TAG_MASK = 0x7fff8 ++ PR_MTE_TAG_SHIFT = 0x3 ++ PR_MTE_TCF_ASYNC = 0x4 ++ PR_MTE_TCF_MASK = 0x6 ++ PR_MTE_TCF_NONE = 0x0 ++ PR_MTE_TCF_SHIFT = 0x1 ++ PR_MTE_TCF_SYNC = 0x2 ++ PR_PAC_APDAKEY = 0x4 ++ PR_PAC_APDBKEY = 0x8 ++ PR_PAC_APGAKEY = 0x10 ++ PR_PAC_APIAKEY = 0x1 ++ PR_PAC_APIBKEY = 0x2 ++ PR_PAC_GET_ENABLED_KEYS = 0x3d ++ PR_PAC_RESET_KEYS = 0x36 ++ PR_PAC_SET_ENABLED_KEYS = 0x3c ++ PR_SCHED_CORE = 0x3e ++ PR_SCHED_CORE_CREATE = 0x1 ++ PR_SCHED_CORE_GET = 0x0 ++ PR_SCHED_CORE_MAX = 0x4 ++ PR_SCHED_CORE_SCOPE_PROCESS_GROUP = 0x2 ++ PR_SCHED_CORE_SCOPE_THREAD = 0x0 ++ PR_SCHED_CORE_SCOPE_THREAD_GROUP = 0x1 ++ PR_SCHED_CORE_SHARE_FROM = 0x3 ++ PR_SCHED_CORE_SHARE_TO = 0x2 ++ PR_SET_CHILD_SUBREAPER = 0x24 ++ PR_SET_DUMPABLE = 0x4 ++ PR_SET_ENDIAN = 0x14 ++ PR_SET_FPEMU = 0xa ++ PR_SET_FPEXC = 0xc ++ PR_SET_FP_MODE = 0x2d ++ PR_SET_IO_FLUSHER = 0x39 ++ PR_SET_KEEPCAPS = 0x8 ++ PR_SET_MM = 0x23 ++ PR_SET_MM_ARG_END = 0x9 ++ PR_SET_MM_ARG_START = 0x8 ++ PR_SET_MM_AUXV = 0xc ++ PR_SET_MM_BRK = 0x7 ++ PR_SET_MM_END_CODE = 0x2 ++ PR_SET_MM_END_DATA = 0x4 ++ PR_SET_MM_ENV_END = 0xb ++ PR_SET_MM_ENV_START = 0xa ++ PR_SET_MM_EXE_FILE = 0xd ++ PR_SET_MM_MAP = 0xe ++ PR_SET_MM_MAP_SIZE = 0xf ++ PR_SET_MM_START_BRK = 0x6 ++ PR_SET_MM_START_CODE = 0x1 ++ PR_SET_MM_START_DATA = 0x3 ++ PR_SET_MM_START_STACK = 0x5 ++ PR_SET_NAME = 0xf ++ PR_SET_NO_NEW_PRIVS = 0x26 ++ PR_SET_PDEATHSIG = 0x1 ++ PR_SET_PTRACER = 0x59616d61 ++ PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PR_SET_SECCOMP = 0x16 ++ PR_SET_SECUREBITS = 0x1c ++ PR_SET_SPECULATION_CTRL = 0x35 ++ PR_SET_SYSCALL_USER_DISPATCH = 0x3b ++ PR_SET_TAGGED_ADDR_CTRL = 0x37 ++ PR_SET_THP_DISABLE = 0x29 ++ PR_SET_TIMERSLACK = 0x1d ++ PR_SET_TIMING = 0xe ++ PR_SET_TSC = 0x1a ++ PR_SET_UNALIGN = 0x6 ++ PR_SET_VMA = 0x53564d41 ++ PR_SET_VMA_ANON_NAME = 0x0 ++ PR_SME_GET_VL = 0x40 ++ PR_SME_SET_VL = 0x3f ++ PR_SME_SET_VL_ONEXEC = 0x40000 ++ PR_SME_VL_INHERIT = 0x20000 ++ PR_SME_VL_LEN_MASK = 0xffff ++ PR_SPEC_DISABLE = 0x4 ++ PR_SPEC_DISABLE_NOEXEC = 0x10 ++ PR_SPEC_ENABLE = 0x2 ++ PR_SPEC_FORCE_DISABLE = 0x8 ++ PR_SPEC_INDIRECT_BRANCH = 0x1 ++ PR_SPEC_L1D_FLUSH = 0x2 ++ PR_SPEC_NOT_AFFECTED = 0x0 ++ PR_SPEC_PRCTL = 0x1 ++ PR_SPEC_STORE_BYPASS = 0x0 ++ PR_SVE_GET_VL = 0x33 ++ PR_SVE_SET_VL = 0x32 ++ PR_SVE_SET_VL_ONEXEC = 0x40000 ++ PR_SVE_VL_INHERIT = 0x20000 ++ PR_SVE_VL_LEN_MASK = 0xffff ++ PR_SYS_DISPATCH_OFF = 0x0 ++ PR_SYS_DISPATCH_ON = 0x1 ++ PR_TAGGED_ADDR_ENABLE = 0x1 ++ PR_TASK_PERF_EVENTS_DISABLE = 0x1f ++ PR_TASK_PERF_EVENTS_ENABLE = 0x20 ++ PR_TIMING_STATISTICAL = 0x0 ++ PR_TIMING_TIMESTAMP = 0x1 ++ PR_TSC_ENABLE = 0x1 ++ PR_TSC_SIGSEGV = 0x2 ++ PR_UNALIGN_NOPRINT = 0x1 ++ PR_UNALIGN_SIGBUS = 0x2 ++ PTRACE_ATTACH = 0x10 ++ PTRACE_CONT = 0x7 ++ PTRACE_DETACH = 0x11 ++ PTRACE_EVENTMSG_SYSCALL_ENTRY = 0x1 ++ PTRACE_EVENTMSG_SYSCALL_EXIT = 0x2 ++ PTRACE_EVENT_CLONE = 0x3 ++ PTRACE_EVENT_EXEC = 0x4 ++ PTRACE_EVENT_EXIT = 0x6 ++ PTRACE_EVENT_FORK = 0x1 ++ PTRACE_EVENT_SECCOMP = 0x7 ++ PTRACE_EVENT_STOP = 0x80 ++ PTRACE_EVENT_VFORK = 0x2 ++ PTRACE_EVENT_VFORK_DONE = 0x5 ++ PTRACE_GETEVENTMSG = 0x4201 ++ PTRACE_GETREGS = 0xc ++ PTRACE_GETREGSET = 0x4204 ++ PTRACE_GETSIGINFO = 0x4202 ++ PTRACE_GETSIGMASK = 0x420a ++ PTRACE_GET_RSEQ_CONFIGURATION = 0x420f ++ PTRACE_GET_SYSCALL_INFO = 0x420e ++ PTRACE_INTERRUPT = 0x4207 ++ PTRACE_KILL = 0x8 ++ PTRACE_LISTEN = 0x4208 ++ PTRACE_O_EXITKILL = 0x100000 ++ PTRACE_O_MASK = 0x3000ff ++ PTRACE_O_SUSPEND_SECCOMP = 0x200000 ++ PTRACE_O_TRACECLONE = 0x8 ++ PTRACE_O_TRACEEXEC = 0x10 ++ PTRACE_O_TRACEEXIT = 0x40 ++ PTRACE_O_TRACEFORK = 0x2 ++ PTRACE_O_TRACESECCOMP = 0x80 ++ PTRACE_O_TRACESYSGOOD = 0x1 ++ PTRACE_O_TRACEVFORK = 0x4 ++ PTRACE_O_TRACEVFORKDONE = 0x20 ++ PTRACE_PEEKDATA = 0x2 ++ PTRACE_PEEKSIGINFO = 0x4209 ++ PTRACE_PEEKSIGINFO_SHARED = 0x1 ++ PTRACE_PEEKTEXT = 0x1 ++ PTRACE_PEEKUSR = 0x3 ++ PTRACE_POKEDATA = 0x5 ++ PTRACE_POKETEXT = 0x4 ++ PTRACE_POKEUSR = 0x6 ++ PTRACE_SECCOMP_GET_FILTER = 0x420c ++ PTRACE_SECCOMP_GET_METADATA = 0x420d ++ PTRACE_SEIZE = 0x4206 ++ PTRACE_SETOPTIONS = 0x4200 ++ PTRACE_SETREGS = 0xd ++ PTRACE_SETREGSET = 0x4205 ++ PTRACE_SETSIGINFO = 0x4203 ++ PTRACE_SETSIGMASK = 0x420b ++ PTRACE_SINGLESTEP = 0x9 ++ PTRACE_SYSCALL = 0x18 ++ PTRACE_SYSCALL_INFO_ENTRY = 0x1 ++ PTRACE_SYSCALL_INFO_EXIT = 0x2 ++ PTRACE_SYSCALL_INFO_NONE = 0x0 ++ PTRACE_SYSCALL_INFO_SECCOMP = 0x3 ++ PTRACE_SYSEMU = 0x1f ++ PTRACE_SYSEMU_SINGLESTEP = 0x20 ++ PTRACE_TRACEME = 0x0 ++ RLIMIT_AS = 0x9 ++ RLIMIT_CORE = 0x4 ++ RLIMIT_CPU = 0x0 ++ RLIMIT_DATA = 0x2 ++ RLIMIT_FSIZE = 0x1 ++ RLIMIT_NOFILE = 0x7 ++ RLIMIT_STACK = 0x3 ++ RLIM_INFINITY = 0xffffffffffffffff ++ RTAX_ADVMSS = 0x8 ++ RTAX_CC_ALGO = 0x10 ++ RTAX_CWND = 0x7 ++ RTAX_FASTOPEN_NO_COOKIE = 0x11 ++ RTAX_FEATURES = 0xc ++ RTAX_FEATURE_ALLFRAG = 0x8 ++ RTAX_FEATURE_ECN = 0x1 ++ RTAX_FEATURE_MASK = 0xf ++ RTAX_FEATURE_SACK = 0x2 ++ RTAX_FEATURE_TIMESTAMP = 0x4 ++ RTAX_HOPLIMIT = 0xa ++ RTAX_INITCWND = 0xb ++ RTAX_INITRWND = 0xe ++ RTAX_LOCK = 0x1 ++ RTAX_MAX = 0x11 ++ RTAX_MTU = 0x2 ++ RTAX_QUICKACK = 0xf ++ RTAX_REORDERING = 0x9 ++ RTAX_RTO_MIN = 0xd ++ RTAX_RTT = 0x4 ++ RTAX_RTTVAR = 0x5 ++ RTAX_SSTHRESH = 0x6 ++ RTAX_UNSPEC = 0x0 ++ RTAX_WINDOW = 0x3 ++ RTA_ALIGNTO = 0x4 ++ RTA_MAX = 0x1e ++ RTCF_DIRECTSRC = 0x4000000 ++ RTCF_DOREDIRECT = 0x1000000 ++ RTCF_LOG = 0x2000000 ++ RTCF_MASQ = 0x400000 ++ RTCF_NAT = 0x800000 ++ RTCF_VALVE = 0x200000 ++ RTF_ADDRCLASSMASK = 0xf8000000 ++ RTF_ADDRCONF = 0x40000 ++ RTF_ALLONLINK = 0x20000 ++ RTF_BROADCAST = 0x10000000 ++ RTF_CACHE = 0x1000000 ++ RTF_DEFAULT = 0x10000 ++ RTF_DYNAMIC = 0x10 ++ RTF_FLOW = 0x2000000 ++ RTF_GATEWAY = 0x2 ++ RTF_HOST = 0x4 ++ RTF_INTERFACE = 0x40000000 ++ RTF_IRTT = 0x100 ++ RTF_LINKRT = 0x100000 ++ RTF_LOCAL = 0x80000000 ++ RTF_MODIFIED = 0x20 ++ RTF_MSS = 0x40 ++ RTF_MTU = 0x40 ++ RTF_MULTICAST = 0x20000000 ++ RTF_NAT = 0x8000000 ++ RTF_NOFORWARD = 0x1000 ++ RTF_NONEXTHOP = 0x200000 ++ RTF_NOPMTUDISC = 0x4000 ++ RTF_POLICY = 0x4000000 ++ RTF_REINSTATE = 0x8 ++ RTF_REJECT = 0x200 ++ RTF_STATIC = 0x400 ++ RTF_THROW = 0x2000 ++ RTF_UP = 0x1 ++ RTF_WINDOW = 0x80 ++ RTF_XRESOLVE = 0x800 ++ RTM_BASE = 0x10 ++ RTM_DELACTION = 0x31 ++ RTM_DELADDR = 0x15 ++ RTM_DELADDRLABEL = 0x49 ++ RTM_DELCHAIN = 0x65 ++ RTM_DELLINK = 0x11 ++ RTM_DELLINKPROP = 0x6d ++ RTM_DELMDB = 0x55 ++ RTM_DELNEIGH = 0x1d ++ RTM_DELNETCONF = 0x51 ++ RTM_DELNEXTHOP = 0x69 ++ RTM_DELNEXTHOPBUCKET = 0x75 ++ RTM_DELNSID = 0x59 ++ RTM_DELQDISC = 0x25 ++ RTM_DELROUTE = 0x19 ++ RTM_DELRULE = 0x21 ++ RTM_DELTCLASS = 0x29 ++ RTM_DELTFILTER = 0x2d ++ RTM_DELTUNNEL = 0x79 ++ RTM_DELVLAN = 0x71 ++ RTM_F_CLONED = 0x200 ++ RTM_F_EQUALIZE = 0x400 ++ RTM_F_FIB_MATCH = 0x2000 ++ RTM_F_LOOKUP_TABLE = 0x1000 ++ RTM_F_NOTIFY = 0x100 ++ RTM_F_OFFLOAD = 0x4000 ++ RTM_F_OFFLOAD_FAILED = 0x20000000 ++ RTM_F_PREFIX = 0x800 ++ RTM_F_TRAP = 0x8000 ++ RTM_GETACTION = 0x32 ++ RTM_GETADDR = 0x16 ++ RTM_GETADDRLABEL = 0x4a ++ RTM_GETANYCAST = 0x3e ++ RTM_GETCHAIN = 0x66 ++ RTM_GETDCB = 0x4e ++ RTM_GETLINK = 0x12 ++ RTM_GETLINKPROP = 0x6e ++ RTM_GETMDB = 0x56 ++ RTM_GETMULTICAST = 0x3a ++ RTM_GETNEIGH = 0x1e ++ RTM_GETNEIGHTBL = 0x42 ++ RTM_GETNETCONF = 0x52 ++ RTM_GETNEXTHOP = 0x6a ++ RTM_GETNEXTHOPBUCKET = 0x76 ++ RTM_GETNSID = 0x5a ++ RTM_GETQDISC = 0x26 ++ RTM_GETROUTE = 0x1a ++ RTM_GETRULE = 0x22 ++ RTM_GETSTATS = 0x5e ++ RTM_GETTCLASS = 0x2a ++ RTM_GETTFILTER = 0x2e ++ RTM_GETTUNNEL = 0x7a ++ RTM_GETVLAN = 0x72 ++ RTM_MAX = 0x7b ++ RTM_NEWACTION = 0x30 ++ RTM_NEWADDR = 0x14 ++ RTM_NEWADDRLABEL = 0x48 ++ RTM_NEWCACHEREPORT = 0x60 ++ RTM_NEWCHAIN = 0x64 ++ RTM_NEWLINK = 0x10 ++ RTM_NEWLINKPROP = 0x6c ++ RTM_NEWMDB = 0x54 ++ RTM_NEWNDUSEROPT = 0x44 ++ RTM_NEWNEIGH = 0x1c ++ RTM_NEWNEIGHTBL = 0x40 ++ RTM_NEWNETCONF = 0x50 ++ RTM_NEWNEXTHOP = 0x68 ++ RTM_NEWNEXTHOPBUCKET = 0x74 ++ RTM_NEWNSID = 0x58 ++ RTM_NEWNVLAN = 0x70 ++ RTM_NEWPREFIX = 0x34 ++ RTM_NEWQDISC = 0x24 ++ RTM_NEWROUTE = 0x18 ++ RTM_NEWRULE = 0x20 ++ RTM_NEWSTATS = 0x5c ++ RTM_NEWTCLASS = 0x28 ++ RTM_NEWTFILTER = 0x2c ++ RTM_NEWTUNNEL = 0x78 ++ RTM_NR_FAMILIES = 0x1b ++ RTM_NR_MSGTYPES = 0x6c ++ RTM_SETDCB = 0x4f ++ RTM_SETLINK = 0x13 ++ RTM_SETNEIGHTBL = 0x43 ++ RTM_SETSTATS = 0x5f ++ RTNH_ALIGNTO = 0x4 ++ RTNH_COMPARE_MASK = 0x59 ++ RTNH_F_DEAD = 0x1 ++ RTNH_F_LINKDOWN = 0x10 ++ RTNH_F_OFFLOAD = 0x8 ++ RTNH_F_ONLINK = 0x4 ++ RTNH_F_PERVASIVE = 0x2 ++ RTNH_F_TRAP = 0x40 ++ RTNH_F_UNRESOLVED = 0x20 ++ RTN_MAX = 0xb ++ RTPROT_BABEL = 0x2a ++ RTPROT_BGP = 0xba ++ RTPROT_BIRD = 0xc ++ RTPROT_BOOT = 0x3 ++ RTPROT_DHCP = 0x10 ++ RTPROT_DNROUTED = 0xd ++ RTPROT_EIGRP = 0xc0 ++ RTPROT_GATED = 0x8 ++ RTPROT_ISIS = 0xbb ++ RTPROT_KEEPALIVED = 0x12 ++ RTPROT_KERNEL = 0x2 ++ RTPROT_MROUTED = 0x11 ++ RTPROT_MRT = 0xa ++ RTPROT_NTK = 0xf ++ RTPROT_OPENR = 0x63 ++ RTPROT_OSPF = 0xbc ++ RTPROT_RA = 0x9 ++ RTPROT_REDIRECT = 0x1 ++ RTPROT_RIP = 0xbd ++ RTPROT_STATIC = 0x4 ++ RTPROT_UNSPEC = 0x0 ++ RTPROT_XORP = 0xe ++ RTPROT_ZEBRA = 0xb ++ RT_CLASS_DEFAULT = 0xfd ++ RT_CLASS_LOCAL = 0xff ++ RT_CLASS_MAIN = 0xfe ++ RT_CLASS_MAX = 0xff ++ RT_CLASS_UNSPEC = 0x0 ++ RUSAGE_CHILDREN = -0x1 ++ RUSAGE_SELF = 0x0 ++ RUSAGE_THREAD = 0x1 ++ SCM_CREDENTIALS = 0x2 ++ SCM_RIGHTS = 0x1 ++ SCM_TIMESTAMP = 0x1d ++ SCM_TIMESTAMPING = 0x25 ++ SCM_TIMESTAMPING_OPT_STATS = 0x36 ++ SCM_TIMESTAMPING_PKTINFO = 0x3a ++ SCM_TIMESTAMPNS = 0x23 ++ SCM_TXTIME = 0x3d ++ SCM_WIFI_STATUS = 0x29 ++ SHUT_RD = 0x0 ++ SHUT_RDWR = 0x2 ++ SHUT_WR = 0x1 ++ SIOCADDDLCI = 0x8980 ++ SIOCADDMULTI = 0x8931 ++ SIOCADDRT = 0x890b ++ SIOCATMARK = 0x8905 ++ SIOCDARP = 0x8953 ++ SIOCDELDLCI = 0x8981 ++ SIOCDELMULTI = 0x8932 ++ SIOCDELRT = 0x890c ++ SIOCDEVPRIVATE = 0x89f0 ++ SIOCDIFADDR = 0x8936 ++ SIOCDRARP = 0x8960 ++ SIOCGARP = 0x8954 ++ SIOCGIFADDR = 0x8915 ++ SIOCGIFBR = 0x8940 ++ SIOCGIFBRDADDR = 0x8919 ++ SIOCGIFCONF = 0x8912 ++ SIOCGIFCOUNT = 0x8938 ++ SIOCGIFDSTADDR = 0x8917 ++ SIOCGIFENCAP = 0x8925 ++ SIOCGIFFLAGS = 0x8913 ++ SIOCGIFHWADDR = 0x8927 ++ SIOCGIFINDEX = 0x8933 ++ SIOCGIFMAP = 0x8970 ++ SIOCGIFMEM = 0x891f ++ SIOCGIFMETRIC = 0x891d ++ SIOCGIFMTU = 0x8921 ++ SIOCGIFNAME = 0x8910 ++ SIOCGIFNETMASK = 0x891b ++ SIOCGIFPFLAGS = 0x8935 ++ SIOCGIFSLAVE = 0x8929 ++ SIOCGIFTXQLEN = 0x8942 ++ SIOCGPGRP = 0x8904 ++ SIOCGRARP = 0x8961 ++ SIOCGSTAMPNS_OLD = 0x8907 ++ SIOCGSTAMP_OLD = 0x8906 ++ SIOCPROTOPRIVATE = 0x89e0 ++ SIOCRTMSG = 0x890d ++ SIOCSARP = 0x8955 ++ SIOCSIFADDR = 0x8916 ++ SIOCSIFBR = 0x8941 ++ SIOCSIFBRDADDR = 0x891a ++ SIOCSIFDSTADDR = 0x8918 ++ SIOCSIFENCAP = 0x8926 ++ SIOCSIFFLAGS = 0x8914 ++ SIOCSIFHWADDR = 0x8924 ++ SIOCSIFHWBROADCAST = 0x8937 ++ SIOCSIFLINK = 0x8911 ++ SIOCSIFMAP = 0x8971 ++ SIOCSIFMEM = 0x8920 ++ SIOCSIFMETRIC = 0x891e ++ SIOCSIFMTU = 0x8922 ++ SIOCSIFNAME = 0x8923 ++ SIOCSIFNETMASK = 0x891c ++ SIOCSIFPFLAGS = 0x8934 ++ SIOCSIFSLAVE = 0x8930 ++ SIOCSIFTXQLEN = 0x8943 ++ SIOCSPGRP = 0x8902 ++ SIOCSRARP = 0x8962 ++ SOCK_BUF_LOCK_MASK = 0x3 ++ SOCK_CLOEXEC = 0x80000 ++ SOCK_DCCP = 0x6 ++ SOCK_DGRAM = 0x2 ++ SOCK_NONBLOCK = 0x800 ++ SOCK_PACKET = 0xa ++ SOCK_RAW = 0x3 ++ SOCK_RCVBUF_LOCK = 0x2 ++ SOCK_RDM = 0x4 ++ SOCK_SEQPACKET = 0x5 ++ SOCK_SNDBUF_LOCK = 0x1 ++ SOCK_STREAM = 0x1 ++ SOCK_TXREHASH_DEFAULT = 0xff ++ SOCK_TXREHASH_DISABLED = 0x0 ++ SOCK_TXREHASH_ENABLED = 0x1 ++ SOL_AAL = 0x109 ++ SOL_ALG = 0x117 ++ SOL_ATM = 0x108 ++ SOL_BLUETOOTH = 0x112 ++ SOL_CAIF = 0x116 ++ SOL_DCCP = 0x10d ++ SOL_DECNET = 0x105 ++ SOL_ICMPV6 = 0x3a ++ SOL_IP = 0x0 ++ SOL_IPV6 = 0x29 ++ SOL_IRDA = 0x10a ++ SOL_IUCV = 0x115 ++ SOL_KCM = 0x119 ++ SOL_LLC = 0x10c ++ SOL_MCTP = 0x11d ++ SOL_MPTCP = 0x11c ++ SOL_NETBEUI = 0x10b ++ SOL_NETLINK = 0x10e ++ SOL_NFC = 0x118 ++ SOL_PACKET = 0x107 ++ SOL_PNPIPE = 0x113 ++ SOL_PPPOL2TP = 0x111 ++ SOL_RAW = 0xff ++ SOL_RDS = 0x114 ++ SOL_RXRPC = 0x110 ++ SOL_SMC = 0x11e ++ SOL_SOCKET = 0x1 ++ SOL_TCP = 0x6 ++ SOL_TIPC = 0x10f ++ SOL_TLS = 0x11a ++ SOL_X25 = 0x106 ++ SOL_XDP = 0x11b ++ SOMAXCONN = 0x1000 ++ SO_ACCEPTCONN = 0x1e ++ SO_ATTACH_BPF = 0x32 ++ SO_ATTACH_FILTER = 0x1a ++ SO_ATTACH_REUSEPORT_CBPF = 0x33 ++ SO_ATTACH_REUSEPORT_EBPF = 0x34 ++ SO_BINDTODEVICE = 0x19 ++ SO_BINDTOIFINDEX = 0x3e ++ SO_BPF_EXTENSIONS = 0x30 ++ SO_BROADCAST = 0x6 ++ SO_BSDCOMPAT = 0xe ++ SO_BUF_LOCK = 0x48 ++ SO_BUSY_POLL = 0x2e ++ SO_BUSY_POLL_BUDGET = 0x46 ++ SO_CNX_ADVICE = 0x35 ++ SO_COOKIE = 0x39 ++ SO_DEBUG = 0x1 ++ SO_DETACH_BPF = 0x1b ++ SO_DETACH_FILTER = 0x1b ++ SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DOMAIN = 0x27 ++ SO_DONTROUTE = 0x5 ++ SO_ERROR = 0x4 ++ SO_GET_FILTER = 0x1a ++ SO_INCOMING_CPU = 0x31 ++ SO_INCOMING_NAPI_ID = 0x38 ++ SO_KEEPALIVE = 0x9 ++ SO_LINGER = 0xd ++ SO_LOCK_FILTER = 0x2c ++ SO_MARK = 0x24 ++ SO_MAX_PACING_RATE = 0x2f ++ SO_MEMINFO = 0x37 ++ SO_NETNS_COOKIE = 0x47 ++ SO_NOFCS = 0x2b ++ SO_NO_CHECK = 0xb ++ SO_OOBINLINE = 0xa ++ SO_PASSCRED = 0x10 ++ SO_PASSSEC = 0x22 ++ SO_PEEK_OFF = 0x2a ++ SO_PEERCRED = 0x11 ++ SO_PEERGROUPS = 0x3b ++ SO_PEERNAME = 0x1c ++ SO_PEERSEC = 0x1f ++ SO_PREFER_BUSY_POLL = 0x45 ++ SO_PRIORITY = 0xc ++ SO_PROTOCOL = 0x26 ++ SO_RCVBUF = 0x8 ++ SO_RCVBUFFORCE = 0x21 ++ SO_RCVLOWAT = 0x12 ++ SO_RCVMARK = 0x4b ++ SO_RCVTIMEO = 0x14 ++ SO_RCVTIMEO_NEW = 0x42 ++ SO_RCVTIMEO_OLD = 0x14 ++ SO_RESERVE_MEM = 0x49 ++ SO_REUSEADDR = 0x2 ++ SO_REUSEPORT = 0xf ++ SO_RXQ_OVFL = 0x28 ++ SO_SECURITY_AUTHENTICATION = 0x16 ++ SO_SECURITY_ENCRYPTION_NETWORK = 0x18 ++ SO_SECURITY_ENCRYPTION_TRANSPORT = 0x17 ++ SO_SELECT_ERR_QUEUE = 0x2d ++ SO_SNDBUF = 0x7 ++ SO_SNDBUFFORCE = 0x20 ++ SO_SNDLOWAT = 0x13 ++ SO_SNDTIMEO = 0x15 ++ SO_SNDTIMEO_NEW = 0x43 ++ SO_SNDTIMEO_OLD = 0x15 ++ SO_TIMESTAMP = 0x1d ++ SO_TIMESTAMPING = 0x25 ++ SO_TIMESTAMPING_NEW = 0x41 ++ SO_TIMESTAMPING_OLD = 0x25 ++ SO_TIMESTAMPNS = 0x23 ++ SO_TIMESTAMPNS_NEW = 0x40 ++ SO_TIMESTAMPNS_OLD = 0x23 ++ SO_TIMESTAMP_NEW = 0x3f ++ SO_TIMESTAMP_OLD = 0x1d ++ SO_TXREHASH = 0x4a ++ SO_TXTIME = 0x3d ++ SO_TYPE = 0x3 ++ SO_WIFI_STATUS = 0x29 ++ SO_ZEROCOPY = 0x3c ++ 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_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 ++ TCFLSH = 0x540b ++ TCIFLUSH = 0x0 ++ TCIOFLUSH = 0x2 ++ TCOFLUSH = 0x1 ++ TCP_CC_INFO = 0x1a ++ TCP_CM_INQ = 0x24 ++ TCP_CONGESTION = 0xd ++ TCP_COOKIE_IN_ALWAYS = 0x1 ++ TCP_COOKIE_MAX = 0x10 ++ TCP_COOKIE_MIN = 0x8 ++ TCP_COOKIE_OUT_NEVER = 0x2 ++ TCP_COOKIE_PAIR_SIZE = 0x20 ++ TCP_COOKIE_TRANSACTIONS = 0xf ++ TCP_CORK = 0x3 ++ TCP_DEFER_ACCEPT = 0x9 ++ TCP_FASTOPEN = 0x17 ++ TCP_FASTOPEN_CONNECT = 0x1e ++ TCP_FASTOPEN_KEY = 0x21 ++ TCP_FASTOPEN_NO_COOKIE = 0x22 ++ TCP_INFO = 0xb ++ TCP_INQ = 0x24 ++ TCP_KEEPCNT = 0x6 ++ TCP_KEEPIDLE = 0x4 ++ TCP_KEEPINTVL = 0x5 ++ TCP_LINGER2 = 0x8 ++ TCP_MAXSEG = 0x2 ++ TCP_MAXWIN = 0xffff ++ TCP_MAX_WINSHIFT = 0xe ++ TCP_MD5SIG = 0xe ++ TCP_MD5SIG_EXT = 0x20 ++ TCP_MD5SIG_FLAG_PREFIX = 0x1 ++ TCP_MD5SIG_MAXKEYLEN = 0x50 ++ TCP_MSS = 0x200 ++ TCP_MSS_DEFAULT = 0x218 ++ TCP_MSS_DESIRED = 0x4c4 ++ TCP_NODELAY = 0x1 ++ TCP_NOTSENT_LOWAT = 0x19 ++ TCP_QUEUE_SEQ = 0x15 ++ TCP_QUICKACK = 0xc ++ TCP_REPAIR = 0x13 ++ TCP_REPAIR_OFF = 0x0 ++ TCP_REPAIR_OFF_NO_WP = -0x1 ++ TCP_REPAIR_ON = 0x1 ++ TCP_REPAIR_OPTIONS = 0x16 ++ TCP_REPAIR_QUEUE = 0x14 ++ TCP_REPAIR_WINDOW = 0x1d ++ TCP_SAVED_SYN = 0x1c ++ TCP_SAVE_SYN = 0x1b ++ TCP_SYNCNT = 0x7 ++ TCP_S_DATA_IN = 0x4 ++ TCP_S_DATA_OUT = 0x8 ++ TCP_THIN_DUPACK = 0x11 ++ TCP_THIN_LINEAR_TIMEOUTS = 0x10 ++ TCP_TIMESTAMP = 0x18 ++ TCP_TX_DELAY = 0x25 ++ TCP_ULP = 0x1f ++ TCP_USER_TIMEOUT = 0x12 ++ TCP_WINDOW_CLAMP = 0xa ++ TCP_ZEROCOPY_RECEIVE = 0x23 ++ TCSAFLUSH = 0x2 ++ TIOCCBRK = 0x5428 ++ TIOCCONS = 0x541d ++ TIOCEXCL = 0x540c ++ TIOCGDEV = 0x80045432 ++ TIOCGETD = 0x5424 ++ TIOCGEXCL = 0x80045440 ++ TIOCGICOUNT = 0x545d ++ TIOCGISO7816 = 0x80285442 ++ TIOCGLCKTRMIOS = 0x5456 ++ TIOCGPGRP = 0x540f ++ TIOCGPKT = 0x80045438 ++ TIOCGPTLCK = 0x80045439 ++ TIOCGPTN = 0x80045430 ++ TIOCGPTPEER = 0x5441 ++ TIOCGRS485 = 0x542e ++ TIOCGSERIAL = 0x541e ++ TIOCGSID = 0x5429 ++ TIOCGSOFTCAR = 0x5419 ++ TIOCGWINSZ = 0x5413 ++ TIOCINQ = 0x541b ++ TIOCLINUX = 0x541c ++ TIOCMBIC = 0x5417 ++ TIOCMBIS = 0x5416 ++ TIOCMGET = 0x5415 ++ TIOCMIWAIT = 0x545c ++ TIOCMSET = 0x5418 ++ 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 = 0x5422 ++ TIOCNXCL = 0x540d ++ TIOCOUTQ = 0x5411 ++ TIOCPKT = 0x5420 ++ TIOCPKT_DATA = 0x0 ++ TIOCPKT_DOSTOP = 0x20 ++ TIOCPKT_FLUSHREAD = 0x1 ++ TIOCPKT_FLUSHWRITE = 0x2 ++ TIOCPKT_IOCTL = 0x40 ++ TIOCPKT_NOSTOP = 0x10 ++ TIOCPKT_START = 0x8 ++ TIOCPKT_STOP = 0x4 ++ TIOCSBRK = 0x5427 ++ TIOCSCTTY = 0x540e ++ TIOCSERCONFIG = 0x5453 ++ TIOCSERGETLSR = 0x5459 ++ TIOCSERGETMULTI = 0x545a ++ TIOCSERGSTRUCT = 0x5458 ++ TIOCSERGWILD = 0x5454 ++ TIOCSERSETMULTI = 0x545b ++ TIOCSERSWILD = 0x5455 ++ TIOCSER_TEMT = 0x1 ++ TIOCSETD = 0x5423 ++ TIOCSIG = 0x40045436 ++ TIOCSISO7816 = 0xc0285443 ++ TIOCSLCKTRMIOS = 0x5457 ++ TIOCSPGRP = 0x5410 ++ TIOCSPTLCK = 0x40045431 ++ TIOCSRS485 = 0x542f ++ TIOCSSERIAL = 0x541f ++ TIOCSSOFTCAR = 0x541a ++ TIOCSTI = 0x5412 ++ TIOCSWINSZ = 0x5414 ++ TIOCVHANGUP = 0x5437 ++ TOSTOP = 0x100 ++ TUNATTACHFILTER = 0x401054d5 ++ TUNDETACHFILTER = 0x401054d6 ++ TUNGETDEVNETNS = 0x54e3 ++ TUNGETFEATURES = 0x800454cf ++ TUNGETFILTER = 0x801054db ++ TUNGETIFF = 0x800454d2 ++ TUNGETSNDBUF = 0x800454d3 ++ TUNGETVNETBE = 0x800454df ++ TUNGETVNETHDRSZ = 0x800454d7 ++ TUNGETVNETLE = 0x800454dd ++ TUNSETCARRIER = 0x400454e2 ++ TUNSETDEBUG = 0x400454c9 ++ TUNSETFILTEREBPF = 0x800454e1 ++ TUNSETGROUP = 0x400454ce ++ TUNSETIFF = 0x400454ca ++ TUNSETIFINDEX = 0x400454da ++ TUNSETLINK = 0x400454cd ++ TUNSETNOCSUM = 0x400454c8 ++ TUNSETOFFLOAD = 0x400454d0 ++ TUNSETOWNER = 0x400454cc ++ TUNSETPERSIST = 0x400454cb ++ TUNSETQUEUE = 0x400454d9 ++ TUNSETSNDBUF = 0x400454d4 ++ TUNSETSTEERINGEBPF = 0x800454e0 ++ TUNSETTXFILTER = 0x400454d1 ++ TUNSETVNETBE = 0x400454de ++ TUNSETVNETHDRSZ = 0x400454d8 ++ TUNSETVNETLE = 0x400454dc ++ VDISCARD = 0xd ++ VEOF = 0x4 ++ VEOL = 0xb ++ VEOL2 = 0x10 ++ VERASE = 0x2 ++ VINTR = 0x0 ++ VKILL = 0x3 ++ VLNEXT = 0xf ++ VMIN = 0x6 ++ VQUIT = 0x1 ++ VREPRINT = 0xc ++ VSTART = 0x8 ++ VSTOP = 0x9 ++ VSUSP = 0xa ++ VSWTC = 0x7 ++ VT0 = 0x0 ++ VT1 = 0x4000 ++ VTDLY = 0x4000 ++ VTIME = 0x5 ++ VWERASE = 0xe ++ WALL = 0x40000000 ++ WCLONE = 0x80000000 ++ WCONTINUED = 0x8 ++ WEXITED = 0x4 ++ WNOHANG = 0x1 ++ WNOTHREAD = 0x20000000 ++ WNOWAIT = 0x1000000 ++ WORDSIZE = 0x40 ++ WSTOPPED = 0x2 ++ WUNTRACED = 0x2 + ) + + // Errors +diff --git a/src/syscall/zsyscall_linux_loong64.go b/src/syscall/zsyscall_linux_loong64.go +index 48c58f3772..b1a2fb7f2b 100644 +--- a/src/syscall/zsyscall_linux_loong64.go ++++ b/src/syscall/zsyscall_linux_loong64.go +@@ -2,6 +2,7 @@ + // Code generated by the command above; DO NOT EDIT. + + //go:build linux && loong64 ++// +build linux,loong64 + + package syscall + +@@ -75,16 +76,6 @@ func openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) + + // 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 readlinkat(dirfd int, path string, buf []byte) (n int, err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) +@@ -1084,46 +1075,6 @@ func Fchown(fd int, uid int, gid int) (err error) { + + // 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 fstatat(dirfd 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(dirfd), 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, buf *Statfs_t) (err error) { + _, _, e1 := Syscall(SYS_FSTATFS, uintptr(fd), uintptr(unsafe.Pointer(buf)), 0) + if e1 != 0 { +@@ -1303,6 +1254,21 @@ func Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n i + + // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + ++func statx(dirfd int, path string, flags int, mask int, stat *statx_t) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_STATX, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(mask), 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, buf *Statfs_t) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(path) +@@ -1562,3 +1528,13 @@ func ppoll(fds *pollFd, nfds int, timeout *Timespec, sigmask *sigset_t) (n int, + } + 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 ++} +diff --git a/src/syscall/zsysnum_linux_loong64.go b/src/syscall/zsysnum_linux_loong64.go +index 0821777056..b117438f02 100644 +--- a/src/syscall/zsysnum_linux_loong64.go ++++ b/src/syscall/zsysnum_linux_loong64.go +@@ -82,8 +82,6 @@ const ( + SYS_SPLICE = 76 + SYS_TEE = 77 + SYS_READLINKAT = 78 +- SYS_FSTATAT = 79 +- SYS_FSTAT = 80 + SYS_SYNC = 81 + SYS_FSYNC = 82 + SYS_FDATASYNC = 83 +@@ -305,4 +303,5 @@ const ( + SYS_LANDLOCK_RESTRICT_SELF = 446 + SYS_PROCESS_MRELEASE = 448 + SYS_FUTEX_WAITV = 449 ++ SYS_SET_MEMPOLICY_HOME_NODE = 450 + ) +diff --git a/src/syscall/ztypes_linux_loong64.go b/src/syscall/ztypes_linux_loong64.go +index ab2d7211fe..40ee6f7d1e 100644 +--- a/src/syscall/ztypes_linux_loong64.go ++++ b/src/syscall/ztypes_linux_loong64.go +@@ -112,6 +112,38 @@ type Stat_t struct { + X__glibc_reserved [2]int32 + } + ++type statxTimestamp struct { ++ Sec int64 ++ Nsec uint32 ++ X__reserved int32 ++} ++ ++type statx_t struct { ++ Mask uint32 ++ Blksize uint32 ++ Attributes uint64 ++ Nlink uint32 ++ Uid uint32 ++ Gid uint32 ++ Mode uint16 ++ X__spare0 [1]uint16 ++ Ino uint64 ++ Size uint64 ++ Blocks uint64 ++ Attributes_mask uint64 ++ Atime statxTimestamp ++ Btime statxTimestamp ++ Ctime statxTimestamp ++ Mtime statxTimestamp ++ Rdev_major uint32 ++ Rdev_minor uint32 ++ Dev_major uint32 ++ Dev_minor uint32 ++ Mnt_id uint64 ++ X__spare2 uint64 ++ X__spare3 [12]uint64 ++} ++ + type Statfs_t struct { + Type int64 + Bsize int64 +@@ -351,7 +383,7 @@ const ( + IFLA_LINKINFO = 0x12 + IFLA_NET_NS_PID = 0x13 + IFLA_IFALIAS = 0x14 +- IFLA_MAX = 0x39 ++ IFLA_MAX = 0x3c + RT_SCOPE_UNIVERSE = 0x0 + RT_SCOPE_SITE = 0xc8 + RT_SCOPE_LINK = 0xfd +@@ -506,9 +538,10 @@ const SizeofInotifyEvent = 0x10 + + type PtraceRegs struct { + Regs [32]uint64 ++ Orig_a0 uint64 + Era uint64 + Badv uint64 +- Reserved [11]uint64 ++ Reserved [10]uint64 + } + + type ptracePsw struct { +@@ -560,10 +593,10 @@ type Ustat_t struct { + } + + type EpollEvent struct { +- Events uint32 +- _ int32 +- Fd int32 +- Pad int32 ++ Events uint32 ++ X_padFd int32 ++ Fd int32 ++ Pad int32 + } + + const ( +@@ -571,6 +604,9 @@ const ( + _AT_REMOVEDIR = 0x200 + _AT_SYMLINK_NOFOLLOW = 0x100 + _AT_EACCESS = 0x200 ++ _AT_EMPTY_PATH = 0x1000 ++ _AT_NO_AUTOMOUNT = 0x800 ++ _STATX_BASIC_STATS = 0x7ff + ) + + type pollFd struct { +-- +2.38.0 + diff --git a/loongarch64/0091-cmd-internal-obj-loong64-add-the-PCALAU12I-instructi.patch b/loongarch64/0091-cmd-internal-obj-loong64-add-the-PCALAU12I-instructi.patch new file mode 100644 index 0000000000000000000000000000000000000000..8f0a1a8e8b42412238341fc4d5bb4dba7c44951c --- /dev/null +++ b/loongarch64/0091-cmd-internal-obj-loong64-add-the-PCALAU12I-instructi.patch @@ -0,0 +1,62 @@ +From 4d7eca71a1dcc53e91efbc47a4761ba79e20c3d7 Mon Sep 17 00:00:00 2001 +From: WANG Xuerui +Date: Sat, 3 Dec 2022 20:57:52 +0800 +Subject: [PATCH 10/18] cmd/internal/obj/loong64: add the PCALAU12I instruction + for reloc use + +The LoongArch ELF psABI v2.00 revamped the relocation design, largely +moving to using the `pcalau12i + addi/ld/st` pair for PC-relative +addressing within +/- 32 bits. The "pcala" in `pcalau12i` stands for +"PC-aligned add"; the instruction's semantics is actually the same as +arm64's `adrp`. + +Add support for emitting this instruction as part of the relevant +addressing ops, for use with new reloc types later. + +Change-Id: Ic1747cd9745aad0d1abb9bd78400cd5ff5978bc8 +--- + src/cmd/internal/obj/loong64/a.out.go | 1 + + src/cmd/internal/obj/loong64/anames.go | 1 + + src/cmd/internal/obj/loong64/asm.go | 2 ++ + 3 files changed, 4 insertions(+) + +diff --git a/src/cmd/internal/obj/loong64/a.out.go b/src/cmd/internal/obj/loong64/a.out.go +index 63ee0ab44a..5fd7b28ff8 100644 +--- a/src/cmd/internal/obj/loong64/a.out.go ++++ b/src/cmd/internal/obj/loong64/a.out.go +@@ -267,6 +267,7 @@ const ( + ALU12IW + ALU32ID + ALU52ID ++ APCALAU12I + APCADDU12I + AJIRL + ABGE +diff --git a/src/cmd/internal/obj/loong64/anames.go b/src/cmd/internal/obj/loong64/anames.go +index 438261d813..ae7bbbd01d 100644 +--- a/src/cmd/internal/obj/loong64/anames.go ++++ b/src/cmd/internal/obj/loong64/anames.go +@@ -33,6 +33,7 @@ var Anames = []string{ + "LU12IW", + "LU32ID", + "LU52ID", ++ "PCALAU12I", + "PCADDU12I", + "JIRL", + "BGE", +diff --git a/src/cmd/internal/obj/loong64/asm.go b/src/cmd/internal/obj/loong64/asm.go +index c583e4d368..b7e8cb18d8 100644 +--- a/src/cmd/internal/obj/loong64/asm.go ++++ b/src/cmd/internal/obj/loong64/asm.go +@@ -1939,6 +1939,8 @@ func (c *ctxt0) opir(a obj.As) uint32 { + return 0x0a << 25 + case ALU32ID: + return 0x0b << 25 ++ case APCALAU12I: ++ return 0x0d << 25 + case APCADDU12I: + return 0x0e << 25 + } +-- +2.38.0 + diff --git a/loongarch64/0092-cmd-asm-link-loong64-switch-to-LoongArch-ELF-psABI-v.patch b/loongarch64/0092-cmd-asm-link-loong64-switch-to-LoongArch-ELF-psABI-v.patch new file mode 100644 index 0000000000000000000000000000000000000000..ad17c7dfe5d75429756301a36311989933866b2a --- /dev/null +++ b/loongarch64/0092-cmd-asm-link-loong64-switch-to-LoongArch-ELF-psABI-v.patch @@ -0,0 +1,725 @@ +From 518996c2f62b0b50dc7e2a2119cb1fab79140295 Mon Sep 17 00:00:00 2001 +From: Guoqi Chen +Date: Thu, 9 Mar 2023 20:38:20 +0800 +Subject: [PATCH 11/18] cmd/{asm,link}/loong64: switch to LoongArch ELF psABI + v2 relocs + +Signed-off-by: Guoqi Chen +Change-Id: I6b9d12b959c96830649f44696c0b5c3320d80e1a +--- + .../asm/internal/asm/testdata/loong64enc2.s | 38 +-- + src/cmd/internal/obj/loong64/asm.go | 74 ++--- + src/cmd/internal/objabi/reloctype.go | 8 +- + src/cmd/internal/objabi/reloctype_string.go | 10 +- + src/cmd/link/internal/ld/elf.go | 2 +- + src/cmd/link/internal/ld/lib.go | 2 +- + src/cmd/link/internal/loong64/asm.go | 300 ++++-------------- + 7 files changed, 127 insertions(+), 307 deletions(-) + +diff --git a/src/cmd/asm/internal/asm/testdata/loong64enc2.s b/src/cmd/asm/internal/asm/testdata/loong64enc2.s +index 675b263acf..6cc54d6249 100644 +--- a/src/cmd/asm/internal/asm/testdata/loong64enc2.s ++++ b/src/cmd/asm/internal/asm/testdata/loong64enc2.s +@@ -61,22 +61,22 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$0 + XOR $-1, R4 // 1efcbf0284f81500 + MOVH R4, R5 // 85c04000a5c04800 + +- // relocation instructions +- MOVW R4, name(SB) // 1e00001cc4038029 +- MOVWU R4, name(SB) // 1e00001cc4038029 +- MOVV R4, name(SB) // 1e00001cc403c029 +- MOVB R4, name(SB) // 1e00001cc4030029 +- MOVBU R4, name(SB) // 1e00001cc4030029 +- MOVF F4, name(SB) // 1e00001cc403402b +- MOVD F4, name(SB) // 1e00001cc403c02b +- MOVW name(SB), R4 // 1e00001cc4038028 +- MOVWU name(SB), R4 // 1e00001cc403802a +- MOVV name(SB), R4 // 1e00001cc403c028 +- MOVB name(SB), R4 // 1e00001cc4030028 +- MOVBU name(SB), R4 // 1e00001cc403002a +- MOVF name(SB), F4 // 1e00001cc403002b +- MOVD name(SB), F4 // 1e00001cc403802b +- MOVH R4, name(SB) // 1e00001cc4034029 +- MOVH name(SB), R4 // 1e00001cc4034028 +- MOVHU R4, name(SB) // 1e00001cc4034029 +- MOVHU name(SB), R4 // 1e00001cc403402a ++ // relocation instructions ++ MOVW R4, name(SB) // 1e00001ac4038029 ++ MOVWU R4, name(SB) // 1e00001ac4038029 ++ MOVV R4, name(SB) // 1e00001ac403c029 ++ MOVB R4, name(SB) // 1e00001ac4030029 ++ MOVBU R4, name(SB) // 1e00001ac4030029 ++ MOVF F4, name(SB) // 1e00001ac403402b ++ MOVD F4, name(SB) // 1e00001ac403c02b ++ MOVW name(SB), R4 // 1e00001ac4038028 ++ MOVWU name(SB), R4 // 1e00001ac403802a ++ MOVV name(SB), R4 // 1e00001ac403c028 ++ MOVB name(SB), R4 // 1e00001ac4030028 ++ MOVBU name(SB), R4 // 1e00001ac403002a ++ MOVF name(SB), F4 // 1e00001ac403002b ++ MOVD name(SB), F4 // 1e00001ac403802b ++ MOVH R4, name(SB) // 1e00001ac4034029 ++ MOVH name(SB), R4 // 1e00001ac4034028 ++ MOVHU R4, name(SB) // 1e00001ac4034029 ++ MOVHU name(SB), R4 // 1e00001ac403402a +diff --git a/src/cmd/internal/obj/loong64/asm.go b/src/cmd/internal/obj/loong64/asm.go +index b7e8cb18d8..9d81569b73 100644 +--- a/src/cmd/internal/obj/loong64/asm.go ++++ b/src/cmd/internal/obj/loong64/asm.go +@@ -601,8 +601,8 @@ func (c *ctxt0) aclass(a *obj.Addr) int { + } + return C_LOREG + +- case obj.NAME_GOTREF: +- return C_GOTADDR ++ case obj.NAME_GOTREF: ++ return C_GOTADDR + } + + return C_GOK +@@ -1496,8 +1496,8 @@ func (c *ctxt0) asmout(p *obj.Prog, o *Optab, out []uint32) { + o1 = c.oprrr(ABREAK) + + // relocation operations +- case 50: // mov r,addr ==> pcaddu12i + sw +- o1 = OP_IR(c.opir(APCADDU12I), uint32(0), uint32(REGTMP)) ++ case 50: // mov r,addr ==> pcalau12i + sw ++ o1 = OP_IR(c.opir(APCALAU12I), uint32(0), uint32(REGTMP)) + rel := obj.Addrel(c.cursym) + rel.Off = int32(c.pc) + rel.Siz = 4 +@@ -1513,8 +1513,8 @@ func (c *ctxt0) asmout(p *obj.Prog, o *Optab, out []uint32) { + rel2.Add = p.To.Offset + rel2.Type = objabi.R_ADDRLOONG64 + +- case 51: // mov addr,r ==> pcaddu12i + lw +- o1 = OP_IR(c.opir(APCADDU12I), uint32(0), uint32(REGTMP)) ++ case 51: // mov addr,r ==> pcalau12i + lw ++ o1 = OP_IR(c.opir(APCALAU12I), uint32(0), uint32(REGTMP)) + rel := obj.Addrel(c.cursym) + rel.Off = int32(c.pc) + rel.Siz = 4 +@@ -1532,7 +1532,7 @@ func (c *ctxt0) asmout(p *obj.Prog, o *Optab, out []uint32) { + case 52: // mov $lext, r + // NOTE: this case does not use REGTMP. If it ever does, + // remove the NOTUSETMP flag in optab. +- o1 = OP_IR(c.opir(APCADDU12I), uint32(0), uint32(p.To.Reg)) ++ o1 = OP_IR(c.opir(APCALAU12I), uint32(0), uint32(p.To.Reg)) + rel := obj.Addrel(c.cursym) + rel.Off = int32(c.pc) + rel.Siz = 4 +@@ -1606,8 +1606,8 @@ func (c *ctxt0) asmout(p *obj.Prog, o *Optab, out []uint32) { + rel2.Type = objabi.R_ADDRLOONG64TLS + o3 = OP_RRR(c.oprrr(AADDV), uint32(REG_R2), uint32(REGTMP), uint32(p.To.Reg)) + +- case 56: // mov r, tlsvar GD model ==> (pcaddu12i + ld.d)__tls_get_addr + (pcaddu12i + addi.d)tlsvar@got + jirl + st.d +- o1 = OP_IR(c.opir(APCADDU12I), uint32(0), uint32(REGTMP)) ++ case 56: // mov r, tlsvar GD model ==> (pcalau12i + ld.d)__tls_get_addr + (pcalau12i + addi.d)tlsvar@got + jirl + st.d ++ o1 = OP_IR(c.opir(APCALAU12I), uint32(0), uint32(REGTMP)) + rel := obj.Addrel(c.cursym) + rel.Off = int32(c.pc) + rel.Siz = 4 +@@ -1616,30 +1616,30 @@ func (c *ctxt0) asmout(p *obj.Prog, o *Optab, out []uint32) { + rel.Type = objabi.R_LOONG64_GOTPCREL_HI + o2 = OP_12IRR(c.opirr(-p.As), uint32(0), uint32(REGTMP), uint32(REGTMP)) + rel2 := obj.Addrel(c.cursym) +- rel2.Off = int32(c.pc+4) ++ rel2.Off = int32(c.pc + 4) + rel2.Siz = 4 + rel2.Sym = c.ctxt.Lookup("__tls_get_addr") + rel2.Add = 0x0 +- rel2.Type = objabi.R_LOONG64_GOTPCREL_LO +- o3 = OP_IR(c.opir(APCADDU12I), uint32(0), uint32(REG_R4)) ++ rel2.Type = objabi.R_LOONG64_GOT_LO ++ o3 = OP_IR(c.opir(APCALAU12I), uint32(0), uint32(REG_R4)) + rel3 := obj.Addrel(c.cursym) +- rel3.Off = int32(c.pc+8) ++ rel3.Off = int32(c.pc + 8) + rel3.Siz = 4 + rel3.Sym = p.To.Sym + rel3.Add = 0x0 + rel3.Type = objabi.R_LOONG64_TLS_GD_PCREL_HI + o4 = OP_12IRR(c.opirr(AADDV), uint32(0), uint32(REG_R4), uint32(REG_R4)) + rel4 := obj.Addrel(c.cursym) +- rel4.Off = int32(c.pc+12) ++ rel4.Off = int32(c.pc + 12) + rel4.Siz = 4 + rel4.Sym = p.To.Sym + rel4.Add = 0x0 +- rel4.Type = objabi.R_LOONG64_TLS_GD_PCREL_LO ++ rel4.Type = objabi.R_LOONG64_TLS_GD_LO + o5 = OP_16IRR(c.opirr(AJIRL), uint32(0), uint32(REGTMP), uint32(REGLINK)) + o6 = OP_12IRR(c.opirr(p.As), uint32(0), uint32(REG_R4), uint32(p.From.Reg)) + +- case 57: // mov tlsvar, r GD model ==> (pcaddu12i + ld.d)__tls_get_addr + (pcaddu12i + addi.d)tlsvar@got + jirl + ld.d +- o1 = OP_IR(c.opir(APCADDU12I), uint32(0), uint32(REGTMP)) ++ case 57: // mov tlsvar, r GD model ==> (pcalau12i + ld.d)__tls_get_addr + (pcalau12i + addi.d)tlsvar@got + jirl + ld.d ++ o1 = OP_IR(c.opir(APCALAU12I), uint32(0), uint32(REGTMP)) + rel := obj.Addrel(c.cursym) + rel.Off = int32(c.pc) + rel.Siz = 4 +@@ -1648,24 +1648,24 @@ func (c *ctxt0) asmout(p *obj.Prog, o *Optab, out []uint32) { + rel.Type = objabi.R_LOONG64_GOTPCREL_HI + o2 = OP_12IRR(c.opirr(-p.As), uint32(0), uint32(REGTMP), uint32(REGTMP)) + rel2 := obj.Addrel(c.cursym) +- rel2.Off = int32(c.pc+4) ++ rel2.Off = int32(c.pc + 4) + rel2.Siz = 4 + rel2.Sym = c.ctxt.Lookup("__tls_get_addr") + rel2.Add = 0x0 +- rel2.Type = objabi.R_LOONG64_GOTPCREL_LO +- o3 = OP_IR(c.opir(APCADDU12I), uint32(0), uint32(REG_R4)) ++ rel2.Type = objabi.R_LOONG64_GOT_LO ++ o3 = OP_IR(c.opir(APCALAU12I), uint32(0), uint32(REG_R4)) + rel3 := obj.Addrel(c.cursym) +- rel3.Off = int32(c.pc+8) ++ rel3.Off = int32(c.pc + 8) + rel3.Siz = 4 + rel3.Sym = p.From.Sym + rel3.Type = objabi.R_LOONG64_TLS_GD_PCREL_HI + rel3.Add = 0x0 + o4 = OP_12IRR(c.opirr(AADDV), uint32(0), uint32(REG_R4), uint32(REG_R4)) + rel4 := obj.Addrel(c.cursym) +- rel4.Off = int32(c.pc+12) ++ rel4.Off = int32(c.pc + 12) + rel4.Siz = 4 + rel4.Sym = p.From.Sym +- rel4.Type = objabi.R_LOONG64_TLS_GD_PCREL_LO ++ rel4.Type = objabi.R_LOONG64_TLS_GD_LO + rel4.Add = 0x0 + o5 = OP_16IRR(c.opirr(AJIRL), uint32(0), uint32(REGTMP), uint32(REGLINK)) + o6 = OP_12IRR(c.opirr(-p.As), uint32(0), uint32(REG_R4), uint32(p.To.Reg)) +@@ -1699,20 +1699,20 @@ func (c *ctxt0) asmout(p *obj.Prog, o *Optab, out []uint32) { + o1 = OP_RR(c.oprr(p.As), uint32(p.From.Reg), uint32(p.To.Reg)) + + case 63: // mov sym@GOT, r ==> pcaddu12i + ld.d +- o1 = OP_IR(c.opir(APCADDU12I), uint32(0), uint32(p.To.Reg)) +- rel := obj.Addrel(c.cursym) +- rel.Off = int32(c.pc) +- rel.Siz = 4 +- rel.Sym = p.From.Sym +- rel.Type = objabi.R_LOONG64_GOTPCREL_HI +- rel.Add = 0x0 +- o2 = OP_12IRR(c.opirr(-p.As), uint32(0), uint32(p.To.Reg), uint32(p.To.Reg)) +- rel2 := obj.Addrel(c.cursym) +- rel2.Off = int32(c.pc + 4) +- rel2.Siz = 4 +- rel2.Sym = p.From.Sym +- rel2.Type = objabi.R_LOONG64_GOTPCREL_LO +- rel2.Add = 0x0 ++ o1 = OP_IR(c.opir(APCALAU12I), uint32(0), uint32(p.To.Reg)) ++ rel := obj.Addrel(c.cursym) ++ rel.Off = int32(c.pc) ++ rel.Siz = 4 ++ rel.Sym = p.From.Sym ++ rel.Type = objabi.R_LOONG64_GOTPCREL_HI ++ rel.Add = 0x0 ++ o2 = OP_12IRR(c.opirr(-p.As), uint32(0), uint32(p.To.Reg), uint32(p.To.Reg)) ++ rel2 := obj.Addrel(c.cursym) ++ rel2.Off = int32(c.pc + 4) ++ rel2.Siz = 4 ++ rel2.Sym = p.From.Sym ++ rel2.Type = objabi.R_LOONG64_GOT_LO ++ rel2.Add = 0x0 + } + + out[0] = o1 +diff --git a/src/cmd/internal/objabi/reloctype.go b/src/cmd/internal/objabi/reloctype.go +index d5bc57e782..0e20d05e4d 100644 +--- a/src/cmd/internal/objabi/reloctype.go ++++ b/src/cmd/internal/objabi/reloctype.go +@@ -249,16 +249,16 @@ const ( + + // Loong64. + +- // R_LOONG64_TLS_GD_PCREL_HI and R_LOONG64_TLS_GD_PCREL_LO relocates an pcaddu12i, addi.d pair to compute ++ // R_LOONG64_TLS_GD_PCREL_HI and R_LOONG64_TLS_GD_PCREL_LO relocates an pcalau12i, addi.d pair to compute + // the address of the GOT slot of the tls symbol, the address will be passed to __tls_get_addr to + // get the true address of tlsvar. + R_LOONG64_TLS_GD_PCREL_HI +- R_LOONG64_TLS_GD_PCREL_LO ++ R_LOONG64_TLS_GD_LO + +- // R_LOONG64_GOTPCREL_HI and R_LOONG64_GOTPCREL_LO relocates an pcaddu12i, addi.d pair to compute ++ // R_LOONG64_GOTPCREL_HI and R_LOONG64_GOTPCREL_LO relocates an pcalau12i, addi.d pair to compute + // the address of the GOT slot of the referenced symbol. + R_LOONG64_GOTPCREL_HI +- R_LOONG64_GOTPCREL_LO ++ R_LOONG64_GOT_LO + + // 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. +diff --git a/src/cmd/internal/objabi/reloctype_string.go b/src/cmd/internal/objabi/reloctype_string.go +index 30fe39ba56..ff8c72c013 100644 +--- a/src/cmd/internal/objabi/reloctype_string.go ++++ b/src/cmd/internal/objabi/reloctype_string.go +@@ -1,4 +1,4 @@ +-// Code generated by "stringer -type=RelocType cmd/internal/objabi/reloctype.go"; DO NOT EDIT. ++// Code generated by "stringer -type=RelocType"; DO NOT EDIT. + + package objabi + +@@ -67,9 +67,9 @@ func _() { + _ = x[R_RISCV_TLS_IE_STYPE-57] + _ = x[R_PCRELDBL-58] + _ = x[R_LOONG64_TLS_GD_PCREL_HI-59] +- _ = x[R_LOONG64_TLS_GD_PCREL_LO-60] ++ _ = x[R_LOONG64_TLS_GD_LO-60] + _ = x[R_LOONG64_GOTPCREL_HI-61] +- _ = x[R_LOONG64_GOTPCREL_LO-62] ++ _ = x[R_LOONG64_GOT_LO-62] + _ = x[R_ADDRMIPSU-63] + _ = x[R_ADDRLOONG64U-64] + _ = x[R_ADDRMIPSTLS-65] +@@ -80,9 +80,9 @@ func _() { + _ = x[R_XCOFFREF-70] + } + +-const _RelocType_name = "R_ADDRR_ADDRPOWERR_ADDRARM64R_ADDRMIPSR_ADDRLOONG64R_ADDROFFR_SIZER_CALLR_CALLARMR_CALLARM64R_CALLINDR_CALLPOWERR_CALLMIPSR_CALLRISCVR_CALLLOONG64R_CONSTR_PCRELR_TLS_LER_TLS_IER_GOTOFFR_PLT0R_PLT1R_PLT2R_USEFIELDR_USETYPER_USEIFACER_USEIFACEMETHODR_METHODOFFR_KEEPR_POWER_TOCR_GOTPCRELR_JMPMIPSR_JMPLOONG64R_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_PCREL_ITYPER_RISCV_PCREL_STYPER_RISCV_TLS_IE_ITYPER_RISCV_TLS_IE_STYPER_PCRELDBLR_LOONG64_TLS_GD_PCREL_HIR_LOONG64_TLS_GD_PCREL_LOR_LOONG64_GOTPCREL_HIR_LOONG64_GOTPCREL_LOR_ADDRMIPSUR_ADDRLOONG64UR_ADDRMIPSTLSR_ADDRLOONG64TLSR_ADDRLOONG64TLSUR_ADDRCUOFFR_WASMIMPORTR_XCOFFREF" ++const _RelocType_name = "R_ADDRR_ADDRPOWERR_ADDRARM64R_ADDRMIPSR_ADDRLOONG64R_ADDROFFR_SIZER_CALLR_CALLARMR_CALLARM64R_CALLINDR_CALLPOWERR_CALLMIPSR_CALLRISCVR_CALLLOONG64R_CONSTR_PCRELR_TLS_LER_TLS_IER_GOTOFFR_PLT0R_PLT1R_PLT2R_USEFIELDR_USETYPER_USEIFACER_USEIFACEMETHODR_METHODOFFR_KEEPR_POWER_TOCR_GOTPCRELR_JMPMIPSR_JMPLOONG64R_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_PCREL_ITYPER_RISCV_PCREL_STYPER_RISCV_TLS_IE_ITYPER_RISCV_TLS_IE_STYPER_PCRELDBLR_LOONG64_TLS_GD_PCREL_HIR_LOONG64_TLS_GD_LOR_LOONG64_GOTPCREL_HIR_LOONG64_GOT_LOR_ADDRMIPSUR_ADDRLOONG64UR_ADDRMIPSTLSR_ADDRLOONG64TLSR_ADDRLOONG64TLSUR_ADDRCUOFFR_WASMIMPORTR_XCOFFREF" + +-var _RelocType_index = [...]uint16{0, 6, 17, 28, 38, 51, 60, 66, 72, 81, 92, 101, 112, 122, 133, 146, 153, 160, 168, 176, 184, 190, 196, 202, 212, 221, 231, 247, 258, 264, 275, 285, 294, 306, 319, 333, 347, 361, 377, 388, 401, 414, 428, 442, 456, 471, 485, 499, 510, 524, 539, 556, 574, 595, 614, 633, 653, 673, 683, 708, 733, 754, 775, 786, 800, 813, 829, 846, 857, 869, 879} ++var _RelocType_index = [...]uint16{0, 6, 17, 28, 38, 51, 60, 66, 72, 81, 92, 101, 112, 122, 133, 146, 153, 160, 168, 176, 184, 190, 196, 202, 212, 221, 231, 247, 258, 264, 275, 285, 294, 306, 319, 333, 347, 361, 377, 388, 401, 414, 428, 442, 456, 471, 485, 499, 510, 524, 539, 556, 574, 595, 614, 633, 653, 673, 683, 708, 727, 748, 764, 775, 789, 802, 818, 835, 846, 858, 868} + + func (i RelocType) String() string { + i -= 1 +diff --git a/src/cmd/link/internal/ld/elf.go b/src/cmd/link/internal/ld/elf.go +index 3fd7140d91..b2b10fbdc0 100644 +--- a/src/cmd/link/internal/ld/elf.go ++++ b/src/cmd/link/internal/ld/elf.go +@@ -229,7 +229,7 @@ func Elfinit(ctxt *Link) { + ehdr.Flags = 0x20000004 /* MIPS 3 CPIC */ + } + if ctxt.Arch.Family == sys.Loong64 { +- ehdr.Flags = 0x3 /* LoongArch lp64d */ ++ ehdr.Flags = 0x43 /* LoongArch ABI v1, lp64d */ + } + if ctxt.Arch.Family == sys.RISCV64 { + ehdr.Flags = 0x4 /* RISCV Float ABI Double */ +diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go +index 2e6e6dd69f..a5ff1ae89c 100644 +--- a/src/cmd/link/internal/ld/lib.go ++++ b/src/cmd/link/internal/ld/lib.go +@@ -795,7 +795,7 @@ func (ctxt *Link) linksetup() { + ctxt.loader.SetAttrReachable(moduledata, true) + ctxt.Moduledata = moduledata + +- if (ctxt.Arch == sys.Arch386 || ctxt.Arch == sys.ArchLoong64) && ctxt.HeadType != objabi.Hwindows { ++ if ctxt.Arch == sys.Arch386 && ctxt.HeadType != objabi.Hwindows { + if (ctxt.BuildMode == BuildModeCArchive && ctxt.IsELF) || ctxt.BuildMode == BuildModeCShared || ctxt.BuildMode == BuildModePIE || ctxt.DynlinkingGo() { + got := ctxt.loader.LookupOrCreateSym("_GLOBAL_OFFSET_TABLE_", 0) + sb := ctxt.loader.MakeSymbolUpdater(got) +diff --git a/src/cmd/link/internal/loong64/asm.go b/src/cmd/link/internal/loong64/asm.go +index 8c65103872..4d36873364 100644 +--- a/src/cmd/link/internal/loong64/asm.go ++++ b/src/cmd/link/internal/loong64/asm.go +@@ -11,6 +11,7 @@ import ( + "cmd/link/internal/loader" + "cmd/link/internal/sym" + "debug/elf" ++ "log" + ) + + func gentext(ctxt *ld.Link, ldr *loader.Loader) { +@@ -23,11 +24,11 @@ func gentext(ctxt *ld.Link, ldr *loader.Loader) { + initfunc.AddUint32(ctxt.Arch, op) + } + +- // 0: pcaddu12i r4, $0 ++ // 0: pcalau12i r4, $0 + // 0: R_ADDRLOONG64U + // 4: addi.d r4, r4, $0 + // 4: R_ADDRLOONG64 +- o(0x1c000004) ++ o(0x1a000004) + rel, _ := initfunc.AddRel(objabi.R_ADDRLOONG64U) + rel.SetOff(0) + rel.SetSiz(4) +@@ -48,7 +49,8 @@ func gentext(ctxt *ld.Link, ldr *loader.Loader) { + } + + func adddynrel(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, s loader.Sym, r loader.Reloc, rIdx int) bool { +- return true ++ log.Fatalf("adddynrel not implemented") ++ return false + } + + func elfreloc1(ctxt *ld.Link, out *ld.OutBuf, ldr *loader.Loader, s loader.Sym, r loader.ExtReloc, ri int, sectoff int64) bool { +@@ -76,201 +78,37 @@ func elfreloc1(ctxt *ld.Link, out *ld.OutBuf, ldr *loader.Loader, s loader.Sym, + } + case objabi.R_ADDRLOONG64TLS: + out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_TLS_TPREL) | uint64(elfsym)<<32) ++ out.Write64(uint64(elf.R_LARCH_TLS_LE_LO12) | uint64(elfsym)<<32) + out.Write64(uint64(r.Xadd)) + +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_ABSOLUTE)) +- out.Write64(uint64(0xfff)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_AND)) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_POP_32_U_10_12)) +- out.Write64(uint64(0x0)) +- + case objabi.R_ADDRLOONG64TLSU: + out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_TLS_TPREL) | uint64(elfsym)<<32) ++ out.Write64(uint64(elf.R_LARCH_TLS_LE_HI20) | uint64(elfsym)<<32) + out.Write64(uint64(r.Xadd)) + +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_ABSOLUTE)) +- out.Write64(uint64(0xc)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_SR)) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_POP_32_S_5_20) | uint64(0)<<32) +- out.Write64(uint64(0x0)) +- + case objabi.R_CALLLOONG64: + out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_PLT_PCREL) | uint64(elfsym)<<32) ++ out.Write64(uint64(elf.R_LARCH_B26) | uint64(elfsym)<<32) + out.Write64(uint64(r.Xadd)) + +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_POP_32_S_0_10_10_16_S2)) +- out.Write64(uint64(0x0)) +- + case objabi.R_LOONG64_TLS_GD_PCREL_HI: +- symgot := ld.ElfSymForReloc(ctxt, ldr.LookupOrCreateSym("_GLOBAL_OFFSET_TABLE_", 0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_PCREL) | uint64(symgot)<<32) +- out.Write64(uint64(0x800)) +- + out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_TLS_GD) | uint64(elfsym)<<32) ++ out.Write64(uint64(elf.R_LARCH_TLS_GD_PC_HI20) | uint64(elfsym)<<32) + out.Write64(uint64(0x0)) + ++ case objabi.R_LOONG64_TLS_GD_LO: + out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_ADD)) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_ABSOLUTE)) +- out.Write64(uint64(0xc)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_SR)) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_POP_32_S_5_20)) +- out.Write64(uint64(0x0)) +- +- case objabi.R_LOONG64_TLS_GD_PCREL_LO: +- symgot := ld.ElfSymForReloc(ctxt, ldr.LookupOrCreateSym("_GLOBAL_OFFSET_TABLE_", 0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_PCREL) | uint64(symgot)<<32) +- out.Write64(uint64(0x4)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_TLS_GD) | uint64(elfsym)<<32) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_ADD)) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_PCREL) | uint64(symgot)<<32) +- out.Write64(uint64(0x804)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_TLS_GD) | uint64(elfsym)<<32) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_ADD)) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_ABSOLUTE)) +- out.Write64(uint64(0xc)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_SR)) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_ABSOLUTE)) +- out.Write64(uint64(0xc)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_SL)) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_SUB)) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_POP_32_S_10_12)) ++ out.Write64(uint64(elf.R_LARCH_GOT_PC_LO12) | uint64(elfsym)<<32) + out.Write64(uint64(0x0)) + + case objabi.R_LOONG64_GOTPCREL_HI: +- symgot := ld.ElfSymForReloc(ctxt, ldr.LookupOrCreateSym("_GLOBAL_OFFSET_TABLE_", 0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_PCREL) | uint64(symgot)<<32) +- out.Write64(uint64(0x800)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_GPREL) | uint64(elfsym)<<32) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_ADD)) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_ABSOLUTE)) +- out.Write64(uint64(0xc)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_SR)) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_POP_32_S_5_20)) +- out.Write64(uint64(0x0)) +- +- case objabi.R_LOONG64_GOTPCREL_LO: +- symgot := ld.ElfSymForReloc(ctxt, ldr.LookupOrCreateSym("_GLOBAL_OFFSET_TABLE_", 0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_PCREL) | uint64(symgot)<<32) +- out.Write64(uint64(0x4)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_GPREL) | uint64(elfsym)<<32) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_ADD)) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_PCREL) | uint64(symgot)<<32) +- out.Write64(uint64(0x804)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_GPREL) | uint64(elfsym)<<32) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_ADD)) +- out.Write64(uint64(0x0)) +- + out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_ABSOLUTE)) +- out.Write64(uint64(0xc)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_SR)) ++ out.Write64(uint64(elf.R_LARCH_GOT_PC_HI20) | uint64(elfsym)<<32) + out.Write64(uint64(0x0)) + ++ case objabi.R_LOONG64_GOT_LO: + out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_ABSOLUTE)) +- out.Write64(uint64(0xc)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_SL)) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_SUB)) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_POP_32_S_10_12)) ++ out.Write64(uint64(elf.R_LARCH_GOT_PC_LO12) | uint64(elfsym)<<32) + out.Write64(uint64(0x0)) + + // The pcaddu12i + addi.d instructions is used to obtain address of a symbol on Loong64. +@@ -280,53 +118,13 @@ func elfreloc1(ctxt *ld.Link, out *ld.OutBuf, ldr *loader.Loader, s loader.Sym, + // width on Loong64 and is used to correct the PC of the addi.d instruction. + case objabi.R_ADDRLOONG64: + out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_PCREL) | uint64(elfsym)<<32) +- out.Write64(uint64(r.Xadd + 0x4)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_PCREL) | uint64(elfsym)<<32) +- out.Write64(uint64(r.Xadd + 0x804)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_ABSOLUTE)) +- out.Write64(uint64(0xc)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_SR)) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_ABSOLUTE)) +- out.Write64(uint64(0xc)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_SL)) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_SUB)) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_POP_32_S_10_12)) +- out.Write64(uint64(0x0)) ++ out.Write64(uint64(elf.R_LARCH_PCALA_LO12) | uint64(elfsym)<<32) ++ out.Write64(uint64(r.Xadd)) + + case objabi.R_ADDRLOONG64U: + out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_PCREL) | uint64(elfsym)<<32) +- out.Write64(uint64(r.Xadd + 0x800)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_PUSH_ABSOLUTE)) +- out.Write64(uint64(0xc)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_SR)) +- out.Write64(uint64(0x0)) +- +- out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_SOP_POP_32_S_5_20) | uint64(0)<<32) +- out.Write64(uint64(0x0)) ++ out.Write64(uint64(elf.R_LARCH_PCALA_HI20) | uint64(elfsym)<<32) ++ out.Write64(uint64(r.Xadd)) + } + + return true +@@ -344,7 +142,6 @@ func archreloc(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, r loade + rs = ldr.ResolveABIAlias(rs) + + if target.IsExternal() { +- nExtReloc := 0 + switch r.Type() { + default: + return val, 0, false +@@ -356,26 +153,18 @@ func archreloc(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, r loade + if rst != sym.SHOSTOBJ && rst != sym.SDYNIMPORT && ldr.SymSect(rs) == nil { + ldr.Errorf(s, "missing section for %s", ldr.SymName(rs)) + } +- nExtReloc = 8 // need two ELF relocations. see elfreloc1 +- if r.Type() == objabi.R_ADDRLOONG64U { +- nExtReloc = 4 +- } +- return val, nExtReloc, true ++ return val, 1, true + case objabi.R_ADDRLOONG64TLS, + objabi.R_ADDRLOONG64TLSU, + objabi.R_CALLLOONG64, + objabi.R_JMPLOONG64: +- nExtReloc = 4 +- if r.Type() == objabi.R_CALLLOONG64 || r.Type() == objabi.R_JMPLOONG64 { +- nExtReloc = 2 +- } +- return val, nExtReloc, true ++ return val, 1, true + case objabi.R_LOONG64_TLS_GD_PCREL_HI, + objabi.R_LOONG64_GOTPCREL_HI: +- return val, 6, true +- case objabi.R_LOONG64_TLS_GD_PCREL_LO, +- objabi.R_LOONG64_GOTPCREL_LO: +- return val, 12, true ++ return val, 1, true ++ case objabi.R_LOONG64_TLS_GD_LO, ++ objabi.R_LOONG64_GOT_LO: ++ return val, 1, true + } + } + +@@ -390,11 +179,11 @@ func archreloc(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, r loade + case objabi.R_ADDRLOONG64, + objabi.R_ADDRLOONG64U: + pc := ldr.SymValue(s) + int64(r.Off()) +- t := ldr.SymAddr(rs) + r.Add() - pc ++ t := calculatePCAlignedReloc(r.Type(), ldr.SymAddr(rs)+r.Add(), pc) + if r.Type() == objabi.R_ADDRLOONG64 { +- return int64(val&0xffc003ff | (((t + 4 - ((t + 4 + 1<<11) >> 12 << 12)) << 10) & 0x3ffc00)), noExtReloc, isOk ++ return int64(val&0xffc003ff | (t << 10)), noExtReloc, isOk + } +- return int64(val&0xfe00001f | (((t + 1<<11) >> 12 << 5) & 0x1ffffe0)), noExtReloc, isOk ++ return int64(val&0xfe00001f | (t << 5)), noExtReloc, isOk + case objabi.R_ADDRLOONG64TLS, + objabi.R_ADDRLOONG64TLSU: + t := ldr.SymAddr(rs) + r.Add() +@@ -420,7 +209,7 @@ func extreloc(target *ld.Target, ldr *loader.Loader, r loader.Reloc, s loader.Sy + switch r.Type() { + case objabi.R_ADDRLOONG64, + objabi.R_LOONG64_GOTPCREL_HI, +- objabi.R_LOONG64_GOTPCREL_LO, ++ objabi.R_LOONG64_GOT_LO, + objabi.R_ADDRLOONG64U: + return ld.ExtrelocViaOuterSym(ldr, r, s), true + +@@ -431,8 +220,39 @@ func extreloc(target *ld.Target, ldr *loader.Loader, r loader.Reloc, s loader.Sy + objabi.R_CALLLOONG64, + objabi.R_JMPLOONG64, + objabi.R_LOONG64_TLS_GD_PCREL_HI, +- objabi.R_LOONG64_TLS_GD_PCREL_LO: ++ objabi.R_LOONG64_TLS_GD_LO: + return ld.ExtrelocSimple(ldr, r), true + } + return loader.ExtReloc{}, false + } ++ ++func isRequestingLowPageBits(t objabi.RelocType) bool { ++ switch t { ++ case objabi.R_ADDRLOONG64: ++ return true ++ } ++ return false ++} ++ ++// Calculates the value to put into the immediate slot, according to the ++// desired relocation type, target and PC. ++// The value to use varies based on the reloc type, because of the arm64-like ++// design of the LoongArch ELF psABI v2 relocs. Namely, the absolute low bits of ++// the target are to be used for the low part, while the page-aligned offset is ++// to be used for the higher part. A "page" here is not related to the system's ++// actual page size, but rather a fixed 12-bit range, just like the semantics of ++// arm64's adrp. ++func calculatePCAlignedReloc(t objabi.RelocType, tgt int64, pc int64) int64 { ++ if isRequestingLowPageBits(t) { ++ // corresponding immediate field is 12 bits wide ++ return tgt & 0xfff ++ } ++ ++ pageDelta := (tgt >> 12) - (pc >> 12) ++ if tgt&0xfff >= 0x800 { ++ // adjust for sign-extended addition of the low bits ++ pageDelta += 1 ++ } ++ // corresponding immediate field is 20 bits wide ++ return pageDelta & 0xfffff ++} +-- +2.38.0 + diff --git a/loongarch64/0093-cmd-link-cmd-internal-in-shared-mode-change-to-use-I.patch b/loongarch64/0093-cmd-link-cmd-internal-in-shared-mode-change-to-use-I.patch new file mode 100644 index 0000000000000000000000000000000000000000..0e6bf605c95a0f01650aded759557ac29d0be041 --- /dev/null +++ b/loongarch64/0093-cmd-link-cmd-internal-in-shared-mode-change-to-use-I.patch @@ -0,0 +1,279 @@ +From ff24c150081b18935652eca7096e7ef61e53b481 Mon Sep 17 00:00:00 2001 +From: Guoqi Chen +Date: Thu, 9 Mar 2023 20:42:05 +0800 +Subject: [PATCH 12/18] cmd/link, cmd/internal: in shared mode, change to use + IE mode to access TLS variables + +Signed-off-by: Guoqi Chen +Change-Id: I878323a18ac4e03e02f952c2e6972bdc26df1612 +--- + src/cmd/dist/test.go | 2 +- + src/cmd/internal/obj/loong64/a.out.go | 2 +- + src/cmd/internal/obj/loong64/asm.go | 82 +++++++-------------- + src/cmd/internal/obj/loong64/cnames.go | 2 +- + src/cmd/internal/objabi/reloctype.go | 10 +-- + src/cmd/internal/objabi/reloctype_string.go | 6 +- + src/cmd/link/internal/loong64/asm.go | 16 ++-- + 7 files changed, 46 insertions(+), 74 deletions(-) + +diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go +index dc1b18906b..209e88888e 100644 +--- a/src/cmd/dist/test.go ++++ b/src/cmd/dist/test.go +@@ -1176,7 +1176,7 @@ func (t *tester) cgoTest(dt *distTest) error { + "android-arm", "android-arm64", + "dragonfly-amd64", + "freebsd-386", "freebsd-amd64", "freebsd-arm", +- "linux-386", "linux-amd64", "linux-arm", "linux-arm64", "linux-ppc64le", "linux-riscv64", "linux-s390x", ++ "linux-386", "linux-amd64", "linux-arm", "linux-arm64", "linux-loong64", "linux-ppc64le", "linux-riscv64", "linux-s390x", + "netbsd-386", "netbsd-amd64", + "openbsd-386", "openbsd-amd64", "openbsd-arm", "openbsd-arm64", "openbsd-mips64": + +diff --git a/src/cmd/internal/obj/loong64/a.out.go b/src/cmd/internal/obj/loong64/a.out.go +index 5fd7b28ff8..fe759bbdb7 100644 +--- a/src/cmd/internal/obj/loong64/a.out.go ++++ b/src/cmd/internal/obj/loong64/a.out.go +@@ -226,7 +226,7 @@ const ( + C_GOK + C_ADDR + C_TLS_LE +- C_TLS_GD ++ C_TLS_IE + C_GOTADDR + C_TEXTSIZE + +diff --git a/src/cmd/internal/obj/loong64/asm.go b/src/cmd/internal/obj/loong64/asm.go +index 9d81569b73..ea43dc7743 100644 +--- a/src/cmd/internal/obj/loong64/asm.go ++++ b/src/cmd/internal/obj/loong64/asm.go +@@ -326,17 +326,17 @@ var optab = []Optab{ + {AMOVW, C_ADDCON, C_NONE, C_FREG, 34, 8, 0, sys.Loong64, 0}, + {AMOVW, C_ANDCON, C_NONE, C_FREG, 34, 8, 0, sys.Loong64, 0}, + +- {AMOVB, C_REG, C_NONE, C_TLS_GD, 56, 24, 0, sys.Loong64, 0}, +- {AMOVW, C_REG, C_NONE, C_TLS_GD, 56, 24, 0, sys.Loong64, 0}, +- {AMOVV, C_REG, C_NONE, C_TLS_GD, 56, 24, 0, sys.Loong64, 0}, +- {AMOVBU, C_REG, C_NONE, C_TLS_GD, 56, 24, 0, sys.Loong64, 0}, +- {AMOVWU, C_REG, C_NONE, C_TLS_GD, 56, 24, 0, sys.Loong64, 0}, +- +- {AMOVB, C_TLS_GD, C_NONE, C_REG, 57, 24, 0, sys.Loong64, 0}, +- {AMOVW, C_TLS_GD, C_NONE, C_REG, 57, 24, 0, sys.Loong64, 0}, +- {AMOVV, C_TLS_GD, C_NONE, C_REG, 57, 24, 0, sys.Loong64, 0}, +- {AMOVBU, C_TLS_GD, C_NONE, C_REG, 57, 24, 0, sys.Loong64, 0}, +- {AMOVWU, C_TLS_GD, C_NONE, C_REG, 57, 24, 0, sys.Loong64, 0}, ++ {AMOVB, C_REG, C_NONE, C_TLS_IE, 56, 16, 0, sys.Loong64, 0}, ++ {AMOVW, C_REG, C_NONE, C_TLS_IE, 56, 16, 0, sys.Loong64, 0}, ++ {AMOVV, C_REG, C_NONE, C_TLS_IE, 56, 16, 0, sys.Loong64, 0}, ++ {AMOVBU, C_REG, C_NONE, C_TLS_IE, 56, 16, 0, sys.Loong64, 0}, ++ {AMOVWU, C_REG, C_NONE, C_TLS_IE, 56, 16, 0, sys.Loong64, 0}, ++ ++ {AMOVB, C_TLS_IE, C_NONE, C_REG, 57, 16, 0, sys.Loong64, 0}, ++ {AMOVW, C_TLS_IE, C_NONE, C_REG, 57, 16, 0, sys.Loong64, 0}, ++ {AMOVV, C_TLS_IE, C_NONE, C_REG, 57, 16, 0, sys.Loong64, 0}, ++ {AMOVBU, C_TLS_IE, C_NONE, C_REG, 57, 16, 0, sys.Loong64, 0}, ++ {AMOVWU, C_TLS_IE, C_NONE, C_REG, 57, 16, 0, sys.Loong64, 0}, + + {AMOVV, C_GOTADDR, C_NONE, C_REG, 63, 8, 0, sys.Loong64, 0}, + +@@ -558,7 +558,7 @@ func (c *ctxt0) aclass(a *obj.Addr) int { + if a.Sym != nil { // use relocation + if a.Sym.Type == objabi.STLSBSS { + if c.ctxt.Flag_shared { +- return C_TLS_GD ++ return C_TLS_IE + } else { + return C_TLS_LE + } +@@ -1606,69 +1606,41 @@ func (c *ctxt0) asmout(p *obj.Prog, o *Optab, out []uint32) { + rel2.Type = objabi.R_ADDRLOONG64TLS + o3 = OP_RRR(c.oprrr(AADDV), uint32(REG_R2), uint32(REGTMP), uint32(p.To.Reg)) + +- case 56: // mov r, tlsvar GD model ==> (pcalau12i + ld.d)__tls_get_addr + (pcalau12i + addi.d)tlsvar@got + jirl + st.d ++ case 56: // mov r, tlsvar IE model ==> (pcalau12i + ld.d)tlsvar@got + add.d + st.d + o1 = OP_IR(c.opir(APCALAU12I), uint32(0), uint32(REGTMP)) + rel := obj.Addrel(c.cursym) + rel.Off = int32(c.pc) + rel.Siz = 4 +- rel.Sym = c.ctxt.Lookup("__tls_get_addr") ++ rel.Sym = p.To.Sym + rel.Add = 0x0 +- rel.Type = objabi.R_LOONG64_GOTPCREL_HI ++ rel.Type = objabi.R_LOONG64_TLS_IE_PCREL_HI + o2 = OP_12IRR(c.opirr(-p.As), uint32(0), uint32(REGTMP), uint32(REGTMP)) + rel2 := obj.Addrel(c.cursym) + rel2.Off = int32(c.pc + 4) + rel2.Siz = 4 +- rel2.Sym = c.ctxt.Lookup("__tls_get_addr") ++ rel2.Sym = p.To.Sym + rel2.Add = 0x0 +- rel2.Type = objabi.R_LOONG64_GOT_LO +- o3 = OP_IR(c.opir(APCALAU12I), uint32(0), uint32(REG_R4)) +- rel3 := obj.Addrel(c.cursym) +- rel3.Off = int32(c.pc + 8) +- rel3.Siz = 4 +- rel3.Sym = p.To.Sym +- rel3.Add = 0x0 +- rel3.Type = objabi.R_LOONG64_TLS_GD_PCREL_HI +- o4 = OP_12IRR(c.opirr(AADDV), uint32(0), uint32(REG_R4), uint32(REG_R4)) +- rel4 := obj.Addrel(c.cursym) +- rel4.Off = int32(c.pc + 12) +- rel4.Siz = 4 +- rel4.Sym = p.To.Sym +- rel4.Add = 0x0 +- rel4.Type = objabi.R_LOONG64_TLS_GD_LO +- o5 = OP_16IRR(c.opirr(AJIRL), uint32(0), uint32(REGTMP), uint32(REGLINK)) +- o6 = OP_12IRR(c.opirr(p.As), uint32(0), uint32(REG_R4), uint32(p.From.Reg)) +- +- case 57: // mov tlsvar, r GD model ==> (pcalau12i + ld.d)__tls_get_addr + (pcalau12i + addi.d)tlsvar@got + jirl + ld.d ++ rel2.Type = objabi.R_LOONG64_TLS_IE_LO ++ o3 = OP_RRR(c.oprrr(AADDVU), uint32(REGTMP), uint32(REG_R2), uint32(REGTMP)) ++ o4 = OP_12IRR(c.opirr(p.As), uint32(0), uint32(REGTMP), uint32(p.From.Reg)) ++ ++ case 57: // mov tlsvar, r IE model ==> (pcalau12i + ld.d)tlsvar@got + add.d + ld.d + o1 = OP_IR(c.opir(APCALAU12I), uint32(0), uint32(REGTMP)) + rel := obj.Addrel(c.cursym) + rel.Off = int32(c.pc) + rel.Siz = 4 +- rel.Sym = c.ctxt.Lookup("__tls_get_addr") ++ rel.Sym = p.From.Sym + rel.Add = 0x0 +- rel.Type = objabi.R_LOONG64_GOTPCREL_HI ++ rel.Type = objabi.R_LOONG64_TLS_IE_PCREL_HI + o2 = OP_12IRR(c.opirr(-p.As), uint32(0), uint32(REGTMP), uint32(REGTMP)) + rel2 := obj.Addrel(c.cursym) + rel2.Off = int32(c.pc + 4) + rel2.Siz = 4 +- rel2.Sym = c.ctxt.Lookup("__tls_get_addr") ++ rel2.Sym = p.From.Sym + rel2.Add = 0x0 +- rel2.Type = objabi.R_LOONG64_GOT_LO +- o3 = OP_IR(c.opir(APCALAU12I), uint32(0), uint32(REG_R4)) +- rel3 := obj.Addrel(c.cursym) +- rel3.Off = int32(c.pc + 8) +- rel3.Siz = 4 +- rel3.Sym = p.From.Sym +- rel3.Type = objabi.R_LOONG64_TLS_GD_PCREL_HI +- rel3.Add = 0x0 +- o4 = OP_12IRR(c.opirr(AADDV), uint32(0), uint32(REG_R4), uint32(REG_R4)) +- rel4 := obj.Addrel(c.cursym) +- rel4.Off = int32(c.pc + 12) +- rel4.Siz = 4 +- rel4.Sym = p.From.Sym +- rel4.Type = objabi.R_LOONG64_TLS_GD_LO +- rel4.Add = 0x0 +- o5 = OP_16IRR(c.opirr(AJIRL), uint32(0), uint32(REGTMP), uint32(REGLINK)) +- o6 = OP_12IRR(c.opirr(-p.As), uint32(0), uint32(REG_R4), uint32(p.To.Reg)) ++ rel2.Type = objabi.R_LOONG64_TLS_IE_LO ++ o3 = OP_RRR(c.oprrr(AADDVU), uint32(REGTMP), uint32(REG_R2), uint32(REGTMP)) ++ o4 = OP_12IRR(c.opirr(-p.As), uint32(0), uint32(REGTMP), uint32(p.To.Reg)) + + case 59: // mov $dcon,r + // NOTE: this case does not use REGTMP. If it ever does, +diff --git a/src/cmd/internal/obj/loong64/cnames.go b/src/cmd/internal/obj/loong64/cnames.go +index b0b4f78c72..c71bb91bd7 100644 +--- a/src/cmd/internal/obj/loong64/cnames.go ++++ b/src/cmd/internal/obj/loong64/cnames.go +@@ -38,7 +38,7 @@ var cnames0 = []string{ + "GOK", + "ADDR", + "TLS_LE", +- "TLS_GD", ++ "TLS_IE", + "GOTADDR", + "TEXTSIZE", + "NCLASS", +diff --git a/src/cmd/internal/objabi/reloctype.go b/src/cmd/internal/objabi/reloctype.go +index 0e20d05e4d..e387412067 100644 +--- a/src/cmd/internal/objabi/reloctype.go ++++ b/src/cmd/internal/objabi/reloctype.go +@@ -249,11 +249,11 @@ const ( + + // Loong64. + +- // R_LOONG64_TLS_GD_PCREL_HI and R_LOONG64_TLS_GD_PCREL_LO relocates an pcalau12i, addi.d pair to compute +- // the address of the GOT slot of the tls symbol, the address will be passed to __tls_get_addr to +- // get the true address of tlsvar. +- R_LOONG64_TLS_GD_PCREL_HI +- R_LOONG64_TLS_GD_LO ++ // R_LOONG64_TLS_IE_PCREL_HI and R_LOONG64_TLS_IE_LO relocates an pcalau12i, ld.d pair to compute ++ // the address of the GOT slot of the tls symbol, the tp register plus the offset to get the real address ++ // of the tlsvar. ++ R_LOONG64_TLS_IE_PCREL_HI ++ R_LOONG64_TLS_IE_LO + + // R_LOONG64_GOTPCREL_HI and R_LOONG64_GOTPCREL_LO relocates an pcalau12i, addi.d pair to compute + // the address of the GOT slot of the referenced symbol. +diff --git a/src/cmd/internal/objabi/reloctype_string.go b/src/cmd/internal/objabi/reloctype_string.go +index ff8c72c013..a0a7a1b9ee 100644 +--- a/src/cmd/internal/objabi/reloctype_string.go ++++ b/src/cmd/internal/objabi/reloctype_string.go +@@ -66,8 +66,8 @@ func _() { + _ = x[R_RISCV_TLS_IE_ITYPE-56] + _ = x[R_RISCV_TLS_IE_STYPE-57] + _ = x[R_PCRELDBL-58] +- _ = x[R_LOONG64_TLS_GD_PCREL_HI-59] +- _ = x[R_LOONG64_TLS_GD_LO-60] ++ _ = x[R_LOONG64_TLS_IE_PCREL_HI-59] ++ _ = x[R_LOONG64_TLS_IE_LO-60] + _ = x[R_LOONG64_GOTPCREL_HI-61] + _ = x[R_LOONG64_GOT_LO-62] + _ = x[R_ADDRMIPSU-63] +@@ -80,7 +80,7 @@ func _() { + _ = x[R_XCOFFREF-70] + } + +-const _RelocType_name = "R_ADDRR_ADDRPOWERR_ADDRARM64R_ADDRMIPSR_ADDRLOONG64R_ADDROFFR_SIZER_CALLR_CALLARMR_CALLARM64R_CALLINDR_CALLPOWERR_CALLMIPSR_CALLRISCVR_CALLLOONG64R_CONSTR_PCRELR_TLS_LER_TLS_IER_GOTOFFR_PLT0R_PLT1R_PLT2R_USEFIELDR_USETYPER_USEIFACER_USEIFACEMETHODR_METHODOFFR_KEEPR_POWER_TOCR_GOTPCRELR_JMPMIPSR_JMPLOONG64R_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_PCREL_ITYPER_RISCV_PCREL_STYPER_RISCV_TLS_IE_ITYPER_RISCV_TLS_IE_STYPER_PCRELDBLR_LOONG64_TLS_GD_PCREL_HIR_LOONG64_TLS_GD_LOR_LOONG64_GOTPCREL_HIR_LOONG64_GOT_LOR_ADDRMIPSUR_ADDRLOONG64UR_ADDRMIPSTLSR_ADDRLOONG64TLSR_ADDRLOONG64TLSUR_ADDRCUOFFR_WASMIMPORTR_XCOFFREF" ++const _RelocType_name = "R_ADDRR_ADDRPOWERR_ADDRARM64R_ADDRMIPSR_ADDRLOONG64R_ADDROFFR_SIZER_CALLR_CALLARMR_CALLARM64R_CALLINDR_CALLPOWERR_CALLMIPSR_CALLRISCVR_CALLLOONG64R_CONSTR_PCRELR_TLS_LER_TLS_IER_GOTOFFR_PLT0R_PLT1R_PLT2R_USEFIELDR_USETYPER_USEIFACER_USEIFACEMETHODR_METHODOFFR_KEEPR_POWER_TOCR_GOTPCRELR_JMPMIPSR_JMPLOONG64R_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_PCREL_ITYPER_RISCV_PCREL_STYPER_RISCV_TLS_IE_ITYPER_RISCV_TLS_IE_STYPER_PCRELDBLR_LOONG64_TLS_IE_PCREL_HIR_LOONG64_TLS_IE_LOR_LOONG64_GOTPCREL_HIR_LOONG64_GOT_LOR_ADDRMIPSUR_ADDRLOONG64UR_ADDRMIPSTLSR_ADDRLOONG64TLSR_ADDRLOONG64TLSUR_ADDRCUOFFR_WASMIMPORTR_XCOFFREF" + + var _RelocType_index = [...]uint16{0, 6, 17, 28, 38, 51, 60, 66, 72, 81, 92, 101, 112, 122, 133, 146, 153, 160, 168, 176, 184, 190, 196, 202, 212, 221, 231, 247, 258, 264, 275, 285, 294, 306, 319, 333, 347, 361, 377, 388, 401, 414, 428, 442, 456, 471, 485, 499, 510, 524, 539, 556, 574, 595, 614, 633, 653, 673, 683, 708, 727, 748, 764, 775, 789, 802, 818, 835, 846, 858, 868} + +diff --git a/src/cmd/link/internal/loong64/asm.go b/src/cmd/link/internal/loong64/asm.go +index 4d36873364..b1a5d6cfff 100644 +--- a/src/cmd/link/internal/loong64/asm.go ++++ b/src/cmd/link/internal/loong64/asm.go +@@ -91,14 +91,14 @@ func elfreloc1(ctxt *ld.Link, out *ld.OutBuf, ldr *loader.Loader, s loader.Sym, + out.Write64(uint64(elf.R_LARCH_B26) | uint64(elfsym)<<32) + out.Write64(uint64(r.Xadd)) + +- case objabi.R_LOONG64_TLS_GD_PCREL_HI: ++ case objabi.R_LOONG64_TLS_IE_PCREL_HI: + out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_TLS_GD_PC_HI20) | uint64(elfsym)<<32) ++ out.Write64(uint64(elf.R_LARCH_TLS_IE_PC_HI20) | uint64(elfsym)<<32) + out.Write64(uint64(0x0)) + +- case objabi.R_LOONG64_TLS_GD_LO: ++ case objabi.R_LOONG64_TLS_IE_LO: + out.Write64(uint64(sectoff)) +- out.Write64(uint64(elf.R_LARCH_GOT_PC_LO12) | uint64(elfsym)<<32) ++ out.Write64(uint64(elf.R_LARCH_TLS_IE_PC_LO12) | uint64(elfsym)<<32) + out.Write64(uint64(0x0)) + + case objabi.R_LOONG64_GOTPCREL_HI: +@@ -159,10 +159,10 @@ func archreloc(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, r loade + objabi.R_CALLLOONG64, + objabi.R_JMPLOONG64: + return val, 1, true +- case objabi.R_LOONG64_TLS_GD_PCREL_HI, ++ case objabi.R_LOONG64_TLS_IE_PCREL_HI, + objabi.R_LOONG64_GOTPCREL_HI: + return val, 1, true +- case objabi.R_LOONG64_TLS_GD_LO, ++ case objabi.R_LOONG64_TLS_IE_LO, + objabi.R_LOONG64_GOT_LO: + return val, 1, true + } +@@ -219,8 +219,8 @@ func extreloc(target *ld.Target, ldr *loader.Loader, r loader.Reloc, s loader.Sy + objabi.R_GOTOFF, + objabi.R_CALLLOONG64, + objabi.R_JMPLOONG64, +- objabi.R_LOONG64_TLS_GD_PCREL_HI, +- objabi.R_LOONG64_TLS_GD_LO: ++ objabi.R_LOONG64_TLS_IE_PCREL_HI, ++ objabi.R_LOONG64_TLS_IE_LO: + return ld.ExtrelocSimple(ldr, r), true + } + return loader.ExtReloc{}, false +-- +2.38.0 + diff --git a/loongarch64/0094-enable-c-archive-test-on-linux-loong64.patch b/loongarch64/0094-enable-c-archive-test-on-linux-loong64.patch new file mode 100644 index 0000000000000000000000000000000000000000..4b93c3e37afd34bbcdf3599e2fa256aca6a7c31c --- /dev/null +++ b/loongarch64/0094-enable-c-archive-test-on-linux-loong64.patch @@ -0,0 +1,28 @@ +From f07d39f85e1ffdbb0539a8041f17d5aa5eebaab3 Mon Sep 17 00:00:00 2001 +From: Xiaolin Zhao +Date: Fri, 10 Mar 2023 11:24:28 +0800 +Subject: [PATCH 13/18] enable c-archive test on linux/loong64 + +Since c-shared is already supported, c-archive can be used. + +Change-Id: Ia704f4fc67992f7773f03f0c6efdf63a149bac93 +--- + src/cmd/dist/test.go | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go +index 209e88888e..5a7c188ab9 100644 +--- a/src/cmd/dist/test.go ++++ b/src/cmd/dist/test.go +@@ -1045,7 +1045,7 @@ func (t *tester) supportedBuildmode(mode string) bool { + switch pair { + case "aix-ppc64", + "darwin-amd64", "darwin-arm64", "ios-arm64", +- "linux-amd64", "linux-386", "linux-ppc64le", "linux-s390x", ++ "linux-amd64", "linux-386", "linux-loong64", "linux-ppc64le", "linux-s390x", + "freebsd-amd64", + "windows-amd64", "windows-386": + return true +-- +2.38.0 + diff --git a/loongarch64/0095-runtime-no-need-to-save-these-registers-in-load_g-sa.patch b/loongarch64/0095-runtime-no-need-to-save-these-registers-in-load_g-sa.patch new file mode 100644 index 0000000000000000000000000000000000000000..9a0b2b4cbb9bd34c80f05a55fdb95a60c7b49217 --- /dev/null +++ b/loongarch64/0095-runtime-no-need-to-save-these-registers-in-load_g-sa.patch @@ -0,0 +1,80 @@ +From b8b2dabfd108c951d0a605582cee622407e5b7d6 Mon Sep 17 00:00:00 2001 +From: limeidan +Date: Fri, 10 Mar 2023 10:49:08 +0800 +Subject: [PATCH 14/18] runtime: no need to save these registers in + load_g&save_g + +Change-Id: I69d7db05010e61e76fbbfb89ee8c4b90393f1367 +(cherry picked from commit e334b261ab666ad9e985a052dab64b01ef71596d) +--- + src/runtime/tls_loong64.s | 42 --------------------------------------- + 1 file changed, 42 deletions(-) + +diff --git a/src/runtime/tls_loong64.s b/src/runtime/tls_loong64.s +index ee3be31afd..dc244bc3b8 100644 +--- a/src/runtime/tls_loong64.s ++++ b/src/runtime/tls_loong64.s +@@ -2,60 +2,18 @@ + // Use of this source code is governed by a BSD-style + // license that can be found in the LICENSE file. + +-// +build loong64 +- +-#include "go_asm.h" +-#include "go_tls.h" +-#include "funcdata.h" + #include "textflag.h" + + // If !iscgo, this is a no-op. +-// +-// NOTE: mcall() assumes this clobbers only R30 (REGTMP). + TEXT runtime·save_g(SB),NOSPLIT,$0-0 + MOVB runtime·iscgo(SB), R30 + BEQ R30, nocgo +- +- // here use the func __tls_get_addr to get the address of tls_g, which clobbers these regs below. +- ADDV $-56, R3 +- MOVV R1, 0(R3) +- MOVV R4, 8(R3) +- MOVV R5, 16(R3) +- MOVV R6, 24(R3) +- MOVV R12, 32(R3) +- MOVV R13, 40(R3) +- MOVV R30, 48(R3) + MOVV g, runtime·tls_g(SB) +- MOVV 0(R3), R1 +- MOVV 8(R3), R4 +- MOVV 16(R3), R5 +- MOVV 24(R3), R6 +- MOVV 32(R3), R12 +- MOVV 40(R3), R13 +- MOVV 48(R3), R30 +- ADDV $56, R3 +- + nocgo: + RET + + TEXT runtime·load_g(SB),NOSPLIT,$0-0 +- ADDV $-56, R3 +- MOVV R1, 0(R3) +- MOVV R4, 8(R3) +- MOVV R5, 16(R3) +- MOVV R6, 24(R3) +- MOVV R12, 32(R3) +- MOVV R13, 40(R3) +- MOVV R30, 48(R3) + MOVV runtime·tls_g(SB), g +- MOVV 0(R3), R1 +- MOVV 8(R3), R4 +- MOVV 16(R3), R5 +- MOVV 24(R3), R6 +- MOVV 32(R3), R12 +- MOVV 40(R3), R13 +- MOVV 48(R3), R30 +- ADDV $56, R3 + RET + + GLOBL runtime·tls_g(SB), TLSBSS, $8 +-- +2.38.0 + diff --git a/loongarch64/0096-cmd-internal-obj-loong64-add-support-for-movgr2cf-an.patch b/loongarch64/0096-cmd-internal-obj-loong64-add-support-for-movgr2cf-an.patch new file mode 100644 index 0000000000000000000000000000000000000000..e10ffd51ba48a8d3507c3db5fc7b7ebdb530d189 --- /dev/null +++ b/loongarch64/0096-cmd-internal-obj-loong64-add-support-for-movgr2cf-an.patch @@ -0,0 +1,53 @@ +From 7c39a1b31fb55c3dc44b1ac05045808299a4d509 Mon Sep 17 00:00:00 2001 +From: huangqiqi +Date: Thu, 16 Mar 2023 12:20:22 +0800 +Subject: [PATCH 15/18] cmd/internal/obj/loong64: add support for movgr2cf and + movcf2gr instructions + +Change-Id: Id12fcc7481c325545a17c52f7d4684f731bca9e3 +--- + src/cmd/asm/internal/asm/testdata/loong64enc1.s | 3 +++ + src/cmd/internal/obj/loong64/asm.go | 9 +++++++++ + 2 files changed, 12 insertions(+) + +diff --git a/src/cmd/asm/internal/asm/testdata/loong64enc1.s b/src/cmd/asm/internal/asm/testdata/loong64enc1.s +index 7e34cc056d..f10bdbc15e 100644 +--- a/src/cmd/asm/internal/asm/testdata/loong64enc1.s ++++ b/src/cmd/asm/internal/asm/testdata/loong64enc1.s +@@ -222,3 +222,6 @@ lable2: + RDTIMELW R4, R0 // 80600000 + RDTIMEHW R4, R0 // 80640000 + RDTIMED R4, R5 // 85680000 ++ ++ MOVV FCC0, R4 // 04dc1401 ++ MOVV R4, FCC0 // 80d81401 +diff --git a/src/cmd/internal/obj/loong64/asm.go b/src/cmd/internal/obj/loong64/asm.go +index ea43dc7743..ec7f6c9617 100644 +--- a/src/cmd/internal/obj/loong64/asm.go ++++ b/src/cmd/internal/obj/loong64/asm.go +@@ -323,6 +323,9 @@ var optab = []Optab{ + {AMOVV, C_REG, C_NONE, C_FREG, 47, 4, 0, sys.Loong64, 0}, + {AMOVV, C_FREG, C_NONE, C_REG, 48, 4, 0, sys.Loong64, 0}, + ++ {AMOVV, C_FCCREG, C_NONE, C_REG, 64, 4, 0, sys.Loong64, 0}, ++ {AMOVV, C_REG, C_NONE, C_FCCREG, 65, 4, 0, sys.Loong64, 0}, ++ + {AMOVW, C_ADDCON, C_NONE, C_FREG, 34, 8, 0, sys.Loong64, 0}, + {AMOVW, C_ANDCON, C_NONE, C_FREG, 34, 8, 0, sys.Loong64, 0}, + +@@ -1685,6 +1688,12 @@ func (c *ctxt0) asmout(p *obj.Prog, o *Optab, out []uint32) { + rel2.Sym = p.From.Sym + rel2.Type = objabi.R_LOONG64_GOT_LO + rel2.Add = 0x0 ++ case 64: // movv c_fcc0, c_reg ==> movcf2gr rd, cj ++ a := OP_TEN(8, 1335) ++ o1 = OP_RR(a, uint32(p.From.Reg), uint32(p.To.Reg)) ++ case 65: // movv c_reg, c_fcc0 ==> movgr2cf cd, rj ++ a := OP_TEN(8, 1334) ++ o1 = OP_RR(a, uint32(p.From.Reg), uint32(p.To.Reg)) + } + + out[0] = o1 +-- +2.38.0 + diff --git a/loongarch64/0097-runtime-save-and-restore-fcc-registers-in-async-pree.patch b/loongarch64/0097-runtime-save-and-restore-fcc-registers-in-async-pree.patch new file mode 100644 index 0000000000000000000000000000000000000000..581687d3571969c74ae8e2f792579c362ea42387 --- /dev/null +++ b/loongarch64/0097-runtime-save-and-restore-fcc-registers-in-async-pree.patch @@ -0,0 +1,72 @@ +From f3b041504eec3e78eab4ee42147f9834b610d84d Mon Sep 17 00:00:00 2001 +From: huangqiqi +Date: Thu, 16 Mar 2023 12:13:15 +0800 +Subject: [PATCH 16/18] runtime: save and restore fcc registers in async + preempt on loong64 + +During the context switch of goroutine scheduling, the value of the +fcc0 register needs to be saved on the stack. + +Change-Id: I1b4d82338841fb562ad13f7b25e274ba9fd87956 +--- + src/runtime/mkpreempt.go | 6 ++++++ + src/runtime/preempt_loong64.s | 12 ++++++++---- + 2 files changed, 14 insertions(+), 4 deletions(-) + +diff --git a/src/runtime/mkpreempt.go b/src/runtime/mkpreempt.go +index 7f74d54289..13f56d0fbb 100644 +--- a/src/runtime/mkpreempt.go ++++ b/src/runtime/mkpreempt.go +@@ -476,6 +476,12 @@ func genLoong64() { + l.add(movf, reg, regsize) + } + ++ // save and restore FCC0 ++ l.addSpecial( ++ mov+" FCC0, R4\n"+mov+" R4, %d(R3)", ++ mov+" %d(R3), R4\n"+mov+" R4, FCC0", ++ regsize) ++ + // allocate frame, save PC of interrupted instruction (in LR) + p(mov+" R1, -%d(R3)", l.stack) + p(sub+" $%d, R3", l.stack) +diff --git a/src/runtime/preempt_loong64.s b/src/runtime/preempt_loong64.s +index 363959eeb4..8e90425a42 100644 +--- a/src/runtime/preempt_loong64.s ++++ b/src/runtime/preempt_loong64.s +@@ -4,8 +4,8 @@ + #include "textflag.h" + + TEXT ·asyncPreempt(SB),NOSPLIT|NOFRAME,$0-0 +- MOVV R1, -472(R3) +- SUBV $472, R3 ++ MOVV R1, -480(R3) ++ SUBV $480, R3 + MOVV R4, 8(R3) + MOVV R5, 16(R3) + MOVV R6, 24(R3) +@@ -64,7 +64,11 @@ TEXT ·asyncPreempt(SB),NOSPLIT|NOFRAME,$0-0 + MOVD F29, 448(R3) + MOVD F30, 456(R3) + MOVD F31, 464(R3) ++ MOVV FCC0, R4 ++ MOVV R4, 472(R3) + CALL ·asyncPreempt2(SB) ++ MOVV 472(R3), R4 ++ MOVV R4, FCC0 + MOVD 464(R3), F31 + MOVD 456(R3), F30 + MOVD 448(R3), F29 +@@ -123,7 +127,7 @@ TEXT ·asyncPreempt(SB),NOSPLIT|NOFRAME,$0-0 + MOVV 24(R3), R6 + MOVV 16(R3), R5 + MOVV 8(R3), R4 +- MOVV 472(R3), R1 ++ MOVV 480(R3), R1 + MOVV (R3), R30 +- ADDV $480, R3 ++ ADDV $488, R3 + JMP (R30) +-- +2.38.0 + diff --git a/loongarch64/0098-cmd-cmd-vendor-pick-up-updates-for-golang.org-x-arch.patch b/loongarch64/0098-cmd-cmd-vendor-pick-up-updates-for-golang.org-x-arch.patch new file mode 100644 index 0000000000000000000000000000000000000000..4ea1abfa50ca4c6a5b0e28c45bc161017b3806c9 --- /dev/null +++ b/loongarch64/0098-cmd-cmd-vendor-pick-up-updates-for-golang.org-x-arch.patch @@ -0,0 +1,2250 @@ +From c6c23ff2886d63cbe3d77af04c1c505fb5182657 Mon Sep 17 00:00:00 2001 +From: Xiaodong Liu +Date: Fri, 10 Feb 2023 15:00:12 +0800 +Subject: [PATCH 17/18] cmd,cmd/vendor: pick up updates for + golang.org/x/arch/loong64 + +Bring in updates to golang.org/x/arch/ to support loong64 disassembler +from CL 358854. + + Used the directions found in README.vendor: + + cd $GOROOT/src/cmd + go get -d golang.org/x/arch@latest + go mod tidy + go mod vendor + +Change-Id: I448f653ca8d530303d0cd05fba1c380b3e0cd6f2 +--- + .../x/arch/loong64/loong64asm/arg.go | 93 + + .../x/arch/loong64/loong64asm/decode.go | 269 +++ + .../x/arch/loong64/loong64asm/gnu.go | 16 + + .../x/arch/loong64/loong64asm/inst.go | 296 ++++ + .../x/arch/loong64/loong64asm/tables.go | 1513 +++++++++++++++++ + 5 files changed, 2187 insertions(+) + create mode 100644 src/cmd/vendor/golang.org/x/arch/loong64/loong64asm/arg.go + create mode 100644 src/cmd/vendor/golang.org/x/arch/loong64/loong64asm/decode.go + create mode 100644 src/cmd/vendor/golang.org/x/arch/loong64/loong64asm/gnu.go + create mode 100644 src/cmd/vendor/golang.org/x/arch/loong64/loong64asm/inst.go + create mode 100644 src/cmd/vendor/golang.org/x/arch/loong64/loong64asm/tables.go + +diff --git a/src/cmd/vendor/golang.org/x/arch/loong64/loong64asm/arg.go b/src/cmd/vendor/golang.org/x/arch/loong64/loong64asm/arg.go +new file mode 100644 +index 0000000000..9496e8c34d +--- /dev/null ++++ b/src/cmd/vendor/golang.org/x/arch/loong64/loong64asm/arg.go +@@ -0,0 +1,93 @@ ++// 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 loong64asm ++ ++// Naming for Go decoder arguments: ++// ++// - arg_fd: a Floating Point operand register fd encoded in the fd[4:0] field ++// ++// - arg_fj: a Floating Point operand register fj encoded in the fj[9:5] field ++// ++// - arg_fk: a Floating Point operand register fk encoded in the fk[14:10] field ++// ++// - arg_fa: a Floating Point operand register fa encoded in the fa[19:15] field ++// ++// - arg_rd: a general-purpose register rd encoded in the rd[4:0] field ++// ++// - arg_rj: a general-purpose register rj encoded in the rj[9:5] field ++// ++// - arg_rk: a general-purpose register rk encoded in the rk[14:10] field ++// ++// - arg_fcsr_4_0: float control status register encoded in [4:0] field ++// ++// - arg_cd_2_0: condition flag register encoded in [2:0] field ++// ++// - arg_sa2_16_15: shift bits constant encoded in [16:15] field ++// ++// - arg_code_14_0: arg for exception process routine encoded in [14:0] field ++// ++// - arg_ui5_14_10: 5bits unsigned immediate ++// ++// - arg_lsbw: For details, please refer to chapter 2.2.3.8 of instruction manual ++// ++// - arg_msbw: For details, please refer to chapter 2.2.3.9 of instruction manual ++// ++// - arg_hint_4_0: hint field implied the prefetch type and the data should fetch to cache's level ++// 0: load to data cache level 1 ++// 8: store to data cache level 1 ++// other: no define ++// ++// - arg_si12_21_10: 12bits signed immediate ++ ++type instArg uint16 ++ ++const ( ++ _ instArg = iota ++ //1-5 ++ arg_fd ++ arg_fj ++ arg_fk ++ arg_fa ++ arg_rd ++ //6-10 ++ arg_rj ++ arg_rk ++ arg_op_4_0 ++ arg_fcsr_4_0 ++ arg_fcsr_9_5 ++ //11-15 ++ arg_csr_23_10 ++ arg_cd ++ arg_cj ++ arg_ca ++ arg_sa2_16_15 ++ //16-20 ++ arg_sa3_17_15 ++ arg_code_4_0 ++ arg_code_14_0 ++ arg_ui5_14_10 ++ arg_ui6_15_10 ++ //21-25 ++ arg_ui12_21_10 ++ arg_lsbw ++ arg_msbw ++ arg_lsbd ++ arg_msbd ++ //26-30 ++ arg_hint_4_0 ++ arg_hint_14_0 ++ arg_level_14_0 ++ arg_level_17_10 ++ arg_seq_17_10 ++ //31-35 ++ arg_si12_21_10 ++ arg_si14_23_10 ++ arg_si16_25_10 ++ arg_si20_24_5 ++ arg_offset_20_0 ++ //36~ ++ arg_offset_25_0 ++ arg_offset_15_0 ++) +diff --git a/src/cmd/vendor/golang.org/x/arch/loong64/loong64asm/decode.go b/src/cmd/vendor/golang.org/x/arch/loong64/loong64asm/decode.go +new file mode 100644 +index 0000000000..ac3448f170 +--- /dev/null ++++ b/src/cmd/vendor/golang.org/x/arch/loong64/loong64asm/decode.go +@@ -0,0 +1,269 @@ ++// 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 loong64asm ++ ++import ( ++ "encoding/binary" ++ "fmt" ++) ++ ++type instArgs [5]instArg ++ ++// An instFormat describes the format of an instruction encoding. ++type instFormat struct { ++ mask uint32 ++ value uint32 ++ op Op ++ // args describe how to decode the instruction arguments. ++ // args is stored as a fixed-size array. ++ // if there are fewer than len(args) arguments, args[i] == 0 marks ++ // the end of the argument list. ++ args instArgs ++} ++ ++var ( ++ errShort = fmt.Errorf("truncated instruction") ++ errUnknown = fmt.Errorf("unknown instruction") ++) ++ ++var decoderCover []bool ++ ++func init() { ++ decoderCover = make([]bool, len(instFormats)) ++} ++ ++// Decode decodes the 4 bytes in src as a single instruction. ++func Decode(src []byte) (inst Inst, err error) { ++ if len(src) < 4 { ++ return Inst{}, errShort ++ } ++ ++ x := binary.LittleEndian.Uint32(src) ++ ++Search: ++ for i := range instFormats { ++ f := &instFormats[i] ++ ++ if (x & f.mask) != f.value { ++ continue ++ } ++ ++ // Decode args. ++ var args Args ++ for j, aop := range f.args { ++ if aop == 0 { ++ break ++ } ++ ++ arg := decodeArg(aop, x, i) ++ if arg == nil { ++ // Cannot decode argument ++ continue Search ++ } ++ ++ args[j] = arg ++ } ++ ++ decoderCover[i] = true ++ inst = Inst{ ++ Op: f.op, ++ Args: args, ++ Enc: x, ++ } ++ return inst, nil ++ } ++ ++ return Inst{}, errUnknown ++} ++ ++// decodeArg decodes the arg described by aop from the instruction bits x. ++// It returns nil if x cannot be decoded according to aop. ++func decodeArg(aop instArg, x uint32, index int) Arg { ++ switch aop { ++ case arg_fd: ++ return F0 + Reg(x&((1<<5)-1)) ++ ++ case arg_fj: ++ return F0 + Reg((x>>5)&((1<<5)-1)) ++ ++ case arg_fk: ++ return F0 + Reg((x>>10)&((1<<5)-1)) ++ ++ case arg_fa: ++ return F0 + Reg((x>>15)&((1<<5)-1)) ++ ++ case arg_rd: ++ return R0 + Reg(x&((1<<5)-1)) ++ ++ case arg_rj: ++ return R0 + Reg((x>>5)&((1<<5)-1)) ++ ++ case arg_rk: ++ return R0 + Reg((x>>10)&((1<<5)-1)) ++ ++ case arg_fcsr_4_0: ++ return FCSR0 + Fcsr(x&((1<<5)-1)) ++ ++ case arg_fcsr_9_5: ++ return FCSR0 + Fcsr((x>>5)&((1<<5)-1)) ++ ++ case arg_cd: ++ return FCC0 + Fcc(x&((1<<3)-1)) ++ ++ case arg_cj: ++ return FCC0 + Fcc((x>>5)&((1<<3)-1)) ++ ++ case arg_ca: ++ return FCC0 + Fcc((x>>15)&((1<<3)-1)) ++ ++ case arg_op_4_0: ++ tmp := x & ((1 << 5) - 1) ++ return Uimm{tmp, false} ++ ++ case arg_csr_23_10: ++ tmp := (x >> 10) & ((1 << 14) - 1) ++ return Uimm{tmp, false} ++ ++ case arg_sa2_16_15: ++ f := &instFormats[index] ++ tmp := SaSimm((x >> 15) & ((1 << 2) - 1)) ++ if (f.op == ALSL_D) || (f.op == ALSL_W) || (f.op == ALSL_WU) { ++ return tmp + 1 ++ } else { ++ return tmp + 0 ++ } ++ ++ case arg_sa3_17_15: ++ return SaSimm((x >> 15) & ((1 << 3) - 1)) ++ ++ case arg_code_4_0: ++ return CodeSimm(x & ((1 << 5) - 1)) ++ ++ case arg_code_14_0: ++ return CodeSimm(x & ((1 << 15) - 1)) ++ ++ case arg_ui5_14_10: ++ tmp := (x >> 10) & ((1 << 5) - 1) ++ return Uimm{tmp, false} ++ ++ case arg_ui6_15_10: ++ tmp := (x >> 10) & ((1 << 6) - 1) ++ return Uimm{tmp, false} ++ ++ case arg_ui12_21_10: ++ tmp := ((x >> 10) & ((1 << 12) - 1) & 0xfff) ++ return Uimm{tmp, false} ++ ++ case arg_lsbw: ++ tmp := (x >> 10) & ((1 << 5) - 1) ++ return Uimm{tmp, false} ++ ++ case arg_msbw: ++ tmp := (x >> 16) & ((1 << 5) - 1) ++ return Uimm{tmp, false} ++ ++ case arg_lsbd: ++ tmp := (x >> 10) & ((1 << 6) - 1) ++ return Uimm{tmp, false} ++ ++ case arg_msbd: ++ tmp := (x >> 16) & ((1 << 6) - 1) ++ return Uimm{tmp, false} ++ ++ case arg_hint_4_0: ++ tmp := int16(x & ((1 << 5) - 1)) ++ return Simm16{tmp, 4} ++ ++ case arg_hint_14_0: ++ tmp := int16(x & ((1 << 15) - 1)) ++ return Simm16{tmp, 15} ++ ++ case arg_level_14_0: ++ tmp := x & ((1 << 15) - 1) ++ return Uimm{tmp, false} ++ ++ case arg_level_17_10: ++ tmp := (x >> 10) & ((1 << 8) - 1) ++ return Uimm{tmp, false} ++ ++ case arg_seq_17_10: ++ tmp := (x >> 10) & ((1 << 8) - 1) ++ return Uimm{tmp, false} ++ ++ case arg_si12_21_10: ++ var tmp int16 ++ ++ //no int12, so sign-extend a 12-bit signed to 16-bit signed ++ if (x & 0x200000) == 0x200000 { ++ tmp = int16(((x >> 10) & ((1 << 12) - 1)) | 0xf000) ++ } else { ++ tmp = int16(((x >> 10) & ((1 << 12) - 1)) | 0x0000) ++ } ++ return Simm16{tmp, 12} ++ ++ case arg_si14_23_10: ++ var tmp int32 ++ if (x & 0x800000) == 0x800000 { ++ tmp = int32((((x >> 10) & ((1 << 14) - 1)) << 2) | 0xffff0000) ++ } else { ++ tmp = int32((((x >> 10) & ((1 << 14) - 1)) << 2) | 0x00000000) ++ } ++ return Simm32{tmp, 16} ++ ++ case arg_si16_25_10: ++ var tmp int32 ++ ++ if (x & 0x2000000) == 0x2000000 { ++ tmp = int32(((x >> 10) & ((1 << 16) - 1)) | 0xffff0000) ++ } else { ++ tmp = int32(((x >> 10) & ((1 << 16) - 1)) | 0x00000000) ++ } ++ ++ return Simm32{tmp, 16} ++ ++ case arg_si20_24_5: ++ var tmp int32 ++ if (x & 0x1000000) == 0x1000000 { ++ tmp = int32(((x >> 5) & ((1 << 20) - 1)) | 0xfff00000) ++ } else { ++ tmp = int32(((x >> 5) & ((1 << 20) - 1)) | 0x00000000) ++ } ++ return Simm32{tmp, 20} ++ ++ case arg_offset_20_0: ++ var tmp int32 ++ ++ if (x & 0x1000000) == 0x1000000 { ++ tmp = int32((((x << 16) | ((x >> 10) & ((1 << 16) - 1))) & ((1 << 21) - 1)) << 2) ++ } else { ++ tmp = int32((((x << 16) | ((x >> 10) & ((1 << 16) - 1))) & ((1 << 21) - 1)) << 2) ++ } ++ ++ return OffsetSimm{tmp, 28} ++ ++ case arg_offset_15_0: ++ var tmp int32 ++ if (x & 0x2000000) == 0x2000000 { ++ tmp = int32((((x >> 10) & ((1 << 16) - 1)) << 2) | 0xfffc0000) ++ } else { ++ tmp = int32((((x >> 10) & ((1 << 16) - 1)) << 2) | 0x00000000) ++ } ++ ++ return OffsetSimm{tmp, 18} ++ ++ case arg_offset_25_0: ++ var tmp int32 ++ ++ if (x & 0x200) == 0x200 { ++ tmp = int32(((((x << 16) | ((x >> 10) & ((1 << 16) - 1))) & ((1 << 26) - 1)) << 2) | 0xf0000000) ++ } else { ++ tmp = int32(((((x << 16) | ((x >> 10) & ((1 << 16) - 1))) & ((1 << 26) - 1)) << 2) | 0x00000000) ++ } ++ ++ return OffsetSimm{tmp, 28} ++ default: ++ return nil ++ } ++} +diff --git a/src/cmd/vendor/golang.org/x/arch/loong64/loong64asm/gnu.go b/src/cmd/vendor/golang.org/x/arch/loong64/loong64asm/gnu.go +new file mode 100644 +index 0000000000..fd6bcffde1 +--- /dev/null ++++ b/src/cmd/vendor/golang.org/x/arch/loong64/loong64asm/gnu.go +@@ -0,0 +1,16 @@ ++// 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 loong64asm ++ ++import ( ++ "strings" ++) ++ ++// GNUSyntax returns the GNU assembler syntax for the instruction, as defined by GNU binutils. ++// This form typically matches the syntax defined in the Loong64 Reference Manual. See ++// https://loongson.github.io/LoongArch-Documentation/LoongArch-Vol1-EN.html ++func GNUSyntax(inst Inst) string { ++ return strings.ToLower(inst.String()) ++} +diff --git a/src/cmd/vendor/golang.org/x/arch/loong64/loong64asm/inst.go b/src/cmd/vendor/golang.org/x/arch/loong64/loong64asm/inst.go +new file mode 100644 +index 0000000000..187a46fc01 +--- /dev/null ++++ b/src/cmd/vendor/golang.org/x/arch/loong64/loong64asm/inst.go +@@ -0,0 +1,296 @@ ++// 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 loong64asm ++ ++import ( ++ "fmt" ++ "strconv" ++ "strings" ++ "unsafe" ++) ++ ++// An Inst is a single instruction. ++type Inst struct { ++ Op Op // Opcode mnemonic ++ Enc uint32 // Raw encoding bits. ++ Args Args // Instruction arguments, in Loong64 manual order. ++} ++ ++func (i Inst) String() string { ++ var args []string ++ ++ for _, arg := range i.Args { ++ if arg == nil { ++ break ++ } ++ ++ args = append(args, arg.String()) ++ } ++ ++ str2 := strings.Join(args, ", ") ++ if str2 == "" { ++ str := i.Op.String() ++ return strings.Replace(str, ", (", "(", -1) ++ } else { ++ str := i.Op.String() + " " + strings.Join(args, ", ") ++ return strings.Replace(str, ", (", "(", -1) ++ } ++} ++ ++// An Op is an Loong64 opcode. ++type Op uint16 ++ ++// NOTE: The actual Op values are defined in tables.go. ++// They are chosen to simplify instruction decoding and ++// are not a dense packing from 0 to N, although the ++// density is high, probably at least 90%. ++func (op Op) String() string { ++ if (op >= Op(len(opstr))) || (opstr[op] == "") { ++ return fmt.Sprintf("Op(%d)", int(op)) ++ } ++ ++ return opstr[op] ++} ++ ++// An Args holds the instruction arguments. ++// If an instruction has fewer than 5 arguments, ++// the final elements in the array are nil. ++type Args [5]Arg ++ ++// An Arg is a single instruction argument ++type Arg interface { ++ String() string ++} ++ ++// A Reg is a single register. ++// The zero value denotes R0, not the absence of a register. ++type Reg uint16 ++ ++const ( ++ //_ Reg = iota ++ ++ // General-purpose register ++ R0 Reg = iota ++ R1 ++ R2 ++ R3 ++ R4 ++ R5 ++ R6 ++ R7 ++ R8 ++ R9 ++ R10 ++ R11 ++ R12 ++ R13 ++ R14 ++ R15 ++ R16 ++ R17 ++ R18 ++ R19 ++ R20 ++ R21 ++ R22 ++ R23 ++ R24 ++ R25 ++ R26 ++ R27 ++ R28 ++ R29 ++ R30 ++ R31 ++ ++ // Float point register ++ F0 ++ F1 ++ F2 ++ F3 ++ F4 ++ F5 ++ F6 ++ F7 ++ F8 ++ F9 ++ F10 ++ F11 ++ F12 ++ F13 ++ F14 ++ F15 ++ F16 ++ F17 ++ F18 ++ F19 ++ F20 ++ F21 ++ F22 ++ F23 ++ F24 ++ F25 ++ F26 ++ F27 ++ F28 ++ F29 ++ F30 ++ F31 ++) ++ ++func (r Reg) String() string { ++ switch { ++ case r == R0: ++ return "$zero" ++ ++ case r == R1: ++ return "$ra" ++ ++ case r == R2: ++ return "$tp" ++ ++ case r == R3: ++ return "$sp" ++ ++ case (r >= R4) && (r <= R11): ++ return fmt.Sprintf("$a%d", int(r-R4)) ++ ++ case (r >= R12) && (r <= R20): ++ return fmt.Sprintf("$t%d", int(r-R12)) ++ ++ case r == R21: ++ return "$r21" ++ ++ case r == R22: ++ return "$fp" ++ ++ case (r >= R23) && (r <= R31): ++ return fmt.Sprintf("$s%d", int(r-R23)) ++ ++ case (r >= F0) && (r <= F7): ++ return fmt.Sprintf("$fa%d", int(r-F0)) ++ ++ case (r >= F8) && (r <= F23): ++ return fmt.Sprintf("$ft%d", int(r-F8)) ++ ++ case (r >= F24) && (r <= F31): ++ return fmt.Sprintf("$fs%d", int(r-F24)) ++ ++ default: ++ return fmt.Sprintf("Unknown(%d)", int(r)) ++ } ++} ++ ++// float control status register ++type Fcsr uint8 ++ ++const ( ++ //_ Fcsr = iota ++ FCSR0 Fcsr = iota ++ FCSR1 ++ FCSR2 ++ FCSR3 ++) ++ ++func (f Fcsr) String() string { ++ switch f { ++ case FCSR0: ++ return fmt.Sprintf("$zero") ++ case FCSR1, FCSR2, FCSR3: ++ return fmt.Sprintf("$r%d", uint8(f)) ++ } ++ ++ return fmt.Sprintf("$unknow%d", uint8(f)) ++} ++ ++// float condition flags register ++type Fcc uint8 ++ ++const ( ++ //_ Fcc = iota ++ FCC0 Fcc = iota ++ FCC1 ++ FCC2 ++ FCC3 ++ FCC4 ++ FCC5 ++ FCC6 ++ FCC7 ++) ++ ++func (f Fcc) String() string { ++ return fmt.Sprintf("$fcc%d", uint8(f)) ++} ++ ++// An Imm is an integer constant. ++type Uimm struct { ++ Imm uint32 ++ Decimal bool ++} ++ ++func (i Uimm) String() string { ++ if i.Decimal == true { ++ return fmt.Sprintf("%d", i.Imm) ++ } else { ++ return fmt.Sprintf("%#x", i.Imm) ++ } ++} ++ ++type Simm16 struct { ++ Imm int16 ++ Width uint8 ++} ++ ++func (si Simm16) String() string { ++ if si.Imm == 0 { ++ return fmt.Sprintf("%#x", int(si.Imm)) ++ } else { ++ hex := int16(si.Imm & ((1 << si.Width) - 1)) ++ str := strconv.FormatUint(uint64(*(*int16)(unsafe.Pointer(&hex))), 16) ++ return fmt.Sprintf("%d(0x%s)", int16(si.Imm), str) ++ } ++} ++ ++type Simm32 struct { ++ Imm int32 ++ Width uint8 ++} ++ ++func (si Simm32) String() string { ++ if si.Imm == 0 { ++ return fmt.Sprintf("%#x", int(si.Imm)) ++ } else { ++ hex := int32(si.Imm & ((1 << si.Width) - 1)) ++ str := strconv.FormatUint(uint64(*(*int32)(unsafe.Pointer(&hex))), 16) ++ return fmt.Sprintf("%d(0x%s)", int32(si.Imm), str) ++ } ++} ++ ++type OffsetSimm struct { ++ Imm int32 ++ Width uint8 ++} ++ ++func (o OffsetSimm) String() string { ++ if o.Imm == 0 { ++ return fmt.Sprintf("%#x", int(o.Imm)) ++ } else { ++ hex := int32(o.Imm & ((1 << o.Width) - 1)) ++ str := strconv.FormatUint(uint64(*(*int32)(unsafe.Pointer(&hex))), 16) ++ return fmt.Sprintf("%d(0x%s)", int32(o.Imm), str) ++ } ++} ++ ++type SaSimm int16 ++ ++func (s SaSimm) String() string { ++ return fmt.Sprintf("%#x", int(s)) ++} ++ ++type CodeSimm int16 ++ ++func (c CodeSimm) String() string { ++ return fmt.Sprintf("%#x", int(c)) ++} +diff --git a/src/cmd/vendor/golang.org/x/arch/loong64/loong64asm/tables.go b/src/cmd/vendor/golang.org/x/arch/loong64/loong64asm/tables.go +new file mode 100644 +index 0000000000..f90e9295f1 +--- /dev/null ++++ b/src/cmd/vendor/golang.org/x/arch/loong64/loong64asm/tables.go +@@ -0,0 +1,1513 @@ ++// Generated by Loong64 internal tool ++// DO NOT EDIT ++// 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 loong64asm ++ ++const ( ++ _ Op = iota ++ ADDI_D ++ ADDI_W ++ ADDU16I_D ++ ADD_D ++ ADD_W ++ ALSL_D ++ ALSL_W ++ ALSL_WU ++ AMADD_D ++ AMADD_DB_D ++ AMADD_DB_W ++ AMADD_W ++ AMAND_D ++ AMAND_DB_D ++ AMAND_DB_W ++ AMAND_W ++ AMMAX_D ++ AMMAX_DB_D ++ AMMAX_DB_DU ++ AMMAX_DB_W ++ AMMAX_DB_WU ++ AMMAX_DU ++ AMMAX_W ++ AMMAX_WU ++ AMMIN_D ++ AMMIN_DB_D ++ AMMIN_DB_DU ++ AMMIN_DB_W ++ AMMIN_DB_WU ++ AMMIN_DU ++ AMMIN_W ++ AMMIN_WU ++ AMOR_D ++ AMOR_DB_D ++ AMOR_DB_W ++ AMOR_W ++ AMSWAP_D ++ AMSWAP_DB_D ++ AMSWAP_DB_W ++ AMSWAP_W ++ AMXOR_D ++ AMXOR_DB_D ++ AMXOR_DB_W ++ AMXOR_W ++ AND ++ ANDI ++ ANDN ++ ASRTGT_D ++ ASRTLE_D ++ B ++ BCEQZ ++ BCNEZ ++ BEQ ++ BEQZ ++ BGE ++ BGEU ++ BITREV_4B ++ BITREV_8B ++ BITREV_D ++ BITREV_W ++ BL ++ BLT ++ BLTU ++ BNE ++ BNEZ ++ BREAK ++ BSTRINS_D ++ BSTRINS_W ++ BSTRPICK_D ++ BSTRPICK_W ++ BYTEPICK_D ++ BYTEPICK_W ++ CACOP ++ CLO_D ++ CLO_W ++ CLZ_D ++ CLZ_W ++ CPUCFG ++ CRCC_W_B_W ++ CRCC_W_D_W ++ CRCC_W_H_W ++ CRCC_W_W_W ++ CRC_W_B_W ++ CRC_W_D_W ++ CRC_W_H_W ++ CRC_W_W_W ++ CSRRD ++ CSRWR ++ CSRXCHG ++ CTO_D ++ CTO_W ++ CTZ_D ++ CTZ_W ++ DBAR ++ DBCL ++ DIV_D ++ DIV_DU ++ DIV_W ++ DIV_WU ++ ERTN ++ EXT_W_B ++ EXT_W_H ++ FABS_D ++ FABS_S ++ FADD_D ++ FADD_S ++ FCLASS_D ++ FCLASS_S ++ FCMP_CAF_D ++ FCMP_CAF_S ++ FCMP_CEQ_D ++ FCMP_CEQ_S ++ FCMP_CLE_D ++ FCMP_CLE_S ++ FCMP_CLT_D ++ FCMP_CLT_S ++ FCMP_CNE_D ++ FCMP_CNE_S ++ FCMP_COR_D ++ FCMP_COR_S ++ FCMP_CUEQ_D ++ FCMP_CUEQ_S ++ FCMP_CULE_D ++ FCMP_CULE_S ++ FCMP_CULT_D ++ FCMP_CULT_S ++ FCMP_CUNE_D ++ FCMP_CUNE_S ++ FCMP_CUN_D ++ FCMP_CUN_S ++ FCMP_SAF_D ++ FCMP_SAF_S ++ FCMP_SEQ_D ++ FCMP_SEQ_S ++ FCMP_SLE_D ++ FCMP_SLE_S ++ FCMP_SLT_D ++ FCMP_SLT_S ++ FCMP_SNE_D ++ FCMP_SNE_S ++ FCMP_SOR_D ++ FCMP_SOR_S ++ FCMP_SUEQ_D ++ FCMP_SUEQ_S ++ FCMP_SULE_D ++ FCMP_SULE_S ++ FCMP_SULT_D ++ FCMP_SULT_S ++ FCMP_SUNE_D ++ FCMP_SUNE_S ++ FCMP_SUN_D ++ FCMP_SUN_S ++ FCOPYSIGN_D ++ FCOPYSIGN_S ++ FCVT_D_S ++ FCVT_S_D ++ FDIV_D ++ FDIV_S ++ FFINT_D_L ++ FFINT_D_W ++ FFINT_S_L ++ FFINT_S_W ++ FLDGT_D ++ FLDGT_S ++ FLDLE_D ++ FLDLE_S ++ FLDX_D ++ FLDX_S ++ FLD_D ++ FLD_S ++ FLOGB_D ++ FLOGB_S ++ FMADD_D ++ FMADD_S ++ FMAXA_D ++ FMAXA_S ++ FMAX_D ++ FMAX_S ++ FMINA_D ++ FMINA_S ++ FMIN_D ++ FMIN_S ++ FMOV_D ++ FMOV_S ++ FMSUB_D ++ FMSUB_S ++ FMUL_D ++ FMUL_S ++ FNEG_D ++ FNEG_S ++ FNMADD_D ++ FNMADD_S ++ FNMSUB_D ++ FNMSUB_S ++ FRECIP_D ++ FRECIP_S ++ FRINT_D ++ FRINT_S ++ FRSQRT_D ++ FRSQRT_S ++ FSCALEB_D ++ FSCALEB_S ++ FSEL ++ FSQRT_D ++ FSQRT_S ++ FSTGT_D ++ FSTGT_S ++ FSTLE_D ++ FSTLE_S ++ FSTX_D ++ FSTX_S ++ FST_D ++ FST_S ++ FSUB_D ++ FSUB_S ++ FTINTRM_L_D ++ FTINTRM_L_S ++ FTINTRM_W_D ++ FTINTRM_W_S ++ FTINTRNE_L_D ++ FTINTRNE_L_S ++ FTINTRNE_W_D ++ FTINTRNE_W_S ++ FTINTRP_L_D ++ FTINTRP_L_S ++ FTINTRP_W_D ++ FTINTRP_W_S ++ FTINTRZ_L_D ++ FTINTRZ_L_S ++ FTINTRZ_W_D ++ FTINTRZ_W_S ++ FTINT_L_D ++ FTINT_L_S ++ FTINT_W_D ++ FTINT_W_S ++ IBAR ++ IDLE ++ INVTLB ++ IOCSRRD_B ++ IOCSRRD_D ++ IOCSRRD_H ++ IOCSRRD_W ++ IOCSRWR_B ++ IOCSRWR_D ++ IOCSRWR_H ++ IOCSRWR_W ++ JIRL ++ LDDIR ++ LDGT_B ++ LDGT_D ++ LDGT_H ++ LDGT_W ++ LDLE_B ++ LDLE_D ++ LDLE_H ++ LDLE_W ++ LDPTE ++ LDPTR_D ++ LDPTR_W ++ LDX_B ++ LDX_BU ++ LDX_D ++ LDX_H ++ LDX_HU ++ LDX_W ++ LDX_WU ++ LD_B ++ LD_BU ++ LD_D ++ LD_H ++ LD_HU ++ LD_W ++ LD_WU ++ LL_D ++ LL_W ++ LU12I_W ++ LU32I_D ++ LU52I_D ++ MASKEQZ ++ MASKNEZ ++ MOD_D ++ MOD_DU ++ MOD_W ++ MOD_WU ++ MOVCF2FR ++ MOVCF2GR ++ MOVFCSR2GR ++ MOVFR2CF ++ MOVFR2GR_D ++ MOVFR2GR_S ++ MOVFRH2GR_S ++ MOVGR2CF ++ MOVGR2FCSR ++ MOVGR2FRH_W ++ MOVGR2FR_D ++ MOVGR2FR_W ++ MULH_D ++ MULH_DU ++ MULH_W ++ MULH_WU ++ MULW_D_W ++ MULW_D_WU ++ MUL_D ++ MUL_W ++ NOR ++ OR ++ ORI ++ ORN ++ PCADDI ++ PCADDU12I ++ PCADDU18I ++ PCALAU12I ++ PRELD ++ PRELDX ++ RDTIMEH_W ++ RDTIMEL_W ++ RDTIME_D ++ REVB_2H ++ REVB_2W ++ REVB_4H ++ REVB_D ++ REVH_2W ++ REVH_D ++ ROTRI_D ++ ROTRI_W ++ ROTR_D ++ ROTR_W ++ SC_D ++ SC_W ++ SLLI_D ++ SLLI_W ++ SLL_D ++ SLL_W ++ SLT ++ SLTI ++ SLTU ++ SLTUI ++ SRAI_D ++ SRAI_W ++ SRA_D ++ SRA_W ++ SRLI_D ++ SRLI_W ++ SRL_D ++ SRL_W ++ STGT_B ++ STGT_D ++ STGT_H ++ STGT_W ++ STLE_B ++ STLE_D ++ STLE_H ++ STLE_W ++ STPTR_D ++ STPTR_W ++ STX_B ++ STX_D ++ STX_H ++ STX_W ++ ST_B ++ ST_D ++ ST_H ++ ST_W ++ SUB_D ++ SUB_W ++ SYSCALL ++ TLBCLR ++ TLBFILL ++ TLBFLUSH ++ TLBRD ++ TLBSRCH ++ TLBWR ++ XOR ++ XORI ++) ++ ++var opstr = [...]string{ ++ ADDI_D: "ADDI.D", ++ ADDI_W: "ADDI.W", ++ ADDU16I_D: "ADDU16I.D", ++ ADD_D: "ADD.D", ++ ADD_W: "ADD.W", ++ ALSL_D: "ALSL.D", ++ ALSL_W: "ALSL.W", ++ ALSL_WU: "ALSL.WU", ++ AMADD_D: "AMADD.D", ++ AMADD_DB_D: "AMADD_DB.D", ++ AMADD_DB_W: "AMADD_DB.W", ++ AMADD_W: "AMADD.W", ++ AMAND_D: "AMAND.D", ++ AMAND_DB_D: "AMAND_DB.D", ++ AMAND_DB_W: "AMAND_DB.W", ++ AMAND_W: "AMAND.W", ++ AMMAX_D: "AMMAX.D", ++ AMMAX_DB_D: "AMMAX_DB.D", ++ AMMAX_DB_DU: "AMMAX_DB.DU", ++ AMMAX_DB_W: "AMMAX_DB.W", ++ AMMAX_DB_WU: "AMMAX_DB.WU", ++ AMMAX_DU: "AMMAX.DU", ++ AMMAX_W: "AMMAX.W", ++ AMMAX_WU: "AMMAX.WU", ++ AMMIN_D: "AMMIN.D", ++ AMMIN_DB_D: "AMMIN_DB.D", ++ AMMIN_DB_DU: "AMMIN_DB.DU", ++ AMMIN_DB_W: "AMMIN_DB.W", ++ AMMIN_DB_WU: "AMMIN_DB.WU", ++ AMMIN_DU: "AMMIN.DU", ++ AMMIN_W: "AMMIN.W", ++ AMMIN_WU: "AMMIN.WU", ++ AMOR_D: "AMOR.D", ++ AMOR_DB_D: "AMOR_DB.D", ++ AMOR_DB_W: "AMOR_DB.W", ++ AMOR_W: "AMOR.W", ++ AMSWAP_D: "AMSWAP.D", ++ AMSWAP_DB_D: "AMSWAP_DB.D", ++ AMSWAP_DB_W: "AMSWAP_DB.W", ++ AMSWAP_W: "AMSWAP.W", ++ AMXOR_D: "AMXOR.D", ++ AMXOR_DB_D: "AMXOR_DB.D", ++ AMXOR_DB_W: "AMXOR_DB.W", ++ AMXOR_W: "AMXOR.W", ++ AND: "AND", ++ ANDI: "ANDI", ++ ANDN: "ANDN", ++ ASRTGT_D: "ASRTGT.D", ++ ASRTLE_D: "ASRTLE.D", ++ B: "B", ++ BCEQZ: "BCEQZ", ++ BCNEZ: "BCNEZ", ++ BEQ: "BEQ", ++ BEQZ: "BEQZ", ++ BGE: "BGE", ++ BGEU: "BGEU", ++ BITREV_4B: "BITREV.4B", ++ BITREV_8B: "BITREV.8B", ++ BITREV_D: "BITREV.D", ++ BITREV_W: "BITREV.W", ++ BL: "BL", ++ BLT: "BLT", ++ BLTU: "BLTU", ++ BNE: "BNE", ++ BNEZ: "BNEZ", ++ BREAK: "BREAK", ++ BSTRINS_D: "BSTRINS.D", ++ BSTRINS_W: "BSTRINS.W", ++ BSTRPICK_D: "BSTRPICK.D", ++ BSTRPICK_W: "BSTRPICK.W", ++ BYTEPICK_D: "BYTEPICK.D", ++ BYTEPICK_W: "BYTEPICK.W", ++ CACOP: "CACOP", ++ CLO_D: "CLO.D", ++ CLO_W: "CLO.W", ++ CLZ_D: "CLZ.D", ++ CLZ_W: "CLZ.W", ++ CPUCFG: "CPUCFG", ++ CRCC_W_B_W: "CRCC.W.B.W", ++ CRCC_W_D_W: "CRCC.W.D.W", ++ CRCC_W_H_W: "CRCC.W.H.W", ++ CRCC_W_W_W: "CRCC.W.W.W", ++ CRC_W_B_W: "CRC.W.B.W", ++ CRC_W_D_W: "CRC.W.D.W", ++ CRC_W_H_W: "CRC.W.H.W", ++ CRC_W_W_W: "CRC.W.W.W", ++ CSRRD: "CSRRD", ++ CSRWR: "CSRWR", ++ CSRXCHG: "CSRXCHG", ++ CTO_D: "CTO.D", ++ CTO_W: "CTO.W", ++ CTZ_D: "CTZ.D", ++ CTZ_W: "CTZ.W", ++ DBAR: "DBAR", ++ DBCL: "DBCL", ++ DIV_D: "DIV.D", ++ DIV_DU: "DIV.DU", ++ DIV_W: "DIV.W", ++ DIV_WU: "DIV.WU", ++ ERTN: "ERTN", ++ EXT_W_B: "EXT.W.B", ++ EXT_W_H: "EXT.W.H", ++ FABS_D: "FABS.D", ++ FABS_S: "FABS.S", ++ FADD_D: "FADD.D", ++ FADD_S: "FADD.S", ++ FCLASS_D: "FCLASS.D", ++ FCLASS_S: "FCLASS.S", ++ FCMP_CAF_D: "FCMP.CAF.D", ++ FCMP_CAF_S: "FCMP.CAF.S", ++ FCMP_CEQ_D: "FCMP.CEQ.D", ++ FCMP_CEQ_S: "FCMP.CEQ.S", ++ FCMP_CLE_D: "FCMP.CLE.D", ++ FCMP_CLE_S: "FCMP.CLE.S", ++ FCMP_CLT_D: "FCMP.CLT.D", ++ FCMP_CLT_S: "FCMP.CLT.S", ++ FCMP_CNE_D: "FCMP.CNE.D", ++ FCMP_CNE_S: "FCMP.CNE.S", ++ FCMP_COR_D: "FCMP.COR.D", ++ FCMP_COR_S: "FCMP.COR.S", ++ FCMP_CUEQ_D: "FCMP.CUEQ.D", ++ FCMP_CUEQ_S: "FCMP.CUEQ.S", ++ FCMP_CULE_D: "FCMP.CULE.D", ++ FCMP_CULE_S: "FCMP.CULE.S", ++ FCMP_CULT_D: "FCMP.CULT.D", ++ FCMP_CULT_S: "FCMP.CULT.S", ++ FCMP_CUNE_D: "FCMP.CUNE.D", ++ FCMP_CUNE_S: "FCMP.CUNE.S", ++ FCMP_CUN_D: "FCMP.CUN.D", ++ FCMP_CUN_S: "FCMP.CUN.S", ++ FCMP_SAF_D: "FCMP.SAF.D", ++ FCMP_SAF_S: "FCMP.SAF.S", ++ FCMP_SEQ_D: "FCMP.SEQ.D", ++ FCMP_SEQ_S: "FCMP.SEQ.S", ++ FCMP_SLE_D: "FCMP.SLE.D", ++ FCMP_SLE_S: "FCMP.SLE.S", ++ FCMP_SLT_D: "FCMP.SLT.D", ++ FCMP_SLT_S: "FCMP.SLT.S", ++ FCMP_SNE_D: "FCMP.SNE.D", ++ FCMP_SNE_S: "FCMP.SNE.S", ++ FCMP_SOR_D: "FCMP.SOR.D", ++ FCMP_SOR_S: "FCMP.SOR.S", ++ FCMP_SUEQ_D: "FCMP.SUEQ.D", ++ FCMP_SUEQ_S: "FCMP.SUEQ.S", ++ FCMP_SULE_D: "FCMP.SULE.D", ++ FCMP_SULE_S: "FCMP.SULE.S", ++ FCMP_SULT_D: "FCMP.SULT.D", ++ FCMP_SULT_S: "FCMP.SULT.S", ++ FCMP_SUNE_D: "FCMP.SUNE.D", ++ FCMP_SUNE_S: "FCMP.SUNE.S", ++ FCMP_SUN_D: "FCMP.SUN.D", ++ FCMP_SUN_S: "FCMP.SUN.S", ++ FCOPYSIGN_D: "FCOPYSIGN.D", ++ FCOPYSIGN_S: "FCOPYSIGN.S", ++ FCVT_D_S: "FCVT.D.S", ++ FCVT_S_D: "FCVT.S.D", ++ FDIV_D: "FDIV.D", ++ FDIV_S: "FDIV.S", ++ FFINT_D_L: "FFINT.D.L", ++ FFINT_D_W: "FFINT.D.W", ++ FFINT_S_L: "FFINT.S.L", ++ FFINT_S_W: "FFINT.S.W", ++ FLDGT_D: "FLDGT.D", ++ FLDGT_S: "FLDGT.S", ++ FLDLE_D: "FLDLE.D", ++ FLDLE_S: "FLDLE.S", ++ FLDX_D: "FLDX.D", ++ FLDX_S: "FLDX.S", ++ FLD_D: "FLD.D", ++ FLD_S: "FLD.S", ++ FLOGB_D: "FLOGB.D", ++ FLOGB_S: "FLOGB.S", ++ FMADD_D: "FMADD.D", ++ FMADD_S: "FMADD.S", ++ FMAXA_D: "FMAXA.D", ++ FMAXA_S: "FMAXA.S", ++ FMAX_D: "FMAX.D", ++ FMAX_S: "FMAX.S", ++ FMINA_D: "FMINA.D", ++ FMINA_S: "FMINA.S", ++ FMIN_D: "FMIN.D", ++ FMIN_S: "FMIN.S", ++ FMOV_D: "FMOV.D", ++ FMOV_S: "FMOV.S", ++ FMSUB_D: "FMSUB.D", ++ FMSUB_S: "FMSUB.S", ++ FMUL_D: "FMUL.D", ++ FMUL_S: "FMUL.S", ++ FNEG_D: "FNEG.D", ++ FNEG_S: "FNEG.S", ++ FNMADD_D: "FNMADD.D", ++ FNMADD_S: "FNMADD.S", ++ FNMSUB_D: "FNMSUB.D", ++ FNMSUB_S: "FNMSUB.S", ++ FRECIP_D: "FRECIP.D", ++ FRECIP_S: "FRECIP.S", ++ FRINT_D: "FRINT.D", ++ FRINT_S: "FRINT.S", ++ FRSQRT_D: "FRSQRT.D", ++ FRSQRT_S: "FRSQRT.S", ++ FSCALEB_D: "FSCALEB.D", ++ FSCALEB_S: "FSCALEB.S", ++ FSEL: "FSEL", ++ FSQRT_D: "FSQRT.D", ++ FSQRT_S: "FSQRT.S", ++ FSTGT_D: "FSTGT.D", ++ FSTGT_S: "FSTGT.S", ++ FSTLE_D: "FSTLE.D", ++ FSTLE_S: "FSTLE.S", ++ FSTX_D: "FSTX.D", ++ FSTX_S: "FSTX.S", ++ FST_D: "FST.D", ++ FST_S: "FST.S", ++ FSUB_D: "FSUB.D", ++ FSUB_S: "FSUB.S", ++ FTINTRM_L_D: "FTINTRM.L.D", ++ FTINTRM_L_S: "FTINTRM.L.S", ++ FTINTRM_W_D: "FTINTRM.W.D", ++ FTINTRM_W_S: "FTINTRM.W.S", ++ FTINTRNE_L_D: "FTINTRNE.L.D", ++ FTINTRNE_L_S: "FTINTRNE.L.S", ++ FTINTRNE_W_D: "FTINTRNE.W.D", ++ FTINTRNE_W_S: "FTINTRNE.W.S", ++ FTINTRP_L_D: "FTINTRP.L.D", ++ FTINTRP_L_S: "FTINTRP.L.S", ++ FTINTRP_W_D: "FTINTRP.W.D", ++ FTINTRP_W_S: "FTINTRP.W.S", ++ FTINTRZ_L_D: "FTINTRZ.L.D", ++ FTINTRZ_L_S: "FTINTRZ.L.S", ++ FTINTRZ_W_D: "FTINTRZ.W.D", ++ FTINTRZ_W_S: "FTINTRZ.W.S", ++ FTINT_L_D: "FTINT.L.D", ++ FTINT_L_S: "FTINT.L.S", ++ FTINT_W_D: "FTINT.W.D", ++ FTINT_W_S: "FTINT.W.S", ++ IBAR: "IBAR", ++ IDLE: "IDLE", ++ INVTLB: "INVTLB", ++ IOCSRRD_B: "IOCSRRD.B", ++ IOCSRRD_D: "IOCSRRD.D", ++ IOCSRRD_H: "IOCSRRD.H", ++ IOCSRRD_W: "IOCSRRD.W", ++ IOCSRWR_B: "IOCSRWR.B", ++ IOCSRWR_D: "IOCSRWR.D", ++ IOCSRWR_H: "IOCSRWR.H", ++ IOCSRWR_W: "IOCSRWR.W", ++ JIRL: "JIRL", ++ LDDIR: "LDDIR", ++ LDGT_B: "LDGT.B", ++ LDGT_D: "LDGT.D", ++ LDGT_H: "LDGT.H", ++ LDGT_W: "LDGT.W", ++ LDLE_B: "LDLE.B", ++ LDLE_D: "LDLE.D", ++ LDLE_H: "LDLE.H", ++ LDLE_W: "LDLE.W", ++ LDPTE: "LDPTE", ++ LDPTR_D: "LDPTR.D", ++ LDPTR_W: "LDPTR.W", ++ LDX_B: "LDX.B", ++ LDX_BU: "LDX.BU", ++ LDX_D: "LDX.D", ++ LDX_H: "LDX.H", ++ LDX_HU: "LDX.HU", ++ LDX_W: "LDX.W", ++ LDX_WU: "LDX.WU", ++ LD_B: "LD.B", ++ LD_BU: "LD.BU", ++ LD_D: "LD.D", ++ LD_H: "LD.H", ++ LD_HU: "LD.HU", ++ LD_W: "LD.W", ++ LD_WU: "LD.WU", ++ LL_D: "LL.D", ++ LL_W: "LL.W", ++ LU12I_W: "LU12I.W", ++ LU32I_D: "LU32I.D", ++ LU52I_D: "LU52I.D", ++ MASKEQZ: "MASKEQZ", ++ MASKNEZ: "MASKNEZ", ++ MOD_D: "MOD.D", ++ MOD_DU: "MOD.DU", ++ MOD_W: "MOD.W", ++ MOD_WU: "MOD.WU", ++ MOVCF2FR: "MOVCF2FR", ++ MOVCF2GR: "MOVCF2GR", ++ MOVFCSR2GR: "MOVFCSR2GR", ++ MOVFR2CF: "MOVFR2CF", ++ MOVFR2GR_D: "MOVFR2GR.D", ++ MOVFR2GR_S: "MOVFR2GR.S", ++ MOVFRH2GR_S: "MOVFRH2GR.S", ++ MOVGR2CF: "MOVGR2CF", ++ MOVGR2FCSR: "MOVGR2FCSR", ++ MOVGR2FRH_W: "MOVGR2FRH.W", ++ MOVGR2FR_D: "MOVGR2FR.D", ++ MOVGR2FR_W: "MOVGR2FR.W", ++ MULH_D: "MULH.D", ++ MULH_DU: "MULH.DU", ++ MULH_W: "MULH.W", ++ MULH_WU: "MULH.WU", ++ MULW_D_W: "MULW.D.W", ++ MULW_D_WU: "MULW.D.WU", ++ MUL_D: "MUL.D", ++ MUL_W: "MUL.W", ++ NOR: "NOR", ++ OR: "OR", ++ ORI: "ORI", ++ ORN: "ORN", ++ PCADDI: "PCADDI", ++ PCADDU12I: "PCADDU12I", ++ PCADDU18I: "PCADDU18I", ++ PCALAU12I: "PCALAU12I", ++ PRELD: "PRELD", ++ PRELDX: "PRELDX", ++ RDTIMEH_W: "RDTIMEH.W", ++ RDTIMEL_W: "RDTIMEL.W", ++ RDTIME_D: "RDTIME.D", ++ REVB_2H: "REVB.2H", ++ REVB_2W: "REVB.2W", ++ REVB_4H: "REVB.4H", ++ REVB_D: "REVB.D", ++ REVH_2W: "REVH.2W", ++ REVH_D: "REVH.D", ++ ROTRI_D: "ROTRI.D", ++ ROTRI_W: "ROTRI.W", ++ ROTR_D: "ROTR.D", ++ ROTR_W: "ROTR.W", ++ SC_D: "SC.D", ++ SC_W: "SC.W", ++ SLLI_D: "SLLI.D", ++ SLLI_W: "SLLI.W", ++ SLL_D: "SLL.D", ++ SLL_W: "SLL.W", ++ SLT: "SLT", ++ SLTI: "SLTI", ++ SLTU: "SLTU", ++ SLTUI: "SLTUI", ++ SRAI_D: "SRAI.D", ++ SRAI_W: "SRAI.W", ++ SRA_D: "SRA.D", ++ SRA_W: "SRA.W", ++ SRLI_D: "SRLI.D", ++ SRLI_W: "SRLI.W", ++ SRL_D: "SRL.D", ++ SRL_W: "SRL.W", ++ STGT_B: "STGT.B", ++ STGT_D: "STGT.D", ++ STGT_H: "STGT.H", ++ STGT_W: "STGT.W", ++ STLE_B: "STLE.B", ++ STLE_D: "STLE.D", ++ STLE_H: "STLE.H", ++ STLE_W: "STLE.W", ++ STPTR_D: "STPTR.D", ++ STPTR_W: "STPTR.W", ++ STX_B: "STX.B", ++ STX_D: "STX.D", ++ STX_H: "STX.H", ++ STX_W: "STX.W", ++ ST_B: "ST.B", ++ ST_D: "ST.D", ++ ST_H: "ST.H", ++ ST_W: "ST.W", ++ SUB_D: "SUB.D", ++ SUB_W: "SUB.W", ++ SYSCALL: "SYSCALL", ++ TLBCLR: "TLBCLR", ++ TLBFILL: "TLBFILL", ++ TLBFLUSH: "TLBFLUSH", ++ TLBRD: "TLBRD", ++ TLBSRCH: "TLBSRCH", ++ TLBWR: "TLBWR", ++ XOR: "XOR", ++ XORI: "XORI", ++} ++ ++var instFormats = [...]instFormat{ ++ // ADDI.D rd, rj, si12 ++ {mask: 0xffc00000, value: 0x02c00000, op: ADDI_D, args: instArgs{arg_rd, arg_rj, arg_si12_21_10}}, ++ // ADDI.W rd, rj, si12 ++ {mask: 0xffc00000, value: 0x02800000, op: ADDI_W, args: instArgs{arg_rd, arg_rj, arg_si12_21_10}}, ++ // ADDU16I.D rd, rj, si16 ++ {mask: 0xfc000000, value: 0x10000000, op: ADDU16I_D, args: instArgs{arg_rd, arg_rj, arg_si16_25_10}}, ++ // ADD.D rd, rj, rk ++ {mask: 0xffff8000, value: 0x00108000, op: ADD_D, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // ADD.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x00100000, op: ADD_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // ALSL.D rd, rj, rk, sa2 ++ {mask: 0xfffe0000, value: 0x002c0000, op: ALSL_D, args: instArgs{arg_rd, arg_rj, arg_rk, arg_sa2_16_15}}, ++ // ALSL.W rd, rj, rk, sa2 ++ {mask: 0xfffe0000, value: 0x00040000, op: ALSL_W, args: instArgs{arg_rd, arg_rj, arg_rk, arg_sa2_16_15}}, ++ // ALSL.WU rd, rj, rk, sa2 ++ {mask: 0xfffe0000, value: 0x00060000, op: ALSL_WU, args: instArgs{arg_rd, arg_rj, arg_rk, arg_sa2_16_15}}, ++ // AMADD.D rd, rk, rj ++ {mask: 0xffff8000, value: 0x38618000, op: AMADD_D, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMADD_DB.D rd, rk, rj ++ {mask: 0xffff8000, value: 0x386a8000, op: AMADD_DB_D, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMADD_DB.W rd, rk, rj ++ {mask: 0xffff8000, value: 0x386a0000, op: AMADD_DB_W, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMADD.W rd, rk, rj ++ {mask: 0xffff8000, value: 0x38610000, op: AMADD_W, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMAND.D rd, rk, rj ++ {mask: 0xffff8000, value: 0x38628000, op: AMAND_D, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMAND_DB.D rd, rk, rj ++ {mask: 0xffff8000, value: 0x386b8000, op: AMAND_DB_D, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMAND_DB.W rd, rk, rj ++ {mask: 0xffff8000, value: 0x386b0000, op: AMAND_DB_W, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMAND.W rd, rk, rj ++ {mask: 0xffff8000, value: 0x38620000, op: AMAND_W, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMMAX.D rd, rk, rj ++ {mask: 0xffff8000, value: 0x38658000, op: AMMAX_D, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMMAX_DB.D rd, rk, rj ++ {mask: 0xffff8000, value: 0x386e8000, op: AMMAX_DB_D, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMMAX_DB.DU rd, rk, rj ++ {mask: 0xffff8000, value: 0x38708000, op: AMMAX_DB_DU, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMMAX_DB.W rd, rk, rj ++ {mask: 0xffff8000, value: 0x386e0000, op: AMMAX_DB_W, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMMAX_DB.WU rd, rk, rj ++ {mask: 0xffff8000, value: 0x38700000, op: AMMAX_DB_WU, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMMAX.DU rd, rk, rj ++ {mask: 0xffff8000, value: 0x38678000, op: AMMAX_DU, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMMAX.W rd, rk, rj ++ {mask: 0xffff8000, value: 0x38650000, op: AMMAX_W, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMMAX.WU rd, rk, rj ++ {mask: 0xffff8000, value: 0x38670000, op: AMMAX_WU, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMMIN.D rd, rk, rj ++ {mask: 0xffff8000, value: 0x38668000, op: AMMIN_D, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMMIN_DB.D rd, rk, rj ++ {mask: 0xffff8000, value: 0x386f8000, op: AMMIN_DB_D, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMMIN_DB.DU rd, rk, rj ++ {mask: 0xffff8000, value: 0x38718000, op: AMMIN_DB_DU, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMMIN_DB.W rd, rk, rj ++ {mask: 0xffff8000, value: 0x386f0000, op: AMMIN_DB_W, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMMIN_DB.WU rd, rk, rj ++ {mask: 0xffff8000, value: 0x38710000, op: AMMIN_DB_WU, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMMIN.DU rd, rk, rj ++ {mask: 0xffff8000, value: 0x38688000, op: AMMIN_DU, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMMIN.W rd, rk, rj ++ {mask: 0xffff8000, value: 0x38660000, op: AMMIN_W, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMMIN.WU rd, rk, rj ++ {mask: 0xffff8000, value: 0x38680000, op: AMMIN_WU, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMOR.D rd, rk, rj ++ {mask: 0xffff8000, value: 0x38638000, op: AMOR_D, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMOR_DB.D rd, rk, rj ++ {mask: 0xffff8000, value: 0x386c8000, op: AMOR_DB_D, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMOR_DB.W rd, rk, rj ++ {mask: 0xffff8000, value: 0x386c0000, op: AMOR_DB_W, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMOR.W rd, rk, rj ++ {mask: 0xffff8000, value: 0x38630000, op: AMOR_W, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMSWAP.D rd, rk, rj ++ {mask: 0xffff8000, value: 0x38608000, op: AMSWAP_D, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMSWAP_DB.D rd, rk, rj ++ {mask: 0xffff8000, value: 0x38698000, op: AMSWAP_DB_D, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMSWAP_DB.W rd, rk, rj ++ {mask: 0xffff8000, value: 0x38690000, op: AMSWAP_DB_W, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMSWAP.W rd, rk, rj ++ {mask: 0xffff8000, value: 0x38600000, op: AMSWAP_W, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMXOR.D rd, rk, rj ++ {mask: 0xffff8000, value: 0x38648000, op: AMXOR_D, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMXOR_DB.D rd, rk, rj ++ {mask: 0xffff8000, value: 0x386d8000, op: AMXOR_DB_D, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMXOR_DB.W rd, rk, rj ++ {mask: 0xffff8000, value: 0x386d0000, op: AMXOR_DB_W, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AMXOR.W rd, rk, rj ++ {mask: 0xffff8000, value: 0x38640000, op: AMXOR_W, args: instArgs{arg_rd, arg_rk, arg_rj}}, ++ // AND rd, rj, rk ++ {mask: 0xffff8000, value: 0x00148000, op: AND, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // ANDI rd, rj, ui12 ++ {mask: 0xffc00000, value: 0x03400000, op: ANDI, args: instArgs{arg_rd, arg_rj, arg_ui12_21_10}}, ++ // ANDN rd, rj, rk ++ {mask: 0xffff8000, value: 0x00168000, op: ANDN, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // ASRTGT.D rj, rk ++ {mask: 0xffff801f, value: 0x00018000, op: ASRTGT_D, args: instArgs{arg_rj, arg_rk}}, ++ // ASRTLE.D rj, rk ++ {mask: 0xffff801f, value: 0x00010000, op: ASRTLE_D, args: instArgs{arg_rj, arg_rk}}, ++ // B offs ++ {mask: 0xfc000000, value: 0x50000000, op: B, args: instArgs{arg_offset_25_0}}, ++ // BCEQZ cj, offs ++ {mask: 0xfc000300, value: 0x48000000, op: BCEQZ, args: instArgs{arg_cj, arg_offset_20_0}}, ++ // BCNEZ cj, offs ++ {mask: 0xfc000300, value: 0x48000100, op: BCNEZ, args: instArgs{arg_cj, arg_offset_20_0}}, ++ // BEQ rj, rd, offs ++ {mask: 0xfc000000, value: 0x58000000, op: BEQ, args: instArgs{arg_rj, arg_rd, arg_offset_15_0}}, ++ // BEQZ rj, offs ++ {mask: 0xfc000000, value: 0x40000000, op: BEQZ, args: instArgs{arg_rj, arg_offset_20_0}}, ++ // BGE rj, rd, offs ++ {mask: 0xfc000000, value: 0x64000000, op: BGE, args: instArgs{arg_rj, arg_rd, arg_offset_15_0}}, ++ // BGEU rj, rd, offs ++ {mask: 0xfc000000, value: 0x6c000000, op: BGEU, args: instArgs{arg_rj, arg_rd, arg_offset_15_0}}, ++ // BITREV.4B rd, rj ++ {mask: 0xfffffc00, value: 0x00004800, op: BITREV_4B, args: instArgs{arg_rd, arg_rj}}, ++ // BITREV.8B rd, rj ++ {mask: 0xfffffc00, value: 0x00004c00, op: BITREV_8B, args: instArgs{arg_rd, arg_rj}}, ++ // BITREV.D rd, rj ++ {mask: 0xfffffc00, value: 0x00005400, op: BITREV_D, args: instArgs{arg_rd, arg_rj}}, ++ // BITREV.W rd, rj ++ {mask: 0xfffffc00, value: 0x00005000, op: BITREV_W, args: instArgs{arg_rd, arg_rj}}, ++ // BL offs ++ {mask: 0xfc000000, value: 0x54000000, op: BL, args: instArgs{arg_offset_25_0}}, ++ // BLT rj, rd, offs ++ {mask: 0xfc000000, value: 0x60000000, op: BLT, args: instArgs{arg_rj, arg_rd, arg_offset_15_0}}, ++ // BLTU rj, rd, offs ++ {mask: 0xfc000000, value: 0x68000000, op: BLTU, args: instArgs{arg_rj, arg_rd, arg_offset_15_0}}, ++ // BNE rj, rd, offs ++ {mask: 0xfc000000, value: 0x5c000000, op: BNE, args: instArgs{arg_rj, arg_rd, arg_offset_15_0}}, ++ // BNEZ rj, offs ++ {mask: 0xfc000000, value: 0x44000000, op: BNEZ, args: instArgs{arg_rj, arg_offset_20_0}}, ++ // BREAK code ++ {mask: 0xffff8000, value: 0x002a0000, op: BREAK, args: instArgs{arg_code_14_0}}, ++ // BSTRINS.D rd, rj, msbd, lsbd ++ {mask: 0xffc00000, value: 0x00800000, op: BSTRINS_D, args: instArgs{arg_rd, arg_rj, arg_msbd, arg_lsbd}}, ++ // BSTRINS.W rd, rj, msbw, lsbw ++ {mask: 0xffe08000, value: 0x00600000, op: BSTRINS_W, args: instArgs{arg_rd, arg_rj, arg_msbw, arg_lsbw}}, ++ // BSTRPICK.D rd, rj, msbd, lsbd ++ {mask: 0xffc00000, value: 0x00c00000, op: BSTRPICK_D, args: instArgs{arg_rd, arg_rj, arg_msbd, arg_lsbd}}, ++ // BSTRPICK.W rd, rj, msbw, lsbw ++ {mask: 0xffe08000, value: 0x00608000, op: BSTRPICK_W, args: instArgs{arg_rd, arg_rj, arg_msbw, arg_lsbw}}, ++ // BYTEPICK.D rd, rj, rk, sa3 ++ {mask: 0xfffc0000, value: 0x000c0000, op: BYTEPICK_D, args: instArgs{arg_rd, arg_rj, arg_rk, arg_sa3_17_15}}, ++ // BYTEPICK.W rd, rj, rk, sa2 ++ {mask: 0xfffe0000, value: 0x00080000, op: BYTEPICK_W, args: instArgs{arg_rd, arg_rj, arg_rk, arg_sa2_16_15}}, ++ // CACOP code, rj, si12 ++ {mask: 0xffc00000, value: 0x06000000, op: CACOP, args: instArgs{arg_code_4_0, arg_rj, arg_si12_21_10}}, ++ // CLO.D rd, rj ++ {mask: 0xfffffc00, value: 0x00002000, op: CLO_D, args: instArgs{arg_rd, arg_rj}}, ++ // CLO.W rd, rj ++ {mask: 0xfffffc00, value: 0x00001000, op: CLO_W, args: instArgs{arg_rd, arg_rj}}, ++ // CLZ.D rd, rj ++ {mask: 0xfffffc00, value: 0x00002400, op: CLZ_D, args: instArgs{arg_rd, arg_rj}}, ++ // CLZ.W rd, rj ++ {mask: 0xfffffc00, value: 0x00001400, op: CLZ_W, args: instArgs{arg_rd, arg_rj}}, ++ // CPUCFG rd, rj ++ {mask: 0xfffffc00, value: 0x00006c00, op: CPUCFG, args: instArgs{arg_rd, arg_rj}}, ++ // CRCC.W.B.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x00260000, op: CRCC_W_B_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // CRCC.W.D.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x00278000, op: CRCC_W_D_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // CRCC.W.H.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x00268000, op: CRCC_W_H_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // CRCC.W.W.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x00270000, op: CRCC_W_W_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // CRC.W.B.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x00240000, op: CRC_W_B_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // CRC.W.D.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x00258000, op: CRC_W_D_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // CRC.W.H.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x00248000, op: CRC_W_H_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // CRC.W.W.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x00250000, op: CRC_W_W_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // CSRRD rd, csr ++ {mask: 0xff0003e0, value: 0x04000000, op: CSRRD, args: instArgs{arg_rd, arg_csr_23_10}}, ++ // CSRWR rd, csr ++ {mask: 0xff0003e0, value: 0x04000020, op: CSRWR, args: instArgs{arg_rd, arg_csr_23_10}}, ++ // CSRXCHG rd, rj, csr ++ {mask: 0xff000000, value: 0x04000000, op: CSRXCHG, args: instArgs{arg_rd, arg_rj, arg_csr_23_10}}, ++ // CTO.D rd, rj ++ {mask: 0xfffffc00, value: 0x00002800, op: CTO_D, args: instArgs{arg_rd, arg_rj}}, ++ // CTO.W rd, rj ++ {mask: 0xfffffc00, value: 0x00001800, op: CTO_W, args: instArgs{arg_rd, arg_rj}}, ++ // CTZ.D rd, rj ++ {mask: 0xfffffc00, value: 0x00002c00, op: CTZ_D, args: instArgs{arg_rd, arg_rj}}, ++ // CTZ.W rd, rj ++ {mask: 0xfffffc00, value: 0x00001c00, op: CTZ_W, args: instArgs{arg_rd, arg_rj}}, ++ // DBAR hint ++ {mask: 0xffff8000, value: 0x38720000, op: DBAR, args: instArgs{arg_hint_14_0}}, ++ // DBCL code ++ {mask: 0xffff8000, value: 0x002a8000, op: DBCL, args: instArgs{arg_code_14_0}}, ++ // DIV.D rd, rj, rk ++ {mask: 0xffff8000, value: 0x00220000, op: DIV_D, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // DIV.DU rd, rj, rk ++ {mask: 0xffff8000, value: 0x00230000, op: DIV_DU, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // DIV.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x00200000, op: DIV_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // DIV.WU rd, rj, rk ++ {mask: 0xffff8000, value: 0x00210000, op: DIV_WU, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // ERTN ++ {mask: 0xffffffff, value: 0x06483800, op: ERTN, args: instArgs{}}, ++ // EXT.W.B rd, rj ++ {mask: 0xfffffc00, value: 0x00005c00, op: EXT_W_B, args: instArgs{arg_rd, arg_rj}}, ++ // EXT.W.H rd, rj ++ {mask: 0xfffffc00, value: 0x00005800, op: EXT_W_H, args: instArgs{arg_rd, arg_rj}}, ++ // FABS.D fd, fj ++ {mask: 0xfffffc00, value: 0x01140800, op: FABS_D, args: instArgs{arg_fd, arg_fj}}, ++ // FABS.S fd, fj ++ {mask: 0xfffffc00, value: 0x01140400, op: FABS_S, args: instArgs{arg_fd, arg_fj}}, ++ // FADD.D fd, fj, fk ++ {mask: 0xffff8000, value: 0x01010000, op: FADD_D, args: instArgs{arg_fd, arg_fj, arg_fk}}, ++ // FADD.S fd, fj, fk ++ {mask: 0xffff8000, value: 0x01008000, op: FADD_S, args: instArgs{arg_fd, arg_fj, arg_fk}}, ++ // FCLASS.D fd, fj ++ {mask: 0xfffffc00, value: 0x01143800, op: FCLASS_D, args: instArgs{arg_fd, arg_fj}}, ++ // FCLASS.S fd, fj ++ {mask: 0xfffffc00, value: 0x01143400, op: FCLASS_S, args: instArgs{arg_fd, arg_fj}}, ++ // FCMP.CAF.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c200000, op: FCMP_CAF_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.CAF.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c100000, op: FCMP_CAF_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.CEQ.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c220000, op: FCMP_CEQ_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.CEQ.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c120000, op: FCMP_CEQ_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.CLE.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c230000, op: FCMP_CLE_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.CLE.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c130000, op: FCMP_CLE_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.CLT.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c210000, op: FCMP_CLT_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.CLT.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c110000, op: FCMP_CLT_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.CNE.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c280000, op: FCMP_CNE_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.CNE.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c180000, op: FCMP_CNE_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.COR.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c2a0000, op: FCMP_COR_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.COR.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c1a0000, op: FCMP_COR_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.CUEQ.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c260000, op: FCMP_CUEQ_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.CUEQ.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c160000, op: FCMP_CUEQ_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.CULE.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c270000, op: FCMP_CULE_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.CULE.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c170000, op: FCMP_CULE_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.CULT.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c250000, op: FCMP_CULT_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.CULT.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c150000, op: FCMP_CULT_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.CUNE.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c2c0000, op: FCMP_CUNE_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.CUNE.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c1c0000, op: FCMP_CUNE_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.CUN.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c240000, op: FCMP_CUN_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.CUN.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c140000, op: FCMP_CUN_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SAF.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c208000, op: FCMP_SAF_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SAF.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c108000, op: FCMP_SAF_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SEQ.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c228000, op: FCMP_SEQ_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SEQ.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c128000, op: FCMP_SEQ_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SLE.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c238000, op: FCMP_SLE_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SLE.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c138000, op: FCMP_SLE_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SLT.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c218000, op: FCMP_SLT_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SLT.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c118000, op: FCMP_SLT_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SNE.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c288000, op: FCMP_SNE_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SNE.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c188000, op: FCMP_SNE_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SOR.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c2a8000, op: FCMP_SOR_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SOR.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c1a8000, op: FCMP_SOR_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SUEQ.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c268000, op: FCMP_SUEQ_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SUEQ.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c168000, op: FCMP_SUEQ_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SULE.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c278000, op: FCMP_SULE_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SULE.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c178000, op: FCMP_SULE_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SULT.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c258000, op: FCMP_SULT_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SULT.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c158000, op: FCMP_SULT_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SUNE.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c2c8000, op: FCMP_SUNE_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SUNE.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c1c8000, op: FCMP_SUNE_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SUN.D cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c248000, op: FCMP_SUN_D, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCMP.SUN.S cd, fj, fk ++ {mask: 0xffff8018, value: 0x0c148000, op: FCMP_SUN_S, args: instArgs{arg_cd, arg_fj, arg_fk}}, ++ // FCOPYSIGN.D fd, fj, fk ++ {mask: 0xffff8000, value: 0x01130000, op: FCOPYSIGN_D, args: instArgs{arg_fd, arg_fj, arg_fk}}, ++ // FCOPYSIGN.S fd, fj, fk ++ {mask: 0xffff8000, value: 0x01128000, op: FCOPYSIGN_S, args: instArgs{arg_fd, arg_fj, arg_fk}}, ++ // FCVT.D.S fd, fj ++ {mask: 0xfffffc00, value: 0x01192400, op: FCVT_D_S, args: instArgs{arg_fd, arg_fj}}, ++ // FCVT.S.D fd, fj ++ {mask: 0xfffffc00, value: 0x01191800, op: FCVT_S_D, args: instArgs{arg_fd, arg_fj}}, ++ // FDIV.D fd, fj, fk ++ {mask: 0xffff8000, value: 0x01070000, op: FDIV_D, args: instArgs{arg_fd, arg_fj, arg_fk}}, ++ // FDIV.S fd, fj, fk ++ {mask: 0xffff8000, value: 0x01068000, op: FDIV_S, args: instArgs{arg_fd, arg_fj, arg_fk}}, ++ // FFINT.D.L fd, fj ++ {mask: 0xfffffc00, value: 0x011d2800, op: FFINT_D_L, args: instArgs{arg_fd, arg_fj}}, ++ // FFINT.D.W fd, fj ++ {mask: 0xfffffc00, value: 0x011d2000, op: FFINT_D_W, args: instArgs{arg_fd, arg_fj}}, ++ // FFINT.S.L fd, fj ++ {mask: 0xfffffc00, value: 0x011d1800, op: FFINT_S_L, args: instArgs{arg_fd, arg_fj}}, ++ // FFINT.S.W fd, fj ++ {mask: 0xfffffc00, value: 0x011d1000, op: FFINT_S_W, args: instArgs{arg_fd, arg_fj}}, ++ // FLDGT.D fd, rj, rk ++ {mask: 0xffff8000, value: 0x38748000, op: FLDGT_D, args: instArgs{arg_fd, arg_rj, arg_rk}}, ++ // FLDGT.S fd, rj, rk ++ {mask: 0xffff8000, value: 0x38740000, op: FLDGT_S, args: instArgs{arg_fd, arg_rj, arg_rk}}, ++ // FLDLE.D fd, rj, rk ++ {mask: 0xffff8000, value: 0x38758000, op: FLDLE_D, args: instArgs{arg_fd, arg_rj, arg_rk}}, ++ // FLDLE.S fd, rj, rk ++ {mask: 0xffff8000, value: 0x38750000, op: FLDLE_S, args: instArgs{arg_fd, arg_rj, arg_rk}}, ++ // FLDX.D fd, rj, rk ++ {mask: 0xffff8000, value: 0x38340000, op: FLDX_D, args: instArgs{arg_fd, arg_rj, arg_rk}}, ++ // FLDX.S fd, rj, rk ++ {mask: 0xffff8000, value: 0x38300000, op: FLDX_S, args: instArgs{arg_fd, arg_rj, arg_rk}}, ++ // FLD.D fd, rj, si12 ++ {mask: 0xffc00000, value: 0x2b800000, op: FLD_D, args: instArgs{arg_fd, arg_rj, arg_si12_21_10}}, ++ // FLD.S fd, rj, si12 ++ {mask: 0xffc00000, value: 0x2b000000, op: FLD_S, args: instArgs{arg_fd, arg_rj, arg_si12_21_10}}, ++ // FLOGB.D fd, fj ++ {mask: 0xfffffc00, value: 0x01142800, op: FLOGB_D, args: instArgs{arg_fd, arg_fj}}, ++ // FLOGB.S fd, fj ++ {mask: 0xfffffc00, value: 0x01142400, op: FLOGB_S, args: instArgs{arg_fd, arg_fj}}, ++ // FMADD.D fd, fj, fk, fa ++ {mask: 0xfff00000, value: 0x08200000, op: FMADD_D, args: instArgs{arg_fd, arg_fj, arg_fk, arg_fa}}, ++ // FMADD.S fd, fj, fk, fa ++ {mask: 0xfff00000, value: 0x08100000, op: FMADD_S, args: instArgs{arg_fd, arg_fj, arg_fk, arg_fa}}, ++ // FMAXA.D fd, fj, fk ++ {mask: 0xffff8000, value: 0x010d0000, op: FMAXA_D, args: instArgs{arg_fd, arg_fj, arg_fk}}, ++ // FMAXA.S fd, fj, fk ++ {mask: 0xffff8000, value: 0x010c8000, op: FMAXA_S, args: instArgs{arg_fd, arg_fj, arg_fk}}, ++ // FMAX.D fd, fj, fk ++ {mask: 0xffff8000, value: 0x01090000, op: FMAX_D, args: instArgs{arg_fd, arg_fj, arg_fk}}, ++ // FMAX.S fd, fj, fk ++ {mask: 0xffff8000, value: 0x01088000, op: FMAX_S, args: instArgs{arg_fd, arg_fj, arg_fk}}, ++ // FMINA.D fd, fj, fk ++ {mask: 0xffff8000, value: 0x010f0000, op: FMINA_D, args: instArgs{arg_fd, arg_fj, arg_fk}}, ++ // FMINA.S fd, fj, fk ++ {mask: 0xffff8000, value: 0x010e8000, op: FMINA_S, args: instArgs{arg_fd, arg_fj, arg_fk}}, ++ // FMIN.D fd, fj, fk ++ {mask: 0xffff8000, value: 0x010b0000, op: FMIN_D, args: instArgs{arg_fd, arg_fj, arg_fk}}, ++ // FMIN.S fd, fj, fk ++ {mask: 0xffff8000, value: 0x010a8000, op: FMIN_S, args: instArgs{arg_fd, arg_fj, arg_fk}}, ++ // FMOV.D fd, fj ++ {mask: 0xfffffc00, value: 0x01149800, op: FMOV_D, args: instArgs{arg_fd, arg_fj}}, ++ // FMOV.S fd, fj ++ {mask: 0xfffffc00, value: 0x01149400, op: FMOV_S, args: instArgs{arg_fd, arg_fj}}, ++ // FMSUB.D fd, fj, fk, fa ++ {mask: 0xfff00000, value: 0x08600000, op: FMSUB_D, args: instArgs{arg_fd, arg_fj, arg_fk, arg_fa}}, ++ // FMSUB.S fd, fj, fk, fa ++ {mask: 0xfff00000, value: 0x08500000, op: FMSUB_S, args: instArgs{arg_fd, arg_fj, arg_fk, arg_fa}}, ++ // FMUL.D fd, fj, fk ++ {mask: 0xffff8000, value: 0x01050000, op: FMUL_D, args: instArgs{arg_fd, arg_fj, arg_fk}}, ++ // FMUL.S fd, fj, fk ++ {mask: 0xffff8000, value: 0x01048000, op: FMUL_S, args: instArgs{arg_fd, arg_fj, arg_fk}}, ++ // FNEG.D fd, fj ++ {mask: 0xfffffc00, value: 0x01141800, op: FNEG_D, args: instArgs{arg_fd, arg_fj}}, ++ // FNEG.S fd, fj ++ {mask: 0xfffffc00, value: 0x01141400, op: FNEG_S, args: instArgs{arg_fd, arg_fj}}, ++ // FNMADD.D fd, fj, fk, fa ++ {mask: 0xfff00000, value: 0x08a00000, op: FNMADD_D, args: instArgs{arg_fd, arg_fj, arg_fk, arg_fa}}, ++ // FNMADD.S fd, fj, fk, fa ++ {mask: 0xfff00000, value: 0x08900000, op: FNMADD_S, args: instArgs{arg_fd, arg_fj, arg_fk, arg_fa}}, ++ // FNMSUB.D fd, fj, fk, fa ++ {mask: 0xfff00000, value: 0x08e00000, op: FNMSUB_D, args: instArgs{arg_fd, arg_fj, arg_fk, arg_fa}}, ++ // FNMSUB.S fd, fj, fk, fa ++ {mask: 0xfff00000, value: 0x08d00000, op: FNMSUB_S, args: instArgs{arg_fd, arg_fj, arg_fk, arg_fa}}, ++ // FRECIP.D fd, fj ++ {mask: 0xfffffc00, value: 0x01145800, op: FRECIP_D, args: instArgs{arg_fd, arg_fj}}, ++ // FRECIP.S fd, fj ++ {mask: 0xfffffc00, value: 0x01145400, op: FRECIP_S, args: instArgs{arg_fd, arg_fj}}, ++ // FRINT.D fd, fj ++ {mask: 0xfffffc00, value: 0x011e4800, op: FRINT_D, args: instArgs{arg_fd, arg_fj}}, ++ // FRINT.S fd, fj ++ {mask: 0xfffffc00, value: 0x011e4400, op: FRINT_S, args: instArgs{arg_fd, arg_fj}}, ++ // FRSQRT.D fd, fj ++ {mask: 0xfffffc00, value: 0x01146800, op: FRSQRT_D, args: instArgs{arg_fd, arg_fj}}, ++ // FRSQRT.S fd, fj ++ {mask: 0xfffffc00, value: 0x01146400, op: FRSQRT_S, args: instArgs{arg_fd, arg_fj}}, ++ // FSCALEB.D fd, fj, fk ++ {mask: 0xffff8000, value: 0x01110000, op: FSCALEB_D, args: instArgs{arg_fd, arg_fj, arg_fk}}, ++ // FSCALEB.S fd, fj, fk ++ {mask: 0xffff8000, value: 0x01108000, op: FSCALEB_S, args: instArgs{arg_fd, arg_fj, arg_fk}}, ++ // FSEL fd, fj, fk, ca ++ {mask: 0xfffc0000, value: 0x0d000000, op: FSEL, args: instArgs{arg_fd, arg_fj, arg_fk, arg_ca}}, ++ // FSQRT.D fd, fj ++ {mask: 0xfffffc00, value: 0x01144800, op: FSQRT_D, args: instArgs{arg_fd, arg_fj}}, ++ // FSQRT.S fd, fj ++ {mask: 0xfffffc00, value: 0x01144400, op: FSQRT_S, args: instArgs{arg_fd, arg_fj}}, ++ // FSTGT.D fd, rj, rk ++ {mask: 0xffff8000, value: 0x38768000, op: FSTGT_D, args: instArgs{arg_fd, arg_rj, arg_rk}}, ++ // FSTGT.S fd, rj, rk ++ {mask: 0xffff8000, value: 0x38760000, op: FSTGT_S, args: instArgs{arg_fd, arg_rj, arg_rk}}, ++ // FSTLE.D fd, rj, rk ++ {mask: 0xffff8000, value: 0x38778000, op: FSTLE_D, args: instArgs{arg_fd, arg_rj, arg_rk}}, ++ // FSTLE.S fd, rj, rk ++ {mask: 0xffff8000, value: 0x38770000, op: FSTLE_S, args: instArgs{arg_fd, arg_rj, arg_rk}}, ++ // FSTX.D fd, rj, rk ++ {mask: 0xffff8000, value: 0x383c0000, op: FSTX_D, args: instArgs{arg_fd, arg_rj, arg_rk}}, ++ // FSTX.S fd, rj, rk ++ {mask: 0xffff8000, value: 0x38380000, op: FSTX_S, args: instArgs{arg_fd, arg_rj, arg_rk}}, ++ // FST.D fd, rj, si12 ++ {mask: 0xffc00000, value: 0x2bc00000, op: FST_D, args: instArgs{arg_fd, arg_rj, arg_si12_21_10}}, ++ // FST.S fd, rj, si12 ++ {mask: 0xffc00000, value: 0x2b400000, op: FST_S, args: instArgs{arg_fd, arg_rj, arg_si12_21_10}}, ++ // FSUB.D fd, fj, fk ++ {mask: 0xffff8000, value: 0x01030000, op: FSUB_D, args: instArgs{arg_fd, arg_fj, arg_fk}}, ++ // FSUB.S fd, fj, fk ++ {mask: 0xffff8000, value: 0x01028000, op: FSUB_S, args: instArgs{arg_fd, arg_fj, arg_fk}}, ++ // FTINTRM.L.D fd, fj ++ {mask: 0xfffffc00, value: 0x011a2800, op: FTINTRM_L_D, args: instArgs{arg_fd, arg_fj}}, ++ // FTINTRM.L.S fd, fj ++ {mask: 0xfffffc00, value: 0x011a2400, op: FTINTRM_L_S, args: instArgs{arg_fd, arg_fj}}, ++ // FTINTRM.W.D fd, fj ++ {mask: 0xfffffc00, value: 0x011a0800, op: FTINTRM_W_D, args: instArgs{arg_fd, arg_fj}}, ++ // FTINTRM.W.S fd, fj ++ {mask: 0xfffffc00, value: 0x011a0400, op: FTINTRM_W_S, args: instArgs{arg_fd, arg_fj}}, ++ // FTINTRNE.L.D fd, fj ++ {mask: 0xfffffc00, value: 0x011ae800, op: FTINTRNE_L_D, args: instArgs{arg_fd, arg_fj}}, ++ // FTINTRNE.L.S fd, fj ++ {mask: 0xfffffc00, value: 0x011ae400, op: FTINTRNE_L_S, args: instArgs{arg_fd, arg_fj}}, ++ // FTINTRNE.W.D fd, fj ++ {mask: 0xfffffc00, value: 0x011ac800, op: FTINTRNE_W_D, args: instArgs{arg_fd, arg_fj}}, ++ // FTINTRNE.W.S fd, fj ++ {mask: 0xfffffc00, value: 0x011ac400, op: FTINTRNE_W_S, args: instArgs{arg_fd, arg_fj}}, ++ // FTINTRP.L.D fd, fj ++ {mask: 0xfffffc00, value: 0x011a6800, op: FTINTRP_L_D, args: instArgs{arg_fd, arg_fj}}, ++ // FTINTRP.L.S fd, fj ++ {mask: 0xfffffc00, value: 0x011a6400, op: FTINTRP_L_S, args: instArgs{arg_fd, arg_fj}}, ++ // FTINTRP.W.D fd, fj ++ {mask: 0xfffffc00, value: 0x011a4800, op: FTINTRP_W_D, args: instArgs{arg_fd, arg_fj}}, ++ // FTINTRP.W.S fd, fj ++ {mask: 0xfffffc00, value: 0x011a4400, op: FTINTRP_W_S, args: instArgs{arg_fd, arg_fj}}, ++ // FTINTRZ.L.D fd, fj ++ {mask: 0xfffffc00, value: 0x011aa800, op: FTINTRZ_L_D, args: instArgs{arg_fd, arg_fj}}, ++ // FTINTRZ.L.S fd, fj ++ {mask: 0xfffffc00, value: 0x011aa400, op: FTINTRZ_L_S, args: instArgs{arg_fd, arg_fj}}, ++ // FTINTRZ.W.D fd, fj ++ {mask: 0xfffffc00, value: 0x011a8800, op: FTINTRZ_W_D, args: instArgs{arg_fd, arg_fj}}, ++ // FTINTRZ.W.S fd, fj ++ {mask: 0xfffffc00, value: 0x011a8400, op: FTINTRZ_W_S, args: instArgs{arg_fd, arg_fj}}, ++ // FTINT.L.D fd, fj ++ {mask: 0xfffffc00, value: 0x011b2800, op: FTINT_L_D, args: instArgs{arg_fd, arg_fj}}, ++ // FTINT.L.S fd, fj ++ {mask: 0xfffffc00, value: 0x011b2400, op: FTINT_L_S, args: instArgs{arg_fd, arg_fj}}, ++ // FTINT.W.D fd, fj ++ {mask: 0xfffffc00, value: 0x011b0800, op: FTINT_W_D, args: instArgs{arg_fd, arg_fj}}, ++ // FTINT.W.S fd, fj ++ {mask: 0xfffffc00, value: 0x011b0400, op: FTINT_W_S, args: instArgs{arg_fd, arg_fj}}, ++ // IBAR hint ++ {mask: 0xffff8000, value: 0x38728000, op: IBAR, args: instArgs{arg_hint_14_0}}, ++ // IDLE level ++ {mask: 0xffff8000, value: 0x06488000, op: IDLE, args: instArgs{arg_level_14_0}}, ++ // INVTLB op, rj, rk ++ {mask: 0xffff8000, value: 0x06498000, op: INVTLB, args: instArgs{arg_op_4_0, arg_rj, arg_rk}}, ++ // IOCSRRD.B rd, rj ++ {mask: 0xfffffc00, value: 0x06480000, op: IOCSRRD_B, args: instArgs{arg_rd, arg_rj}}, ++ // IOCSRRD.D rd, rj ++ {mask: 0xfffffc00, value: 0x06480c00, op: IOCSRRD_D, args: instArgs{arg_rd, arg_rj}}, ++ // IOCSRRD.H rd, rj ++ {mask: 0xfffffc00, value: 0x06480400, op: IOCSRRD_H, args: instArgs{arg_rd, arg_rj}}, ++ // IOCSRRD.W rd, rj ++ {mask: 0xfffffc00, value: 0x06480800, op: IOCSRRD_W, args: instArgs{arg_rd, arg_rj}}, ++ // IOCSRWR.B rd, rj ++ {mask: 0xfffffc00, value: 0x06481000, op: IOCSRWR_B, args: instArgs{arg_rd, arg_rj}}, ++ // IOCSRWR.D rd, rj ++ {mask: 0xfffffc00, value: 0x06481c00, op: IOCSRWR_D, args: instArgs{arg_rd, arg_rj}}, ++ // IOCSRWR.H rd, rj ++ {mask: 0xfffffc00, value: 0x06481400, op: IOCSRWR_H, args: instArgs{arg_rd, arg_rj}}, ++ // IOCSRWR.W rd, rj ++ {mask: 0xfffffc00, value: 0x06481800, op: IOCSRWR_W, args: instArgs{arg_rd, arg_rj}}, ++ // JIRL rd, rj, offs ++ {mask: 0xfc000000, value: 0x4c000000, op: JIRL, args: instArgs{arg_rd, arg_rj, arg_offset_15_0}}, ++ // LDDIR rd, rj, level ++ {mask: 0xfffc0000, value: 0x06400000, op: LDDIR, args: instArgs{arg_rd, arg_rj, arg_level_17_10}}, ++ // LDGT.B rd, rj, rk ++ {mask: 0xffff8000, value: 0x38780000, op: LDGT_B, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // LDGT.D rd, rj, rk ++ {mask: 0xffff8000, value: 0x38798000, op: LDGT_D, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // LDGT.H rd, rj, rk ++ {mask: 0xffff8000, value: 0x38788000, op: LDGT_H, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // LDGT.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x38790000, op: LDGT_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // LDLE.B rd, rj, rk ++ {mask: 0xffff8000, value: 0x387a0000, op: LDLE_B, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // LDLE.D rd, rj, rk ++ {mask: 0xffff8000, value: 0x387b8000, op: LDLE_D, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // LDLE.H rd, rj, rk ++ {mask: 0xffff8000, value: 0x387a8000, op: LDLE_H, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // LDLE.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x387b0000, op: LDLE_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // LDPTE rj, seq ++ {mask: 0xfffc001f, value: 0x06440000, op: LDPTE, args: instArgs{arg_rj, arg_seq_17_10}}, ++ // LDPTR.D rd, rj, si14 ++ {mask: 0xff000000, value: 0x26000000, op: LDPTR_D, args: instArgs{arg_rd, arg_rj, arg_si14_23_10}}, ++ // LDPTR.W rd, rj, si14 ++ {mask: 0xff000000, value: 0x24000000, op: LDPTR_W, args: instArgs{arg_rd, arg_rj, arg_si14_23_10}}, ++ // LDX.B rd, rj, rk ++ {mask: 0xffff8000, value: 0x38000000, op: LDX_B, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // LDX.BU rd, rj, rk ++ {mask: 0xffff8000, value: 0x38200000, op: LDX_BU, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // LDX.D rd, rj, rk ++ {mask: 0xffff8000, value: 0x380c0000, op: LDX_D, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // LDX.H rd, rj, rk ++ {mask: 0xffff8000, value: 0x38040000, op: LDX_H, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // LDX.HU rd, rj, rk ++ {mask: 0xffff8000, value: 0x38240000, op: LDX_HU, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // LDX.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x38080000, op: LDX_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // LDX.WU rd, rj, rk ++ {mask: 0xffff8000, value: 0x38280000, op: LDX_WU, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // LD.B rd, rj, si12 ++ {mask: 0xffc00000, value: 0x28000000, op: LD_B, args: instArgs{arg_rd, arg_rj, arg_si12_21_10}}, ++ // LD.BU rd, rj, si12 ++ {mask: 0xffc00000, value: 0x2a000000, op: LD_BU, args: instArgs{arg_rd, arg_rj, arg_si12_21_10}}, ++ // LD.D rd, rj, si12 ++ {mask: 0xffc00000, value: 0x28c00000, op: LD_D, args: instArgs{arg_rd, arg_rj, arg_si12_21_10}}, ++ // LD.H rd, rj, si12 ++ {mask: 0xffc00000, value: 0x28400000, op: LD_H, args: instArgs{arg_rd, arg_rj, arg_si12_21_10}}, ++ // LD.HU rd, rj, si12 ++ {mask: 0xffc00000, value: 0x2a400000, op: LD_HU, args: instArgs{arg_rd, arg_rj, arg_si12_21_10}}, ++ // LD.W rd, rj, si12 ++ {mask: 0xffc00000, value: 0x28800000, op: LD_W, args: instArgs{arg_rd, arg_rj, arg_si12_21_10}}, ++ // LD.WU rd, rj, si12 ++ {mask: 0xffc00000, value: 0x2a800000, op: LD_WU, args: instArgs{arg_rd, arg_rj, arg_si12_21_10}}, ++ // LL.D rd, rj, si14 ++ {mask: 0xff000000, value: 0x22000000, op: LL_D, args: instArgs{arg_rd, arg_rj, arg_si14_23_10}}, ++ // LL.W rd, rj, si14 ++ {mask: 0xff000000, value: 0x20000000, op: LL_W, args: instArgs{arg_rd, arg_rj, arg_si14_23_10}}, ++ // LU12I.W rd, si20 ++ {mask: 0xfe000000, value: 0x14000000, op: LU12I_W, args: instArgs{arg_rd, arg_si20_24_5}}, ++ // LU32I.D rd, si20 ++ {mask: 0xfe000000, value: 0x16000000, op: LU32I_D, args: instArgs{arg_rd, arg_si20_24_5}}, ++ // LU52I.D rd, rj, si12 ++ {mask: 0xffc00000, value: 0x03000000, op: LU52I_D, args: instArgs{arg_rd, arg_rj, arg_si12_21_10}}, ++ // MASKEQZ rd, rj, rk ++ {mask: 0xffff8000, value: 0x00130000, op: MASKEQZ, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // MASKNEZ rd, rj, rk ++ {mask: 0xffff8000, value: 0x00138000, op: MASKNEZ, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // MOD.D rd, rj, rk ++ {mask: 0xffff8000, value: 0x00228000, op: MOD_D, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // MOD.DU rd, rj, rk ++ {mask: 0xffff8000, value: 0x00238000, op: MOD_DU, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // MOD.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x00208000, op: MOD_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // MOD.WU rd, rj, rk ++ {mask: 0xffff8000, value: 0x00218000, op: MOD_WU, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // MOVCF2FR fd, cj ++ {mask: 0xffffff00, value: 0x0114d400, op: MOVCF2FR, args: instArgs{arg_fd, arg_cj}}, ++ // MOVCF2GR rd, cj ++ {mask: 0xffffff00, value: 0x0114dc00, op: MOVCF2GR, args: instArgs{arg_rd, arg_cj}}, ++ // MOVFCSR2GR rd, fcsr ++ {mask: 0xfffffc00, value: 0x0114c800, op: MOVFCSR2GR, args: instArgs{arg_rd, arg_fcsr_9_5}}, ++ // MOVFR2CF cd, fj ++ {mask: 0xfffffc18, value: 0x0114d000, op: MOVFR2CF, args: instArgs{arg_cd, arg_fj}}, ++ // MOVFR2GR.D rd, fj ++ {mask: 0xfffffc00, value: 0x0114b800, op: MOVFR2GR_D, args: instArgs{arg_rd, arg_fj}}, ++ // MOVFR2GR.S rd, fj ++ {mask: 0xfffffc00, value: 0x0114b400, op: MOVFR2GR_S, args: instArgs{arg_rd, arg_fj}}, ++ // MOVFRH2GR.S rd, fj ++ {mask: 0xfffffc00, value: 0x0114bc00, op: MOVFRH2GR_S, args: instArgs{arg_rd, arg_fj}}, ++ // MOVGR2CF cd, rj ++ {mask: 0xfffffc18, value: 0x0114d800, op: MOVGR2CF, args: instArgs{arg_cd, arg_rj}}, ++ // MOVGR2FCSR fcsr, rj ++ {mask: 0xfffffc00, value: 0x0114c000, op: MOVGR2FCSR, args: instArgs{arg_fcsr_4_0, arg_rj}}, ++ // MOVGR2FRH.W fd, rj ++ {mask: 0xfffffc00, value: 0x0114ac00, op: MOVGR2FRH_W, args: instArgs{arg_fd, arg_rj}}, ++ // MOVGR2FR.D fd, rj ++ {mask: 0xfffffc00, value: 0x0114a800, op: MOVGR2FR_D, args: instArgs{arg_fd, arg_rj}}, ++ // MOVGR2FR.W fd, rj ++ {mask: 0xfffffc00, value: 0x0114a400, op: MOVGR2FR_W, args: instArgs{arg_fd, arg_rj}}, ++ // MULH.D rd, rj, rk ++ {mask: 0xffff8000, value: 0x001e0000, op: MULH_D, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // MULH.DU rd, rj, rk ++ {mask: 0xffff8000, value: 0x001e8000, op: MULH_DU, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // MULH.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x001c8000, op: MULH_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // MULH.WU rd, rj, rk ++ {mask: 0xffff8000, value: 0x001d0000, op: MULH_WU, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // MULW.D.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x001f0000, op: MULW_D_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // MULW.D.WU rd, rj, rk ++ {mask: 0xffff8000, value: 0x001f8000, op: MULW_D_WU, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // MUL.D rd, rj, rk ++ {mask: 0xffff8000, value: 0x001d8000, op: MUL_D, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // MUL.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x001c0000, op: MUL_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // NOR rd, rj, rk ++ {mask: 0xffff8000, value: 0x00140000, op: NOR, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // OR rd, rj, rk ++ {mask: 0xffff8000, value: 0x00150000, op: OR, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // ORI rd, rj, ui12 ++ {mask: 0xffc00000, value: 0x03800000, op: ORI, args: instArgs{arg_rd, arg_rj, arg_ui12_21_10}}, ++ // ORN rd, rj, rk ++ {mask: 0xffff8000, value: 0x00160000, op: ORN, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // PCADDI rd, si20 ++ {mask: 0xfe000000, value: 0x18000000, op: PCADDI, args: instArgs{arg_rd, arg_si20_24_5}}, ++ // PCADDU12I rd, si20 ++ {mask: 0xfe000000, value: 0x1c000000, op: PCADDU12I, args: instArgs{arg_rd, arg_si20_24_5}}, ++ // PCADDU18I rd, si20 ++ {mask: 0xfe000000, value: 0x1e000000, op: PCADDU18I, args: instArgs{arg_rd, arg_si20_24_5}}, ++ // PCALAU12I rd, si20 ++ {mask: 0xfe000000, value: 0x1a000000, op: PCALAU12I, args: instArgs{arg_rd, arg_si20_24_5}}, ++ // PRELD hint, rj, si12 ++ {mask: 0xffc00000, value: 0x2ac00000, op: PRELD, args: instArgs{arg_hint_4_0, arg_rj, arg_si12_21_10}}, ++ // PRELDX hint, rj, rk ++ {mask: 0xffff8000, value: 0x382c0000, op: PRELDX, args: instArgs{arg_hint_4_0, arg_rj, arg_rk}}, ++ // RDTIMEH.W rd, rj ++ {mask: 0xfffffc00, value: 0x00006400, op: RDTIMEH_W, args: instArgs{arg_rd, arg_rj}}, ++ // RDTIMEL.W rd, rj ++ {mask: 0xfffffc00, value: 0x00006000, op: RDTIMEL_W, args: instArgs{arg_rd, arg_rj}}, ++ // RDTIME.D rd, rj ++ {mask: 0xfffffc00, value: 0x00006800, op: RDTIME_D, args: instArgs{arg_rd, arg_rj}}, ++ // REVB.2H rd, rj ++ {mask: 0xfffffc00, value: 0x00003000, op: REVB_2H, args: instArgs{arg_rd, arg_rj}}, ++ // REVB.2W rd, rj ++ {mask: 0xfffffc00, value: 0x00003800, op: REVB_2W, args: instArgs{arg_rd, arg_rj}}, ++ // REVB.4H rd, rj ++ {mask: 0xfffffc00, value: 0x00003400, op: REVB_4H, args: instArgs{arg_rd, arg_rj}}, ++ // REVB.D rd, rj ++ {mask: 0xfffffc00, value: 0x00003c00, op: REVB_D, args: instArgs{arg_rd, arg_rj}}, ++ // REVH.2W rd, rj ++ {mask: 0xfffffc00, value: 0x00004000, op: REVH_2W, args: instArgs{arg_rd, arg_rj}}, ++ // REVH.D rd, rj ++ {mask: 0xfffffc00, value: 0x00004400, op: REVH_D, args: instArgs{arg_rd, arg_rj}}, ++ // ROTRI.D rd, rj, ui6 ++ {mask: 0xffff0000, value: 0x004d0000, op: ROTRI_D, args: instArgs{arg_rd, arg_rj, arg_ui6_15_10}}, ++ // ROTRI.W rd, rj, ui5 ++ {mask: 0xffff8000, value: 0x004c8000, op: ROTRI_W, args: instArgs{arg_rd, arg_rj, arg_ui5_14_10}}, ++ // ROTR.D rd, rj, rk ++ {mask: 0xffff8000, value: 0x001b8000, op: ROTR_D, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // ROTR.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x001b0000, op: ROTR_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // SC.D rd, rj, si14 ++ {mask: 0xff000000, value: 0x23000000, op: SC_D, args: instArgs{arg_rd, arg_rj, arg_si14_23_10}}, ++ // SC.W rd, rj, si14 ++ {mask: 0xff000000, value: 0x21000000, op: SC_W, args: instArgs{arg_rd, arg_rj, arg_si14_23_10}}, ++ // SLLI.D rd, rj, ui6 ++ {mask: 0xffff0000, value: 0x00410000, op: SLLI_D, args: instArgs{arg_rd, arg_rj, arg_ui6_15_10}}, ++ // SLLI.W rd, rj, ui5 ++ {mask: 0xffff8000, value: 0x00408000, op: SLLI_W, args: instArgs{arg_rd, arg_rj, arg_ui5_14_10}}, ++ // SLL.D rd, rj, rk ++ {mask: 0xffff8000, value: 0x00188000, op: SLL_D, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // SLL.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x00170000, op: SLL_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // SLT rd, rj, rk ++ {mask: 0xffff8000, value: 0x00120000, op: SLT, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // SLTI rd, rj, si12 ++ {mask: 0xffc00000, value: 0x02000000, op: SLTI, args: instArgs{arg_rd, arg_rj, arg_si12_21_10}}, ++ // SLTU rd, rj, rk ++ {mask: 0xffff8000, value: 0x00128000, op: SLTU, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // SLTUI rd, rj, si12 ++ {mask: 0xffc00000, value: 0x02400000, op: SLTUI, args: instArgs{arg_rd, arg_rj, arg_si12_21_10}}, ++ // SRAI.D rd, rj, ui6 ++ {mask: 0xffff0000, value: 0x00490000, op: SRAI_D, args: instArgs{arg_rd, arg_rj, arg_ui6_15_10}}, ++ // SRAI.W rd, rj, ui5 ++ {mask: 0xffff8000, value: 0x00488000, op: SRAI_W, args: instArgs{arg_rd, arg_rj, arg_ui5_14_10}}, ++ // SRA.D rd, rj, rk ++ {mask: 0xffff8000, value: 0x00198000, op: SRA_D, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // SRA.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x00180000, op: SRA_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // SRLI.D rd, rj, ui6 ++ {mask: 0xffff0000, value: 0x00450000, op: SRLI_D, args: instArgs{arg_rd, arg_rj, arg_ui6_15_10}}, ++ // SRLI.W rd, rj, ui5 ++ {mask: 0xffff8000, value: 0x00448000, op: SRLI_W, args: instArgs{arg_rd, arg_rj, arg_ui5_14_10}}, ++ // SRL.D rd, rj, rk ++ {mask: 0xffff8000, value: 0x00190000, op: SRL_D, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // SRL.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x00178000, op: SRL_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // STGT.B rd, rj, rk ++ {mask: 0xffff8000, value: 0x387c0000, op: STGT_B, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // STGT.D rd, rj, rk ++ {mask: 0xffff8000, value: 0x387d8000, op: STGT_D, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // STGT.H rd, rj, rk ++ {mask: 0xffff8000, value: 0x387c8000, op: STGT_H, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // STGT.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x387d0000, op: STGT_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // STLE.B rd, rj, rk ++ {mask: 0xffff8000, value: 0x387e0000, op: STLE_B, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // STLE.D rd, rj, rk ++ {mask: 0xffff8000, value: 0x387f8000, op: STLE_D, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // STLE.H rd, rj, rk ++ {mask: 0xffff8000, value: 0x387e8000, op: STLE_H, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // STLE.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x387f0000, op: STLE_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // STPTR.D rd, rj, si14 ++ {mask: 0xff000000, value: 0x27000000, op: STPTR_D, args: instArgs{arg_rd, arg_rj, arg_si14_23_10}}, ++ // STPTR.W rd, rj, si14 ++ {mask: 0xff000000, value: 0x25000000, op: STPTR_W, args: instArgs{arg_rd, arg_rj, arg_si14_23_10}}, ++ // STX.B rd, rj, rk ++ {mask: 0xffff8000, value: 0x38100000, op: STX_B, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // STX.D rd, rj, rk ++ {mask: 0xffff8000, value: 0x381c0000, op: STX_D, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // STX.H rd, rj, rk ++ {mask: 0xffff8000, value: 0x38140000, op: STX_H, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // STX.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x38180000, op: STX_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // ST.B rd, rj, si12 ++ {mask: 0xffc00000, value: 0x29000000, op: ST_B, args: instArgs{arg_rd, arg_rj, arg_si12_21_10}}, ++ // ST.D rd, rj, si12 ++ {mask: 0xffc00000, value: 0x29c00000, op: ST_D, args: instArgs{arg_rd, arg_rj, arg_si12_21_10}}, ++ // ST.H rd, rj, si12 ++ {mask: 0xffc00000, value: 0x29400000, op: ST_H, args: instArgs{arg_rd, arg_rj, arg_si12_21_10}}, ++ // ST.W rd, rj, si12 ++ {mask: 0xffc00000, value: 0x29800000, op: ST_W, args: instArgs{arg_rd, arg_rj, arg_si12_21_10}}, ++ // SUB.D rd, rj, rk ++ {mask: 0xffff8000, value: 0x00118000, op: SUB_D, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // SUB.W rd, rj, rk ++ {mask: 0xffff8000, value: 0x00110000, op: SUB_W, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // SYSCALL code ++ {mask: 0xffff8000, value: 0x002b0000, op: SYSCALL, args: instArgs{arg_code_14_0}}, ++ // TLBCLR ++ {mask: 0xffffffff, value: 0x06482000, op: TLBCLR, args: instArgs{}}, ++ // TLBFILL ++ {mask: 0xffffffff, value: 0x06483400, op: TLBFILL, args: instArgs{}}, ++ // TLBFLUSH ++ {mask: 0xffffffff, value: 0x06482400, op: TLBFLUSH, args: instArgs{}}, ++ // TLBRD ++ {mask: 0xffffffff, value: 0x06482c00, op: TLBRD, args: instArgs{}}, ++ // TLBSRCH ++ {mask: 0xffffffff, value: 0x06482800, op: TLBSRCH, args: instArgs{}}, ++ // TLBWR ++ {mask: 0xffffffff, value: 0x06483000, op: TLBWR, args: instArgs{}}, ++ // XOR rd, rj, rk ++ {mask: 0xffff8000, value: 0x00158000, op: XOR, args: instArgs{arg_rd, arg_rj, arg_rk}}, ++ // XORI rd, rj, ui12 ++ {mask: 0xffc00000, value: 0x03c00000, op: XORI, args: instArgs{arg_rd, arg_rj, arg_ui12_21_10}}, ++} +-- +2.38.0 + diff --git a/loongarch64/0099-cmd-internal-objfile-add-loong64-disassembler-suppor.patch b/loongarch64/0099-cmd-internal-objfile-add-loong64-disassembler-suppor.patch new file mode 100644 index 0000000000000000000000000000000000000000..115ae62e6f35fdd5d10c4a1c2785634b5bbd02dd --- /dev/null +++ b/loongarch64/0099-cmd-internal-objfile-add-loong64-disassembler-suppor.patch @@ -0,0 +1,73 @@ +From 8c234d2418b20e31a3082aa076d1b5a9a7012570 Mon Sep 17 00:00:00 2001 +From: Xiaodong Liu +Date: Fri, 10 Feb 2023 15:10:48 +0800 +Subject: [PATCH 18/18] cmd/internal/objfile: add loong64 disassembler support + +Change-Id: I5628436209aa58f1ba781db15ca6e78b62123065 +--- + src/cmd/internal/objfile/disasm.go | 14 ++++++++++++++ + src/cmd/internal/objfile/elf.go | 2 ++ + 2 files changed, 16 insertions(+) + +diff --git a/src/cmd/internal/objfile/disasm.go b/src/cmd/internal/objfile/disasm.go +index b5f1cd1632..ea383b1c91 100644 +--- a/src/cmd/internal/objfile/disasm.go ++++ b/src/cmd/internal/objfile/disasm.go +@@ -23,6 +23,7 @@ import ( + + "golang.org/x/arch/arm/armasm" + "golang.org/x/arch/arm64/arm64asm" ++ "golang.org/x/arch/loong64/loong64asm" + "golang.org/x/arch/ppc64/ppc64asm" + "golang.org/x/arch/x86/x86asm" + ) +@@ -366,6 +367,17 @@ func disasm_arm64(code []byte, pc uint64, lookup lookupFunc, byteOrder binary.By + return text, 4 + } + ++func disasm_loong64(code []byte, pc uint64, lookup lookupFunc, byteOrder binary.ByteOrder, gnuAsm bool) (string, int) { ++ inst, err := loong64asm.Decode(code) ++ var text string ++ if err != nil || inst.Op == 0 { ++ text = "?" ++ } else if gnuAsm { ++ text = fmt.Sprintf("%s %s", "", loong64asm.GNUSyntax(inst)) ++ } ++ return text, 4 ++} ++ + func disasm_ppc64(code []byte, pc uint64, lookup lookupFunc, byteOrder binary.ByteOrder, gnuAsm bool) (string, int) { + inst, err := ppc64asm.Decode(code, byteOrder) + var text string +@@ -388,6 +400,7 @@ var disasms = map[string]disasmFunc{ + "amd64": disasm_amd64, + "arm": disasm_arm, + "arm64": disasm_arm64, ++ "loong64": disasm_loong64, + "ppc64": disasm_ppc64, + "ppc64le": disasm_ppc64, + } +@@ -397,6 +410,7 @@ var byteOrders = map[string]binary.ByteOrder{ + "amd64": binary.LittleEndian, + "arm": binary.LittleEndian, + "arm64": binary.LittleEndian, ++ "loong64": binary.LittleEndian, + "ppc64": binary.BigEndian, + "ppc64le": binary.LittleEndian, + "s390x": binary.BigEndian, +diff --git a/src/cmd/internal/objfile/elf.go b/src/cmd/internal/objfile/elf.go +index a48a9df5d6..50c8c19548 100644 +--- a/src/cmd/internal/objfile/elf.go ++++ b/src/cmd/internal/objfile/elf.go +@@ -101,6 +101,8 @@ func (f *elfFile) goarch() string { + return "arm" + case elf.EM_AARCH64: + return "arm64" ++ case elf.EM_LOONGARCH: ++ return "loong64" + case elf.EM_PPC64: + if f.elf.ByteOrder == binary.LittleEndian { + return "ppc64le" +-- +2.38.0 +