Файловый менеджер - Редактировать - /var/www/html/objabi.zip
Ðазад
PK ! ���t� � pkgspecial.gonu �[��� // Copyright 2023 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 objabi import "sync" // PkgSpecial indicates special build properties of a given runtime-related // package. type PkgSpecial struct { // Runtime indicates that this package is "runtime" or imported by // "runtime". This has several effects (which maybe should be split out): // // - Implicit allocation is disallowed. // // - Various runtime pragmas are enabled. // // - Optimizations are always enabled. // // This should be set for runtime and all packages it imports, and may be // set for additional packages. Runtime bool // NoInstrument indicates this package should not receive sanitizer // instrumentation. In many of these, instrumentation could cause infinite // recursion. This is all runtime packages, plus those that support the // sanitizers. NoInstrument bool // NoRaceFunc indicates functions in this package should not get // racefuncenter/racefuncexit instrumentation Memory accesses in these // packages are either uninteresting or will cause false positives. NoRaceFunc bool // AllowAsmABI indicates that assembly in this package is allowed to use ABI // selectors in symbol names. Generally this is needed for packages that // interact closely with the runtime package or have performance-critical // assembly. AllowAsmABI bool } var runtimePkgs = []string{ "runtime", "runtime/internal/atomic", "runtime/internal/math", "runtime/internal/sys", "runtime/internal/syscall", "internal/abi", "internal/bytealg", "internal/chacha8rand", "internal/coverage/rtcov", "internal/cpu", "internal/goarch", "internal/godebugs", "internal/goexperiment", "internal/goos", } // extraNoInstrumentPkgs is the set of packages in addition to runtimePkgs that // should have NoInstrument set. var extraNoInstrumentPkgs = []string{ "runtime/race", "runtime/msan", "runtime/asan", // We omit bytealg even though it's imported by runtime because it also // backs a lot of package bytes. Currently we don't have a way to omit race // instrumentation when used from the runtime while keeping race // instrumentation when used from user code. Somehow this doesn't seem to // cause problems, though we may be skating on thin ice. See #61204. "-internal/bytealg", } var noRaceFuncPkgs = []string{"sync", "sync/atomic"} var allowAsmABIPkgs = []string{ "runtime", "reflect", "syscall", "internal/bytealg", "internal/chacha8rand", "runtime/internal/syscall", "runtime/internal/startlinetest", } var ( pkgSpecials map[string]PkgSpecial pkgSpecialsOnce sync.Once ) // LookupPkgSpecial returns special build properties for the given package path. func LookupPkgSpecial(pkgPath string) PkgSpecial { pkgSpecialsOnce.Do(func() { // Construct pkgSpecials from various package lists. This lets us use // more flexible logic, while keeping the final map simple, and avoids // the init-time cost of a map. pkgSpecials = make(map[string]PkgSpecial) set := func(elt string, f func(*PkgSpecial)) { s := pkgSpecials[elt] f(&s) pkgSpecials[elt] = s } for _, pkg := range runtimePkgs { set(pkg, func(ps *PkgSpecial) { ps.Runtime = true; ps.NoInstrument = true }) } for _, pkg := range extraNoInstrumentPkgs { if pkg[0] == '-' { set(pkg[1:], func(ps *PkgSpecial) { ps.NoInstrument = false }) } else { set(pkg, func(ps *PkgSpecial) { ps.NoInstrument = true }) } } for _, pkg := range noRaceFuncPkgs { set(pkg, func(ps *PkgSpecial) { ps.NoRaceFunc = true }) } for _, pkg := range allowAsmABIPkgs { set(pkg, func(ps *PkgSpecial) { ps.AllowAsmABI = true }) } }) return pkgSpecials[pkgPath] } PK ! ��W�0 0 symkind.gonu �[��� // Derived from Inferno utils/6l/l.h and related files. // https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/l.h // // Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved. // Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net) // Portions Copyright © 1997-1999 Vita Nuova Limited // Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com) // Portions Copyright © 2004,2006 Bruce Ellis // Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net) // Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others // Portions Copyright © 2009 The Go Authors. All rights reserved. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. package objabi // A SymKind describes the kind of memory represented by a symbol. type SymKind uint8 // Defined SymKind values. // These are used to index into cmd/link/internal/sym/AbiSymKindToSymKind // // TODO(rsc): Give idiomatic Go names. // //go:generate stringer -type=SymKind const ( // An otherwise invalid zero value for the type Sxxx SymKind = iota // Executable instructions STEXT // Read only static data SRODATA // Static data that does not contain any pointers SNOPTRDATA // Static data SDATA // Statically data that is initially all 0s SBSS // Statically data that is initially all 0s and does not contain pointers SNOPTRBSS // Thread-local data that is initially all 0s STLSBSS // Debugging data SDWARFCUINFO SDWARFCONST SDWARFFCN SDWARFABSFCN SDWARFTYPE SDWARFVAR SDWARFRANGE SDWARFLOC SDWARFLINES // Coverage instrumentation counter for libfuzzer. SLIBFUZZER_8BIT_COUNTER // Coverage instrumentation counter, aux variable for cmd/cover SCOVERAGE_COUNTER SCOVERAGE_AUXVAR SSEHUNWINDINFO // Update cmd/link/internal/sym/AbiSymKindToSymKind for new SymKind values. ) PK ! ��ssb b flag_test.gonu �[��� // Copyright 2020 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package objabi import "testing" func TestDecodeArg(t *testing.T) { t.Parallel() tests := []struct { arg, want string }{ {"", ""}, {"hello", "hello"}, {"hello\\n", "hello\n"}, {"hello\\nthere", "hello\nthere"}, {"hello\\\\there", "hello\\there"}, {"\\\\\\n", "\\\n"}, } for _, test := range tests { if got := DecodeArg(test.arg); got != test.want { t.Errorf("decodoeArg(%q) = %q, want %q", test.arg, got, test.want) } } } PK ! �hՈ � stack.gonu �[��� // Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package objabi import ( "internal/abi" "internal/buildcfg" ) func StackNosplit(race bool) int { // This arithmetic must match that in runtime/stack.go:stackNosplit. return abi.StackNosplitBase * stackGuardMultiplier(race) } // stackGuardMultiplier returns a multiplier to apply to the default // stack guard size. Larger multipliers are used for non-optimized // builds that have larger stack frames or for specific targets. func stackGuardMultiplier(race bool) int { // This arithmetic must match that in runtime/internal/sys/consts.go:StackGuardMultiplier. n := 1 // On AIX, a larger stack is needed for syscalls. if buildcfg.GOOS == "aix" { n += 1 } // The race build also needs more stack. if race { n += 1 } return n } PK ! �V^$� � head.gonu �[��� // Derived from Inferno utils/6l/l.h and related files. // https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/l.h // // Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved. // Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net) // Portions Copyright © 1997-1999 Vita Nuova Limited // Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com) // Portions Copyright © 2004,2006 Bruce Ellis // Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net) // Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others // Portions Copyright © 2009 The Go Authors. All rights reserved. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. package objabi import "fmt" // HeadType is the executable header type. type HeadType uint8 const ( Hunknown HeadType = iota Hdarwin Hdragonfly Hfreebsd Hjs Hlinux Hnetbsd Hopenbsd Hplan9 Hsolaris Hwasip1 Hwindows Haix ) func (h *HeadType) Set(s string) error { switch s { case "aix": *h = Haix case "darwin", "ios": *h = Hdarwin case "dragonfly": *h = Hdragonfly case "freebsd": *h = Hfreebsd case "js": *h = Hjs case "linux", "android": *h = Hlinux case "netbsd": *h = Hnetbsd case "openbsd": *h = Hopenbsd case "plan9": *h = Hplan9 case "illumos", "solaris": *h = Hsolaris case "wasip1": *h = Hwasip1 case "windows": *h = Hwindows default: return fmt.Errorf("invalid headtype: %q", s) } return nil } func (h HeadType) String() string { switch h { case Haix: return "aix" case Hdarwin: return "darwin" case Hdragonfly: return "dragonfly" case Hfreebsd: return "freebsd" case Hjs: return "js" case Hlinux: return "linux" case Hnetbsd: return "netbsd" case Hopenbsd: return "openbsd" case Hplan9: return "plan9" case Hsolaris: return "solaris" case Hwasip1: return "wasip1" case Hwindows: return "windows" } return fmt.Sprintf("HeadType(%d)", h) } PK ! `�LJ path_test.gonu �[��� // Copyright 2017 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 objabi import ( "internal/testenv" "os/exec" "strings" "testing" ) var escapeTests = []struct { Path string Escaped string }{ {"foo/bar/v1", "foo/bar/v1"}, {"foo/bar/v.1", "foo/bar/v%2e1"}, {"f.o.o/b.a.r/v1", "f.o.o/b.a.r/v1"}, {"f.o.o/b.a.r/v.1", "f.o.o/b.a.r/v%2e1"}, {"f.o.o/b.a.r/v..1", "f.o.o/b.a.r/v%2e%2e1"}, {"f.o.o/b.a.r/v..1.", "f.o.o/b.a.r/v%2e%2e1%2e"}, {"f.o.o/b.a.r/v%1", "f.o.o/b.a.r/v%251"}, {"runtime", "runtime"}, {"sync/atomic", "sync/atomic"}, {"golang.org/x/tools/godoc", "golang.org/x/tools/godoc"}, {"foo.bar/baz.quux", "foo.bar/baz%2equux"}, {"", ""}, {"%foo%bar", "%25foo%25bar"}, {"\x01\x00\x7F☺", "%01%00%7f%e2%98%ba"}, } func TestPathToPrefix(t *testing.T) { for _, tc := range escapeTests { if got := PathToPrefix(tc.Path); got != tc.Escaped { t.Errorf("expected PathToPrefix(%s) = %s, got %s", tc.Path, tc.Escaped, got) } } } func TestPrefixToPath(t *testing.T) { for _, tc := range escapeTests { got, err := PrefixToPath(tc.Escaped) if err != nil { t.Errorf("expected PrefixToPath(%s) err = nil, got %v", tc.Escaped, err) } if got != tc.Path { t.Errorf("expected PrefixToPath(%s) = %s, got %s", tc.Escaped, tc.Path, got) } } } func TestPrefixToPathError(t *testing.T) { tests := []string{ "foo%", "foo%1", "foo%%12", "foo%1g", } for _, tc := range tests { _, err := PrefixToPath(tc) if err == nil { t.Errorf("expected PrefixToPath(%s) err != nil, got nil", tc) } } } func TestRuntimePackageList(t *testing.T) { // Test that all packages imported by the runtime are marked as runtime // packages. testenv.MustHaveGoBuild(t) goCmd, err := testenv.GoTool() if err != nil { t.Fatal(err) } pkgList, err := exec.Command(goCmd, "list", "-deps", "runtime").Output() if err != nil { if err, ok := err.(*exec.ExitError); ok { t.Log(string(err.Stderr)) } t.Fatal(err) } for _, pkg := range strings.Split(strings.TrimRight(string(pkgList), "\n"), "\n") { if pkg == "unsafe" { continue } if !LookupPkgSpecial(pkg).Runtime { t.Errorf("package %s is imported by runtime, but not marked Runtime", pkg) } } } PK ! {�)�� � path.gonu �[��� // Copyright 2017 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 objabi import ( "fmt" "strconv" "strings" ) // PathToPrefix converts raw string to the prefix that will be used in the // symbol table. All control characters, space, '%' and '"', as well as // non-7-bit clean bytes turn into %xx. The period needs escaping only in the // last segment of the path, and it makes for happier users if we escape that as // little as possible. func PathToPrefix(s string) string { slash := strings.LastIndex(s, "/") // check for chars that need escaping n := 0 for r := 0; r < len(s); r++ { if c := s[r]; c <= ' ' || (c == '.' && r > slash) || c == '%' || c == '"' || c >= 0x7F { n++ } } // quick exit if n == 0 { return s } // escape const hex = "0123456789abcdef" p := make([]byte, 0, len(s)+2*n) for r := 0; r < len(s); r++ { if c := s[r]; c <= ' ' || (c == '.' && r > slash) || c == '%' || c == '"' || c >= 0x7F { p = append(p, '%', hex[c>>4], hex[c&0xF]) } else { p = append(p, c) } } return string(p) } // PrefixToPath is the inverse of PathToPrefix, replacing escape sequences with // the original character. func PrefixToPath(s string) (string, error) { percent := strings.IndexByte(s, '%') if percent == -1 { return s, nil } p := make([]byte, 0, len(s)) for i := 0; i < len(s); { if s[i] != '%' { p = append(p, s[i]) i++ continue } if i+2 >= len(s) { // Not enough characters remaining to be a valid escape // sequence. return "", fmt.Errorf("malformed prefix %q: escape sequence must contain two hex digits", s) } b, err := strconv.ParseUint(s[i+1:i+3], 16, 8) if err != nil { // Not a valid escape sequence. return "", fmt.Errorf("malformed prefix %q: escape sequence %q must contain two hex digits", s, s[i:i+3]) } p = append(p, byte(b)) i += 3 } return string(p), nil } PK ! 8���� � typekind.gonu �[��� // Copyright 2012 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package objabi // Must match runtime and reflect. // Included by cmd/gc. const ( KindBool = 1 + iota KindInt KindInt8 KindInt16 KindInt32 KindInt64 KindUint KindUint8 KindUint16 KindUint32 KindUint64 KindUintptr KindFloat32 KindFloat64 KindComplex64 KindComplex128 KindArray KindChan KindFunc KindInterface KindMap KindPtr KindSlice KindString KindStruct KindUnsafePointer KindDirectIface = 1 << 5 KindGCProg = 1 << 6 KindMask = (1 << 5) - 1 ) PK ! �lv v funcid.gonu �[��� // 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. package objabi import ( "internal/abi" "strings" ) var funcIDs = map[string]abi.FuncID{ "abort": abi.FuncID_abort, "asmcgocall": abi.FuncID_asmcgocall, "asyncPreempt": abi.FuncID_asyncPreempt, "cgocallback": abi.FuncID_cgocallback, "corostart": abi.FuncID_corostart, "debugCallV2": abi.FuncID_debugCallV2, "gcBgMarkWorker": abi.FuncID_gcBgMarkWorker, "rt0_go": abi.FuncID_rt0_go, "goexit": abi.FuncID_goexit, "gogo": abi.FuncID_gogo, "gopanic": abi.FuncID_gopanic, "handleAsyncEvent": abi.FuncID_handleAsyncEvent, "main": abi.FuncID_runtime_main, "mcall": abi.FuncID_mcall, "morestack": abi.FuncID_morestack, "mstart": abi.FuncID_mstart, "panicwrap": abi.FuncID_panicwrap, "runfinq": abi.FuncID_runfinq, "sigpanic": abi.FuncID_sigpanic, "systemstack_switch": abi.FuncID_systemstack_switch, "systemstack": abi.FuncID_systemstack, // Don't show in call stack but otherwise not special. "deferreturn": abi.FuncIDWrapper, } // Get the function ID for the named function in the named file. // The function should be package-qualified. func GetFuncID(name string, isWrapper bool) abi.FuncID { if isWrapper { return abi.FuncIDWrapper } if strings.HasPrefix(name, "runtime.") { if id, ok := funcIDs[name[len("runtime."):]]; ok { return id } } return abi.FuncIDNormal } PK ! ]��/� � line_test.gonu �[��� // Copyright 2019 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package objabi import ( "path/filepath" "runtime" "testing" ) // On Windows, "/foo" is reported as a relative path // (it is relative to the current drive letter), // so we need add a drive letter to test absolute path cases. func drive() string { if runtime.GOOS == "windows" { return "c:" } return "" } var absFileTests = []struct { dir string file string rewrites string abs string }{ {"/d", "f", "", "/d/f"}, {"/d", drive() + "/f", "", drive() + "/f"}, {"/d", "f/g", "", "/d/f/g"}, {"/d", drive() + "/f/g", "", drive() + "/f/g"}, {"/d", "f", "/d/f", "??"}, {"/d", "f/g", "/d/f", "g"}, {"/d", "f/g", "/d/f=>h", "h/g"}, {"/d", "f/g", "/d/f=>/h", "/h/g"}, {"/d", "f/g", "/d/f=>/h;/d/e=>/i", "/h/g"}, {"/d", "e/f", "/d/f=>/h;/d/e=>/i", "/i/f"}, } func TestAbsFile(t *testing.T) { for _, tt := range absFileTests { abs := filepath.FromSlash(AbsFile(filepath.FromSlash(tt.dir), filepath.FromSlash(tt.file), tt.rewrites)) want := filepath.FromSlash(tt.abs) if abs != want { t.Errorf("AbsFile(%q, %q, %q) = %q, want %q", tt.dir, tt.file, tt.rewrites, abs, want) } } } PK ! 4j�$ $ autotype.gonu �[��� // Derived from Inferno utils/6l/l.h and related files. // https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/l.h // // Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved. // Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net) // Portions Copyright © 1997-1999 Vita Nuova Limited // Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com) // Portions Copyright © 2004,2006 Bruce Ellis // Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net) // Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others // Portions Copyright © 2009 The Go Authors. All rights reserved. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. package objabi // Auto.name const ( A_AUTO = 1 + iota A_PARAM A_DELETED_AUTO ) PK ! 8��d@ @ zbootstrap.gonu �[��� // Code generated by go tool dist; DO NOT EDIT. package objabi PK ! ��~� � util.gonu �[��� // Copyright 2015 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 objabi import ( "fmt" "strings" "internal/buildcfg" ) const ( ElfRelocOffset = 256 MachoRelocOffset = 2048 // reserve enough space for ELF relocations GlobalDictPrefix = ".dict" // prefix for names of global dictionaries ) // HeaderString returns the toolchain configuration string written in // Go object headers. This string ensures we don't attempt to import // or link object files that are incompatible with each other. This // string always starts with "go object ". func HeaderString() string { archExtra := "" if k, v := buildcfg.GOGOARCH(); k != "" && v != "" { archExtra = " " + k + "=" + v } return fmt.Sprintf("go object %s %s %s%s X:%s\n", buildcfg.GOOS, buildcfg.GOARCH, buildcfg.Version, archExtra, strings.Join(buildcfg.Experiment.Enabled(), ",")) } PK ! x���� � reloctype_string.gonu �[��� // Code generated by "stringer -type=RelocType"; DO NOT EDIT. package objabi import "strconv" func _() { // An "invalid array index" compiler error signifies that the constant values have changed. // Re-run the stringer command to generate them again. var x [1]struct{} _ = x[R_ADDR-1] _ = x[R_ADDRPOWER-2] _ = x[R_ADDRARM64-3] _ = x[R_ADDRMIPS-4] _ = x[R_ADDROFF-5] _ = x[R_SIZE-6] _ = x[R_CALL-7] _ = x[R_CALLARM-8] _ = x[R_CALLARM64-9] _ = x[R_CALLIND-10] _ = x[R_CALLPOWER-11] _ = x[R_CALLMIPS-12] _ = x[R_CONST-13] _ = x[R_PCREL-14] _ = x[R_TLS_LE-15] _ = x[R_TLS_IE-16] _ = x[R_GOTOFF-17] _ = x[R_PLT0-18] _ = x[R_PLT1-19] _ = x[R_PLT2-20] _ = x[R_USEFIELD-21] _ = x[R_USETYPE-22] _ = x[R_USEIFACE-23] _ = x[R_USEIFACEMETHOD-24] _ = x[R_USENAMEDMETHOD-25] _ = x[R_METHODOFF-26] _ = x[R_KEEP-27] _ = x[R_POWER_TOC-28] _ = x[R_GOTPCREL-29] _ = x[R_JMPMIPS-30] _ = x[R_DWARFSECREF-31] _ = x[R_DWARFFILEREF-32] _ = x[R_ARM64_TLS_LE-33] _ = x[R_ARM64_TLS_IE-34] _ = x[R_ARM64_GOTPCREL-35] _ = x[R_ARM64_GOT-36] _ = x[R_ARM64_PCREL-37] _ = x[R_ARM64_PCREL_LDST8-38] _ = x[R_ARM64_PCREL_LDST16-39] _ = x[R_ARM64_PCREL_LDST32-40] _ = x[R_ARM64_PCREL_LDST64-41] _ = x[R_ARM64_LDST8-42] _ = x[R_ARM64_LDST16-43] _ = x[R_ARM64_LDST32-44] _ = x[R_ARM64_LDST64-45] _ = x[R_ARM64_LDST128-46] _ = x[R_POWER_TLS_LE-47] _ = x[R_POWER_TLS_IE-48] _ = x[R_POWER_TLS-49] _ = x[R_POWER_TLS_IE_PCREL34-50] _ = x[R_POWER_TLS_LE_TPREL34-51] _ = x[R_ADDRPOWER_DS-52] _ = x[R_ADDRPOWER_GOT-53] _ = x[R_ADDRPOWER_GOT_PCREL34-54] _ = x[R_ADDRPOWER_PCREL-55] _ = x[R_ADDRPOWER_TOCREL-56] _ = x[R_ADDRPOWER_TOCREL_DS-57] _ = x[R_ADDRPOWER_D34-58] _ = x[R_ADDRPOWER_PCREL34-59] _ = x[R_RISCV_JAL-60] _ = x[R_RISCV_JAL_TRAMP-61] _ = x[R_RISCV_CALL-62] _ = x[R_RISCV_PCREL_ITYPE-63] _ = x[R_RISCV_PCREL_STYPE-64] _ = x[R_RISCV_TLS_IE-65] _ = x[R_RISCV_TLS_LE-66] _ = x[R_RISCV_GOT_HI20-67] _ = x[R_RISCV_PCREL_HI20-68] _ = x[R_RISCV_PCREL_LO12_I-69] _ = x[R_RISCV_PCREL_LO12_S-70] _ = x[R_RISCV_BRANCH-71] _ = x[R_RISCV_RVC_BRANCH-72] _ = x[R_RISCV_RVC_JUMP-73] _ = x[R_PCRELDBL-74] _ = x[R_ADDRLOONG64-75] _ = x[R_ADDRLOONG64U-76] _ = x[R_ADDRLOONG64TLS-77] _ = x[R_ADDRLOONG64TLSU-78] _ = x[R_CALLLOONG64-79] _ = x[R_LOONG64_TLS_IE_PCREL_HI-80] _ = x[R_LOONG64_TLS_IE_LO-81] _ = x[R_LOONG64_GOT_HI-82] _ = x[R_LOONG64_GOT_LO-83] _ = x[R_JMPLOONG64-84] _ = x[R_ADDRMIPSU-85] _ = x[R_ADDRMIPSTLS-86] _ = x[R_ADDRCUOFF-87] _ = x[R_WASMIMPORT-88] _ = x[R_XCOFFREF-89] _ = x[R_PEIMAGEOFF-90] _ = x[R_INITORDER-91] } const _RelocType_name = "R_ADDRR_ADDRPOWERR_ADDRARM64R_ADDRMIPSR_ADDROFFR_SIZER_CALLR_CALLARMR_CALLARM64R_CALLINDR_CALLPOWERR_CALLMIPSR_CONSTR_PCRELR_TLS_LER_TLS_IER_GOTOFFR_PLT0R_PLT1R_PLT2R_USEFIELDR_USETYPER_USEIFACER_USEIFACEMETHODR_USENAMEDMETHODR_METHODOFFR_KEEPR_POWER_TOCR_GOTPCRELR_JMPMIPSR_DWARFSECREFR_DWARFFILEREFR_ARM64_TLS_LER_ARM64_TLS_IER_ARM64_GOTPCRELR_ARM64_GOTR_ARM64_PCRELR_ARM64_PCREL_LDST8R_ARM64_PCREL_LDST16R_ARM64_PCREL_LDST32R_ARM64_PCREL_LDST64R_ARM64_LDST8R_ARM64_LDST16R_ARM64_LDST32R_ARM64_LDST64R_ARM64_LDST128R_POWER_TLS_LER_POWER_TLS_IER_POWER_TLSR_POWER_TLS_IE_PCREL34R_POWER_TLS_LE_TPREL34R_ADDRPOWER_DSR_ADDRPOWER_GOTR_ADDRPOWER_GOT_PCREL34R_ADDRPOWER_PCRELR_ADDRPOWER_TOCRELR_ADDRPOWER_TOCREL_DSR_ADDRPOWER_D34R_ADDRPOWER_PCREL34R_RISCV_JALR_RISCV_JAL_TRAMPR_RISCV_CALLR_RISCV_PCREL_ITYPER_RISCV_PCREL_STYPER_RISCV_TLS_IER_RISCV_TLS_LER_RISCV_GOT_HI20R_RISCV_PCREL_HI20R_RISCV_PCREL_LO12_IR_RISCV_PCREL_LO12_SR_RISCV_BRANCHR_RISCV_RVC_BRANCHR_RISCV_RVC_JUMPR_PCRELDBLR_ADDRLOONG64R_ADDRLOONG64UR_ADDRLOONG64TLSR_ADDRLOONG64TLSUR_CALLLOONG64R_LOONG64_TLS_IE_PCREL_HIR_LOONG64_TLS_IE_LOR_LOONG64_GOT_HIR_LOONG64_GOT_LOR_JMPLOONG64R_ADDRMIPSUR_ADDRMIPSTLSR_ADDRCUOFFR_WASMIMPORTR_XCOFFREFR_PEIMAGEOFFR_INITORDER" var _RelocType_index = [...]uint16{0, 6, 17, 28, 38, 47, 53, 59, 68, 79, 88, 99, 109, 116, 123, 131, 139, 147, 153, 159, 165, 175, 184, 194, 210, 226, 237, 243, 254, 264, 273, 286, 300, 314, 328, 344, 355, 368, 387, 407, 427, 447, 460, 474, 488, 502, 517, 531, 545, 556, 578, 600, 614, 629, 652, 669, 687, 708, 723, 742, 753, 770, 782, 801, 820, 834, 848, 864, 882, 902, 922, 936, 954, 970, 980, 993, 1007, 1023, 1040, 1053, 1078, 1097, 1113, 1129, 1141, 1152, 1165, 1176, 1188, 1198, 1210, 1221} func (i RelocType) String() string { i -= 1 if i < 0 || i >= RelocType(len(_RelocType_index)-1) { return "RelocType(" + strconv.FormatInt(int64(i+1), 10) + ")" } return _RelocType_name[_RelocType_index[i]:_RelocType_index[i+1]] } PK ! Iz?I symkind_string.gonu �[��� // Code generated by "stringer -type=SymKind"; DO NOT EDIT. package objabi import "strconv" func _() { // An "invalid array index" compiler error signifies that the constant values have changed. // Re-run the stringer command to generate them again. var x [1]struct{} _ = x[Sxxx-0] _ = x[STEXT-1] _ = x[SRODATA-2] _ = x[SNOPTRDATA-3] _ = x[SDATA-4] _ = x[SBSS-5] _ = x[SNOPTRBSS-6] _ = x[STLSBSS-7] _ = x[SDWARFCUINFO-8] _ = x[SDWARFCONST-9] _ = x[SDWARFFCN-10] _ = x[SDWARFABSFCN-11] _ = x[SDWARFTYPE-12] _ = x[SDWARFVAR-13] _ = x[SDWARFRANGE-14] _ = x[SDWARFLOC-15] _ = x[SDWARFLINES-16] _ = x[SLIBFUZZER_8BIT_COUNTER-17] _ = x[SCOVERAGE_COUNTER-18] _ = x[SCOVERAGE_AUXVAR-19] _ = x[SSEHUNWINDINFO-20] } const _SymKind_name = "SxxxSTEXTSRODATASNOPTRDATASDATASBSSSNOPTRBSSSTLSBSSSDWARFCUINFOSDWARFCONSTSDWARFFCNSDWARFABSFCNSDWARFTYPESDWARFVARSDWARFRANGESDWARFLOCSDWARFLINESSLIBFUZZER_8BIT_COUNTERSCOVERAGE_COUNTERSCOVERAGE_AUXVARSSEHUNWINDINFO" var _SymKind_index = [...]uint8{0, 4, 9, 16, 26, 31, 35, 44, 51, 63, 74, 83, 95, 105, 114, 125, 134, 145, 168, 185, 201, 215} func (i SymKind) String() string { if i >= SymKind(len(_SymKind_index)-1) { return "SymKind(" + strconv.FormatInt(int64(i), 10) + ")" } return _SymKind_name[_SymKind_index[i]:_SymKind_index[i+1]] } PK ! uĖ� line.gonu �[��� // Copyright 2009 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 objabi import ( "internal/buildcfg" "os" "path/filepath" "runtime" "strings" ) // WorkingDir returns the current working directory // (or "/???" if the directory cannot be identified), // with "/" as separator. func WorkingDir() string { var path string path, _ = os.Getwd() if path == "" { path = "/???" } return filepath.ToSlash(path) } // AbsFile returns the absolute filename for file in the given directory, // as rewritten by the rewrites argument. // For unrewritten paths, AbsFile rewrites a leading $GOROOT prefix to the literal "$GOROOT". // If the resulting path is the empty string, the result is "??". // // The rewrites argument is a ;-separated list of rewrites. // Each rewrite is of the form "prefix" or "prefix=>replace", // where prefix must match a leading sequence of path elements // and is either removed entirely or replaced by the replacement. func AbsFile(dir, file, rewrites string) string { abs := file if dir != "" && !filepath.IsAbs(file) { abs = filepath.Join(dir, file) } abs, rewritten := ApplyRewrites(abs, rewrites) if !rewritten && buildcfg.GOROOT != "" && hasPathPrefix(abs, buildcfg.GOROOT) { abs = "$GOROOT" + abs[len(buildcfg.GOROOT):] } // Rewrite paths to match the slash convention of the target. // This helps ensure that cross-compiled distributions remain // bit-for-bit identical to natively compiled distributions. if runtime.GOOS == "windows" { abs = strings.ReplaceAll(abs, `\`, "/") } if abs == "" { abs = "??" } return abs } // ApplyRewrites returns the filename for file in the given directory, // as rewritten by the rewrites argument. // // The rewrites argument is a ;-separated list of rewrites. // Each rewrite is of the form "prefix" or "prefix=>replace", // where prefix must match a leading sequence of path elements // and is either removed entirely or replaced by the replacement. func ApplyRewrites(file, rewrites string) (string, bool) { start := 0 for i := 0; i <= len(rewrites); i++ { if i == len(rewrites) || rewrites[i] == ';' { if new, ok := applyRewrite(file, rewrites[start:i]); ok { return new, true } start = i + 1 } } return file, false } // applyRewrite applies the rewrite to the path, // returning the rewritten path and a boolean // indicating whether the rewrite applied at all. func applyRewrite(path, rewrite string) (string, bool) { prefix, replace := rewrite, "" if j := strings.LastIndex(rewrite, "=>"); j >= 0 { prefix, replace = rewrite[:j], rewrite[j+len("=>"):] } if prefix == "" || !hasPathPrefix(path, prefix) { return path, false } if len(path) == len(prefix) { return replace, true } if replace == "" { return path[len(prefix)+1:], true } return replace + path[len(prefix):], true } // Does s have t as a path prefix? // That is, does s == t or does s begin with t followed by a slash? // For portability, we allow ASCII case folding, so that hasPathPrefix("a/b/c", "A/B") is true. // Similarly, we allow slash folding, so that hasPathPrefix("a/b/c", "a\\b") is true. // We do not allow full Unicode case folding, for fear of causing more confusion // or harm than good. (For an example of the kinds of things that can go wrong, // see http://article.gmane.org/gmane.linux.kernel/1853266.) func hasPathPrefix(s string, t string) bool { if len(t) > len(s) { return false } var i int for i = 0; i < len(t); i++ { cs := int(s[i]) ct := int(t[i]) if 'A' <= cs && cs <= 'Z' { cs += 'a' - 'A' } if 'A' <= ct && ct <= 'Z' { ct += 'a' - 'A' } if cs == '\\' { cs = '/' } if ct == '\\' { ct = '/' } if cs != ct { return false } } return i >= len(s) || s[i] == '/' || s[i] == '\\' } PK ! ݑ�� & & flag.gonu �[��� // Copyright 2015 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 objabi import ( "flag" "fmt" "internal/bisect" "internal/buildcfg" "io" "log" "os" "reflect" "sort" "strconv" "strings" ) func Flagcount(name, usage string, val *int) { flag.Var((*count)(val), name, usage) } func Flagfn1(name, usage string, f func(string)) { flag.Var(fn1(f), name, usage) } func Flagprint(w io.Writer) { flag.CommandLine.SetOutput(w) flag.PrintDefaults() } func Flagparse(usage func()) { flag.Usage = usage os.Args = expandArgs(os.Args) flag.Parse() } // expandArgs expands "response files" arguments in the provided slice. // // A "response file" argument starts with '@' and the rest of that // argument is a filename with CR-or-CRLF-separated arguments. Each // argument in the named files can also contain response file // arguments. See Issue 18468. // // The returned slice 'out' aliases 'in' iff the input did not contain // any response file arguments. // // TODO: handle relative paths of recursive expansions in different directories? // Is there a spec for this? Are relative paths allowed? func expandArgs(in []string) (out []string) { // out is nil until we see a "@" argument. for i, s := range in { if strings.HasPrefix(s, "@") { if out == nil { out = make([]string, 0, len(in)*2) out = append(out, in[:i]...) } slurp, err := os.ReadFile(s[1:]) if err != nil { log.Fatal(err) } args := strings.Split(strings.TrimSpace(strings.Replace(string(slurp), "\r", "", -1)), "\n") for i, arg := range args { args[i] = DecodeArg(arg) } out = append(out, expandArgs(args)...) } else if out != nil { out = append(out, s) } } if out == nil { return in } return } func AddVersionFlag() { flag.Var(versionFlag{}, "V", "print version and exit") } var buildID string // filled in by linker type versionFlag struct{} func (versionFlag) IsBoolFlag() bool { return true } func (versionFlag) Get() interface{} { return nil } func (versionFlag) String() string { return "" } func (versionFlag) Set(s string) error { name := os.Args[0] name = name[strings.LastIndex(name, `/`)+1:] name = name[strings.LastIndex(name, `\`)+1:] name = strings.TrimSuffix(name, ".exe") p := "" if s == "goexperiment" { // test/run.go uses this to discover the full set of // experiment tags. Report everything. p = " X:" + strings.Join(buildcfg.Experiment.All(), ",") } else { // If the enabled experiments differ from the baseline, // include that difference. if goexperiment := buildcfg.Experiment.String(); goexperiment != "" { p = " X:" + goexperiment } } // The go command invokes -V=full to get a unique identifier // for this tool. It is assumed that the release version is sufficient // for releases, but during development we include the full // build ID of the binary, so that if the compiler is changed and // rebuilt, we notice and rebuild all packages. if s == "full" { if strings.HasPrefix(buildcfg.Version, "devel") { p += " buildID=" + buildID } } fmt.Printf("%s version %s%s\n", name, buildcfg.Version, p) os.Exit(0) return nil } // count is a flag.Value that is like a flag.Bool and a flag.Int. // If used as -name, it increments the count, but -name=x sets the count. // Used for verbose flag -v. type count int func (c *count) String() string { return fmt.Sprint(int(*c)) } func (c *count) Set(s string) error { switch s { case "true": *c++ case "false": *c = 0 default: n, err := strconv.Atoi(s) if err != nil { return fmt.Errorf("invalid count %q", s) } *c = count(n) } return nil } func (c *count) Get() interface{} { return int(*c) } func (c *count) IsBoolFlag() bool { return true } func (c *count) IsCountFlag() bool { return true } type fn1 func(string) func (f fn1) Set(s string) error { f(s) return nil } func (f fn1) String() string { return "" } // DecodeArg decodes an argument. // // This function is public for testing with the parallel encoder. func DecodeArg(arg string) string { // If no encoding, fastpath out. if !strings.ContainsAny(arg, "\\\n") { return arg } var b strings.Builder var wasBS bool for _, r := range arg { if wasBS { switch r { case '\\': b.WriteByte('\\') case 'n': b.WriteByte('\n') default: // This shouldn't happen. The only backslashes that reach here // should encode '\n' and '\\' exclusively. panic("badly formatted input") } } else if r == '\\' { wasBS = true continue } else { b.WriteRune(r) } wasBS = false } return b.String() } type debugField struct { name string help string concurrentOk bool // true if this field/flag is compatible with concurrent compilation val interface{} // *int or *string } type DebugFlag struct { tab map[string]debugField concurrentOk *bool // this is non-nil only for compiler's DebugFlags, but only compiler has concurrent:ok fields debugSSA DebugSSA // this is non-nil only for compiler's DebugFlags. } // A DebugSSA function is called to set a -d ssa/... option. // If nil, those options are reported as invalid options. // If DebugSSA returns a non-empty string, that text is reported as a compiler error. // If phase is "help", it should print usage information and terminate the process. type DebugSSA func(phase, flag string, val int, valString string) string // NewDebugFlag constructs a DebugFlag for the fields of debug, which // must be a pointer to a struct. // // Each field of *debug is a different value, named for the lower-case of the field name. // Each field must be an int or string and must have a `help` struct tag. // There may be an "Any bool" field, which will be set if any debug flags are set. // // The returned flag takes a comma-separated list of settings. // Each setting is name=value; for ints, name is short for name=1. // // If debugSSA is non-nil, any debug flags of the form ssa/... will be // passed to debugSSA for processing. func NewDebugFlag(debug interface{}, debugSSA DebugSSA) *DebugFlag { flag := &DebugFlag{ tab: make(map[string]debugField), debugSSA: debugSSA, } v := reflect.ValueOf(debug).Elem() t := v.Type() for i := 0; i < t.NumField(); i++ { f := t.Field(i) ptr := v.Field(i).Addr().Interface() if f.Name == "ConcurrentOk" { switch ptr := ptr.(type) { default: panic("debug.ConcurrentOk must have type bool") case *bool: flag.concurrentOk = ptr } continue } name := strings.ToLower(f.Name) help := f.Tag.Get("help") if help == "" { panic(fmt.Sprintf("debug.%s is missing help text", f.Name)) } concurrent := f.Tag.Get("concurrent") switch ptr.(type) { default: panic(fmt.Sprintf("debug.%s has invalid type %v (must be int, string, or *bisect.Matcher)", f.Name, f.Type)) case *int, *string, **bisect.Matcher: // ok } flag.tab[name] = debugField{name, help, concurrent == "ok", ptr} } return flag } func (f *DebugFlag) Set(debugstr string) error { if debugstr == "" { return nil } for _, name := range strings.Split(debugstr, ",") { if name == "" { continue } // display help about the debug option itself and quit if name == "help" { fmt.Print(debugHelpHeader) maxLen, names := 0, []string{} if f.debugSSA != nil { maxLen = len("ssa/help") } for name := range f.tab { if len(name) > maxLen { maxLen = len(name) } names = append(names, name) } sort.Strings(names) // Indent multi-line help messages. nl := fmt.Sprintf("\n\t%-*s\t", maxLen, "") for _, name := range names { help := f.tab[name].help fmt.Printf("\t%-*s\t%s\n", maxLen, name, strings.Replace(help, "\n", nl, -1)) } if f.debugSSA != nil { // ssa options have their own help fmt.Printf("\t%-*s\t%s\n", maxLen, "ssa/help", "print help about SSA debugging") } os.Exit(0) } val, valstring, haveInt := 1, "", true if i := strings.IndexAny(name, "=:"); i >= 0 { var err error name, valstring = name[:i], name[i+1:] val, err = strconv.Atoi(valstring) if err != nil { val, haveInt = 1, false } } if t, ok := f.tab[name]; ok { switch vp := t.val.(type) { case nil: // Ignore case *string: *vp = valstring case *int: if !haveInt { log.Fatalf("invalid debug value %v", name) } *vp = val case **bisect.Matcher: var err error *vp, err = bisect.New(valstring) if err != nil { log.Fatalf("debug flag %v: %v", name, err) } default: panic("bad debugtab type") } // assembler DebugFlags don't have a ConcurrentOk field to reset, so check against that. if !t.concurrentOk && f.concurrentOk != nil { *f.concurrentOk = false } } else if f.debugSSA != nil && strings.HasPrefix(name, "ssa/") { // expect form ssa/phase/flag // e.g. -d=ssa/generic_cse/time // _ in phase name also matches space phase := name[4:] flag := "debug" // default flag is debug if i := strings.Index(phase, "/"); i >= 0 { flag = phase[i+1:] phase = phase[:i] } err := f.debugSSA(phase, flag, val, valstring) if err != "" { log.Fatalf(err) } // Setting this false for -d=ssa/... preserves old behavior // of turning off concurrency for any debug flags. // It's not known for sure if this is necessary, but it is safe. *f.concurrentOk = false } else { return fmt.Errorf("unknown debug key %s\n", name) } } return nil } const debugHelpHeader = `usage: -d arg[,arg]* and arg is <key>[=<value>] <key> is one of: ` func (f *DebugFlag) String() string { return "" } PK ! :y+BE BE reloctype.gonu �[��� // Derived from Inferno utils/6l/l.h and related files. // https://bitbucket.org/inferno-os/inferno-os/src/master/utils/6l/l.h // // Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved. // Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net) // Portions Copyright © 1997-1999 Vita Nuova Limited // Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com) // Portions Copyright © 2004,2006 Bruce Ellis // Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net) // Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others // Portions Copyright © 2009 The Go Authors. All rights reserved. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. package objabi type RelocType int16 //go:generate stringer -type=RelocType const ( R_ADDR RelocType = 1 + iota // R_ADDRPOWER relocates a pair of "D-form" instructions (instructions with 16-bit // immediates in the low half of the instruction word), usually addis followed by // another add or a load, inserting the "high adjusted" 16 bits of the address of // the referenced symbol into the immediate field of the first instruction and the // low 16 bits into that of the second instruction. R_ADDRPOWER // R_ADDRARM64 relocates an adrp, add pair to compute the address of the // referenced symbol. R_ADDRARM64 // R_ADDRMIPS (only used on mips/mips64) resolves to the low 16 bits of an external // address, by encoding it into the instruction. R_ADDRMIPS // R_ADDROFF resolves to a 32-bit offset from the beginning of the section // holding the data being relocated to the referenced symbol. R_ADDROFF R_SIZE R_CALL R_CALLARM R_CALLARM64 R_CALLIND R_CALLPOWER // R_CALLMIPS (only used on mips64) resolves to non-PC-relative target address // of a CALL (JAL) instruction, by encoding the address into the instruction. R_CALLMIPS R_CONST R_PCREL // R_TLS_LE, used on 386, amd64, and ARM, resolves to the offset of the // thread-local symbol from the thread local base and is used to implement the // "local exec" model for tls access (r.Sym is not set on intel platforms but is // set to a TLS symbol -- runtime.tlsg -- in the linker when externally linking). R_TLS_LE // R_TLS_IE, used 386, amd64, and ARM resolves to the PC-relative offset to a GOT // slot containing the offset from the thread-local symbol from the thread local // base and is used to implemented the "initial exec" model for tls access (r.Sym // is not set on intel platforms but is set to a TLS symbol -- runtime.tlsg -- in // the linker when externally linking). R_TLS_IE R_GOTOFF R_PLT0 R_PLT1 R_PLT2 R_USEFIELD // R_USETYPE resolves to an *rtype, but no relocation is created. The // linker uses this as a signal that the pointed-to type information // should be linked into the final binary, even if there are no other // direct references. (This is used for types reachable by reflection.) R_USETYPE // R_USEIFACE marks a type is converted to an interface in the function this // relocation is applied to. The target is a type descriptor or an itab // (in the latter case it refers to the concrete type contained in the itab). // This is a marker relocation (0-sized), for the linker's reachabililty // analysis. R_USEIFACE // R_USEIFACEMETHOD marks an interface method that is used in the function // this relocation is applied to. The target is an interface type descriptor. // The addend is the offset of the method in the type descriptor. // This is a marker relocation (0-sized), for the linker's reachabililty // analysis. R_USEIFACEMETHOD // R_USENAMEDMETHOD marks that methods with a specific name must not be eliminated. // The target is a symbol containing the name of a method called via a generic // interface or looked up via MethodByName("F"). R_USENAMEDMETHOD // R_METHODOFF resolves to a 32-bit offset from the beginning of the section // holding the data being relocated to the referenced symbol. // It is a variant of R_ADDROFF used when linking from the uncommonType of a // *rtype, and may be set to zero by the linker if it determines the method // text is unreachable by the linked program. R_METHODOFF // R_KEEP tells the linker to keep the referred-to symbol in the final binary // if the symbol containing the R_KEEP relocation is in the final binary. R_KEEP R_POWER_TOC R_GOTPCREL // R_JMPMIPS (only used on mips64) resolves to non-PC-relative target address // of a JMP instruction, by encoding the address into the instruction. // The stack nosplit check ignores this since it is not a function call. R_JMPMIPS // R_DWARFSECREF resolves to the offset of the symbol from its section. // Target of relocation must be size 4 (in current implementation). R_DWARFSECREF // R_DWARFFILEREF resolves to an index into the DWARF .debug_line // file table for the specified file symbol. Must be applied to an // attribute of form DW_FORM_data4. R_DWARFFILEREF // Platform dependent relocations. Architectures with fixed width instructions // have the inherent issue that a 32-bit (or 64-bit!) displacement cannot be // stuffed into a 32-bit instruction, so an address needs to be spread across // several instructions, and in turn this requires a sequence of relocations, each // updating a part of an instruction. This leads to relocation codes that are // inherently processor specific. // Arm64. // Set a MOV[NZ] immediate field to bits [15:0] of the offset from the thread // local base to the thread local variable defined by the referenced (thread // local) symbol. Error if the offset does not fit into 16 bits. R_ARM64_TLS_LE // Relocates an ADRP; LD64 instruction sequence to load the offset between // the thread local base and the thread local variable defined by the // referenced (thread local) symbol from the GOT. R_ARM64_TLS_IE // R_ARM64_GOTPCREL relocates an adrp, ld64 pair to compute the address of the GOT // slot of the referenced symbol. R_ARM64_GOTPCREL // R_ARM64_GOT resolves a GOT-relative instruction sequence, usually an adrp // followed by another ld instruction. R_ARM64_GOT // R_ARM64_PCREL resolves a PC-relative addresses instruction sequence, usually an // adrp followed by another add instruction. R_ARM64_PCREL // R_ARM64_PCREL_LDST8 resolves a PC-relative addresses instruction sequence, usually an // adrp followed by a LD8 or ST8 instruction. R_ARM64_PCREL_LDST8 // R_ARM64_PCREL_LDST16 resolves a PC-relative addresses instruction sequence, usually an // adrp followed by a LD16 or ST16 instruction. R_ARM64_PCREL_LDST16 // R_ARM64_PCREL_LDST32 resolves a PC-relative addresses instruction sequence, usually an // adrp followed by a LD32 or ST32 instruction. R_ARM64_PCREL_LDST32 // R_ARM64_PCREL_LDST64 resolves a PC-relative addresses instruction sequence, usually an // adrp followed by a LD64 or ST64 instruction. R_ARM64_PCREL_LDST64 // R_ARM64_LDST8 sets a LD/ST immediate value to bits [11:0] of a local address. R_ARM64_LDST8 // R_ARM64_LDST16 sets a LD/ST immediate value to bits [11:1] of a local address. R_ARM64_LDST16 // R_ARM64_LDST32 sets a LD/ST immediate value to bits [11:2] of a local address. R_ARM64_LDST32 // R_ARM64_LDST64 sets a LD/ST immediate value to bits [11:3] of a local address. R_ARM64_LDST64 // R_ARM64_LDST128 sets a LD/ST immediate value to bits [11:4] of a local address. R_ARM64_LDST128 // PPC64. // R_POWER_TLS_LE is used to implement the "local exec" model for tls // access. It resolves to the offset of the thread-local symbol from the // thread pointer (R13) and is split against a pair of instructions to // support a 32 bit displacement. R_POWER_TLS_LE // R_POWER_TLS_IE is used to implement the "initial exec" model for tls access. It // relocates a D-form, DS-form instruction sequence like R_ADDRPOWER_DS. It // inserts to the offset of GOT slot for the thread-local symbol from the TOC (the // GOT slot is filled by the dynamic linker with the offset of the thread-local // symbol from the thread pointer (R13)). R_POWER_TLS_IE // R_POWER_TLS marks an X-form instruction such as "ADD R3,R13,R4" as completing // a sequence of GOT-relative relocations to compute a TLS address. This can be // used by the system linker to to rewrite the GOT-relative TLS relocation into a // simpler thread-pointer relative relocation. See table 3.26 and 3.28 in the // ppc64 elfv2 1.4 ABI on this transformation. Likewise, the second argument // (usually called RB in X-form instructions) is assumed to be R13. R_POWER_TLS // R_POWER_TLS_IE_PCREL34 is similar to R_POWER_TLS_IE, but marks a single MOVD // which has been assembled as a single prefixed load doubleword without using the // TOC. R_POWER_TLS_IE_PCREL34 // R_POWER_TLS_LE_TPREL34 is similar to R_POWER_TLS_LE, but computes an offset from // the thread pointer in one prefixed instruction. R_POWER_TLS_LE_TPREL34 // R_ADDRPOWER_DS is similar to R_ADDRPOWER above, but assumes the second // instruction is a "DS-form" instruction, which has an immediate field occupying // bits [15:2] of the instruction word. Bits [15:2] of the address of the // relocated symbol are inserted into this field; it is an error if the last two // bits of the address are not 0. R_ADDRPOWER_DS // R_ADDRPOWER_GOT relocates a D-form + DS-form instruction sequence by inserting // a relative displacement of referenced symbol's GOT entry to the TOC pointer. R_ADDRPOWER_GOT // R_ADDRPOWER_GOT_PCREL34 is identical to R_ADDRPOWER_GOT, but uses a PC relative // sequence to generate a GOT symbol addresses. R_ADDRPOWER_GOT_PCREL34 // R_ADDRPOWER_PCREL relocates two D-form instructions like R_ADDRPOWER, but // inserts the displacement from the place being relocated to the address of the // relocated symbol instead of just its address. R_ADDRPOWER_PCREL // R_ADDRPOWER_TOCREL relocates two D-form instructions like R_ADDRPOWER, but // inserts the offset from the TOC to the address of the relocated symbol // rather than the symbol's address. R_ADDRPOWER_TOCREL // R_ADDRPOWER_TOCREL_DS relocates a D-form, DS-form instruction sequence like // R_ADDRPOWER_DS but inserts the offset from the TOC to the address of the // relocated symbol rather than the symbol's address. R_ADDRPOWER_TOCREL_DS // R_ADDRPOWER_D34 relocates a single prefixed D-form load/store operation. All // prefixed forms are D form. The high 18 bits are stored in the prefix, // and the low 16 are stored in the suffix. The address is absolute. R_ADDRPOWER_D34 // R_ADDRPOWER_PCREL34 relates a single prefixed D-form load/store/add operation. // All prefixed forms are D form. The resulting address is relative to the // PC. It is a signed 34 bit offset. R_ADDRPOWER_PCREL34 // RISC-V. // R_RISCV_JAL resolves a 20 bit offset for a J-type instruction. R_RISCV_JAL // R_RISCV_JAL_TRAMP is the same as R_RISCV_JAL but denotes the use of a // trampoline, which we may be able to avoid during relocation. These are // only used by the linker and are not emitted by the compiler or assembler. R_RISCV_JAL_TRAMP // R_RISCV_CALL resolves a 32 bit PC-relative address for an AUIPC + JALR // instruction pair. R_RISCV_CALL // R_RISCV_PCREL_ITYPE resolves a 32 bit PC-relative address for an // AUIPC + I-type instruction pair. R_RISCV_PCREL_ITYPE // R_RISCV_PCREL_STYPE resolves a 32 bit PC-relative address for an // AUIPC + S-type instruction pair. R_RISCV_PCREL_STYPE // R_RISCV_TLS_IE resolves a 32 bit TLS initial-exec address for an // AUIPC + I-type instruction pair. R_RISCV_TLS_IE // R_RISCV_TLS_LE resolves a 32 bit TLS local-exec address for a // LUI + I-type instruction sequence. R_RISCV_TLS_LE // R_RISCV_GOT_HI20 resolves the high 20 bits of a 32-bit PC-relative GOT // address. R_RISCV_GOT_HI20 // R_RISCV_PCREL_HI20 resolves the high 20 bits of a 32-bit PC-relative // address. R_RISCV_PCREL_HI20 // R_RISCV_PCREL_LO12_I resolves the low 12 bits of a 32-bit PC-relative // address using an I-type instruction. R_RISCV_PCREL_LO12_I // R_RISCV_PCREL_LO12_S resolves the low 12 bits of a 32-bit PC-relative // address using an S-type instruction. R_RISCV_PCREL_LO12_S // R_RISCV_BRANCH resolves a 12-bit PC-relative branch offset. R_RISCV_BRANCH // R_RISCV_RVC_BRANCH resolves an 8-bit PC-relative offset for a CB-type // instruction. R_RISCV_RVC_BRANCH // R_RISCV_RVC_JUMP resolves an 11-bit PC-relative offset for a CJ-type // instruction. R_RISCV_RVC_JUMP // R_PCRELDBL relocates s390x 2-byte aligned PC-relative addresses. // TODO(mundaym): remove once variants can be serialized - see issue 14218. R_PCRELDBL // Loong64. // R_ADDRLOONG64 resolves to the low 12 bits of an external address, by encoding // it into the instruction. R_ADDRLOONG64 // R_ADDRLOONG64U resolves to the sign-adjusted "upper" 20 bits (bit 5-24) of an // external address, by encoding it into the instruction. R_ADDRLOONG64U // R_ADDRLOONG64TLS resolves to the low 12 bits of a TLS address (offset from // thread pointer), by encoding it into the instruction. R_ADDRLOONG64TLS // R_ADDRLOONG64TLSU resolves to the high 20 bits of a TLS address (offset from // thread pointer), by encoding it into the instruction. R_ADDRLOONG64TLSU // R_CALLLOONG64 resolves to non-PC-relative target address of a CALL (BL/JIRL) // instruction, by encoding the address into the instruction. R_CALLLOONG64 // R_LOONG64_TLS_IE_PCREL_HI and R_LOONG64_TLS_IE_LO relocates a pcalau12i, ld.d // pair to compute the address of the GOT slot of the tls symbol. R_LOONG64_TLS_IE_PCREL_HI R_LOONG64_TLS_IE_LO // R_LOONG64_GOT_HI and R_LOONG64_GOT_LO resolves a GOT-relative instruction sequence, // usually an pcalau12i followed by another ld or addi instruction. R_LOONG64_GOT_HI R_LOONG64_GOT_LO // R_JMPLOONG64 resolves to non-PC-relative target address of a JMP instruction, // by encoding the address into the instruction. R_JMPLOONG64 // R_ADDRMIPSU (only used on mips/mips64) resolves to the sign-adjusted "upper" 16 // bits (bit 16-31) of an external address, by encoding it into the instruction. R_ADDRMIPSU // R_ADDRMIPSTLS (only used on mips64) resolves to the low 16 bits of a TLS // address (offset from thread pointer), by encoding it into the instruction. R_ADDRMIPSTLS // R_ADDRCUOFF resolves to a pointer-sized offset from the start of the // symbol's DWARF compile unit. R_ADDRCUOFF // R_WASMIMPORT resolves to the index of the WebAssembly function import. R_WASMIMPORT // R_XCOFFREF (only used on aix/ppc64) prevents garbage collection by ld // of a symbol. This isn't a real relocation, it can be placed in anywhere // in a symbol and target any symbols. R_XCOFFREF // R_PEIMAGEOFF resolves to a 32-bit offset from the start address of where // the executable file is mapped in memory. R_PEIMAGEOFF // R_INITORDER specifies an ordering edge between two inittask records. // (From one p..inittask record to another one.) // This relocation does not apply any changes to the actual data, it is // just used in the linker to order the inittask records appropriately. R_INITORDER // R_WEAK marks the relocation as a weak reference. // A weak relocation does not make the symbol it refers to reachable, // and is only honored by the linker if the symbol is in some other way // reachable. R_WEAK = -1 << 15 R_WEAKADDR = R_WEAK | R_ADDR R_WEAKADDROFF = R_WEAK | R_ADDROFF ) // IsDirectCall reports whether r is a relocation for a direct call. // A direct call is a CALL instruction that takes the target address // as an immediate. The address is embedded into the instruction(s), possibly // with limited width. An indirect call is a CALL instruction that takes // the target address in register or memory. func (r RelocType) IsDirectCall() bool { switch r { case R_CALL, R_CALLARM, R_CALLARM64, R_CALLLOONG64, R_CALLMIPS, R_CALLPOWER, R_RISCV_CALL, R_RISCV_JAL, R_RISCV_JAL_TRAMP: return true } return false } // IsDirectJump reports whether r is a relocation for a direct jump. // A direct jump is a JMP instruction that takes the target address // as an immediate. The address is embedded into the instruction, possibly // with limited width. An indirect jump is a JMP instruction that takes // the target address in register or memory. func (r RelocType) IsDirectJump() bool { switch r { case R_JMPMIPS: return true case R_JMPLOONG64: return true } return false } // IsDirectCallOrJump reports whether r is a relocation for a direct // call or a direct jump. func (r RelocType) IsDirectCallOrJump() bool { return r.IsDirectCall() || r.IsDirectJump() } PK ! ���t� � pkgspecial.gonu �[��� PK ! ��W�0 0 � symkind.gonu �[��� PK ! ��ssb b a flag_test.gonu �[��� PK ! �hՈ � � stack.gonu �[��� PK ! �V^$� � � head.gonu �[��� PK ! `�LJ �, path_test.gonu �[��� PK ! {�)�� � �5 path.gonu �[��� PK ! 8���� � �= typekind.gonu �[��� PK ! �lv v �@ funcid.gonu �[��� PK ! ]��/� � WG line_test.gonu �[��� PK ! 4j�$ $ �L autotype.gonu �[��� PK ! 8��d@ @ �S zbootstrap.gonu �[��� PK ! ��~� � mT util.gonu �[��� PK ! x���� � eX reloctype_string.gonu �[��� PK ! Iz?I ~j symkind_string.gonu �[��� PK ! uĖ� �o line.gonu �[��� PK ! ݑ�� & & ' flag.gonu �[��� PK ! :y+BE BE i� reloctype.gonu �[��� PK B ��
| ver. 1.1 | |
.
| PHP 8.4.18 | Ð“ÐµÐ½ÐµÑ€Ð°Ñ†Ð¸Ñ Ñтраницы: 0 |
proxy
|
phpinfo
|
ÐаÑтройка