From bc7116320b1a6442e8d354e87474feaf118f3ec0 Mon Sep 17 00:00:00 2001 From: Zxilly Date: Wed, 14 Feb 2024 04:53:08 +0800 Subject: [PATCH 01/18] feat: add brute force search fallback for elf --- elf.go | 93 +++++++++++++++++++++++++++++++++++++++++++++++---- file.go | 13 +++++-- file_test.go | 6 +++- macho.go | 13 +++++-- moduledata.go | 51 +++++++++++++++++++++++----- pclntab.go | 63 ++++++++++------------------------ pe.go | 38 ++++++++++++++++++--- 7 files changed, 206 insertions(+), 71 deletions(-) diff --git a/elf.go b/elf.go index 69577d0..e541078 100644 --- a/elf.go +++ b/elf.go @@ -46,6 +46,19 @@ type elfFile struct { osFile *os.File } +func (e *elfFile) getSymbolValue(s string) (uint64, error) { + syms, err := e.file.Symbols() + if err != nil { + return 0, fmt.Errorf("error when getting the symbols: %w", err) + } + for _, sym := range syms { + if sym.Name == s { + return sym.Value, nil + } + } + return 0, fmt.Errorf("symbol %s not found", s) +} + func (e *elfFile) getParsedFile() any { return e.file } @@ -54,25 +67,91 @@ func (e *elfFile) getFile() *os.File { return e.osFile } -func (e *elfFile) getPCLNTab() (*gosym.Table, error) { +func (e *elfFile) getPCLNTab(textStart uint64) (table *gosym.Table, err error) { + var data []byte pclnSection := e.file.Section(".gopclntab") if pclnSection == nil { - // No section found. Check if the PIE section exist instead. + // No section found. Check if the PIE section exists instead. pclnSection = e.file.Section(".data.rel.ro.gopclntab") } - if pclnSection == nil { - return nil, fmt.Errorf("no gopclntab section found") + if pclnSection != nil { + data, err = pclnSection.Data() + if err != nil { + return nil, fmt.Errorf("could not get the data for the pclntab: %w", err) + } + goto ret + } + + // try to get data from symbol + data = e.symbolData("runtime.pclntab", "runtime.epclntab") + if data != nil { + goto ret } - pclndat, err := pclnSection.Data() + // try brute force searching for the pclntab + _, data, err = e.searchForPclnTab() if err != nil { - return nil, fmt.Errorf("could not get the data for the pclntab: %w", err) + return nil, fmt.Errorf("could not find the pclntab: %w", err) } - pcln := gosym.NewLineTable(pclndat, e.file.Section(".text").Addr) +ret: + pcln := gosym.NewLineTable(data, textStart) return gosym.NewTable(make([]byte, 0), pcln) } +func (e *elfFile) searchForPclnTab() (uint64, []byte, error) { + // Only use linkmode=external and buildmode=pie will lead to this + // Since the external linker merged all .data.rel.ro.* sections into .data.rel.ro + // So we have to find .data.rel.ro.gopclntab manually + sec := e.file.Section(".data.rel.ro") + if sec == nil { + return 0, nil, ErrNoPCLNTab + } + data, err := sec.Data() + if err != nil { + return 0, nil, fmt.Errorf("could not get the data for the pclntab: %w", err) + } + + tab, err := searchSectionForTab(data, e.getFileInfo().ByteOrder) + if err != nil { + return 0, nil, fmt.Errorf("could not find the pclntab: %w", err) + } + addr := sec.Addr + sec.FileSize - uint64(len(tab)) + return addr, tab, nil +} + +func (e *elfFile) symbolData(start, end string) []byte { + elfSyms, err := e.file.Symbols() + if err != nil { + return nil + } + var addr, eaddr uint64 + for _, s := range elfSyms { + if s.Name == start { + addr = s.Value + } else if s.Name == end { + eaddr = s.Value + } + if addr != 0 && eaddr != 0 { + break + } + } + if addr == 0 || eaddr < addr { + return nil + } + size := eaddr - addr + data := make([]byte, size) + for _, prog := range e.file.Progs { + if prog.Vaddr <= addr && addr+size-1 <= prog.Vaddr+prog.Filesz-1 { + if _, err := prog.ReadAt(data, int64(addr-prog.Vaddr)); err != nil { + return nil + } + return data + } + } + return nil +} + func (e *elfFile) Close() error { err := e.file.Close() if err != nil { diff --git a/file.go b/file.go index 4e31842..712db66 100644 --- a/file.go +++ b/file.go @@ -159,6 +159,10 @@ func (f *GoFile) Moduledata() (Moduledata, error) { return f.moduledata, nil } +// initPackages initializes the packages in the binary. +// Note: this init depends on the moduledata initialization internal since PCLNTab() is called. +// any further modifications to moduledata initialization should consider this +// or a cycle dependency will be created. func (f *GoFile) initPackages() error { f.initPackagesOnce.Do(func() { tab, err := f.PCLNTab() @@ -378,7 +382,11 @@ func (f *GoFile) Close() error { // PCLNTab returns the PCLN table. func (f *GoFile) PCLNTab() (*gosym.Table, error) { - return f.fh.getPCLNTab() + err := f.initModuleData() + if err != nil { + return nil, err + } + return f.fh.getPCLNTab(f.moduledata.TextAddr) } // GetTypes returns a map of all types found in the binary file. @@ -436,7 +444,8 @@ func sortTypes(types map[uint64]*GoType) []*GoType { type fileHandler interface { io.Closer - getPCLNTab() (*gosym.Table, error) + getSymbolValue(string) (uint64, error) + getPCLNTab(uint64) (*gosym.Table, error) getRData() ([]byte, error) getCodeSection() (uint64, []byte, error) getSectionDataFromAddress(uint64) (uint64, []byte, error) diff --git a/file_test.go b/file_test.go index 3f1472f..a26c9af 100644 --- a/file_test.go +++ b/file_test.go @@ -175,6 +175,10 @@ type mockFileHandler struct { mGetSectionDataFromAddress func(uint64) (uint64, []byte, error) } +func (m *mockFileHandler) getSymbolValue(s string) (uint64, error) { + panic("implement me") +} + func (m *mockFileHandler) getFile() *os.File { panic("not implemented") } @@ -187,7 +191,7 @@ func (m *mockFileHandler) Close() error { panic("not implemented") } -func (m *mockFileHandler) getPCLNTab() (*gosym.Table, error) { +func (m *mockFileHandler) getPCLNTab(uint64) (*gosym.Table, error) { panic("not implemented") } diff --git a/macho.go b/macho.go index aa181da..b53789a 100644 --- a/macho.go +++ b/macho.go @@ -45,6 +45,15 @@ type machoFile struct { osFile *os.File } +func (m *machoFile) getSymbolValue(s string) (uint64, error) { + for _, sym := range m.file.Symtab.Syms { + if sym.Name == s { + return sym.Value, nil + } + } + return 0, fmt.Errorf("symbol %s not found", s) +} + func (m *machoFile) getParsedFile() any { return m.file } @@ -61,7 +70,7 @@ func (m *machoFile) Close() error { return m.osFile.Close() } -func (m *machoFile) getPCLNTab() (*gosym.Table, error) { +func (m *machoFile) getPCLNTab(textStart uint64) (*gosym.Table, error) { section := m.file.Section("__gopclntab") if section == nil { return nil, ErrNoPCLNTab @@ -70,7 +79,7 @@ func (m *machoFile) getPCLNTab() (*gosym.Table, error) { if data == nil { return nil, err } - pcln := gosym.NewLineTable(data, m.file.Section("__text").Addr) + pcln := gosym.NewLineTable(data, textStart) return gosym.NewTable(nil, pcln) } diff --git a/moduledata.go b/moduledata.go index 20143f4..b8bbb76 100644 --- a/moduledata.go +++ b/moduledata.go @@ -256,12 +256,7 @@ func pickVersionedModuleData(info *FileInfo) (modulable, error) { return buf, nil } -func extractModuledata(fileInfo *FileInfo, f fileHandler) (moduledata, error) { - vmd, err := pickVersionedModuleData(fileInfo) - if err != nil { - return moduledata{}, err - } - +func searchModuledata(vmd modulable, fileInfo *FileInfo, f fileHandler) (moduledata, error) { vmdSize := binary.Size(vmd) _, secData, err := f.getSectionData(f.moduledataSection()) @@ -312,9 +307,6 @@ search: goto invalidMD } - // Add the file handler. - md.fh = f - return md, nil invalidMD: @@ -322,6 +314,47 @@ invalidMD: goto search } +func readModuledataFromSymbol(vmd modulable, fileInfo *FileInfo, f fileHandler) (moduledata, error) { + vmdSize := binary.Size(vmd) + + addr, err := f.getSymbolValue("runtime.firstmoduledata") + if err != nil { + return moduledata{}, err + } + + base, data, err := f.getSectionDataFromOffset(addr) + if err != nil { + return moduledata{}, err + } + + if addr-base+uint64(vmdSize) > uint64(len(data)) { + return moduledata{}, errors.New("moduledata is too big") + } + + r := bytes.NewReader(data[addr-base : addr-base+uint64(vmdSize)]) + err = binary.Read(r, fileInfo.ByteOrder, vmd) + if err != nil { + return moduledata{}, fmt.Errorf("error when reading module data from file: %w", err) + } + + // Believe the symbol is correct, so no validation is needed. + return vmd.toModuledata(), nil +} + +func extractModuledata(fileInfo *FileInfo, f fileHandler) (moduledata, error) { + vmd, err := pickVersionedModuleData(fileInfo) + if err != nil { + return moduledata{}, err + } + + md, err := readModuledataFromSymbol(vmd, fileInfo, f) + if err == nil { + return md, nil + } + + return searchModuledata(vmd, fileInfo, f) +} + func readUIntTo64(r io.Reader, byteOrder binary.ByteOrder, is32bit bool) (addr uint64, err error) { if is32bit { var addr32 uint32 diff --git a/pclntab.go b/pclntab.go index 900f1e3..4078020 100644 --- a/pclntab.go +++ b/pclntab.go @@ -19,56 +19,27 @@ package gore import ( "bytes" - "debug/pe" + "encoding/binary" ) -// pclntab12magic is the magic bytes used for binaries compiled with Go -// prior to 1.16 -var pclntab12magic = []byte{0xfb, 0xff, 0xff, 0xff, 0x0, 0x0} - -// pclntab116magic is the magic bytes used for binaries compiled with -// Go 1.16 and Go 1.17. -var pclntab116magic = []byte{0xfa, 0xff, 0xff, 0xff, 0x0, 0x0} - -// pclntab118magic is the magic bytes used for binaries compiled with -// Go 1.18 and Go 1.19. -var pclntab118magic = []byte{0xf0, 0xff, 0xff, 0xff, 0x0, 0x0} - -// pclntab120magic is the magic bytes used for binaries compiled with -// Go 1.20 and onwards. -var pclntab120magic = []byte{0xf1, 0xff, 0xff, 0xff, 0x0, 0x0} - -// searchFileForPCLNTab will search the .rdata and .text section for the -// PCLN table. Note!! The address returned by this function needs to be -// adjusted by adding the image base address!!! -func searchFileForPCLNTab(f *pe.File) (uint32, []byte, error) { - for _, v := range []string{".rdata", ".text"} { - sec := f.Section(v) - if sec == nil { - continue - } - secData, err := sec.Data() - if err != nil { - continue - } - tab, err := searchSectionForTab(secData) - if err == ErrNoPCLNTab { - continue - } - // TODO: Switch to returning a uint64 instead. - addr := sec.VirtualAddress + uint32(len(secData)-len(tab)) - return addr, tab, err - } - return 0, []byte{}, ErrNoPCLNTab -} +// keep sync with debug/gosym/pclntab.go +const ( + gopclntab12magic uint32 = 0xfffffffb + gopclntab116magic uint32 = 0xfffffffa + gopclntab118magic uint32 = 0xfffffff0 + gopclntab120magic uint32 = 0xfffffff1 +) // searchSectionForTab looks for the PCLN table within the section. -func searchSectionForTab(secData []byte) ([]byte, error) { +func searchSectionForTab(secData []byte, order binary.ByteOrder) ([]byte, error) { // First check for the current magic used. If this fails, it could be // an older version. So check for the old header. -MAGIC_LOOP: - for _, magic := range [][]byte{pclntab120magic, pclntab118magic, pclntab116magic, pclntab12magic} { - off := bytes.LastIndex(secData, magic) +MagicLoop: + for _, magic := range []uint32{gopclntab120magic, gopclntab118magic, gopclntab116magic, gopclntab12magic} { + bMagic := make([]byte, 6) // 4 bytes for the magic, 2 bytes for padding. + order.PutUint32(bMagic, magic) + + off := bytes.LastIndex(secData, bMagic) if off == -1 { continue // Try other magic. } @@ -80,9 +51,9 @@ MAGIC_LOOP: (buf[7] != 4 && buf[7] != 8) { // pointer size // Header doesn't match. if off-1 <= 0 { - continue MAGIC_LOOP + continue MagicLoop } - off = bytes.LastIndex(secData[:off-1], magic) + off = bytes.LastIndex(secData[:off-1], bMagic) continue } // Header match diff --git a/pe.go b/pe.go index 6a58d16..cdd3a05 100644 --- a/pe.go +++ b/pe.go @@ -60,6 +60,15 @@ type peFile struct { imageBase uint64 } +func (p *peFile) getSymbolValue(s string) (uint64, error) { + for _, sym := range p.file.Symbols { + if sym.Name == s { + return uint64(sym.Value), nil + } + } + return 0, fmt.Errorf("symbol %s not found", s) +} + func (p *peFile) getParsedFile() any { return p.file } @@ -68,16 +77,37 @@ func (p *peFile) getFile() *os.File { return p.osFile } -func (p *peFile) getPCLNTab() (*gosym.Table, error) { - addr, pclndat, err := searchFileForPCLNTab(p.file) +func (p *peFile) getPCLNTab(textStart uint64) (*gosym.Table, error) { + addr, pclndat, err := p.searchForPCLNTab() if err != nil { return nil, err } - pcln := gosym.NewLineTable(pclndat, uint64(p.file.Section(".text").VirtualAddress)+p.imageBase) + pcln := gosym.NewLineTable(pclndat, textStart) p.pclntabAddr = uint64(addr) + p.imageBase return gosym.NewTable(make([]byte, 0), pcln) } +// searchFileForPCLNTab will search the .rdata section for the +// PCLN table. +func (p *peFile) searchForPCLNTab() (uint32, []byte, error) { + sec := p.file.Section(".rdata") + if sec == nil { + return 0, nil, ErrNoPCLNTab + } + secData, err := sec.Data() + if err != nil { + return 0, nil, err + } + + tab, err := searchSectionForTab(secData, p.getFileInfo().ByteOrder) + if err != nil { + return 0, nil, err + } + + addr := sec.VirtualAddress + uint32(len(secData)-len(tab)) + return addr, tab, err +} + func (p *peFile) Close() error { err := p.file.Close() if err != nil { @@ -108,7 +138,7 @@ func (p *peFile) moduledataSection() string { } func (p *peFile) getPCLNTABData() (uint64, []byte, error) { - b, d, e := searchFileForPCLNTab(p.file) + b, d, e := p.searchForPCLNTab() return p.imageBase + uint64(b), d, e } From 45c48abffaabb6f6ac36abf0b5aa86c8cb7e58e2 Mon Sep 17 00:00:00 2001 From: Zxilly Date: Wed, 14 Feb 2024 05:05:31 +0800 Subject: [PATCH 02/18] fix: disable tryFromSchedInit --- goversion.go | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/goversion.go b/goversion.go index 8b0c2b6..d214aa5 100644 --- a/goversion.go +++ b/goversion.go @@ -74,9 +74,17 @@ func findGoCompilerVersion(f *GoFile) (*GoVersion, error) { } // Try to determine the version based on the schedinit function. - if v := tryFromSchedInit(f); v != nil { - return v, nil - } + // FIXME: find a way to resolve cycle dependency + // As for now, tryFromSchedInit has following dependencies: + // tryFromSchedInit -> GetSTDLib -> ensureCompilerVersion -> findGoCompilerVersion + // -> ensureCompilerVersion + // so the cycle is created. + // The problem is that we need to resolve moduledata for pclntab to get the correct textStart + // and the moduledata relies on the compiler version. + + //if v := tryFromSchedInit(f); v != nil { + // return v, nil + //} // If no version was found, search the sections for the // version string. From 851482cab57ee3b49c394b0a3fffd32f4443ada0 Mon Sep 17 00:00:00 2001 From: Zxilly Date: Wed, 14 Feb 2024 05:16:00 +0800 Subject: [PATCH 03/18] fix: add missing filehandler --- moduledata.go | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/moduledata.go b/moduledata.go index b8bbb76..752fedd 100644 --- a/moduledata.go +++ b/moduledata.go @@ -349,10 +349,16 @@ func extractModuledata(fileInfo *FileInfo, f fileHandler) (moduledata, error) { md, err := readModuledataFromSymbol(vmd, fileInfo, f) if err == nil { + md.fh = f return md, nil } - return searchModuledata(vmd, fileInfo, f) + md, err = searchModuledata(vmd, fileInfo, f) + if err != nil { + return moduledata{}, err + } + md.fh = f + return md, nil } func readUIntTo64(r io.Reader, byteOrder binary.ByteOrder, is32bit bool) (addr uint64, err error) { From 7ebb7e27e3d2da4d6c83664dc0d0c735dac36e59 Mon Sep 17 00:00:00 2001 From: Zxilly Date: Wed, 14 Feb 2024 05:28:36 +0800 Subject: [PATCH 04/18] fix: add fallback section for pe --- pe.go | 31 +++++++++++++++++-------------- 1 file changed, 17 insertions(+), 14 deletions(-) diff --git a/pe.go b/pe.go index cdd3a05..6b6067a 100644 --- a/pe.go +++ b/pe.go @@ -90,22 +90,25 @@ func (p *peFile) getPCLNTab(textStart uint64) (*gosym.Table, error) { // searchFileForPCLNTab will search the .rdata section for the // PCLN table. func (p *peFile) searchForPCLNTab() (uint32, []byte, error) { - sec := p.file.Section(".rdata") - if sec == nil { - return 0, nil, ErrNoPCLNTab - } - secData, err := sec.Data() - if err != nil { - return 0, nil, err - } + for _, s := range []string{".rdata", ".text"} { + sec := p.file.Section(s) + if sec == nil { + continue + } + secData, err := sec.Data() + if err != nil { + return 0, nil, err + } - tab, err := searchSectionForTab(secData, p.getFileInfo().ByteOrder) - if err != nil { - return 0, nil, err - } + tab, err := searchSectionForTab(secData, p.getFileInfo().ByteOrder) + if err != nil { + continue + } - addr := sec.VirtualAddress + uint32(len(secData)-len(tab)) - return addr, tab, err + addr := sec.VirtualAddress + uint32(len(secData)-len(tab)) + return addr, tab, err + } + return 0, nil, ErrNoPCLNTab } func (p *peFile) Close() error { From 4bdf611e2befd6a87851b6e65e1ead7bfe40cf49 Mon Sep 17 00:00:00 2001 From: Zxilly Date: Wed, 14 Feb 2024 05:33:24 +0800 Subject: [PATCH 05/18] docs: update cycle dependency comment --- goversion.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/goversion.go b/goversion.go index d214aa5..60ccdf3 100644 --- a/goversion.go +++ b/goversion.go @@ -77,7 +77,7 @@ func findGoCompilerVersion(f *GoFile) (*GoVersion, error) { // FIXME: find a way to resolve cycle dependency // As for now, tryFromSchedInit has following dependencies: // tryFromSchedInit -> GetSTDLib -> ensureCompilerVersion -> findGoCompilerVersion - // -> ensureCompilerVersion + // -> tryFromSchedInit // so the cycle is created. // The problem is that we need to resolve moduledata for pclntab to get the correct textStart // and the moduledata relies on the compiler version. From 9f3e2f51848ebb50479f2aee1ce138e527c17cd7 Mon Sep 17 00:00:00 2001 From: Zxilly Date: Thu, 15 Feb 2024 01:22:56 +0800 Subject: [PATCH 06/18] fix: move to new api --- moduledata.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/moduledata.go b/moduledata.go index 752fedd..484d1e3 100644 --- a/moduledata.go +++ b/moduledata.go @@ -322,7 +322,7 @@ func readModuledataFromSymbol(vmd modulable, fileInfo *FileInfo, f fileHandler) return moduledata{}, err } - base, data, err := f.getSectionDataFromOffset(addr) + base, data, err := f.getSectionDataFromAddress(addr) if err != nil { return moduledata{}, err } From 7a7903f99e55ff131241cf9dcb66efb266a85278 Mon Sep 17 00:00:00 2001 From: Zxilly Date: Thu, 15 Feb 2024 02:37:56 +0800 Subject: [PATCH 07/18] feat: allow tryFromSchedInit works with symbol --- elf.go | 10 +++---- file.go | 3 +- file_test.go | 2 +- goversion.go | 71 +++++++++++++++++++++++++---------------------- goversion_test.go | 2 ++ macho.go | 37 ++++++++++++++++++++---- moduledata.go | 2 +- pe.go | 55 ++++++++++++++++++++++++++++++++---- 8 files changed, 131 insertions(+), 51 deletions(-) diff --git a/elf.go b/elf.go index e541078..1a3efc6 100644 --- a/elf.go +++ b/elf.go @@ -46,17 +46,17 @@ type elfFile struct { osFile *os.File } -func (e *elfFile) getSymbolValue(s string) (uint64, error) { +func (e *elfFile) getSymbol(name string) (uint64, uint64, error) { syms, err := e.file.Symbols() if err != nil { - return 0, fmt.Errorf("error when getting the symbols: %w", err) + return 0, 0, fmt.Errorf("error when getting the symbols: %w", err) } for _, sym := range syms { - if sym.Name == s { - return sym.Value, nil + if sym.Name == name { + return sym.Size, sym.Value, nil } } - return 0, fmt.Errorf("symbol %s not found", s) + return 0, 0, fmt.Errorf("symbol %s not found", name) } func (e *elfFile) getParsedFile() any { diff --git a/file.go b/file.go index 712db66..14c71eb 100644 --- a/file.go +++ b/file.go @@ -444,7 +444,8 @@ func sortTypes(types map[uint64]*GoType) []*GoType { type fileHandler interface { io.Closer - getSymbolValue(string) (uint64, error) + // returns the size, value and error + getSymbol(name string) (uint64, uint64, error) getPCLNTab(uint64) (*gosym.Table, error) getRData() ([]byte, error) getCodeSection() (uint64, []byte, error) diff --git a/file_test.go b/file_test.go index a26c9af..05e9447 100644 --- a/file_test.go +++ b/file_test.go @@ -175,7 +175,7 @@ type mockFileHandler struct { mGetSectionDataFromAddress func(uint64) (uint64, []byte, error) } -func (m *mockFileHandler) getSymbolValue(s string) (uint64, error) { +func (m *mockFileHandler) getSymbol(name string) (uint64, uint64, error) { panic("implement me") } diff --git a/goversion.go b/goversion.go index 60ccdf3..bd8bf93 100644 --- a/goversion.go +++ b/goversion.go @@ -76,15 +76,14 @@ func findGoCompilerVersion(f *GoFile) (*GoVersion, error) { // Try to determine the version based on the schedinit function. // FIXME: find a way to resolve cycle dependency // As for now, tryFromSchedInit has following dependencies: - // tryFromSchedInit -> GetSTDLib -> ensureCompilerVersion -> findGoCompilerVersion - // -> tryFromSchedInit + // tryFromSchedInit -> GetSTDLib -> initPackages -> ensureCompilerVersion + // -> findGoCompilerVersion -> tryFromSchedInit // so the cycle is created. // The problem is that we need to resolve moduledata for pclntab to get the correct textStart // and the moduledata relies on the compiler version. - - //if v := tryFromSchedInit(f); v != nil { - // return v, nil - //} + if v := tryFromSchedInit(f); v != nil { + return v, nil + } // If no version was found, search the sections for the // version string. @@ -135,35 +134,41 @@ func tryFromSchedInit(f *GoFile) *GoVersion { is32 = true } - // Find schedinit function. - var fcn *Function - std, err := f.GetSTDLib() + // FIXME: disable for now, see the comment in findGoCompilerVersion + // // Find schedinit function. + // var fcn *Function + // std, err := f.GetSTDLib() + // if err != nil { + // return nil + // } + // + //pkgLoop: + // for _, v := range std { + // if v.Name != "runtime" { + // continue + // } + // for _, vv := range v.Functions { + // if vv.Name != "schedinit" { + // continue + // } + // fcn = vv + // break pkgLoop + // } + // } + // + // // Check if the function was found + // if fcn == nil { + // // If we can't find the function there is nothing to do. + // return nil + // } + + addr, size, err := f.fh.getSymbol("runtime.schedinit") if err != nil { return nil } -pkgLoop: - for _, v := range std { - if v.Name != "runtime" { - continue - } - for _, vv := range v.Functions { - if vv.Name != "schedinit" { - continue - } - fcn = vv - break pkgLoop - } - } - - // Check if the function was found - if fcn == nil { - // If we can't find the function there is nothing to do. - return nil - } - // Get the raw hex. - buf, err := f.Bytes(fcn.Offset, fcn.End-fcn.Offset) + buf, err := f.Bytes(addr, size) if err != nil { return nil } @@ -193,12 +198,12 @@ pkgLoop: } // Check what it's loading and if it's pointing to the compiler version used. - // First assume that the address is a direct addressing. + // First, assume that the address is a direct addressing. arg := inst.Args[1].(x86asm.Mem) addr := arg.Disp if arg.Base == x86asm.EIP || arg.Base == x86asm.RIP { // If the addressing is based on the instruction pointer, fix the address. - addr = addr + int64(fcn.Offset) + int64(s) + addr = addr + int64(addr) + int64(s) } // If the addressing is based on the stack pointer, this is not the right @@ -235,7 +240,7 @@ pkgLoop: continue } - // Likely the version string. + // Likely a version string. ver := string(bstr) resolvedVer := ResolveGoVersion(ver) diff --git a/goversion_test.go b/goversion_test.go index acc5fd5..c4a0aa8 100644 --- a/goversion_test.go +++ b/goversion_test.go @@ -102,6 +102,8 @@ func TestVersionComparer(t *testing.T) { } func TestExtractVersionFromInitSched(t *testing.T) { + t.Skip("Gold not contains the unstripped binary") + r := require.New(t) tests := []struct { diff --git a/macho.go b/macho.go index b53789a..4ee75c3 100644 --- a/macho.go +++ b/macho.go @@ -21,8 +21,11 @@ import ( "debug/dwarf" "debug/gosym" "debug/macho" + "errors" "fmt" + "math" "os" + "slices" ) func openMachO(fp string) (*machoFile, error) { @@ -45,13 +48,37 @@ type machoFile struct { osFile *os.File } -func (m *machoFile) getSymbolValue(s string) (uint64, error) { - for _, sym := range m.file.Symtab.Syms { - if sym.Name == s { - return sym.Value, nil +func (m *machoFile) getSymbol(name string) (uint64, uint64, error) { + var addrs []uint64 + + foundedAddr := uint64(math.MaxUint64) + + const stabTypeMask = 0xe0 + + for _, s := range m.file.Symtab.Syms { + if s.Type&stabTypeMask != 0 || s.Sect == 0 { + continue + } + + addrs = append(addrs, s.Value) + + if s.Name == name { + foundedAddr = s.Value } } - return 0, fmt.Errorf("symbol %s not found", s) + + if foundedAddr == math.MaxUint64 { + return 0, 0, fmt.Errorf("symbol %s not found", name) + } + + slices.Sort(addrs) + + index, _ := slices.BinarySearch(addrs, foundedAddr) + + if index == len(addrs)-1 { + return foundedAddr, 0, errors.New("size not available") + } + return foundedAddr, addrs[index+1] - foundedAddr, nil } func (m *machoFile) getParsedFile() any { diff --git a/moduledata.go b/moduledata.go index 484d1e3..d7b4956 100644 --- a/moduledata.go +++ b/moduledata.go @@ -317,7 +317,7 @@ invalidMD: func readModuledataFromSymbol(vmd modulable, fileInfo *FileInfo, f fileHandler) (moduledata, error) { vmdSize := binary.Size(vmd) - addr, err := f.getSymbolValue("runtime.firstmoduledata") + _, addr, err := f.getSymbol("runtime.firstmoduledata") if err != nil { return moduledata{}, err } diff --git a/pe.go b/pe.go index 6b6067a..50b9032 100644 --- a/pe.go +++ b/pe.go @@ -22,8 +22,11 @@ import ( "debug/gosym" "debug/pe" "encoding/binary" + "errors" "fmt" + "math" "os" + "slices" ) func openPE(fp string) (peF *peFile, err error) { @@ -60,13 +63,55 @@ type peFile struct { imageBase uint64 } -func (p *peFile) getSymbolValue(s string) (uint64, error) { - for _, sym := range p.file.Symbols { - if sym.Name == s { - return uint64(sym.Value), nil +func (p *peFile) getSymbol(name string) (uint64, uint64, error) { + var addrs []uint64 + + const ( + NUndef = 0 // An undefined (extern) symbol + NAbs = -1 // An absolute symbol (e_value is a constant, not an address) + NDebug = -2 // A debugging symbol + ) + + foundedAddr := uint64(math.MaxUint64) + + for _, s := range p.file.Symbols { + switch s.SectionNumber { + case NUndef, NDebug: + continue + case NAbs: + if s.Name == name { + // for absolute symbols, we don't care about the size + return uint64(s.Value), 0, nil + } + continue } + + if s.SectionNumber < 0 || len(p.file.Sections) < int(s.SectionNumber) { + return 0, 0, fmt.Errorf("invalid section number in symbol table") + } + + sect := p.file.Sections[s.SectionNumber-1] + addr := p.imageBase + uint64(sect.VirtualAddress) + uint64(s.Value) + + addrs = append(addrs, addr) + + if s.Name == name { + foundedAddr = addr + } + } + + if foundedAddr == math.MaxUint64 { + return 0, 0, fmt.Errorf("symbol not found") + } + + slices.Sort(addrs) + + index, _ := slices.BinarySearch(addrs, foundedAddr) + + if index == len(addrs)-1 { + return foundedAddr, 0, errors.New("size not available") } - return 0, fmt.Errorf("symbol %s not found", s) + return foundedAddr, addrs[index+1] - foundedAddr, nil } func (p *peFile) getParsedFile() any { From 7c1b23a7f0891146d4df88b265499c4db084b5f8 Mon Sep 17 00:00:00 2001 From: Zxilly Date: Thu, 22 Feb 2024 20:14:25 +0800 Subject: [PATCH 08/18] refactor: remove duplicate pclntab getter --- elf.go | 83 +++++++++++++++++++++++----------------------------- file.go | 10 +++++-- file_test.go | 5 ---- macho.go | 14 --------- pclntab.go | 22 ++++++++++++++ pe.go | 46 +++++++++++++++-------------- 6 files changed, 90 insertions(+), 90 deletions(-) diff --git a/elf.go b/elf.go index 1a3efc6..2ec684d 100644 --- a/elf.go +++ b/elf.go @@ -20,7 +20,6 @@ package gore import ( "debug/dwarf" "debug/elf" - "debug/gosym" "errors" "fmt" "os" @@ -36,7 +35,7 @@ func openELF(fp string) (*elfFile, error) { if err != nil { return nil, fmt.Errorf("error when parsing the ELF file: %w", err) } - return &elfFile{file: f, osFile: osFile}, nil + return &elfFile{file: f, osFile: osFile, pcln: newPclnTabOnce()}, nil } var _ fileHandler = (*elfFile)(nil) @@ -44,6 +43,7 @@ var _ fileHandler = (*elfFile)(nil) type elfFile struct { file *elf.File osFile *os.File + pcln *pclntabOnce } func (e *elfFile) getSymbol(name string) (uint64, uint64, error) { @@ -67,38 +67,6 @@ func (e *elfFile) getFile() *os.File { return e.osFile } -func (e *elfFile) getPCLNTab(textStart uint64) (table *gosym.Table, err error) { - var data []byte - pclnSection := e.file.Section(".gopclntab") - if pclnSection == nil { - // No section found. Check if the PIE section exists instead. - pclnSection = e.file.Section(".data.rel.ro.gopclntab") - } - if pclnSection != nil { - data, err = pclnSection.Data() - if err != nil { - return nil, fmt.Errorf("could not get the data for the pclntab: %w", err) - } - goto ret - } - - // try to get data from symbol - data = e.symbolData("runtime.pclntab", "runtime.epclntab") - if data != nil { - goto ret - } - - // try brute force searching for the pclntab - _, data, err = e.searchForPclnTab() - if err != nil { - return nil, fmt.Errorf("could not find the pclntab: %w", err) - } - -ret: - pcln := gosym.NewLineTable(data, textStart) - return gosym.NewTable(make([]byte, 0), pcln) -} - func (e *elfFile) searchForPclnTab() (uint64, []byte, error) { // Only use linkmode=external and buildmode=pie will lead to this // Since the external linker merged all .data.rel.ro.* sections into .data.rel.ro @@ -120,10 +88,10 @@ func (e *elfFile) searchForPclnTab() (uint64, []byte, error) { return addr, tab, nil } -func (e *elfFile) symbolData(start, end string) []byte { +func (e *elfFile) symbolData(start, end string) (uint64, uint64, []byte) { elfSyms, err := e.file.Symbols() if err != nil { - return nil + return 0, 0, nil } var addr, eaddr uint64 for _, s := range elfSyms { @@ -137,19 +105,19 @@ func (e *elfFile) symbolData(start, end string) []byte { } } if addr == 0 || eaddr < addr { - return nil + return 0, 0, nil } size := eaddr - addr data := make([]byte, size) for _, prog := range e.file.Progs { if prog.Vaddr <= addr && addr+size-1 <= prog.Vaddr+prog.Filesz-1 { if _, err := prog.ReadAt(data, int64(addr-prog.Vaddr)); err != nil { - return nil + return 0, 0, nil } - return data + return addr, eaddr, data } } - return nil + return 0, 0, nil } func (e *elfFile) Close() error { @@ -180,13 +148,36 @@ func (e *elfFile) getCodeSection() (uint64, []byte, error) { return section.Addr, data, nil } -func (e *elfFile) getPCLNTABData() (uint64, []byte, error) { - start, data, err := e.getSectionData(".gopclntab") - if errors.Is(err, ErrSectionDoesNotExist) { - // Try PIE location - return e.getSectionData(".data.rel.ro.gopclntab") +func (e *elfFile) getPCLNTABData() (start uint64, data []byte, err error) { + return e.pcln.load(e.getPCLNTABDataImpl) +} + +func (e *elfFile) getPCLNTABDataImpl() (start uint64, data []byte, err error) { + pclnSection := e.file.Section(".gopclntab") + if pclnSection == nil { + // No section found. Check if the PIE section exists instead. + pclnSection = e.file.Section(".data.rel.ro.gopclntab") + } + if pclnSection != nil { + data, err = pclnSection.Data() + if err != nil { + return 0, nil, fmt.Errorf("could not get the data for the pclntab: %w", err) + } + return pclnSection.Addr, data, nil + } + + // try to get data from symbol + start, _, data = e.symbolData("runtime.pclntab", "runtime.epclntab") + if data != nil { + return start, data, nil + } + + // try brute force searching for the pclntab + start, data, err = e.searchForPclnTab() + if err != nil { + return 0, nil, fmt.Errorf("could not find the pclntab: %w", err) } - return start, data, err + return } func (e *elfFile) moduledataSection() string { diff --git a/file.go b/file.go index 14c71eb..fbfd2a9 100644 --- a/file.go +++ b/file.go @@ -386,7 +386,12 @@ func (f *GoFile) PCLNTab() (*gosym.Table, error) { if err != nil { return nil, err } - return f.fh.getPCLNTab(f.moduledata.TextAddr) + _, data, err := f.fh.getPCLNTABData() + if err != nil { + return nil, err + } + pcln := gosym.NewLineTable(data, f.moduledata.TextAddr) + return gosym.NewTable(make([]byte, 0), pcln) } // GetTypes returns a map of all types found in the binary file. @@ -446,13 +451,12 @@ type fileHandler interface { io.Closer // returns the size, value and error getSymbol(name string) (uint64, uint64, error) - getPCLNTab(uint64) (*gosym.Table, error) + getPCLNTABData() (uint64, []byte, error) getRData() ([]byte, error) getCodeSection() (uint64, []byte, error) getSectionDataFromAddress(uint64) (uint64, []byte, error) getSectionData(string) (uint64, []byte, error) getFileInfo() *FileInfo - getPCLNTABData() (uint64, []byte, error) moduledataSection() string getBuildID() (string, error) getFile() *os.File diff --git a/file_test.go b/file_test.go index 05e9447..5ba5dd6 100644 --- a/file_test.go +++ b/file_test.go @@ -20,7 +20,6 @@ package gore import ( "debug/dwarf" "debug/elf" - "debug/gosym" "debug/macho" "debug/pe" "errors" @@ -191,10 +190,6 @@ func (m *mockFileHandler) Close() error { panic("not implemented") } -func (m *mockFileHandler) getPCLNTab(uint64) (*gosym.Table, error) { - panic("not implemented") -} - func (m *mockFileHandler) getRData() ([]byte, error) { panic("not implemented") } diff --git a/macho.go b/macho.go index 4ee75c3..a360751 100644 --- a/macho.go +++ b/macho.go @@ -19,7 +19,6 @@ package gore import ( "debug/dwarf" - "debug/gosym" "debug/macho" "errors" "fmt" @@ -97,19 +96,6 @@ func (m *machoFile) Close() error { return m.osFile.Close() } -func (m *machoFile) getPCLNTab(textStart uint64) (*gosym.Table, error) { - section := m.file.Section("__gopclntab") - if section == nil { - return nil, ErrNoPCLNTab - } - data, err := section.Data() - if data == nil { - return nil, err - } - pcln := gosym.NewLineTable(data, textStart) - return gosym.NewTable(nil, pcln) -} - func (m *machoFile) getRData() ([]byte, error) { _, data, err := m.getSectionData("__rodata") return data, err diff --git a/pclntab.go b/pclntab.go index 4078020..7baf409 100644 --- a/pclntab.go +++ b/pclntab.go @@ -20,6 +20,7 @@ package gore import ( "bytes" "encoding/binary" + "sync" ) // keep sync with debug/gosym/pclntab.go @@ -30,6 +31,27 @@ const ( gopclntab120magic uint32 = 0xfffffff1 ) +// if the target relies on a brute force search, +// use this cache the result +type pclntabOnce struct { + *sync.Once + pclntab []byte + start uint64 + err error +} + +func newPclnTabOnce() *pclntabOnce { + return &pclntabOnce{Once: &sync.Once{}} +} + +func (o *pclntabOnce) load(loader func() (uint64, []byte, error)) (uint64, []byte, error) { + o.Do(func() { + o.start, o.pclntab, o.err = loader() + }) + return o.start, o.pclntab, o.err + +} + // searchSectionForTab looks for the PCLN table within the section. func searchSectionForTab(secData []byte, order binary.ByteOrder) ([]byte, error) { // First check for the current magic used. If this fails, it could be diff --git a/pe.go b/pe.go index 50b9032..c858440 100644 --- a/pe.go +++ b/pe.go @@ -19,7 +19,6 @@ package gore import ( "debug/dwarf" - "debug/gosym" "debug/pe" "encoding/binary" "errors" @@ -50,17 +49,30 @@ func openPE(fp string) (peF *peFile, err error) { err = fmt.Errorf("error when parsing the PE file: %w", err) return } - peF = &peFile{file: f, osFile: osFile} + + imageBase := uint64(0) + + switch hdr := f.OptionalHeader.(type) { + case *pe.OptionalHeader32: + imageBase = uint64(hdr.ImageBase) + case *pe.OptionalHeader64: + imageBase = hdr.ImageBase + default: + err = errors.New("unknown optional header type") + return + } + + peF = &peFile{file: f, osFile: osFile, imageBase: imageBase, pcln: newPclnTabOnce()} return } var _ fileHandler = (*peFile)(nil) type peFile struct { - file *pe.File - osFile *os.File - pclntabAddr uint64 - imageBase uint64 + file *pe.File + osFile *os.File + imageBase uint64 + pcln *pclntabOnce } func (p *peFile) getSymbol(name string) (uint64, uint64, error) { @@ -122,16 +134,6 @@ func (p *peFile) getFile() *os.File { return p.osFile } -func (p *peFile) getPCLNTab(textStart uint64) (*gosym.Table, error) { - addr, pclndat, err := p.searchForPCLNTab() - if err != nil { - return nil, err - } - pcln := gosym.NewLineTable(pclndat, textStart) - p.pclntabAddr = uint64(addr) + p.imageBase - return gosym.NewTable(make([]byte, 0), pcln) -} - // searchFileForPCLNTab will search the .rdata section for the // PCLN table. func (p *peFile) searchForPCLNTab() (uint32, []byte, error) { @@ -186,8 +188,12 @@ func (p *peFile) moduledataSection() string { } func (p *peFile) getPCLNTABData() (uint64, []byte, error) { - b, d, e := p.searchForPCLNTab() - return p.imageBase + uint64(b), d, e + return p.pcln.load(p.getPCLNTABDataImpl) +} + +func (p *peFile) getPCLNTABDataImpl() (uint64, []byte, error) { + start, data, err := p.searchForPCLNTab() + return p.imageBase + uint64(start), data, err } func (p *peFile) getSectionDataFromAddress(address uint64) (uint64, []byte, error) { @@ -218,13 +224,9 @@ func (p *peFile) getFileInfo() *FileInfo { fi := &FileInfo{ByteOrder: binary.LittleEndian, OS: "windows"} if p.file.Machine == pe.IMAGE_FILE_MACHINE_I386 { fi.WordSize = intSize32 - optHdr := p.file.OptionalHeader.(*pe.OptionalHeader32) - p.imageBase = uint64(optHdr.ImageBase) fi.Arch = Arch386 } else { fi.WordSize = intSize64 - optHdr := p.file.OptionalHeader.(*pe.OptionalHeader64) - p.imageBase = optHdr.ImageBase fi.Arch = ArchAMD64 } return fi From 8b62444dbd9735b82a287c606ba0826860bbb999 Mon Sep 17 00:00:00 2001 From: Zxilly Date: Thu, 22 Feb 2024 21:03:26 +0800 Subject: [PATCH 09/18] feat: add moduledata list for later search --- gen/moduledata.go | 84 +- moduledata_gen.go | 3813 +++++++++++++++++++++++---------------------- 2 files changed, 1983 insertions(+), 1914 deletions(-) diff --git a/gen/moduledata.go b/gen/moduledata.go index baed79d..5d3af13 100644 --- a/gen/moduledata.go +++ b/gen/moduledata.go @@ -19,6 +19,7 @@ package main import ( "bytes" + "cmp" "fmt" "github.com/go-git/go-git/v5/plumbing" "github.com/goretk/gore/extern" @@ -29,6 +30,7 @@ import ( "go/token" "os" "regexp" + "slices" "sort" "strconv" "strings" @@ -90,7 +92,6 @@ func getCurrentMaxGoBit() (int, error) { if typeSpec, ok := spec.(*ast.TypeSpec); ok { if _, ok := typeSpec.Type.(*ast.StructType); ok { name := typeSpec.Name.Name - if moduleNameMatcher.MatchString(name) { matches := moduleNameMatcher.FindStringSubmatch(name) if len(matches) != 2 { @@ -213,6 +214,26 @@ func (g *moduleDataGenerator) writeSelector() { g.writeln(`return nil, fmt.Errorf("unsupported version %%d and bits %%d", v, bits)`) g.writeln("}\n}\n") +} + +func (g *moduleDataGenerator) writeModuleListGetter() { + g.writeln("func getModuleDataList(bits int) ([]modulable, error) {") + g.writeln("if bits != 32 && bits != 64 { return nil, fmt.Errorf(\"unsupported bits %d\", bits)}") + + g.writeln("if bits == 32 {") + g.writeln("return []modulable{") + for _, versionCode := range g.knownVersions { + g.writeln("&%s{},", g.generateTypeName(versionCode, 32)) + } + g.writeln("}, nil") + g.writeln("} else {") + g.writeln("return []modulable{") + for _, versionCode := range g.knownVersions { + g.writeln("&%s{},", g.generateTypeName(versionCode, 64)) + } + g.writeln("}, nil") + g.writeln("}") + g.writeln("}\n") } @@ -227,10 +248,6 @@ func (*moduleDataGenerator) wrapValue(name string, bits int) string { return name } -func (*moduleDataGenerator) title(s string) string { - return strings.ToUpper(s[:1]) + s[1:] -} - func (g *moduleDataGenerator) writeln(format string, a ...interface{}) { _, _ = fmt.Fprintf(g.buf, format+"\n", a...) } @@ -266,17 +283,17 @@ func (g *moduleDataGenerator) writeVersionedModuleData(versionCode int, code str switch t := field.Type.(type) { case *ast.StarExpr: - g.writeln("%s uint%d", g.title(name.Name), bits) + g.writeln("%s uint%d", name.Name, bits) case *ast.ArrayType: - g.writeln("%s, %[1]slen, %[1]scap uint%d", g.title(name.Name), bits) + g.writeln("%s, %[1]slen, %[1]scap uint%d", name.Name, bits) case *ast.Ident: switch t.Name { case "uintptr": - g.writeln("%s uint%d", g.title(name.Name), bits) + g.writeln("%s uint%d", name.Name, bits) case "string": - g.writeln("%s, %[1]slen uint%d", g.title(name.Name), bits) + g.writeln("%s, %[1]slen uint%d", name.Name, bits) case "uint8": - g.writeln("%s uint8", g.title(name.Name)) + g.writeln("%s uint8", name.Name) default: panic(fmt.Sprintf("unhandled type: %+v", t)) } @@ -302,57 +319,57 @@ func (g *moduleDataGenerator) writeVersionedModuleData(versionCode int, code str g.writeln("return moduledata{") if exist("text", "etext") { - g.writeln("TextAddr: %s,", g.wrapValue("md.Text", bits)) - g.writeln("TextLen: %s,", g.wrapValue("md.Etext - md.Text", bits)) + g.writeln("TextAddr: %s,", g.wrapValue("md.text", bits)) + g.writeln("TextLen: %s,", g.wrapValue("md.etext - md.text", bits)) } if exist("noptrdata", "enoptrdata") { - g.writeln("NoPtrDataAddr: %s,", g.wrapValue("md.Noptrdata", bits)) - g.writeln("NoPtrDataLen: %s,", g.wrapValue("md.Enoptrdata - md.Noptrdata", bits)) + g.writeln("NoPtrDataAddr: %s,", g.wrapValue("md.noptrdata", bits)) + g.writeln("NoPtrDataLen: %s,", g.wrapValue("md.enoptrdata - md.noptrdata", bits)) } if exist("data", "edata") { - g.writeln("DataAddr: %s,", g.wrapValue("md.Data", bits)) - g.writeln("DataLen: %s,", g.wrapValue("md.Edata - md.Data", bits)) + g.writeln("DataAddr: %s,", g.wrapValue("md.data", bits)) + g.writeln("DataLen: %s,", g.wrapValue("md.edata - md.data", bits)) } if exist("bss", "ebss") { - g.writeln("BssAddr: %s,", g.wrapValue("md.Bss", bits)) - g.writeln("BssLen: %s,", g.wrapValue("md.Ebss - md.Bss", bits)) + g.writeln("BssAddr: %s,", g.wrapValue("md.bss", bits)) + g.writeln("BssLen: %s,", g.wrapValue("md.ebss - md.bss", bits)) } if exist("noptrbss", "enoptrbss") { - g.writeln("NoPtrBssAddr: %s,", g.wrapValue("md.Noptrbss", bits)) - g.writeln("NoPtrBssLen: %s,", g.wrapValue("md.Enoptrbss - md.Noptrbss", bits)) + g.writeln("NoPtrBssAddr: %s,", g.wrapValue("md.noptrbss", bits)) + g.writeln("NoPtrBssLen: %s,", g.wrapValue("md.enoptrbss - md.noptrbss", bits)) } if exist("types", "etypes") { - g.writeln("TypesAddr: %s,", g.wrapValue("md.Types", bits)) - g.writeln("TypesLen: %s,", g.wrapValue("md.Etypes - md.Types", bits)) + g.writeln("TypesAddr: %s,", g.wrapValue("md.types", bits)) + g.writeln("TypesLen: %s,", g.wrapValue("md.etypes - md.types", bits)) } if exist("typelinks") { - g.writeln("TypelinkAddr: %s,", g.wrapValue("md.Typelinks", bits)) - g.writeln("TypelinkLen: %s,", g.wrapValue("md.Typelinkslen", bits)) + g.writeln("TypelinkAddr: %s,", g.wrapValue("md.typelinks", bits)) + g.writeln("TypelinkLen: %s,", g.wrapValue("md.typelinkslen", bits)) } if exist("itablinks") { - g.writeln("ITabLinkAddr: %s,", g.wrapValue("md.Itablinks", bits)) - g.writeln("ITabLinkLen: %s,", g.wrapValue("md.Itablinkslen", bits)) + g.writeln("ITabLinkAddr: %s,", g.wrapValue("md.itablinks", bits)) + g.writeln("ITabLinkLen: %s,", g.wrapValue("md.itablinkslen", bits)) } if exist("ftab") { - g.writeln("FuncTabAddr: %s,", g.wrapValue("md.Ftab", bits)) - g.writeln("FuncTabLen: %s,", g.wrapValue("md.Ftablen", bits)) + g.writeln("FuncTabAddr: %s,", g.wrapValue("md.ftab", bits)) + g.writeln("FuncTabLen: %s,", g.wrapValue("md.ftablen", bits)) } if exist("pclntable") { - g.writeln("PCLNTabAddr: %s,", g.wrapValue("md.Pclntable", bits)) - g.writeln("PCLNTabLen: %s,", g.wrapValue("md.Pclntablelen", bits)) + g.writeln("PCLNTabAddr: %s,", g.wrapValue("md.pclntable", bits)) + g.writeln("PCLNTabLen: %s,", g.wrapValue("md.pclntablelen", bits)) } if exist("gofunc") { - g.writeln("GoFuncVal: %s,", g.wrapValue("md.Gofunc", bits)) + g.writeln("GoFuncVal: %s,", g.wrapValue("md.gofunc", bits)) } g.writeln("}\n}\n") @@ -384,7 +401,9 @@ func generateModuleData() { versionCodes = append(versionCodes, versionCode) } - sort.Ints(versionCodes) + slices.SortFunc(versionCodes, func(a, b int) int { + return -cmp.Compare(a, b) + }) for _, versionCode := range versionCodes { err = g.add(versionCode, sources[versionCode]) @@ -394,6 +413,7 @@ func generateModuleData() { } g.writeSelector() + g.writeModuleListGetter() out, err := format.Source(g.buf.Bytes()) if err != nil { diff --git a/moduledata_gen.go b/moduledata_gen.go index fbaab77..ddacae9 100644 --- a/moduledata_gen.go +++ b/moduledata_gen.go @@ -21,2111 +21,2160 @@ package gore import "fmt" -type moduledata_1_5_32 struct { - Pclntable, Pclntablelen, Pclntablecap uint32 - Ftab, Ftablen, Ftabcap uint32 - Filetab, Filetablen, Filetabcap uint32 - Findfunctab uint32 - Minpc uint32 - Maxpc uint32 - Text uint32 - Etext uint32 - Noptrdata uint32 - Enoptrdata uint32 - Data uint32 - Edata uint32 - Bss uint32 - Ebss uint32 - Noptrbss uint32 - Enoptrbss uint32 - End uint32 - Gcdata uint32 - Gcbss uint32 - Typelinks, Typelinkslen, Typelinkscap uint32 +type moduledata_1_22_32 struct { + pcHeader uint32 + funcnametab, funcnametablen, funcnametabcap uint32 + cutab, cutablen, cutabcap uint32 + filetab, filetablen, filetabcap uint32 + pctab, pctablen, pctabcap uint32 + pclntable, pclntablelen, pclntablecap uint32 + ftab, ftablen, ftabcap uint32 + findfunctab uint32 + minpc uint32 + maxpc uint32 + text uint32 + etext uint32 + noptrdata uint32 + enoptrdata uint32 + data uint32 + edata uint32 + bss uint32 + ebss uint32 + noptrbss uint32 + enoptrbss uint32 + covctrs uint32 + ecovctrs uint32 + end uint32 + gcdata uint32 + gcbss uint32 + types uint32 + etypes uint32 + rodata uint32 + gofunc uint32 + textsectmap, textsectmaplen, textsectmapcap uint32 + typelinks, typelinkslen, typelinkscap uint32 + itablinks, itablinkslen, itablinkscap uint32 + ptab, ptablen, ptabcap uint32 + pluginpath, pluginpathlen uint32 + pkghashes, pkghasheslen, pkghashescap uint32 + inittasks, inittaskslen, inittaskscap uint32 } -func (md moduledata_1_5_32) toModuledata() moduledata { +func (md moduledata_1_22_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.Text), - TextLen: uint64(md.Etext - md.Text), - NoPtrDataAddr: uint64(md.Noptrdata), - NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), - DataAddr: uint64(md.Data), - DataLen: uint64(md.Edata - md.Data), - BssAddr: uint64(md.Bss), - BssLen: uint64(md.Ebss - md.Bss), - NoPtrBssAddr: uint64(md.Noptrbss), - NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), - TypelinkAddr: uint64(md.Typelinks), - TypelinkLen: uint64(md.Typelinkslen), - FuncTabAddr: uint64(md.Ftab), - FuncTabLen: uint64(md.Ftablen), - PCLNTabAddr: uint64(md.Pclntable), - PCLNTabLen: uint64(md.Pclntablelen), + TextAddr: uint64(md.text), + TextLen: uint64(md.etext - md.text), + NoPtrDataAddr: uint64(md.noptrdata), + NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), + DataAddr: uint64(md.data), + DataLen: uint64(md.edata - md.data), + BssAddr: uint64(md.bss), + BssLen: uint64(md.ebss - md.bss), + NoPtrBssAddr: uint64(md.noptrbss), + NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), + TypesAddr: uint64(md.types), + TypesLen: uint64(md.etypes - md.types), + TypelinkAddr: uint64(md.typelinks), + TypelinkLen: uint64(md.typelinkslen), + ITabLinkAddr: uint64(md.itablinks), + ITabLinkLen: uint64(md.itablinkslen), + FuncTabAddr: uint64(md.ftab), + FuncTabLen: uint64(md.ftablen), + PCLNTabAddr: uint64(md.pclntable), + PCLNTabLen: uint64(md.pclntablelen), + GoFuncVal: uint64(md.gofunc), } } -type moduledata_1_5_64 struct { - Pclntable, Pclntablelen, Pclntablecap uint64 - Ftab, Ftablen, Ftabcap uint64 - Filetab, Filetablen, Filetabcap uint64 - Findfunctab uint64 - Minpc uint64 - Maxpc uint64 - Text uint64 - Etext uint64 - Noptrdata uint64 - Enoptrdata uint64 - Data uint64 - Edata uint64 - Bss uint64 - Ebss uint64 - Noptrbss uint64 - Enoptrbss uint64 - End uint64 - Gcdata uint64 - Gcbss uint64 - Typelinks, Typelinkslen, Typelinkscap uint64 +type moduledata_1_22_64 struct { + pcHeader uint64 + funcnametab, funcnametablen, funcnametabcap uint64 + cutab, cutablen, cutabcap uint64 + filetab, filetablen, filetabcap uint64 + pctab, pctablen, pctabcap uint64 + pclntable, pclntablelen, pclntablecap uint64 + ftab, ftablen, ftabcap uint64 + findfunctab uint64 + minpc uint64 + maxpc uint64 + text uint64 + etext uint64 + noptrdata uint64 + enoptrdata uint64 + data uint64 + edata uint64 + bss uint64 + ebss uint64 + noptrbss uint64 + enoptrbss uint64 + covctrs uint64 + ecovctrs uint64 + end uint64 + gcdata uint64 + gcbss uint64 + types uint64 + etypes uint64 + rodata uint64 + gofunc uint64 + textsectmap, textsectmaplen, textsectmapcap uint64 + typelinks, typelinkslen, typelinkscap uint64 + itablinks, itablinkslen, itablinkscap uint64 + ptab, ptablen, ptabcap uint64 + pluginpath, pluginpathlen uint64 + pkghashes, pkghasheslen, pkghashescap uint64 + inittasks, inittaskslen, inittaskscap uint64 } -func (md moduledata_1_5_64) toModuledata() moduledata { +func (md moduledata_1_22_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.Text, - TextLen: md.Etext - md.Text, - NoPtrDataAddr: md.Noptrdata, - NoPtrDataLen: md.Enoptrdata - md.Noptrdata, - DataAddr: md.Data, - DataLen: md.Edata - md.Data, - BssAddr: md.Bss, - BssLen: md.Ebss - md.Bss, - NoPtrBssAddr: md.Noptrbss, - NoPtrBssLen: md.Enoptrbss - md.Noptrbss, - TypelinkAddr: md.Typelinks, - TypelinkLen: md.Typelinkslen, - FuncTabAddr: md.Ftab, - FuncTabLen: md.Ftablen, - PCLNTabAddr: md.Pclntable, - PCLNTabLen: md.Pclntablelen, + TextAddr: md.text, + TextLen: md.etext - md.text, + NoPtrDataAddr: md.noptrdata, + NoPtrDataLen: md.enoptrdata - md.noptrdata, + DataAddr: md.data, + DataLen: md.edata - md.data, + BssAddr: md.bss, + BssLen: md.ebss - md.bss, + NoPtrBssAddr: md.noptrbss, + NoPtrBssLen: md.enoptrbss - md.noptrbss, + TypesAddr: md.types, + TypesLen: md.etypes - md.types, + TypelinkAddr: md.typelinks, + TypelinkLen: md.typelinkslen, + ITabLinkAddr: md.itablinks, + ITabLinkLen: md.itablinkslen, + FuncTabAddr: md.ftab, + FuncTabLen: md.ftablen, + PCLNTabAddr: md.pclntable, + PCLNTabLen: md.pclntablelen, + GoFuncVal: md.gofunc, } } -type moduledata_1_6_32 struct { - Pclntable, Pclntablelen, Pclntablecap uint32 - Ftab, Ftablen, Ftabcap uint32 - Filetab, Filetablen, Filetabcap uint32 - Findfunctab uint32 - Minpc uint32 - Maxpc uint32 - Text uint32 - Etext uint32 - Noptrdata uint32 - Enoptrdata uint32 - Data uint32 - Edata uint32 - Bss uint32 - Ebss uint32 - Noptrbss uint32 - Enoptrbss uint32 - End uint32 - Gcdata uint32 - Gcbss uint32 - Typelinks, Typelinkslen, Typelinkscap uint32 +type moduledata_1_21_32 struct { + pcHeader uint32 + funcnametab, funcnametablen, funcnametabcap uint32 + cutab, cutablen, cutabcap uint32 + filetab, filetablen, filetabcap uint32 + pctab, pctablen, pctabcap uint32 + pclntable, pclntablelen, pclntablecap uint32 + ftab, ftablen, ftabcap uint32 + findfunctab uint32 + minpc uint32 + maxpc uint32 + text uint32 + etext uint32 + noptrdata uint32 + enoptrdata uint32 + data uint32 + edata uint32 + bss uint32 + ebss uint32 + noptrbss uint32 + enoptrbss uint32 + covctrs uint32 + ecovctrs uint32 + end uint32 + gcdata uint32 + gcbss uint32 + types uint32 + etypes uint32 + rodata uint32 + gofunc uint32 + textsectmap, textsectmaplen, textsectmapcap uint32 + typelinks, typelinkslen, typelinkscap uint32 + itablinks, itablinkslen, itablinkscap uint32 + ptab, ptablen, ptabcap uint32 + pluginpath, pluginpathlen uint32 + pkghashes, pkghasheslen, pkghashescap uint32 + inittasks, inittaskslen, inittaskscap uint32 } -func (md moduledata_1_6_32) toModuledata() moduledata { +func (md moduledata_1_21_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.Text), - TextLen: uint64(md.Etext - md.Text), - NoPtrDataAddr: uint64(md.Noptrdata), - NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), - DataAddr: uint64(md.Data), - DataLen: uint64(md.Edata - md.Data), - BssAddr: uint64(md.Bss), - BssLen: uint64(md.Ebss - md.Bss), - NoPtrBssAddr: uint64(md.Noptrbss), - NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), - TypelinkAddr: uint64(md.Typelinks), - TypelinkLen: uint64(md.Typelinkslen), - FuncTabAddr: uint64(md.Ftab), - FuncTabLen: uint64(md.Ftablen), - PCLNTabAddr: uint64(md.Pclntable), - PCLNTabLen: uint64(md.Pclntablelen), + TextAddr: uint64(md.text), + TextLen: uint64(md.etext - md.text), + NoPtrDataAddr: uint64(md.noptrdata), + NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), + DataAddr: uint64(md.data), + DataLen: uint64(md.edata - md.data), + BssAddr: uint64(md.bss), + BssLen: uint64(md.ebss - md.bss), + NoPtrBssAddr: uint64(md.noptrbss), + NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), + TypesAddr: uint64(md.types), + TypesLen: uint64(md.etypes - md.types), + TypelinkAddr: uint64(md.typelinks), + TypelinkLen: uint64(md.typelinkslen), + ITabLinkAddr: uint64(md.itablinks), + ITabLinkLen: uint64(md.itablinkslen), + FuncTabAddr: uint64(md.ftab), + FuncTabLen: uint64(md.ftablen), + PCLNTabAddr: uint64(md.pclntable), + PCLNTabLen: uint64(md.pclntablelen), + GoFuncVal: uint64(md.gofunc), } } -type moduledata_1_6_64 struct { - Pclntable, Pclntablelen, Pclntablecap uint64 - Ftab, Ftablen, Ftabcap uint64 - Filetab, Filetablen, Filetabcap uint64 - Findfunctab uint64 - Minpc uint64 - Maxpc uint64 - Text uint64 - Etext uint64 - Noptrdata uint64 - Enoptrdata uint64 - Data uint64 - Edata uint64 - Bss uint64 - Ebss uint64 - Noptrbss uint64 - Enoptrbss uint64 - End uint64 - Gcdata uint64 - Gcbss uint64 - Typelinks, Typelinkslen, Typelinkscap uint64 +type moduledata_1_21_64 struct { + pcHeader uint64 + funcnametab, funcnametablen, funcnametabcap uint64 + cutab, cutablen, cutabcap uint64 + filetab, filetablen, filetabcap uint64 + pctab, pctablen, pctabcap uint64 + pclntable, pclntablelen, pclntablecap uint64 + ftab, ftablen, ftabcap uint64 + findfunctab uint64 + minpc uint64 + maxpc uint64 + text uint64 + etext uint64 + noptrdata uint64 + enoptrdata uint64 + data uint64 + edata uint64 + bss uint64 + ebss uint64 + noptrbss uint64 + enoptrbss uint64 + covctrs uint64 + ecovctrs uint64 + end uint64 + gcdata uint64 + gcbss uint64 + types uint64 + etypes uint64 + rodata uint64 + gofunc uint64 + textsectmap, textsectmaplen, textsectmapcap uint64 + typelinks, typelinkslen, typelinkscap uint64 + itablinks, itablinkslen, itablinkscap uint64 + ptab, ptablen, ptabcap uint64 + pluginpath, pluginpathlen uint64 + pkghashes, pkghasheslen, pkghashescap uint64 + inittasks, inittaskslen, inittaskscap uint64 } -func (md moduledata_1_6_64) toModuledata() moduledata { +func (md moduledata_1_21_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.Text, - TextLen: md.Etext - md.Text, - NoPtrDataAddr: md.Noptrdata, - NoPtrDataLen: md.Enoptrdata - md.Noptrdata, - DataAddr: md.Data, - DataLen: md.Edata - md.Data, - BssAddr: md.Bss, - BssLen: md.Ebss - md.Bss, - NoPtrBssAddr: md.Noptrbss, - NoPtrBssLen: md.Enoptrbss - md.Noptrbss, - TypelinkAddr: md.Typelinks, - TypelinkLen: md.Typelinkslen, - FuncTabAddr: md.Ftab, - FuncTabLen: md.Ftablen, - PCLNTabAddr: md.Pclntable, - PCLNTabLen: md.Pclntablelen, + TextAddr: md.text, + TextLen: md.etext - md.text, + NoPtrDataAddr: md.noptrdata, + NoPtrDataLen: md.enoptrdata - md.noptrdata, + DataAddr: md.data, + DataLen: md.edata - md.data, + BssAddr: md.bss, + BssLen: md.ebss - md.bss, + NoPtrBssAddr: md.noptrbss, + NoPtrBssLen: md.enoptrbss - md.noptrbss, + TypesAddr: md.types, + TypesLen: md.etypes - md.types, + TypelinkAddr: md.typelinks, + TypelinkLen: md.typelinkslen, + ITabLinkAddr: md.itablinks, + ITabLinkLen: md.itablinkslen, + FuncTabAddr: md.ftab, + FuncTabLen: md.ftablen, + PCLNTabAddr: md.pclntable, + PCLNTabLen: md.pclntablelen, + GoFuncVal: md.gofunc, } } -type moduledata_1_7_32 struct { - Pclntable, Pclntablelen, Pclntablecap uint32 - Ftab, Ftablen, Ftabcap uint32 - Filetab, Filetablen, Filetabcap uint32 - Findfunctab uint32 - Minpc uint32 - Maxpc uint32 - Text uint32 - Etext uint32 - Noptrdata uint32 - Enoptrdata uint32 - Data uint32 - Edata uint32 - Bss uint32 - Ebss uint32 - Noptrbss uint32 - Enoptrbss uint32 - End uint32 - Gcdata uint32 - Gcbss uint32 - Types uint32 - Etypes uint32 - Typelinks, Typelinkslen, Typelinkscap uint32 - Itablinks, Itablinkslen, Itablinkscap uint32 +type moduledata_1_20_32 struct { + pcHeader uint32 + funcnametab, funcnametablen, funcnametabcap uint32 + cutab, cutablen, cutabcap uint32 + filetab, filetablen, filetabcap uint32 + pctab, pctablen, pctabcap uint32 + pclntable, pclntablelen, pclntablecap uint32 + ftab, ftablen, ftabcap uint32 + findfunctab uint32 + minpc uint32 + maxpc uint32 + text uint32 + etext uint32 + noptrdata uint32 + enoptrdata uint32 + data uint32 + edata uint32 + bss uint32 + ebss uint32 + noptrbss uint32 + enoptrbss uint32 + covctrs uint32 + ecovctrs uint32 + end uint32 + gcdata uint32 + gcbss uint32 + types uint32 + etypes uint32 + rodata uint32 + gofunc uint32 + textsectmap, textsectmaplen, textsectmapcap uint32 + typelinks, typelinkslen, typelinkscap uint32 + itablinks, itablinkslen, itablinkscap uint32 + ptab, ptablen, ptabcap uint32 + pluginpath, pluginpathlen uint32 + pkghashes, pkghasheslen, pkghashescap uint32 } -func (md moduledata_1_7_32) toModuledata() moduledata { +func (md moduledata_1_20_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.Text), - TextLen: uint64(md.Etext - md.Text), - NoPtrDataAddr: uint64(md.Noptrdata), - NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), - DataAddr: uint64(md.Data), - DataLen: uint64(md.Edata - md.Data), - BssAddr: uint64(md.Bss), - BssLen: uint64(md.Ebss - md.Bss), - NoPtrBssAddr: uint64(md.Noptrbss), - NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), - TypesAddr: uint64(md.Types), - TypesLen: uint64(md.Etypes - md.Types), - TypelinkAddr: uint64(md.Typelinks), - TypelinkLen: uint64(md.Typelinkslen), - ITabLinkAddr: uint64(md.Itablinks), - ITabLinkLen: uint64(md.Itablinkslen), - FuncTabAddr: uint64(md.Ftab), - FuncTabLen: uint64(md.Ftablen), - PCLNTabAddr: uint64(md.Pclntable), - PCLNTabLen: uint64(md.Pclntablelen), + TextAddr: uint64(md.text), + TextLen: uint64(md.etext - md.text), + NoPtrDataAddr: uint64(md.noptrdata), + NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), + DataAddr: uint64(md.data), + DataLen: uint64(md.edata - md.data), + BssAddr: uint64(md.bss), + BssLen: uint64(md.ebss - md.bss), + NoPtrBssAddr: uint64(md.noptrbss), + NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), + TypesAddr: uint64(md.types), + TypesLen: uint64(md.etypes - md.types), + TypelinkAddr: uint64(md.typelinks), + TypelinkLen: uint64(md.typelinkslen), + ITabLinkAddr: uint64(md.itablinks), + ITabLinkLen: uint64(md.itablinkslen), + FuncTabAddr: uint64(md.ftab), + FuncTabLen: uint64(md.ftablen), + PCLNTabAddr: uint64(md.pclntable), + PCLNTabLen: uint64(md.pclntablelen), + GoFuncVal: uint64(md.gofunc), } } -type moduledata_1_7_64 struct { - Pclntable, Pclntablelen, Pclntablecap uint64 - Ftab, Ftablen, Ftabcap uint64 - Filetab, Filetablen, Filetabcap uint64 - Findfunctab uint64 - Minpc uint64 - Maxpc uint64 - Text uint64 - Etext uint64 - Noptrdata uint64 - Enoptrdata uint64 - Data uint64 - Edata uint64 - Bss uint64 - Ebss uint64 - Noptrbss uint64 - Enoptrbss uint64 - End uint64 - Gcdata uint64 - Gcbss uint64 - Types uint64 - Etypes uint64 - Typelinks, Typelinkslen, Typelinkscap uint64 - Itablinks, Itablinkslen, Itablinkscap uint64 +type moduledata_1_20_64 struct { + pcHeader uint64 + funcnametab, funcnametablen, funcnametabcap uint64 + cutab, cutablen, cutabcap uint64 + filetab, filetablen, filetabcap uint64 + pctab, pctablen, pctabcap uint64 + pclntable, pclntablelen, pclntablecap uint64 + ftab, ftablen, ftabcap uint64 + findfunctab uint64 + minpc uint64 + maxpc uint64 + text uint64 + etext uint64 + noptrdata uint64 + enoptrdata uint64 + data uint64 + edata uint64 + bss uint64 + ebss uint64 + noptrbss uint64 + enoptrbss uint64 + covctrs uint64 + ecovctrs uint64 + end uint64 + gcdata uint64 + gcbss uint64 + types uint64 + etypes uint64 + rodata uint64 + gofunc uint64 + textsectmap, textsectmaplen, textsectmapcap uint64 + typelinks, typelinkslen, typelinkscap uint64 + itablinks, itablinkslen, itablinkscap uint64 + ptab, ptablen, ptabcap uint64 + pluginpath, pluginpathlen uint64 + pkghashes, pkghasheslen, pkghashescap uint64 } -func (md moduledata_1_7_64) toModuledata() moduledata { +func (md moduledata_1_20_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.Text, - TextLen: md.Etext - md.Text, - NoPtrDataAddr: md.Noptrdata, - NoPtrDataLen: md.Enoptrdata - md.Noptrdata, - DataAddr: md.Data, - DataLen: md.Edata - md.Data, - BssAddr: md.Bss, - BssLen: md.Ebss - md.Bss, - NoPtrBssAddr: md.Noptrbss, - NoPtrBssLen: md.Enoptrbss - md.Noptrbss, - TypesAddr: md.Types, - TypesLen: md.Etypes - md.Types, - TypelinkAddr: md.Typelinks, - TypelinkLen: md.Typelinkslen, - ITabLinkAddr: md.Itablinks, - ITabLinkLen: md.Itablinkslen, - FuncTabAddr: md.Ftab, - FuncTabLen: md.Ftablen, - PCLNTabAddr: md.Pclntable, - PCLNTabLen: md.Pclntablelen, + TextAddr: md.text, + TextLen: md.etext - md.text, + NoPtrDataAddr: md.noptrdata, + NoPtrDataLen: md.enoptrdata - md.noptrdata, + DataAddr: md.data, + DataLen: md.edata - md.data, + BssAddr: md.bss, + BssLen: md.ebss - md.bss, + NoPtrBssAddr: md.noptrbss, + NoPtrBssLen: md.enoptrbss - md.noptrbss, + TypesAddr: md.types, + TypesLen: md.etypes - md.types, + TypelinkAddr: md.typelinks, + TypelinkLen: md.typelinkslen, + ITabLinkAddr: md.itablinks, + ITabLinkLen: md.itablinkslen, + FuncTabAddr: md.ftab, + FuncTabLen: md.ftablen, + PCLNTabAddr: md.pclntable, + PCLNTabLen: md.pclntablelen, + GoFuncVal: md.gofunc, } } -type moduledata_1_8_32 struct { - Pclntable, Pclntablelen, Pclntablecap uint32 - Ftab, Ftablen, Ftabcap uint32 - Filetab, Filetablen, Filetabcap uint32 - Findfunctab uint32 - Minpc uint32 - Maxpc uint32 - Text uint32 - Etext uint32 - Noptrdata uint32 - Enoptrdata uint32 - Data uint32 - Edata uint32 - Bss uint32 - Ebss uint32 - Noptrbss uint32 - Enoptrbss uint32 - End uint32 - Gcdata uint32 - Gcbss uint32 - Types uint32 - Etypes uint32 - Textsectmap, Textsectmaplen, Textsectmapcap uint32 - Typelinks, Typelinkslen, Typelinkscap uint32 - Itablinks, Itablinkslen, Itablinkscap uint32 - Ptab, Ptablen, Ptabcap uint32 - Pluginpath, Pluginpathlen uint32 - Pkghashes, Pkghasheslen, Pkghashescap uint32 +type moduledata_1_19_32 struct { + pcHeader uint32 + funcnametab, funcnametablen, funcnametabcap uint32 + cutab, cutablen, cutabcap uint32 + filetab, filetablen, filetabcap uint32 + pctab, pctablen, pctabcap uint32 + pclntable, pclntablelen, pclntablecap uint32 + ftab, ftablen, ftabcap uint32 + findfunctab uint32 + minpc uint32 + maxpc uint32 + text uint32 + etext uint32 + noptrdata uint32 + enoptrdata uint32 + data uint32 + edata uint32 + bss uint32 + ebss uint32 + noptrbss uint32 + enoptrbss uint32 + end uint32 + gcdata uint32 + gcbss uint32 + types uint32 + etypes uint32 + rodata uint32 + gofunc uint32 + textsectmap, textsectmaplen, textsectmapcap uint32 + typelinks, typelinkslen, typelinkscap uint32 + itablinks, itablinkslen, itablinkscap uint32 + ptab, ptablen, ptabcap uint32 + pluginpath, pluginpathlen uint32 + pkghashes, pkghasheslen, pkghashescap uint32 } -func (md moduledata_1_8_32) toModuledata() moduledata { +func (md moduledata_1_19_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.Text), - TextLen: uint64(md.Etext - md.Text), - NoPtrDataAddr: uint64(md.Noptrdata), - NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), - DataAddr: uint64(md.Data), - DataLen: uint64(md.Edata - md.Data), - BssAddr: uint64(md.Bss), - BssLen: uint64(md.Ebss - md.Bss), - NoPtrBssAddr: uint64(md.Noptrbss), - NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), - TypesAddr: uint64(md.Types), - TypesLen: uint64(md.Etypes - md.Types), - TypelinkAddr: uint64(md.Typelinks), - TypelinkLen: uint64(md.Typelinkslen), - ITabLinkAddr: uint64(md.Itablinks), - ITabLinkLen: uint64(md.Itablinkslen), - FuncTabAddr: uint64(md.Ftab), - FuncTabLen: uint64(md.Ftablen), - PCLNTabAddr: uint64(md.Pclntable), - PCLNTabLen: uint64(md.Pclntablelen), + TextAddr: uint64(md.text), + TextLen: uint64(md.etext - md.text), + NoPtrDataAddr: uint64(md.noptrdata), + NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), + DataAddr: uint64(md.data), + DataLen: uint64(md.edata - md.data), + BssAddr: uint64(md.bss), + BssLen: uint64(md.ebss - md.bss), + NoPtrBssAddr: uint64(md.noptrbss), + NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), + TypesAddr: uint64(md.types), + TypesLen: uint64(md.etypes - md.types), + TypelinkAddr: uint64(md.typelinks), + TypelinkLen: uint64(md.typelinkslen), + ITabLinkAddr: uint64(md.itablinks), + ITabLinkLen: uint64(md.itablinkslen), + FuncTabAddr: uint64(md.ftab), + FuncTabLen: uint64(md.ftablen), + PCLNTabAddr: uint64(md.pclntable), + PCLNTabLen: uint64(md.pclntablelen), + GoFuncVal: uint64(md.gofunc), } } -type moduledata_1_8_64 struct { - Pclntable, Pclntablelen, Pclntablecap uint64 - Ftab, Ftablen, Ftabcap uint64 - Filetab, Filetablen, Filetabcap uint64 - Findfunctab uint64 - Minpc uint64 - Maxpc uint64 - Text uint64 - Etext uint64 - Noptrdata uint64 - Enoptrdata uint64 - Data uint64 - Edata uint64 - Bss uint64 - Ebss uint64 - Noptrbss uint64 - Enoptrbss uint64 - End uint64 - Gcdata uint64 - Gcbss uint64 - Types uint64 - Etypes uint64 - Textsectmap, Textsectmaplen, Textsectmapcap uint64 - Typelinks, Typelinkslen, Typelinkscap uint64 - Itablinks, Itablinkslen, Itablinkscap uint64 - Ptab, Ptablen, Ptabcap uint64 - Pluginpath, Pluginpathlen uint64 - Pkghashes, Pkghasheslen, Pkghashescap uint64 +type moduledata_1_19_64 struct { + pcHeader uint64 + funcnametab, funcnametablen, funcnametabcap uint64 + cutab, cutablen, cutabcap uint64 + filetab, filetablen, filetabcap uint64 + pctab, pctablen, pctabcap uint64 + pclntable, pclntablelen, pclntablecap uint64 + ftab, ftablen, ftabcap uint64 + findfunctab uint64 + minpc uint64 + maxpc uint64 + text uint64 + etext uint64 + noptrdata uint64 + enoptrdata uint64 + data uint64 + edata uint64 + bss uint64 + ebss uint64 + noptrbss uint64 + enoptrbss uint64 + end uint64 + gcdata uint64 + gcbss uint64 + types uint64 + etypes uint64 + rodata uint64 + gofunc uint64 + textsectmap, textsectmaplen, textsectmapcap uint64 + typelinks, typelinkslen, typelinkscap uint64 + itablinks, itablinkslen, itablinkscap uint64 + ptab, ptablen, ptabcap uint64 + pluginpath, pluginpathlen uint64 + pkghashes, pkghasheslen, pkghashescap uint64 } -func (md moduledata_1_8_64) toModuledata() moduledata { +func (md moduledata_1_19_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.Text, - TextLen: md.Etext - md.Text, - NoPtrDataAddr: md.Noptrdata, - NoPtrDataLen: md.Enoptrdata - md.Noptrdata, - DataAddr: md.Data, - DataLen: md.Edata - md.Data, - BssAddr: md.Bss, - BssLen: md.Ebss - md.Bss, - NoPtrBssAddr: md.Noptrbss, - NoPtrBssLen: md.Enoptrbss - md.Noptrbss, - TypesAddr: md.Types, - TypesLen: md.Etypes - md.Types, - TypelinkAddr: md.Typelinks, - TypelinkLen: md.Typelinkslen, - ITabLinkAddr: md.Itablinks, - ITabLinkLen: md.Itablinkslen, - FuncTabAddr: md.Ftab, - FuncTabLen: md.Ftablen, - PCLNTabAddr: md.Pclntable, - PCLNTabLen: md.Pclntablelen, + TextAddr: md.text, + TextLen: md.etext - md.text, + NoPtrDataAddr: md.noptrdata, + NoPtrDataLen: md.enoptrdata - md.noptrdata, + DataAddr: md.data, + DataLen: md.edata - md.data, + BssAddr: md.bss, + BssLen: md.ebss - md.bss, + NoPtrBssAddr: md.noptrbss, + NoPtrBssLen: md.enoptrbss - md.noptrbss, + TypesAddr: md.types, + TypesLen: md.etypes - md.types, + TypelinkAddr: md.typelinks, + TypelinkLen: md.typelinkslen, + ITabLinkAddr: md.itablinks, + ITabLinkLen: md.itablinkslen, + FuncTabAddr: md.ftab, + FuncTabLen: md.ftablen, + PCLNTabAddr: md.pclntable, + PCLNTabLen: md.pclntablelen, + GoFuncVal: md.gofunc, } } -type moduledata_1_9_32 struct { - Pclntable, Pclntablelen, Pclntablecap uint32 - Ftab, Ftablen, Ftabcap uint32 - Filetab, Filetablen, Filetabcap uint32 - Findfunctab uint32 - Minpc uint32 - Maxpc uint32 - Text uint32 - Etext uint32 - Noptrdata uint32 - Enoptrdata uint32 - Data uint32 - Edata uint32 - Bss uint32 - Ebss uint32 - Noptrbss uint32 - Enoptrbss uint32 - End uint32 - Gcdata uint32 - Gcbss uint32 - Types uint32 - Etypes uint32 - Textsectmap, Textsectmaplen, Textsectmapcap uint32 - Typelinks, Typelinkslen, Typelinkscap uint32 - Itablinks, Itablinkslen, Itablinkscap uint32 - Ptab, Ptablen, Ptabcap uint32 - Pluginpath, Pluginpathlen uint32 - Pkghashes, Pkghasheslen, Pkghashescap uint32 +type moduledata_1_18_32 struct { + pcHeader uint32 + funcnametab, funcnametablen, funcnametabcap uint32 + cutab, cutablen, cutabcap uint32 + filetab, filetablen, filetabcap uint32 + pctab, pctablen, pctabcap uint32 + pclntable, pclntablelen, pclntablecap uint32 + ftab, ftablen, ftabcap uint32 + findfunctab uint32 + minpc uint32 + maxpc uint32 + text uint32 + etext uint32 + noptrdata uint32 + enoptrdata uint32 + data uint32 + edata uint32 + bss uint32 + ebss uint32 + noptrbss uint32 + enoptrbss uint32 + end uint32 + gcdata uint32 + gcbss uint32 + types uint32 + etypes uint32 + rodata uint32 + gofunc uint32 + textsectmap, textsectmaplen, textsectmapcap uint32 + typelinks, typelinkslen, typelinkscap uint32 + itablinks, itablinkslen, itablinkscap uint32 + ptab, ptablen, ptabcap uint32 + pluginpath, pluginpathlen uint32 + pkghashes, pkghasheslen, pkghashescap uint32 } -func (md moduledata_1_9_32) toModuledata() moduledata { +func (md moduledata_1_18_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.Text), - TextLen: uint64(md.Etext - md.Text), - NoPtrDataAddr: uint64(md.Noptrdata), - NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), - DataAddr: uint64(md.Data), - DataLen: uint64(md.Edata - md.Data), - BssAddr: uint64(md.Bss), - BssLen: uint64(md.Ebss - md.Bss), - NoPtrBssAddr: uint64(md.Noptrbss), - NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), - TypesAddr: uint64(md.Types), - TypesLen: uint64(md.Etypes - md.Types), - TypelinkAddr: uint64(md.Typelinks), - TypelinkLen: uint64(md.Typelinkslen), - ITabLinkAddr: uint64(md.Itablinks), - ITabLinkLen: uint64(md.Itablinkslen), - FuncTabAddr: uint64(md.Ftab), - FuncTabLen: uint64(md.Ftablen), - PCLNTabAddr: uint64(md.Pclntable), - PCLNTabLen: uint64(md.Pclntablelen), + TextAddr: uint64(md.text), + TextLen: uint64(md.etext - md.text), + NoPtrDataAddr: uint64(md.noptrdata), + NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), + DataAddr: uint64(md.data), + DataLen: uint64(md.edata - md.data), + BssAddr: uint64(md.bss), + BssLen: uint64(md.ebss - md.bss), + NoPtrBssAddr: uint64(md.noptrbss), + NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), + TypesAddr: uint64(md.types), + TypesLen: uint64(md.etypes - md.types), + TypelinkAddr: uint64(md.typelinks), + TypelinkLen: uint64(md.typelinkslen), + ITabLinkAddr: uint64(md.itablinks), + ITabLinkLen: uint64(md.itablinkslen), + FuncTabAddr: uint64(md.ftab), + FuncTabLen: uint64(md.ftablen), + PCLNTabAddr: uint64(md.pclntable), + PCLNTabLen: uint64(md.pclntablelen), + GoFuncVal: uint64(md.gofunc), } } -type moduledata_1_9_64 struct { - Pclntable, Pclntablelen, Pclntablecap uint64 - Ftab, Ftablen, Ftabcap uint64 - Filetab, Filetablen, Filetabcap uint64 - Findfunctab uint64 - Minpc uint64 - Maxpc uint64 - Text uint64 - Etext uint64 - Noptrdata uint64 - Enoptrdata uint64 - Data uint64 - Edata uint64 - Bss uint64 - Ebss uint64 - Noptrbss uint64 - Enoptrbss uint64 - End uint64 - Gcdata uint64 - Gcbss uint64 - Types uint64 - Etypes uint64 - Textsectmap, Textsectmaplen, Textsectmapcap uint64 - Typelinks, Typelinkslen, Typelinkscap uint64 - Itablinks, Itablinkslen, Itablinkscap uint64 - Ptab, Ptablen, Ptabcap uint64 - Pluginpath, Pluginpathlen uint64 - Pkghashes, Pkghasheslen, Pkghashescap uint64 +type moduledata_1_18_64 struct { + pcHeader uint64 + funcnametab, funcnametablen, funcnametabcap uint64 + cutab, cutablen, cutabcap uint64 + filetab, filetablen, filetabcap uint64 + pctab, pctablen, pctabcap uint64 + pclntable, pclntablelen, pclntablecap uint64 + ftab, ftablen, ftabcap uint64 + findfunctab uint64 + minpc uint64 + maxpc uint64 + text uint64 + etext uint64 + noptrdata uint64 + enoptrdata uint64 + data uint64 + edata uint64 + bss uint64 + ebss uint64 + noptrbss uint64 + enoptrbss uint64 + end uint64 + gcdata uint64 + gcbss uint64 + types uint64 + etypes uint64 + rodata uint64 + gofunc uint64 + textsectmap, textsectmaplen, textsectmapcap uint64 + typelinks, typelinkslen, typelinkscap uint64 + itablinks, itablinkslen, itablinkscap uint64 + ptab, ptablen, ptabcap uint64 + pluginpath, pluginpathlen uint64 + pkghashes, pkghasheslen, pkghashescap uint64 } -func (md moduledata_1_9_64) toModuledata() moduledata { +func (md moduledata_1_18_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.Text, - TextLen: md.Etext - md.Text, - NoPtrDataAddr: md.Noptrdata, - NoPtrDataLen: md.Enoptrdata - md.Noptrdata, - DataAddr: md.Data, - DataLen: md.Edata - md.Data, - BssAddr: md.Bss, - BssLen: md.Ebss - md.Bss, - NoPtrBssAddr: md.Noptrbss, - NoPtrBssLen: md.Enoptrbss - md.Noptrbss, - TypesAddr: md.Types, - TypesLen: md.Etypes - md.Types, - TypelinkAddr: md.Typelinks, - TypelinkLen: md.Typelinkslen, - ITabLinkAddr: md.Itablinks, - ITabLinkLen: md.Itablinkslen, - FuncTabAddr: md.Ftab, - FuncTabLen: md.Ftablen, - PCLNTabAddr: md.Pclntable, - PCLNTabLen: md.Pclntablelen, + TextAddr: md.text, + TextLen: md.etext - md.text, + NoPtrDataAddr: md.noptrdata, + NoPtrDataLen: md.enoptrdata - md.noptrdata, + DataAddr: md.data, + DataLen: md.edata - md.data, + BssAddr: md.bss, + BssLen: md.ebss - md.bss, + NoPtrBssAddr: md.noptrbss, + NoPtrBssLen: md.enoptrbss - md.noptrbss, + TypesAddr: md.types, + TypesLen: md.etypes - md.types, + TypelinkAddr: md.typelinks, + TypelinkLen: md.typelinkslen, + ITabLinkAddr: md.itablinks, + ITabLinkLen: md.itablinkslen, + FuncTabAddr: md.ftab, + FuncTabLen: md.ftablen, + PCLNTabAddr: md.pclntable, + PCLNTabLen: md.pclntablelen, + GoFuncVal: md.gofunc, } } -type moduledata_1_10_32 struct { - Pclntable, Pclntablelen, Pclntablecap uint32 - Ftab, Ftablen, Ftabcap uint32 - Filetab, Filetablen, Filetabcap uint32 - Findfunctab uint32 - Minpc uint32 - Maxpc uint32 - Text uint32 - Etext uint32 - Noptrdata uint32 - Enoptrdata uint32 - Data uint32 - Edata uint32 - Bss uint32 - Ebss uint32 - Noptrbss uint32 - Enoptrbss uint32 - End uint32 - Gcdata uint32 - Gcbss uint32 - Types uint32 - Etypes uint32 - Textsectmap, Textsectmaplen, Textsectmapcap uint32 - Typelinks, Typelinkslen, Typelinkscap uint32 - Itablinks, Itablinkslen, Itablinkscap uint32 - Ptab, Ptablen, Ptabcap uint32 - Pluginpath, Pluginpathlen uint32 - Pkghashes, Pkghasheslen, Pkghashescap uint32 +type moduledata_1_17_32 struct { + pcHeader uint32 + funcnametab, funcnametablen, funcnametabcap uint32 + cutab, cutablen, cutabcap uint32 + filetab, filetablen, filetabcap uint32 + pctab, pctablen, pctabcap uint32 + pclntable, pclntablelen, pclntablecap uint32 + ftab, ftablen, ftabcap uint32 + findfunctab uint32 + minpc uint32 + maxpc uint32 + text uint32 + etext uint32 + noptrdata uint32 + enoptrdata uint32 + data uint32 + edata uint32 + bss uint32 + ebss uint32 + noptrbss uint32 + enoptrbss uint32 + end uint32 + gcdata uint32 + gcbss uint32 + types uint32 + etypes uint32 + textsectmap, textsectmaplen, textsectmapcap uint32 + typelinks, typelinkslen, typelinkscap uint32 + itablinks, itablinkslen, itablinkscap uint32 + ptab, ptablen, ptabcap uint32 + pluginpath, pluginpathlen uint32 + pkghashes, pkghasheslen, pkghashescap uint32 } -func (md moduledata_1_10_32) toModuledata() moduledata { +func (md moduledata_1_17_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.Text), - TextLen: uint64(md.Etext - md.Text), - NoPtrDataAddr: uint64(md.Noptrdata), - NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), - DataAddr: uint64(md.Data), - DataLen: uint64(md.Edata - md.Data), - BssAddr: uint64(md.Bss), - BssLen: uint64(md.Ebss - md.Bss), - NoPtrBssAddr: uint64(md.Noptrbss), - NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), - TypesAddr: uint64(md.Types), - TypesLen: uint64(md.Etypes - md.Types), - TypelinkAddr: uint64(md.Typelinks), - TypelinkLen: uint64(md.Typelinkslen), - ITabLinkAddr: uint64(md.Itablinks), - ITabLinkLen: uint64(md.Itablinkslen), - FuncTabAddr: uint64(md.Ftab), - FuncTabLen: uint64(md.Ftablen), - PCLNTabAddr: uint64(md.Pclntable), - PCLNTabLen: uint64(md.Pclntablelen), + TextAddr: uint64(md.text), + TextLen: uint64(md.etext - md.text), + NoPtrDataAddr: uint64(md.noptrdata), + NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), + DataAddr: uint64(md.data), + DataLen: uint64(md.edata - md.data), + BssAddr: uint64(md.bss), + BssLen: uint64(md.ebss - md.bss), + NoPtrBssAddr: uint64(md.noptrbss), + NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), + TypesAddr: uint64(md.types), + TypesLen: uint64(md.etypes - md.types), + TypelinkAddr: uint64(md.typelinks), + TypelinkLen: uint64(md.typelinkslen), + ITabLinkAddr: uint64(md.itablinks), + ITabLinkLen: uint64(md.itablinkslen), + FuncTabAddr: uint64(md.ftab), + FuncTabLen: uint64(md.ftablen), + PCLNTabAddr: uint64(md.pclntable), + PCLNTabLen: uint64(md.pclntablelen), } } -type moduledata_1_10_64 struct { - Pclntable, Pclntablelen, Pclntablecap uint64 - Ftab, Ftablen, Ftabcap uint64 - Filetab, Filetablen, Filetabcap uint64 - Findfunctab uint64 - Minpc uint64 - Maxpc uint64 - Text uint64 - Etext uint64 - Noptrdata uint64 - Enoptrdata uint64 - Data uint64 - Edata uint64 - Bss uint64 - Ebss uint64 - Noptrbss uint64 - Enoptrbss uint64 - End uint64 - Gcdata uint64 - Gcbss uint64 - Types uint64 - Etypes uint64 - Textsectmap, Textsectmaplen, Textsectmapcap uint64 - Typelinks, Typelinkslen, Typelinkscap uint64 - Itablinks, Itablinkslen, Itablinkscap uint64 - Ptab, Ptablen, Ptabcap uint64 - Pluginpath, Pluginpathlen uint64 - Pkghashes, Pkghasheslen, Pkghashescap uint64 +type moduledata_1_17_64 struct { + pcHeader uint64 + funcnametab, funcnametablen, funcnametabcap uint64 + cutab, cutablen, cutabcap uint64 + filetab, filetablen, filetabcap uint64 + pctab, pctablen, pctabcap uint64 + pclntable, pclntablelen, pclntablecap uint64 + ftab, ftablen, ftabcap uint64 + findfunctab uint64 + minpc uint64 + maxpc uint64 + text uint64 + etext uint64 + noptrdata uint64 + enoptrdata uint64 + data uint64 + edata uint64 + bss uint64 + ebss uint64 + noptrbss uint64 + enoptrbss uint64 + end uint64 + gcdata uint64 + gcbss uint64 + types uint64 + etypes uint64 + textsectmap, textsectmaplen, textsectmapcap uint64 + typelinks, typelinkslen, typelinkscap uint64 + itablinks, itablinkslen, itablinkscap uint64 + ptab, ptablen, ptabcap uint64 + pluginpath, pluginpathlen uint64 + pkghashes, pkghasheslen, pkghashescap uint64 } -func (md moduledata_1_10_64) toModuledata() moduledata { +func (md moduledata_1_17_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.Text, - TextLen: md.Etext - md.Text, - NoPtrDataAddr: md.Noptrdata, - NoPtrDataLen: md.Enoptrdata - md.Noptrdata, - DataAddr: md.Data, - DataLen: md.Edata - md.Data, - BssAddr: md.Bss, - BssLen: md.Ebss - md.Bss, - NoPtrBssAddr: md.Noptrbss, - NoPtrBssLen: md.Enoptrbss - md.Noptrbss, - TypesAddr: md.Types, - TypesLen: md.Etypes - md.Types, - TypelinkAddr: md.Typelinks, - TypelinkLen: md.Typelinkslen, - ITabLinkAddr: md.Itablinks, - ITabLinkLen: md.Itablinkslen, - FuncTabAddr: md.Ftab, - FuncTabLen: md.Ftablen, - PCLNTabAddr: md.Pclntable, - PCLNTabLen: md.Pclntablelen, + TextAddr: md.text, + TextLen: md.etext - md.text, + NoPtrDataAddr: md.noptrdata, + NoPtrDataLen: md.enoptrdata - md.noptrdata, + DataAddr: md.data, + DataLen: md.edata - md.data, + BssAddr: md.bss, + BssLen: md.ebss - md.bss, + NoPtrBssAddr: md.noptrbss, + NoPtrBssLen: md.enoptrbss - md.noptrbss, + TypesAddr: md.types, + TypesLen: md.etypes - md.types, + TypelinkAddr: md.typelinks, + TypelinkLen: md.typelinkslen, + ITabLinkAddr: md.itablinks, + ITabLinkLen: md.itablinkslen, + FuncTabAddr: md.ftab, + FuncTabLen: md.ftablen, + PCLNTabAddr: md.pclntable, + PCLNTabLen: md.pclntablelen, } } -type moduledata_1_11_32 struct { - Pclntable, Pclntablelen, Pclntablecap uint32 - Ftab, Ftablen, Ftabcap uint32 - Filetab, Filetablen, Filetabcap uint32 - Findfunctab uint32 - Minpc uint32 - Maxpc uint32 - Text uint32 - Etext uint32 - Noptrdata uint32 - Enoptrdata uint32 - Data uint32 - Edata uint32 - Bss uint32 - Ebss uint32 - Noptrbss uint32 - Enoptrbss uint32 - End uint32 - Gcdata uint32 - Gcbss uint32 - Types uint32 - Etypes uint32 - Textsectmap, Textsectmaplen, Textsectmapcap uint32 - Typelinks, Typelinkslen, Typelinkscap uint32 - Itablinks, Itablinkslen, Itablinkscap uint32 - Ptab, Ptablen, Ptabcap uint32 - Pluginpath, Pluginpathlen uint32 - Pkghashes, Pkghasheslen, Pkghashescap uint32 +type moduledata_1_16_32 struct { + pcHeader uint32 + funcnametab, funcnametablen, funcnametabcap uint32 + cutab, cutablen, cutabcap uint32 + filetab, filetablen, filetabcap uint32 + pctab, pctablen, pctabcap uint32 + pclntable, pclntablelen, pclntablecap uint32 + ftab, ftablen, ftabcap uint32 + findfunctab uint32 + minpc uint32 + maxpc uint32 + text uint32 + etext uint32 + noptrdata uint32 + enoptrdata uint32 + data uint32 + edata uint32 + bss uint32 + ebss uint32 + noptrbss uint32 + enoptrbss uint32 + end uint32 + gcdata uint32 + gcbss uint32 + types uint32 + etypes uint32 + textsectmap, textsectmaplen, textsectmapcap uint32 + typelinks, typelinkslen, typelinkscap uint32 + itablinks, itablinkslen, itablinkscap uint32 + ptab, ptablen, ptabcap uint32 + pluginpath, pluginpathlen uint32 + pkghashes, pkghasheslen, pkghashescap uint32 } -func (md moduledata_1_11_32) toModuledata() moduledata { +func (md moduledata_1_16_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.Text), - TextLen: uint64(md.Etext - md.Text), - NoPtrDataAddr: uint64(md.Noptrdata), - NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), - DataAddr: uint64(md.Data), - DataLen: uint64(md.Edata - md.Data), - BssAddr: uint64(md.Bss), - BssLen: uint64(md.Ebss - md.Bss), - NoPtrBssAddr: uint64(md.Noptrbss), - NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), - TypesAddr: uint64(md.Types), - TypesLen: uint64(md.Etypes - md.Types), - TypelinkAddr: uint64(md.Typelinks), - TypelinkLen: uint64(md.Typelinkslen), - ITabLinkAddr: uint64(md.Itablinks), - ITabLinkLen: uint64(md.Itablinkslen), - FuncTabAddr: uint64(md.Ftab), - FuncTabLen: uint64(md.Ftablen), - PCLNTabAddr: uint64(md.Pclntable), - PCLNTabLen: uint64(md.Pclntablelen), + TextAddr: uint64(md.text), + TextLen: uint64(md.etext - md.text), + NoPtrDataAddr: uint64(md.noptrdata), + NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), + DataAddr: uint64(md.data), + DataLen: uint64(md.edata - md.data), + BssAddr: uint64(md.bss), + BssLen: uint64(md.ebss - md.bss), + NoPtrBssAddr: uint64(md.noptrbss), + NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), + TypesAddr: uint64(md.types), + TypesLen: uint64(md.etypes - md.types), + TypelinkAddr: uint64(md.typelinks), + TypelinkLen: uint64(md.typelinkslen), + ITabLinkAddr: uint64(md.itablinks), + ITabLinkLen: uint64(md.itablinkslen), + FuncTabAddr: uint64(md.ftab), + FuncTabLen: uint64(md.ftablen), + PCLNTabAddr: uint64(md.pclntable), + PCLNTabLen: uint64(md.pclntablelen), } } -type moduledata_1_11_64 struct { - Pclntable, Pclntablelen, Pclntablecap uint64 - Ftab, Ftablen, Ftabcap uint64 - Filetab, Filetablen, Filetabcap uint64 - Findfunctab uint64 - Minpc uint64 - Maxpc uint64 - Text uint64 - Etext uint64 - Noptrdata uint64 - Enoptrdata uint64 - Data uint64 - Edata uint64 - Bss uint64 - Ebss uint64 - Noptrbss uint64 - Enoptrbss uint64 - End uint64 - Gcdata uint64 - Gcbss uint64 - Types uint64 - Etypes uint64 - Textsectmap, Textsectmaplen, Textsectmapcap uint64 - Typelinks, Typelinkslen, Typelinkscap uint64 - Itablinks, Itablinkslen, Itablinkscap uint64 - Ptab, Ptablen, Ptabcap uint64 - Pluginpath, Pluginpathlen uint64 - Pkghashes, Pkghasheslen, Pkghashescap uint64 +type moduledata_1_16_64 struct { + pcHeader uint64 + funcnametab, funcnametablen, funcnametabcap uint64 + cutab, cutablen, cutabcap uint64 + filetab, filetablen, filetabcap uint64 + pctab, pctablen, pctabcap uint64 + pclntable, pclntablelen, pclntablecap uint64 + ftab, ftablen, ftabcap uint64 + findfunctab uint64 + minpc uint64 + maxpc uint64 + text uint64 + etext uint64 + noptrdata uint64 + enoptrdata uint64 + data uint64 + edata uint64 + bss uint64 + ebss uint64 + noptrbss uint64 + enoptrbss uint64 + end uint64 + gcdata uint64 + gcbss uint64 + types uint64 + etypes uint64 + textsectmap, textsectmaplen, textsectmapcap uint64 + typelinks, typelinkslen, typelinkscap uint64 + itablinks, itablinkslen, itablinkscap uint64 + ptab, ptablen, ptabcap uint64 + pluginpath, pluginpathlen uint64 + pkghashes, pkghasheslen, pkghashescap uint64 } -func (md moduledata_1_11_64) toModuledata() moduledata { +func (md moduledata_1_16_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.Text, - TextLen: md.Etext - md.Text, - NoPtrDataAddr: md.Noptrdata, - NoPtrDataLen: md.Enoptrdata - md.Noptrdata, - DataAddr: md.Data, - DataLen: md.Edata - md.Data, - BssAddr: md.Bss, - BssLen: md.Ebss - md.Bss, - NoPtrBssAddr: md.Noptrbss, - NoPtrBssLen: md.Enoptrbss - md.Noptrbss, - TypesAddr: md.Types, - TypesLen: md.Etypes - md.Types, - TypelinkAddr: md.Typelinks, - TypelinkLen: md.Typelinkslen, - ITabLinkAddr: md.Itablinks, - ITabLinkLen: md.Itablinkslen, - FuncTabAddr: md.Ftab, - FuncTabLen: md.Ftablen, - PCLNTabAddr: md.Pclntable, - PCLNTabLen: md.Pclntablelen, + TextAddr: md.text, + TextLen: md.etext - md.text, + NoPtrDataAddr: md.noptrdata, + NoPtrDataLen: md.enoptrdata - md.noptrdata, + DataAddr: md.data, + DataLen: md.edata - md.data, + BssAddr: md.bss, + BssLen: md.ebss - md.bss, + NoPtrBssAddr: md.noptrbss, + NoPtrBssLen: md.enoptrbss - md.noptrbss, + TypesAddr: md.types, + TypesLen: md.etypes - md.types, + TypelinkAddr: md.typelinks, + TypelinkLen: md.typelinkslen, + ITabLinkAddr: md.itablinks, + ITabLinkLen: md.itablinkslen, + FuncTabAddr: md.ftab, + FuncTabLen: md.ftablen, + PCLNTabAddr: md.pclntable, + PCLNTabLen: md.pclntablelen, } } -type moduledata_1_12_32 struct { - Pclntable, Pclntablelen, Pclntablecap uint32 - Ftab, Ftablen, Ftabcap uint32 - Filetab, Filetablen, Filetabcap uint32 - Findfunctab uint32 - Minpc uint32 - Maxpc uint32 - Text uint32 - Etext uint32 - Noptrdata uint32 - Enoptrdata uint32 - Data uint32 - Edata uint32 - Bss uint32 - Ebss uint32 - Noptrbss uint32 - Enoptrbss uint32 - End uint32 - Gcdata uint32 - Gcbss uint32 - Types uint32 - Etypes uint32 - Textsectmap, Textsectmaplen, Textsectmapcap uint32 - Typelinks, Typelinkslen, Typelinkscap uint32 - Itablinks, Itablinkslen, Itablinkscap uint32 - Ptab, Ptablen, Ptabcap uint32 - Pluginpath, Pluginpathlen uint32 - Pkghashes, Pkghasheslen, Pkghashescap uint32 +type moduledata_1_15_32 struct { + pclntable, pclntablelen, pclntablecap uint32 + ftab, ftablen, ftabcap uint32 + filetab, filetablen, filetabcap uint32 + findfunctab uint32 + minpc uint32 + maxpc uint32 + text uint32 + etext uint32 + noptrdata uint32 + enoptrdata uint32 + data uint32 + edata uint32 + bss uint32 + ebss uint32 + noptrbss uint32 + enoptrbss uint32 + end uint32 + gcdata uint32 + gcbss uint32 + types uint32 + etypes uint32 + textsectmap, textsectmaplen, textsectmapcap uint32 + typelinks, typelinkslen, typelinkscap uint32 + itablinks, itablinkslen, itablinkscap uint32 + ptab, ptablen, ptabcap uint32 + pluginpath, pluginpathlen uint32 + pkghashes, pkghasheslen, pkghashescap uint32 } -func (md moduledata_1_12_32) toModuledata() moduledata { +func (md moduledata_1_15_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.Text), - TextLen: uint64(md.Etext - md.Text), - NoPtrDataAddr: uint64(md.Noptrdata), - NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), - DataAddr: uint64(md.Data), - DataLen: uint64(md.Edata - md.Data), - BssAddr: uint64(md.Bss), - BssLen: uint64(md.Ebss - md.Bss), - NoPtrBssAddr: uint64(md.Noptrbss), - NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), - TypesAddr: uint64(md.Types), - TypesLen: uint64(md.Etypes - md.Types), - TypelinkAddr: uint64(md.Typelinks), - TypelinkLen: uint64(md.Typelinkslen), - ITabLinkAddr: uint64(md.Itablinks), - ITabLinkLen: uint64(md.Itablinkslen), - FuncTabAddr: uint64(md.Ftab), - FuncTabLen: uint64(md.Ftablen), - PCLNTabAddr: uint64(md.Pclntable), - PCLNTabLen: uint64(md.Pclntablelen), + TextAddr: uint64(md.text), + TextLen: uint64(md.etext - md.text), + NoPtrDataAddr: uint64(md.noptrdata), + NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), + DataAddr: uint64(md.data), + DataLen: uint64(md.edata - md.data), + BssAddr: uint64(md.bss), + BssLen: uint64(md.ebss - md.bss), + NoPtrBssAddr: uint64(md.noptrbss), + NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), + TypesAddr: uint64(md.types), + TypesLen: uint64(md.etypes - md.types), + TypelinkAddr: uint64(md.typelinks), + TypelinkLen: uint64(md.typelinkslen), + ITabLinkAddr: uint64(md.itablinks), + ITabLinkLen: uint64(md.itablinkslen), + FuncTabAddr: uint64(md.ftab), + FuncTabLen: uint64(md.ftablen), + PCLNTabAddr: uint64(md.pclntable), + PCLNTabLen: uint64(md.pclntablelen), } } -type moduledata_1_12_64 struct { - Pclntable, Pclntablelen, Pclntablecap uint64 - Ftab, Ftablen, Ftabcap uint64 - Filetab, Filetablen, Filetabcap uint64 - Findfunctab uint64 - Minpc uint64 - Maxpc uint64 - Text uint64 - Etext uint64 - Noptrdata uint64 - Enoptrdata uint64 - Data uint64 - Edata uint64 - Bss uint64 - Ebss uint64 - Noptrbss uint64 - Enoptrbss uint64 - End uint64 - Gcdata uint64 - Gcbss uint64 - Types uint64 - Etypes uint64 - Textsectmap, Textsectmaplen, Textsectmapcap uint64 - Typelinks, Typelinkslen, Typelinkscap uint64 - Itablinks, Itablinkslen, Itablinkscap uint64 - Ptab, Ptablen, Ptabcap uint64 - Pluginpath, Pluginpathlen uint64 - Pkghashes, Pkghasheslen, Pkghashescap uint64 +type moduledata_1_15_64 struct { + pclntable, pclntablelen, pclntablecap uint64 + ftab, ftablen, ftabcap uint64 + filetab, filetablen, filetabcap uint64 + findfunctab uint64 + minpc uint64 + maxpc uint64 + text uint64 + etext uint64 + noptrdata uint64 + enoptrdata uint64 + data uint64 + edata uint64 + bss uint64 + ebss uint64 + noptrbss uint64 + enoptrbss uint64 + end uint64 + gcdata uint64 + gcbss uint64 + types uint64 + etypes uint64 + textsectmap, textsectmaplen, textsectmapcap uint64 + typelinks, typelinkslen, typelinkscap uint64 + itablinks, itablinkslen, itablinkscap uint64 + ptab, ptablen, ptabcap uint64 + pluginpath, pluginpathlen uint64 + pkghashes, pkghasheslen, pkghashescap uint64 } -func (md moduledata_1_12_64) toModuledata() moduledata { +func (md moduledata_1_15_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.Text, - TextLen: md.Etext - md.Text, - NoPtrDataAddr: md.Noptrdata, - NoPtrDataLen: md.Enoptrdata - md.Noptrdata, - DataAddr: md.Data, - DataLen: md.Edata - md.Data, - BssAddr: md.Bss, - BssLen: md.Ebss - md.Bss, - NoPtrBssAddr: md.Noptrbss, - NoPtrBssLen: md.Enoptrbss - md.Noptrbss, - TypesAddr: md.Types, - TypesLen: md.Etypes - md.Types, - TypelinkAddr: md.Typelinks, - TypelinkLen: md.Typelinkslen, - ITabLinkAddr: md.Itablinks, - ITabLinkLen: md.Itablinkslen, - FuncTabAddr: md.Ftab, - FuncTabLen: md.Ftablen, - PCLNTabAddr: md.Pclntable, - PCLNTabLen: md.Pclntablelen, + TextAddr: md.text, + TextLen: md.etext - md.text, + NoPtrDataAddr: md.noptrdata, + NoPtrDataLen: md.enoptrdata - md.noptrdata, + DataAddr: md.data, + DataLen: md.edata - md.data, + BssAddr: md.bss, + BssLen: md.ebss - md.bss, + NoPtrBssAddr: md.noptrbss, + NoPtrBssLen: md.enoptrbss - md.noptrbss, + TypesAddr: md.types, + TypesLen: md.etypes - md.types, + TypelinkAddr: md.typelinks, + TypelinkLen: md.typelinkslen, + ITabLinkAddr: md.itablinks, + ITabLinkLen: md.itablinkslen, + FuncTabAddr: md.ftab, + FuncTabLen: md.ftablen, + PCLNTabAddr: md.pclntable, + PCLNTabLen: md.pclntablelen, } } -type moduledata_1_13_32 struct { - Pclntable, Pclntablelen, Pclntablecap uint32 - Ftab, Ftablen, Ftabcap uint32 - Filetab, Filetablen, Filetabcap uint32 - Findfunctab uint32 - Minpc uint32 - Maxpc uint32 - Text uint32 - Etext uint32 - Noptrdata uint32 - Enoptrdata uint32 - Data uint32 - Edata uint32 - Bss uint32 - Ebss uint32 - Noptrbss uint32 - Enoptrbss uint32 - End uint32 - Gcdata uint32 - Gcbss uint32 - Types uint32 - Etypes uint32 - Textsectmap, Textsectmaplen, Textsectmapcap uint32 - Typelinks, Typelinkslen, Typelinkscap uint32 - Itablinks, Itablinkslen, Itablinkscap uint32 - Ptab, Ptablen, Ptabcap uint32 - Pluginpath, Pluginpathlen uint32 - Pkghashes, Pkghasheslen, Pkghashescap uint32 +type moduledata_1_14_32 struct { + pclntable, pclntablelen, pclntablecap uint32 + ftab, ftablen, ftabcap uint32 + filetab, filetablen, filetabcap uint32 + findfunctab uint32 + minpc uint32 + maxpc uint32 + text uint32 + etext uint32 + noptrdata uint32 + enoptrdata uint32 + data uint32 + edata uint32 + bss uint32 + ebss uint32 + noptrbss uint32 + enoptrbss uint32 + end uint32 + gcdata uint32 + gcbss uint32 + types uint32 + etypes uint32 + textsectmap, textsectmaplen, textsectmapcap uint32 + typelinks, typelinkslen, typelinkscap uint32 + itablinks, itablinkslen, itablinkscap uint32 + ptab, ptablen, ptabcap uint32 + pluginpath, pluginpathlen uint32 + pkghashes, pkghasheslen, pkghashescap uint32 } -func (md moduledata_1_13_32) toModuledata() moduledata { +func (md moduledata_1_14_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.Text), - TextLen: uint64(md.Etext - md.Text), - NoPtrDataAddr: uint64(md.Noptrdata), - NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), - DataAddr: uint64(md.Data), - DataLen: uint64(md.Edata - md.Data), - BssAddr: uint64(md.Bss), - BssLen: uint64(md.Ebss - md.Bss), - NoPtrBssAddr: uint64(md.Noptrbss), - NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), - TypesAddr: uint64(md.Types), - TypesLen: uint64(md.Etypes - md.Types), - TypelinkAddr: uint64(md.Typelinks), - TypelinkLen: uint64(md.Typelinkslen), - ITabLinkAddr: uint64(md.Itablinks), - ITabLinkLen: uint64(md.Itablinkslen), - FuncTabAddr: uint64(md.Ftab), - FuncTabLen: uint64(md.Ftablen), - PCLNTabAddr: uint64(md.Pclntable), - PCLNTabLen: uint64(md.Pclntablelen), + TextAddr: uint64(md.text), + TextLen: uint64(md.etext - md.text), + NoPtrDataAddr: uint64(md.noptrdata), + NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), + DataAddr: uint64(md.data), + DataLen: uint64(md.edata - md.data), + BssAddr: uint64(md.bss), + BssLen: uint64(md.ebss - md.bss), + NoPtrBssAddr: uint64(md.noptrbss), + NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), + TypesAddr: uint64(md.types), + TypesLen: uint64(md.etypes - md.types), + TypelinkAddr: uint64(md.typelinks), + TypelinkLen: uint64(md.typelinkslen), + ITabLinkAddr: uint64(md.itablinks), + ITabLinkLen: uint64(md.itablinkslen), + FuncTabAddr: uint64(md.ftab), + FuncTabLen: uint64(md.ftablen), + PCLNTabAddr: uint64(md.pclntable), + PCLNTabLen: uint64(md.pclntablelen), } } -type moduledata_1_13_64 struct { - Pclntable, Pclntablelen, Pclntablecap uint64 - Ftab, Ftablen, Ftabcap uint64 - Filetab, Filetablen, Filetabcap uint64 - Findfunctab uint64 - Minpc uint64 - Maxpc uint64 - Text uint64 - Etext uint64 - Noptrdata uint64 - Enoptrdata uint64 - Data uint64 - Edata uint64 - Bss uint64 - Ebss uint64 - Noptrbss uint64 - Enoptrbss uint64 - End uint64 - Gcdata uint64 - Gcbss uint64 - Types uint64 - Etypes uint64 - Textsectmap, Textsectmaplen, Textsectmapcap uint64 - Typelinks, Typelinkslen, Typelinkscap uint64 - Itablinks, Itablinkslen, Itablinkscap uint64 - Ptab, Ptablen, Ptabcap uint64 - Pluginpath, Pluginpathlen uint64 - Pkghashes, Pkghasheslen, Pkghashescap uint64 +type moduledata_1_14_64 struct { + pclntable, pclntablelen, pclntablecap uint64 + ftab, ftablen, ftabcap uint64 + filetab, filetablen, filetabcap uint64 + findfunctab uint64 + minpc uint64 + maxpc uint64 + text uint64 + etext uint64 + noptrdata uint64 + enoptrdata uint64 + data uint64 + edata uint64 + bss uint64 + ebss uint64 + noptrbss uint64 + enoptrbss uint64 + end uint64 + gcdata uint64 + gcbss uint64 + types uint64 + etypes uint64 + textsectmap, textsectmaplen, textsectmapcap uint64 + typelinks, typelinkslen, typelinkscap uint64 + itablinks, itablinkslen, itablinkscap uint64 + ptab, ptablen, ptabcap uint64 + pluginpath, pluginpathlen uint64 + pkghashes, pkghasheslen, pkghashescap uint64 } -func (md moduledata_1_13_64) toModuledata() moduledata { +func (md moduledata_1_14_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.Text, - TextLen: md.Etext - md.Text, - NoPtrDataAddr: md.Noptrdata, - NoPtrDataLen: md.Enoptrdata - md.Noptrdata, - DataAddr: md.Data, - DataLen: md.Edata - md.Data, - BssAddr: md.Bss, - BssLen: md.Ebss - md.Bss, - NoPtrBssAddr: md.Noptrbss, - NoPtrBssLen: md.Enoptrbss - md.Noptrbss, - TypesAddr: md.Types, - TypesLen: md.Etypes - md.Types, - TypelinkAddr: md.Typelinks, - TypelinkLen: md.Typelinkslen, - ITabLinkAddr: md.Itablinks, - ITabLinkLen: md.Itablinkslen, - FuncTabAddr: md.Ftab, - FuncTabLen: md.Ftablen, - PCLNTabAddr: md.Pclntable, - PCLNTabLen: md.Pclntablelen, + TextAddr: md.text, + TextLen: md.etext - md.text, + NoPtrDataAddr: md.noptrdata, + NoPtrDataLen: md.enoptrdata - md.noptrdata, + DataAddr: md.data, + DataLen: md.edata - md.data, + BssAddr: md.bss, + BssLen: md.ebss - md.bss, + NoPtrBssAddr: md.noptrbss, + NoPtrBssLen: md.enoptrbss - md.noptrbss, + TypesAddr: md.types, + TypesLen: md.etypes - md.types, + TypelinkAddr: md.typelinks, + TypelinkLen: md.typelinkslen, + ITabLinkAddr: md.itablinks, + ITabLinkLen: md.itablinkslen, + FuncTabAddr: md.ftab, + FuncTabLen: md.ftablen, + PCLNTabAddr: md.pclntable, + PCLNTabLen: md.pclntablelen, } } -type moduledata_1_14_32 struct { - Pclntable, Pclntablelen, Pclntablecap uint32 - Ftab, Ftablen, Ftabcap uint32 - Filetab, Filetablen, Filetabcap uint32 - Findfunctab uint32 - Minpc uint32 - Maxpc uint32 - Text uint32 - Etext uint32 - Noptrdata uint32 - Enoptrdata uint32 - Data uint32 - Edata uint32 - Bss uint32 - Ebss uint32 - Noptrbss uint32 - Enoptrbss uint32 - End uint32 - Gcdata uint32 - Gcbss uint32 - Types uint32 - Etypes uint32 - Textsectmap, Textsectmaplen, Textsectmapcap uint32 - Typelinks, Typelinkslen, Typelinkscap uint32 - Itablinks, Itablinkslen, Itablinkscap uint32 - Ptab, Ptablen, Ptabcap uint32 - Pluginpath, Pluginpathlen uint32 - Pkghashes, Pkghasheslen, Pkghashescap uint32 +type moduledata_1_13_32 struct { + pclntable, pclntablelen, pclntablecap uint32 + ftab, ftablen, ftabcap uint32 + filetab, filetablen, filetabcap uint32 + findfunctab uint32 + minpc uint32 + maxpc uint32 + text uint32 + etext uint32 + noptrdata uint32 + enoptrdata uint32 + data uint32 + edata uint32 + bss uint32 + ebss uint32 + noptrbss uint32 + enoptrbss uint32 + end uint32 + gcdata uint32 + gcbss uint32 + types uint32 + etypes uint32 + textsectmap, textsectmaplen, textsectmapcap uint32 + typelinks, typelinkslen, typelinkscap uint32 + itablinks, itablinkslen, itablinkscap uint32 + ptab, ptablen, ptabcap uint32 + pluginpath, pluginpathlen uint32 + pkghashes, pkghasheslen, pkghashescap uint32 } -func (md moduledata_1_14_32) toModuledata() moduledata { +func (md moduledata_1_13_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.Text), - TextLen: uint64(md.Etext - md.Text), - NoPtrDataAddr: uint64(md.Noptrdata), - NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), - DataAddr: uint64(md.Data), - DataLen: uint64(md.Edata - md.Data), - BssAddr: uint64(md.Bss), - BssLen: uint64(md.Ebss - md.Bss), - NoPtrBssAddr: uint64(md.Noptrbss), - NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), - TypesAddr: uint64(md.Types), - TypesLen: uint64(md.Etypes - md.Types), - TypelinkAddr: uint64(md.Typelinks), - TypelinkLen: uint64(md.Typelinkslen), - ITabLinkAddr: uint64(md.Itablinks), - ITabLinkLen: uint64(md.Itablinkslen), - FuncTabAddr: uint64(md.Ftab), - FuncTabLen: uint64(md.Ftablen), - PCLNTabAddr: uint64(md.Pclntable), - PCLNTabLen: uint64(md.Pclntablelen), + TextAddr: uint64(md.text), + TextLen: uint64(md.etext - md.text), + NoPtrDataAddr: uint64(md.noptrdata), + NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), + DataAddr: uint64(md.data), + DataLen: uint64(md.edata - md.data), + BssAddr: uint64(md.bss), + BssLen: uint64(md.ebss - md.bss), + NoPtrBssAddr: uint64(md.noptrbss), + NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), + TypesAddr: uint64(md.types), + TypesLen: uint64(md.etypes - md.types), + TypelinkAddr: uint64(md.typelinks), + TypelinkLen: uint64(md.typelinkslen), + ITabLinkAddr: uint64(md.itablinks), + ITabLinkLen: uint64(md.itablinkslen), + FuncTabAddr: uint64(md.ftab), + FuncTabLen: uint64(md.ftablen), + PCLNTabAddr: uint64(md.pclntable), + PCLNTabLen: uint64(md.pclntablelen), } } -type moduledata_1_14_64 struct { - Pclntable, Pclntablelen, Pclntablecap uint64 - Ftab, Ftablen, Ftabcap uint64 - Filetab, Filetablen, Filetabcap uint64 - Findfunctab uint64 - Minpc uint64 - Maxpc uint64 - Text uint64 - Etext uint64 - Noptrdata uint64 - Enoptrdata uint64 - Data uint64 - Edata uint64 - Bss uint64 - Ebss uint64 - Noptrbss uint64 - Enoptrbss uint64 - End uint64 - Gcdata uint64 - Gcbss uint64 - Types uint64 - Etypes uint64 - Textsectmap, Textsectmaplen, Textsectmapcap uint64 - Typelinks, Typelinkslen, Typelinkscap uint64 - Itablinks, Itablinkslen, Itablinkscap uint64 - Ptab, Ptablen, Ptabcap uint64 - Pluginpath, Pluginpathlen uint64 - Pkghashes, Pkghasheslen, Pkghashescap uint64 +type moduledata_1_13_64 struct { + pclntable, pclntablelen, pclntablecap uint64 + ftab, ftablen, ftabcap uint64 + filetab, filetablen, filetabcap uint64 + findfunctab uint64 + minpc uint64 + maxpc uint64 + text uint64 + etext uint64 + noptrdata uint64 + enoptrdata uint64 + data uint64 + edata uint64 + bss uint64 + ebss uint64 + noptrbss uint64 + enoptrbss uint64 + end uint64 + gcdata uint64 + gcbss uint64 + types uint64 + etypes uint64 + textsectmap, textsectmaplen, textsectmapcap uint64 + typelinks, typelinkslen, typelinkscap uint64 + itablinks, itablinkslen, itablinkscap uint64 + ptab, ptablen, ptabcap uint64 + pluginpath, pluginpathlen uint64 + pkghashes, pkghasheslen, pkghashescap uint64 } -func (md moduledata_1_14_64) toModuledata() moduledata { +func (md moduledata_1_13_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.Text, - TextLen: md.Etext - md.Text, - NoPtrDataAddr: md.Noptrdata, - NoPtrDataLen: md.Enoptrdata - md.Noptrdata, - DataAddr: md.Data, - DataLen: md.Edata - md.Data, - BssAddr: md.Bss, - BssLen: md.Ebss - md.Bss, - NoPtrBssAddr: md.Noptrbss, - NoPtrBssLen: md.Enoptrbss - md.Noptrbss, - TypesAddr: md.Types, - TypesLen: md.Etypes - md.Types, - TypelinkAddr: md.Typelinks, - TypelinkLen: md.Typelinkslen, - ITabLinkAddr: md.Itablinks, - ITabLinkLen: md.Itablinkslen, - FuncTabAddr: md.Ftab, - FuncTabLen: md.Ftablen, - PCLNTabAddr: md.Pclntable, - PCLNTabLen: md.Pclntablelen, + TextAddr: md.text, + TextLen: md.etext - md.text, + NoPtrDataAddr: md.noptrdata, + NoPtrDataLen: md.enoptrdata - md.noptrdata, + DataAddr: md.data, + DataLen: md.edata - md.data, + BssAddr: md.bss, + BssLen: md.ebss - md.bss, + NoPtrBssAddr: md.noptrbss, + NoPtrBssLen: md.enoptrbss - md.noptrbss, + TypesAddr: md.types, + TypesLen: md.etypes - md.types, + TypelinkAddr: md.typelinks, + TypelinkLen: md.typelinkslen, + ITabLinkAddr: md.itablinks, + ITabLinkLen: md.itablinkslen, + FuncTabAddr: md.ftab, + FuncTabLen: md.ftablen, + PCLNTabAddr: md.pclntable, + PCLNTabLen: md.pclntablelen, } } -type moduledata_1_15_32 struct { - Pclntable, Pclntablelen, Pclntablecap uint32 - Ftab, Ftablen, Ftabcap uint32 - Filetab, Filetablen, Filetabcap uint32 - Findfunctab uint32 - Minpc uint32 - Maxpc uint32 - Text uint32 - Etext uint32 - Noptrdata uint32 - Enoptrdata uint32 - Data uint32 - Edata uint32 - Bss uint32 - Ebss uint32 - Noptrbss uint32 - Enoptrbss uint32 - End uint32 - Gcdata uint32 - Gcbss uint32 - Types uint32 - Etypes uint32 - Textsectmap, Textsectmaplen, Textsectmapcap uint32 - Typelinks, Typelinkslen, Typelinkscap uint32 - Itablinks, Itablinkslen, Itablinkscap uint32 - Ptab, Ptablen, Ptabcap uint32 - Pluginpath, Pluginpathlen uint32 - Pkghashes, Pkghasheslen, Pkghashescap uint32 +type moduledata_1_12_32 struct { + pclntable, pclntablelen, pclntablecap uint32 + ftab, ftablen, ftabcap uint32 + filetab, filetablen, filetabcap uint32 + findfunctab uint32 + minpc uint32 + maxpc uint32 + text uint32 + etext uint32 + noptrdata uint32 + enoptrdata uint32 + data uint32 + edata uint32 + bss uint32 + ebss uint32 + noptrbss uint32 + enoptrbss uint32 + end uint32 + gcdata uint32 + gcbss uint32 + types uint32 + etypes uint32 + textsectmap, textsectmaplen, textsectmapcap uint32 + typelinks, typelinkslen, typelinkscap uint32 + itablinks, itablinkslen, itablinkscap uint32 + ptab, ptablen, ptabcap uint32 + pluginpath, pluginpathlen uint32 + pkghashes, pkghasheslen, pkghashescap uint32 } -func (md moduledata_1_15_32) toModuledata() moduledata { +func (md moduledata_1_12_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.Text), - TextLen: uint64(md.Etext - md.Text), - NoPtrDataAddr: uint64(md.Noptrdata), - NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), - DataAddr: uint64(md.Data), - DataLen: uint64(md.Edata - md.Data), - BssAddr: uint64(md.Bss), - BssLen: uint64(md.Ebss - md.Bss), - NoPtrBssAddr: uint64(md.Noptrbss), - NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), - TypesAddr: uint64(md.Types), - TypesLen: uint64(md.Etypes - md.Types), - TypelinkAddr: uint64(md.Typelinks), - TypelinkLen: uint64(md.Typelinkslen), - ITabLinkAddr: uint64(md.Itablinks), - ITabLinkLen: uint64(md.Itablinkslen), - FuncTabAddr: uint64(md.Ftab), - FuncTabLen: uint64(md.Ftablen), - PCLNTabAddr: uint64(md.Pclntable), - PCLNTabLen: uint64(md.Pclntablelen), + TextAddr: uint64(md.text), + TextLen: uint64(md.etext - md.text), + NoPtrDataAddr: uint64(md.noptrdata), + NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), + DataAddr: uint64(md.data), + DataLen: uint64(md.edata - md.data), + BssAddr: uint64(md.bss), + BssLen: uint64(md.ebss - md.bss), + NoPtrBssAddr: uint64(md.noptrbss), + NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), + TypesAddr: uint64(md.types), + TypesLen: uint64(md.etypes - md.types), + TypelinkAddr: uint64(md.typelinks), + TypelinkLen: uint64(md.typelinkslen), + ITabLinkAddr: uint64(md.itablinks), + ITabLinkLen: uint64(md.itablinkslen), + FuncTabAddr: uint64(md.ftab), + FuncTabLen: uint64(md.ftablen), + PCLNTabAddr: uint64(md.pclntable), + PCLNTabLen: uint64(md.pclntablelen), } } -type moduledata_1_15_64 struct { - Pclntable, Pclntablelen, Pclntablecap uint64 - Ftab, Ftablen, Ftabcap uint64 - Filetab, Filetablen, Filetabcap uint64 - Findfunctab uint64 - Minpc uint64 - Maxpc uint64 - Text uint64 - Etext uint64 - Noptrdata uint64 - Enoptrdata uint64 - Data uint64 - Edata uint64 - Bss uint64 - Ebss uint64 - Noptrbss uint64 - Enoptrbss uint64 - End uint64 - Gcdata uint64 - Gcbss uint64 - Types uint64 - Etypes uint64 - Textsectmap, Textsectmaplen, Textsectmapcap uint64 - Typelinks, Typelinkslen, Typelinkscap uint64 - Itablinks, Itablinkslen, Itablinkscap uint64 - Ptab, Ptablen, Ptabcap uint64 - Pluginpath, Pluginpathlen uint64 - Pkghashes, Pkghasheslen, Pkghashescap uint64 +type moduledata_1_12_64 struct { + pclntable, pclntablelen, pclntablecap uint64 + ftab, ftablen, ftabcap uint64 + filetab, filetablen, filetabcap uint64 + findfunctab uint64 + minpc uint64 + maxpc uint64 + text uint64 + etext uint64 + noptrdata uint64 + enoptrdata uint64 + data uint64 + edata uint64 + bss uint64 + ebss uint64 + noptrbss uint64 + enoptrbss uint64 + end uint64 + gcdata uint64 + gcbss uint64 + types uint64 + etypes uint64 + textsectmap, textsectmaplen, textsectmapcap uint64 + typelinks, typelinkslen, typelinkscap uint64 + itablinks, itablinkslen, itablinkscap uint64 + ptab, ptablen, ptabcap uint64 + pluginpath, pluginpathlen uint64 + pkghashes, pkghasheslen, pkghashescap uint64 } -func (md moduledata_1_15_64) toModuledata() moduledata { +func (md moduledata_1_12_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.Text, - TextLen: md.Etext - md.Text, - NoPtrDataAddr: md.Noptrdata, - NoPtrDataLen: md.Enoptrdata - md.Noptrdata, - DataAddr: md.Data, - DataLen: md.Edata - md.Data, - BssAddr: md.Bss, - BssLen: md.Ebss - md.Bss, - NoPtrBssAddr: md.Noptrbss, - NoPtrBssLen: md.Enoptrbss - md.Noptrbss, - TypesAddr: md.Types, - TypesLen: md.Etypes - md.Types, - TypelinkAddr: md.Typelinks, - TypelinkLen: md.Typelinkslen, - ITabLinkAddr: md.Itablinks, - ITabLinkLen: md.Itablinkslen, - FuncTabAddr: md.Ftab, - FuncTabLen: md.Ftablen, - PCLNTabAddr: md.Pclntable, - PCLNTabLen: md.Pclntablelen, + TextAddr: md.text, + TextLen: md.etext - md.text, + NoPtrDataAddr: md.noptrdata, + NoPtrDataLen: md.enoptrdata - md.noptrdata, + DataAddr: md.data, + DataLen: md.edata - md.data, + BssAddr: md.bss, + BssLen: md.ebss - md.bss, + NoPtrBssAddr: md.noptrbss, + NoPtrBssLen: md.enoptrbss - md.noptrbss, + TypesAddr: md.types, + TypesLen: md.etypes - md.types, + TypelinkAddr: md.typelinks, + TypelinkLen: md.typelinkslen, + ITabLinkAddr: md.itablinks, + ITabLinkLen: md.itablinkslen, + FuncTabAddr: md.ftab, + FuncTabLen: md.ftablen, + PCLNTabAddr: md.pclntable, + PCLNTabLen: md.pclntablelen, } } -type moduledata_1_16_32 struct { - PcHeader uint32 - Funcnametab, Funcnametablen, Funcnametabcap uint32 - Cutab, Cutablen, Cutabcap uint32 - Filetab, Filetablen, Filetabcap uint32 - Pctab, Pctablen, Pctabcap uint32 - Pclntable, Pclntablelen, Pclntablecap uint32 - Ftab, Ftablen, Ftabcap uint32 - Findfunctab uint32 - Minpc uint32 - Maxpc uint32 - Text uint32 - Etext uint32 - Noptrdata uint32 - Enoptrdata uint32 - Data uint32 - Edata uint32 - Bss uint32 - Ebss uint32 - Noptrbss uint32 - Enoptrbss uint32 - End uint32 - Gcdata uint32 - Gcbss uint32 - Types uint32 - Etypes uint32 - Textsectmap, Textsectmaplen, Textsectmapcap uint32 - Typelinks, Typelinkslen, Typelinkscap uint32 - Itablinks, Itablinkslen, Itablinkscap uint32 - Ptab, Ptablen, Ptabcap uint32 - Pluginpath, Pluginpathlen uint32 - Pkghashes, Pkghasheslen, Pkghashescap uint32 +type moduledata_1_11_32 struct { + pclntable, pclntablelen, pclntablecap uint32 + ftab, ftablen, ftabcap uint32 + filetab, filetablen, filetabcap uint32 + findfunctab uint32 + minpc uint32 + maxpc uint32 + text uint32 + etext uint32 + noptrdata uint32 + enoptrdata uint32 + data uint32 + edata uint32 + bss uint32 + ebss uint32 + noptrbss uint32 + enoptrbss uint32 + end uint32 + gcdata uint32 + gcbss uint32 + types uint32 + etypes uint32 + textsectmap, textsectmaplen, textsectmapcap uint32 + typelinks, typelinkslen, typelinkscap uint32 + itablinks, itablinkslen, itablinkscap uint32 + ptab, ptablen, ptabcap uint32 + pluginpath, pluginpathlen uint32 + pkghashes, pkghasheslen, pkghashescap uint32 } -func (md moduledata_1_16_32) toModuledata() moduledata { +func (md moduledata_1_11_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.Text), - TextLen: uint64(md.Etext - md.Text), - NoPtrDataAddr: uint64(md.Noptrdata), - NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), - DataAddr: uint64(md.Data), - DataLen: uint64(md.Edata - md.Data), - BssAddr: uint64(md.Bss), - BssLen: uint64(md.Ebss - md.Bss), - NoPtrBssAddr: uint64(md.Noptrbss), - NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), - TypesAddr: uint64(md.Types), - TypesLen: uint64(md.Etypes - md.Types), - TypelinkAddr: uint64(md.Typelinks), - TypelinkLen: uint64(md.Typelinkslen), - ITabLinkAddr: uint64(md.Itablinks), - ITabLinkLen: uint64(md.Itablinkslen), - FuncTabAddr: uint64(md.Ftab), - FuncTabLen: uint64(md.Ftablen), - PCLNTabAddr: uint64(md.Pclntable), - PCLNTabLen: uint64(md.Pclntablelen), + TextAddr: uint64(md.text), + TextLen: uint64(md.etext - md.text), + NoPtrDataAddr: uint64(md.noptrdata), + NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), + DataAddr: uint64(md.data), + DataLen: uint64(md.edata - md.data), + BssAddr: uint64(md.bss), + BssLen: uint64(md.ebss - md.bss), + NoPtrBssAddr: uint64(md.noptrbss), + NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), + TypesAddr: uint64(md.types), + TypesLen: uint64(md.etypes - md.types), + TypelinkAddr: uint64(md.typelinks), + TypelinkLen: uint64(md.typelinkslen), + ITabLinkAddr: uint64(md.itablinks), + ITabLinkLen: uint64(md.itablinkslen), + FuncTabAddr: uint64(md.ftab), + FuncTabLen: uint64(md.ftablen), + PCLNTabAddr: uint64(md.pclntable), + PCLNTabLen: uint64(md.pclntablelen), } } -type moduledata_1_16_64 struct { - PcHeader uint64 - Funcnametab, Funcnametablen, Funcnametabcap uint64 - Cutab, Cutablen, Cutabcap uint64 - Filetab, Filetablen, Filetabcap uint64 - Pctab, Pctablen, Pctabcap uint64 - Pclntable, Pclntablelen, Pclntablecap uint64 - Ftab, Ftablen, Ftabcap uint64 - Findfunctab uint64 - Minpc uint64 - Maxpc uint64 - Text uint64 - Etext uint64 - Noptrdata uint64 - Enoptrdata uint64 - Data uint64 - Edata uint64 - Bss uint64 - Ebss uint64 - Noptrbss uint64 - Enoptrbss uint64 - End uint64 - Gcdata uint64 - Gcbss uint64 - Types uint64 - Etypes uint64 - Textsectmap, Textsectmaplen, Textsectmapcap uint64 - Typelinks, Typelinkslen, Typelinkscap uint64 - Itablinks, Itablinkslen, Itablinkscap uint64 - Ptab, Ptablen, Ptabcap uint64 - Pluginpath, Pluginpathlen uint64 - Pkghashes, Pkghasheslen, Pkghashescap uint64 +type moduledata_1_11_64 struct { + pclntable, pclntablelen, pclntablecap uint64 + ftab, ftablen, ftabcap uint64 + filetab, filetablen, filetabcap uint64 + findfunctab uint64 + minpc uint64 + maxpc uint64 + text uint64 + etext uint64 + noptrdata uint64 + enoptrdata uint64 + data uint64 + edata uint64 + bss uint64 + ebss uint64 + noptrbss uint64 + enoptrbss uint64 + end uint64 + gcdata uint64 + gcbss uint64 + types uint64 + etypes uint64 + textsectmap, textsectmaplen, textsectmapcap uint64 + typelinks, typelinkslen, typelinkscap uint64 + itablinks, itablinkslen, itablinkscap uint64 + ptab, ptablen, ptabcap uint64 + pluginpath, pluginpathlen uint64 + pkghashes, pkghasheslen, pkghashescap uint64 } -func (md moduledata_1_16_64) toModuledata() moduledata { +func (md moduledata_1_11_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.Text, - TextLen: md.Etext - md.Text, - NoPtrDataAddr: md.Noptrdata, - NoPtrDataLen: md.Enoptrdata - md.Noptrdata, - DataAddr: md.Data, - DataLen: md.Edata - md.Data, - BssAddr: md.Bss, - BssLen: md.Ebss - md.Bss, - NoPtrBssAddr: md.Noptrbss, - NoPtrBssLen: md.Enoptrbss - md.Noptrbss, - TypesAddr: md.Types, - TypesLen: md.Etypes - md.Types, - TypelinkAddr: md.Typelinks, - TypelinkLen: md.Typelinkslen, - ITabLinkAddr: md.Itablinks, - ITabLinkLen: md.Itablinkslen, - FuncTabAddr: md.Ftab, - FuncTabLen: md.Ftablen, - PCLNTabAddr: md.Pclntable, - PCLNTabLen: md.Pclntablelen, + TextAddr: md.text, + TextLen: md.etext - md.text, + NoPtrDataAddr: md.noptrdata, + NoPtrDataLen: md.enoptrdata - md.noptrdata, + DataAddr: md.data, + DataLen: md.edata - md.data, + BssAddr: md.bss, + BssLen: md.ebss - md.bss, + NoPtrBssAddr: md.noptrbss, + NoPtrBssLen: md.enoptrbss - md.noptrbss, + TypesAddr: md.types, + TypesLen: md.etypes - md.types, + TypelinkAddr: md.typelinks, + TypelinkLen: md.typelinkslen, + ITabLinkAddr: md.itablinks, + ITabLinkLen: md.itablinkslen, + FuncTabAddr: md.ftab, + FuncTabLen: md.ftablen, + PCLNTabAddr: md.pclntable, + PCLNTabLen: md.pclntablelen, } } -type moduledata_1_17_32 struct { - PcHeader uint32 - Funcnametab, Funcnametablen, Funcnametabcap uint32 - Cutab, Cutablen, Cutabcap uint32 - Filetab, Filetablen, Filetabcap uint32 - Pctab, Pctablen, Pctabcap uint32 - Pclntable, Pclntablelen, Pclntablecap uint32 - Ftab, Ftablen, Ftabcap uint32 - Findfunctab uint32 - Minpc uint32 - Maxpc uint32 - Text uint32 - Etext uint32 - Noptrdata uint32 - Enoptrdata uint32 - Data uint32 - Edata uint32 - Bss uint32 - Ebss uint32 - Noptrbss uint32 - Enoptrbss uint32 - End uint32 - Gcdata uint32 - Gcbss uint32 - Types uint32 - Etypes uint32 - Textsectmap, Textsectmaplen, Textsectmapcap uint32 - Typelinks, Typelinkslen, Typelinkscap uint32 - Itablinks, Itablinkslen, Itablinkscap uint32 - Ptab, Ptablen, Ptabcap uint32 - Pluginpath, Pluginpathlen uint32 - Pkghashes, Pkghasheslen, Pkghashescap uint32 +type moduledata_1_10_32 struct { + pclntable, pclntablelen, pclntablecap uint32 + ftab, ftablen, ftabcap uint32 + filetab, filetablen, filetabcap uint32 + findfunctab uint32 + minpc uint32 + maxpc uint32 + text uint32 + etext uint32 + noptrdata uint32 + enoptrdata uint32 + data uint32 + edata uint32 + bss uint32 + ebss uint32 + noptrbss uint32 + enoptrbss uint32 + end uint32 + gcdata uint32 + gcbss uint32 + types uint32 + etypes uint32 + textsectmap, textsectmaplen, textsectmapcap uint32 + typelinks, typelinkslen, typelinkscap uint32 + itablinks, itablinkslen, itablinkscap uint32 + ptab, ptablen, ptabcap uint32 + pluginpath, pluginpathlen uint32 + pkghashes, pkghasheslen, pkghashescap uint32 } -func (md moduledata_1_17_32) toModuledata() moduledata { +func (md moduledata_1_10_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.Text), - TextLen: uint64(md.Etext - md.Text), - NoPtrDataAddr: uint64(md.Noptrdata), - NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), - DataAddr: uint64(md.Data), - DataLen: uint64(md.Edata - md.Data), - BssAddr: uint64(md.Bss), - BssLen: uint64(md.Ebss - md.Bss), - NoPtrBssAddr: uint64(md.Noptrbss), - NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), - TypesAddr: uint64(md.Types), - TypesLen: uint64(md.Etypes - md.Types), - TypelinkAddr: uint64(md.Typelinks), - TypelinkLen: uint64(md.Typelinkslen), - ITabLinkAddr: uint64(md.Itablinks), - ITabLinkLen: uint64(md.Itablinkslen), - FuncTabAddr: uint64(md.Ftab), - FuncTabLen: uint64(md.Ftablen), - PCLNTabAddr: uint64(md.Pclntable), - PCLNTabLen: uint64(md.Pclntablelen), + TextAddr: uint64(md.text), + TextLen: uint64(md.etext - md.text), + NoPtrDataAddr: uint64(md.noptrdata), + NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), + DataAddr: uint64(md.data), + DataLen: uint64(md.edata - md.data), + BssAddr: uint64(md.bss), + BssLen: uint64(md.ebss - md.bss), + NoPtrBssAddr: uint64(md.noptrbss), + NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), + TypesAddr: uint64(md.types), + TypesLen: uint64(md.etypes - md.types), + TypelinkAddr: uint64(md.typelinks), + TypelinkLen: uint64(md.typelinkslen), + ITabLinkAddr: uint64(md.itablinks), + ITabLinkLen: uint64(md.itablinkslen), + FuncTabAddr: uint64(md.ftab), + FuncTabLen: uint64(md.ftablen), + PCLNTabAddr: uint64(md.pclntable), + PCLNTabLen: uint64(md.pclntablelen), } } -type moduledata_1_17_64 struct { - PcHeader uint64 - Funcnametab, Funcnametablen, Funcnametabcap uint64 - Cutab, Cutablen, Cutabcap uint64 - Filetab, Filetablen, Filetabcap uint64 - Pctab, Pctablen, Pctabcap uint64 - Pclntable, Pclntablelen, Pclntablecap uint64 - Ftab, Ftablen, Ftabcap uint64 - Findfunctab uint64 - Minpc uint64 - Maxpc uint64 - Text uint64 - Etext uint64 - Noptrdata uint64 - Enoptrdata uint64 - Data uint64 - Edata uint64 - Bss uint64 - Ebss uint64 - Noptrbss uint64 - Enoptrbss uint64 - End uint64 - Gcdata uint64 - Gcbss uint64 - Types uint64 - Etypes uint64 - Textsectmap, Textsectmaplen, Textsectmapcap uint64 - Typelinks, Typelinkslen, Typelinkscap uint64 - Itablinks, Itablinkslen, Itablinkscap uint64 - Ptab, Ptablen, Ptabcap uint64 - Pluginpath, Pluginpathlen uint64 - Pkghashes, Pkghasheslen, Pkghashescap uint64 +type moduledata_1_10_64 struct { + pclntable, pclntablelen, pclntablecap uint64 + ftab, ftablen, ftabcap uint64 + filetab, filetablen, filetabcap uint64 + findfunctab uint64 + minpc uint64 + maxpc uint64 + text uint64 + etext uint64 + noptrdata uint64 + enoptrdata uint64 + data uint64 + edata uint64 + bss uint64 + ebss uint64 + noptrbss uint64 + enoptrbss uint64 + end uint64 + gcdata uint64 + gcbss uint64 + types uint64 + etypes uint64 + textsectmap, textsectmaplen, textsectmapcap uint64 + typelinks, typelinkslen, typelinkscap uint64 + itablinks, itablinkslen, itablinkscap uint64 + ptab, ptablen, ptabcap uint64 + pluginpath, pluginpathlen uint64 + pkghashes, pkghasheslen, pkghashescap uint64 } -func (md moduledata_1_17_64) toModuledata() moduledata { +func (md moduledata_1_10_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.Text, - TextLen: md.Etext - md.Text, - NoPtrDataAddr: md.Noptrdata, - NoPtrDataLen: md.Enoptrdata - md.Noptrdata, - DataAddr: md.Data, - DataLen: md.Edata - md.Data, - BssAddr: md.Bss, - BssLen: md.Ebss - md.Bss, - NoPtrBssAddr: md.Noptrbss, - NoPtrBssLen: md.Enoptrbss - md.Noptrbss, - TypesAddr: md.Types, - TypesLen: md.Etypes - md.Types, - TypelinkAddr: md.Typelinks, - TypelinkLen: md.Typelinkslen, - ITabLinkAddr: md.Itablinks, - ITabLinkLen: md.Itablinkslen, - FuncTabAddr: md.Ftab, - FuncTabLen: md.Ftablen, - PCLNTabAddr: md.Pclntable, - PCLNTabLen: md.Pclntablelen, + TextAddr: md.text, + TextLen: md.etext - md.text, + NoPtrDataAddr: md.noptrdata, + NoPtrDataLen: md.enoptrdata - md.noptrdata, + DataAddr: md.data, + DataLen: md.edata - md.data, + BssAddr: md.bss, + BssLen: md.ebss - md.bss, + NoPtrBssAddr: md.noptrbss, + NoPtrBssLen: md.enoptrbss - md.noptrbss, + TypesAddr: md.types, + TypesLen: md.etypes - md.types, + TypelinkAddr: md.typelinks, + TypelinkLen: md.typelinkslen, + ITabLinkAddr: md.itablinks, + ITabLinkLen: md.itablinkslen, + FuncTabAddr: md.ftab, + FuncTabLen: md.ftablen, + PCLNTabAddr: md.pclntable, + PCLNTabLen: md.pclntablelen, } } -type moduledata_1_18_32 struct { - PcHeader uint32 - Funcnametab, Funcnametablen, Funcnametabcap uint32 - Cutab, Cutablen, Cutabcap uint32 - Filetab, Filetablen, Filetabcap uint32 - Pctab, Pctablen, Pctabcap uint32 - Pclntable, Pclntablelen, Pclntablecap uint32 - Ftab, Ftablen, Ftabcap uint32 - Findfunctab uint32 - Minpc uint32 - Maxpc uint32 - Text uint32 - Etext uint32 - Noptrdata uint32 - Enoptrdata uint32 - Data uint32 - Edata uint32 - Bss uint32 - Ebss uint32 - Noptrbss uint32 - Enoptrbss uint32 - End uint32 - Gcdata uint32 - Gcbss uint32 - Types uint32 - Etypes uint32 - Rodata uint32 - Gofunc uint32 - Textsectmap, Textsectmaplen, Textsectmapcap uint32 - Typelinks, Typelinkslen, Typelinkscap uint32 - Itablinks, Itablinkslen, Itablinkscap uint32 - Ptab, Ptablen, Ptabcap uint32 - Pluginpath, Pluginpathlen uint32 - Pkghashes, Pkghasheslen, Pkghashescap uint32 +type moduledata_1_9_32 struct { + pclntable, pclntablelen, pclntablecap uint32 + ftab, ftablen, ftabcap uint32 + filetab, filetablen, filetabcap uint32 + findfunctab uint32 + minpc uint32 + maxpc uint32 + text uint32 + etext uint32 + noptrdata uint32 + enoptrdata uint32 + data uint32 + edata uint32 + bss uint32 + ebss uint32 + noptrbss uint32 + enoptrbss uint32 + end uint32 + gcdata uint32 + gcbss uint32 + types uint32 + etypes uint32 + textsectmap, textsectmaplen, textsectmapcap uint32 + typelinks, typelinkslen, typelinkscap uint32 + itablinks, itablinkslen, itablinkscap uint32 + ptab, ptablen, ptabcap uint32 + pluginpath, pluginpathlen uint32 + pkghashes, pkghasheslen, pkghashescap uint32 } -func (md moduledata_1_18_32) toModuledata() moduledata { +func (md moduledata_1_9_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.Text), - TextLen: uint64(md.Etext - md.Text), - NoPtrDataAddr: uint64(md.Noptrdata), - NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), - DataAddr: uint64(md.Data), - DataLen: uint64(md.Edata - md.Data), - BssAddr: uint64(md.Bss), - BssLen: uint64(md.Ebss - md.Bss), - NoPtrBssAddr: uint64(md.Noptrbss), - NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), - TypesAddr: uint64(md.Types), - TypesLen: uint64(md.Etypes - md.Types), - TypelinkAddr: uint64(md.Typelinks), - TypelinkLen: uint64(md.Typelinkslen), - ITabLinkAddr: uint64(md.Itablinks), - ITabLinkLen: uint64(md.Itablinkslen), - FuncTabAddr: uint64(md.Ftab), - FuncTabLen: uint64(md.Ftablen), - PCLNTabAddr: uint64(md.Pclntable), - PCLNTabLen: uint64(md.Pclntablelen), - GoFuncVal: uint64(md.Gofunc), + TextAddr: uint64(md.text), + TextLen: uint64(md.etext - md.text), + NoPtrDataAddr: uint64(md.noptrdata), + NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), + DataAddr: uint64(md.data), + DataLen: uint64(md.edata - md.data), + BssAddr: uint64(md.bss), + BssLen: uint64(md.ebss - md.bss), + NoPtrBssAddr: uint64(md.noptrbss), + NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), + TypesAddr: uint64(md.types), + TypesLen: uint64(md.etypes - md.types), + TypelinkAddr: uint64(md.typelinks), + TypelinkLen: uint64(md.typelinkslen), + ITabLinkAddr: uint64(md.itablinks), + ITabLinkLen: uint64(md.itablinkslen), + FuncTabAddr: uint64(md.ftab), + FuncTabLen: uint64(md.ftablen), + PCLNTabAddr: uint64(md.pclntable), + PCLNTabLen: uint64(md.pclntablelen), } } -type moduledata_1_18_64 struct { - PcHeader uint64 - Funcnametab, Funcnametablen, Funcnametabcap uint64 - Cutab, Cutablen, Cutabcap uint64 - Filetab, Filetablen, Filetabcap uint64 - Pctab, Pctablen, Pctabcap uint64 - Pclntable, Pclntablelen, Pclntablecap uint64 - Ftab, Ftablen, Ftabcap uint64 - Findfunctab uint64 - Minpc uint64 - Maxpc uint64 - Text uint64 - Etext uint64 - Noptrdata uint64 - Enoptrdata uint64 - Data uint64 - Edata uint64 - Bss uint64 - Ebss uint64 - Noptrbss uint64 - Enoptrbss uint64 - End uint64 - Gcdata uint64 - Gcbss uint64 - Types uint64 - Etypes uint64 - Rodata uint64 - Gofunc uint64 - Textsectmap, Textsectmaplen, Textsectmapcap uint64 - Typelinks, Typelinkslen, Typelinkscap uint64 - Itablinks, Itablinkslen, Itablinkscap uint64 - Ptab, Ptablen, Ptabcap uint64 - Pluginpath, Pluginpathlen uint64 - Pkghashes, Pkghasheslen, Pkghashescap uint64 +type moduledata_1_9_64 struct { + pclntable, pclntablelen, pclntablecap uint64 + ftab, ftablen, ftabcap uint64 + filetab, filetablen, filetabcap uint64 + findfunctab uint64 + minpc uint64 + maxpc uint64 + text uint64 + etext uint64 + noptrdata uint64 + enoptrdata uint64 + data uint64 + edata uint64 + bss uint64 + ebss uint64 + noptrbss uint64 + enoptrbss uint64 + end uint64 + gcdata uint64 + gcbss uint64 + types uint64 + etypes uint64 + textsectmap, textsectmaplen, textsectmapcap uint64 + typelinks, typelinkslen, typelinkscap uint64 + itablinks, itablinkslen, itablinkscap uint64 + ptab, ptablen, ptabcap uint64 + pluginpath, pluginpathlen uint64 + pkghashes, pkghasheslen, pkghashescap uint64 } -func (md moduledata_1_18_64) toModuledata() moduledata { +func (md moduledata_1_9_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.Text, - TextLen: md.Etext - md.Text, - NoPtrDataAddr: md.Noptrdata, - NoPtrDataLen: md.Enoptrdata - md.Noptrdata, - DataAddr: md.Data, - DataLen: md.Edata - md.Data, - BssAddr: md.Bss, - BssLen: md.Ebss - md.Bss, - NoPtrBssAddr: md.Noptrbss, - NoPtrBssLen: md.Enoptrbss - md.Noptrbss, - TypesAddr: md.Types, - TypesLen: md.Etypes - md.Types, - TypelinkAddr: md.Typelinks, - TypelinkLen: md.Typelinkslen, - ITabLinkAddr: md.Itablinks, - ITabLinkLen: md.Itablinkslen, - FuncTabAddr: md.Ftab, - FuncTabLen: md.Ftablen, - PCLNTabAddr: md.Pclntable, - PCLNTabLen: md.Pclntablelen, - GoFuncVal: md.Gofunc, + TextAddr: md.text, + TextLen: md.etext - md.text, + NoPtrDataAddr: md.noptrdata, + NoPtrDataLen: md.enoptrdata - md.noptrdata, + DataAddr: md.data, + DataLen: md.edata - md.data, + BssAddr: md.bss, + BssLen: md.ebss - md.bss, + NoPtrBssAddr: md.noptrbss, + NoPtrBssLen: md.enoptrbss - md.noptrbss, + TypesAddr: md.types, + TypesLen: md.etypes - md.types, + TypelinkAddr: md.typelinks, + TypelinkLen: md.typelinkslen, + ITabLinkAddr: md.itablinks, + ITabLinkLen: md.itablinkslen, + FuncTabAddr: md.ftab, + FuncTabLen: md.ftablen, + PCLNTabAddr: md.pclntable, + PCLNTabLen: md.pclntablelen, } } -type moduledata_1_19_32 struct { - PcHeader uint32 - Funcnametab, Funcnametablen, Funcnametabcap uint32 - Cutab, Cutablen, Cutabcap uint32 - Filetab, Filetablen, Filetabcap uint32 - Pctab, Pctablen, Pctabcap uint32 - Pclntable, Pclntablelen, Pclntablecap uint32 - Ftab, Ftablen, Ftabcap uint32 - Findfunctab uint32 - Minpc uint32 - Maxpc uint32 - Text uint32 - Etext uint32 - Noptrdata uint32 - Enoptrdata uint32 - Data uint32 - Edata uint32 - Bss uint32 - Ebss uint32 - Noptrbss uint32 - Enoptrbss uint32 - End uint32 - Gcdata uint32 - Gcbss uint32 - Types uint32 - Etypes uint32 - Rodata uint32 - Gofunc uint32 - Textsectmap, Textsectmaplen, Textsectmapcap uint32 - Typelinks, Typelinkslen, Typelinkscap uint32 - Itablinks, Itablinkslen, Itablinkscap uint32 - Ptab, Ptablen, Ptabcap uint32 - Pluginpath, Pluginpathlen uint32 - Pkghashes, Pkghasheslen, Pkghashescap uint32 +type moduledata_1_8_32 struct { + pclntable, pclntablelen, pclntablecap uint32 + ftab, ftablen, ftabcap uint32 + filetab, filetablen, filetabcap uint32 + findfunctab uint32 + minpc uint32 + maxpc uint32 + text uint32 + etext uint32 + noptrdata uint32 + enoptrdata uint32 + data uint32 + edata uint32 + bss uint32 + ebss uint32 + noptrbss uint32 + enoptrbss uint32 + end uint32 + gcdata uint32 + gcbss uint32 + types uint32 + etypes uint32 + textsectmap, textsectmaplen, textsectmapcap uint32 + typelinks, typelinkslen, typelinkscap uint32 + itablinks, itablinkslen, itablinkscap uint32 + ptab, ptablen, ptabcap uint32 + pluginpath, pluginpathlen uint32 + pkghashes, pkghasheslen, pkghashescap uint32 } -func (md moduledata_1_19_32) toModuledata() moduledata { +func (md moduledata_1_8_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.Text), - TextLen: uint64(md.Etext - md.Text), - NoPtrDataAddr: uint64(md.Noptrdata), - NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), - DataAddr: uint64(md.Data), - DataLen: uint64(md.Edata - md.Data), - BssAddr: uint64(md.Bss), - BssLen: uint64(md.Ebss - md.Bss), - NoPtrBssAddr: uint64(md.Noptrbss), - NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), - TypesAddr: uint64(md.Types), - TypesLen: uint64(md.Etypes - md.Types), - TypelinkAddr: uint64(md.Typelinks), - TypelinkLen: uint64(md.Typelinkslen), - ITabLinkAddr: uint64(md.Itablinks), - ITabLinkLen: uint64(md.Itablinkslen), - FuncTabAddr: uint64(md.Ftab), - FuncTabLen: uint64(md.Ftablen), - PCLNTabAddr: uint64(md.Pclntable), - PCLNTabLen: uint64(md.Pclntablelen), - GoFuncVal: uint64(md.Gofunc), + TextAddr: uint64(md.text), + TextLen: uint64(md.etext - md.text), + NoPtrDataAddr: uint64(md.noptrdata), + NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), + DataAddr: uint64(md.data), + DataLen: uint64(md.edata - md.data), + BssAddr: uint64(md.bss), + BssLen: uint64(md.ebss - md.bss), + NoPtrBssAddr: uint64(md.noptrbss), + NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), + TypesAddr: uint64(md.types), + TypesLen: uint64(md.etypes - md.types), + TypelinkAddr: uint64(md.typelinks), + TypelinkLen: uint64(md.typelinkslen), + ITabLinkAddr: uint64(md.itablinks), + ITabLinkLen: uint64(md.itablinkslen), + FuncTabAddr: uint64(md.ftab), + FuncTabLen: uint64(md.ftablen), + PCLNTabAddr: uint64(md.pclntable), + PCLNTabLen: uint64(md.pclntablelen), } } -type moduledata_1_19_64 struct { - PcHeader uint64 - Funcnametab, Funcnametablen, Funcnametabcap uint64 - Cutab, Cutablen, Cutabcap uint64 - Filetab, Filetablen, Filetabcap uint64 - Pctab, Pctablen, Pctabcap uint64 - Pclntable, Pclntablelen, Pclntablecap uint64 - Ftab, Ftablen, Ftabcap uint64 - Findfunctab uint64 - Minpc uint64 - Maxpc uint64 - Text uint64 - Etext uint64 - Noptrdata uint64 - Enoptrdata uint64 - Data uint64 - Edata uint64 - Bss uint64 - Ebss uint64 - Noptrbss uint64 - Enoptrbss uint64 - End uint64 - Gcdata uint64 - Gcbss uint64 - Types uint64 - Etypes uint64 - Rodata uint64 - Gofunc uint64 - Textsectmap, Textsectmaplen, Textsectmapcap uint64 - Typelinks, Typelinkslen, Typelinkscap uint64 - Itablinks, Itablinkslen, Itablinkscap uint64 - Ptab, Ptablen, Ptabcap uint64 - Pluginpath, Pluginpathlen uint64 - Pkghashes, Pkghasheslen, Pkghashescap uint64 +type moduledata_1_8_64 struct { + pclntable, pclntablelen, pclntablecap uint64 + ftab, ftablen, ftabcap uint64 + filetab, filetablen, filetabcap uint64 + findfunctab uint64 + minpc uint64 + maxpc uint64 + text uint64 + etext uint64 + noptrdata uint64 + enoptrdata uint64 + data uint64 + edata uint64 + bss uint64 + ebss uint64 + noptrbss uint64 + enoptrbss uint64 + end uint64 + gcdata uint64 + gcbss uint64 + types uint64 + etypes uint64 + textsectmap, textsectmaplen, textsectmapcap uint64 + typelinks, typelinkslen, typelinkscap uint64 + itablinks, itablinkslen, itablinkscap uint64 + ptab, ptablen, ptabcap uint64 + pluginpath, pluginpathlen uint64 + pkghashes, pkghasheslen, pkghashescap uint64 } -func (md moduledata_1_19_64) toModuledata() moduledata { +func (md moduledata_1_8_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.Text, - TextLen: md.Etext - md.Text, - NoPtrDataAddr: md.Noptrdata, - NoPtrDataLen: md.Enoptrdata - md.Noptrdata, - DataAddr: md.Data, - DataLen: md.Edata - md.Data, - BssAddr: md.Bss, - BssLen: md.Ebss - md.Bss, - NoPtrBssAddr: md.Noptrbss, - NoPtrBssLen: md.Enoptrbss - md.Noptrbss, - TypesAddr: md.Types, - TypesLen: md.Etypes - md.Types, - TypelinkAddr: md.Typelinks, - TypelinkLen: md.Typelinkslen, - ITabLinkAddr: md.Itablinks, - ITabLinkLen: md.Itablinkslen, - FuncTabAddr: md.Ftab, - FuncTabLen: md.Ftablen, - PCLNTabAddr: md.Pclntable, - PCLNTabLen: md.Pclntablelen, - GoFuncVal: md.Gofunc, + TextAddr: md.text, + TextLen: md.etext - md.text, + NoPtrDataAddr: md.noptrdata, + NoPtrDataLen: md.enoptrdata - md.noptrdata, + DataAddr: md.data, + DataLen: md.edata - md.data, + BssAddr: md.bss, + BssLen: md.ebss - md.bss, + NoPtrBssAddr: md.noptrbss, + NoPtrBssLen: md.enoptrbss - md.noptrbss, + TypesAddr: md.types, + TypesLen: md.etypes - md.types, + TypelinkAddr: md.typelinks, + TypelinkLen: md.typelinkslen, + ITabLinkAddr: md.itablinks, + ITabLinkLen: md.itablinkslen, + FuncTabAddr: md.ftab, + FuncTabLen: md.ftablen, + PCLNTabAddr: md.pclntable, + PCLNTabLen: md.pclntablelen, } } -type moduledata_1_20_32 struct { - PcHeader uint32 - Funcnametab, Funcnametablen, Funcnametabcap uint32 - Cutab, Cutablen, Cutabcap uint32 - Filetab, Filetablen, Filetabcap uint32 - Pctab, Pctablen, Pctabcap uint32 - Pclntable, Pclntablelen, Pclntablecap uint32 - Ftab, Ftablen, Ftabcap uint32 - Findfunctab uint32 - Minpc uint32 - Maxpc uint32 - Text uint32 - Etext uint32 - Noptrdata uint32 - Enoptrdata uint32 - Data uint32 - Edata uint32 - Bss uint32 - Ebss uint32 - Noptrbss uint32 - Enoptrbss uint32 - Covctrs uint32 - Ecovctrs uint32 - End uint32 - Gcdata uint32 - Gcbss uint32 - Types uint32 - Etypes uint32 - Rodata uint32 - Gofunc uint32 - Textsectmap, Textsectmaplen, Textsectmapcap uint32 - Typelinks, Typelinkslen, Typelinkscap uint32 - Itablinks, Itablinkslen, Itablinkscap uint32 - Ptab, Ptablen, Ptabcap uint32 - Pluginpath, Pluginpathlen uint32 - Pkghashes, Pkghasheslen, Pkghashescap uint32 +type moduledata_1_7_32 struct { + pclntable, pclntablelen, pclntablecap uint32 + ftab, ftablen, ftabcap uint32 + filetab, filetablen, filetabcap uint32 + findfunctab uint32 + minpc uint32 + maxpc uint32 + text uint32 + etext uint32 + noptrdata uint32 + enoptrdata uint32 + data uint32 + edata uint32 + bss uint32 + ebss uint32 + noptrbss uint32 + enoptrbss uint32 + end uint32 + gcdata uint32 + gcbss uint32 + types uint32 + etypes uint32 + typelinks, typelinkslen, typelinkscap uint32 + itablinks, itablinkslen, itablinkscap uint32 } -func (md moduledata_1_20_32) toModuledata() moduledata { +func (md moduledata_1_7_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.Text), - TextLen: uint64(md.Etext - md.Text), - NoPtrDataAddr: uint64(md.Noptrdata), - NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), - DataAddr: uint64(md.Data), - DataLen: uint64(md.Edata - md.Data), - BssAddr: uint64(md.Bss), - BssLen: uint64(md.Ebss - md.Bss), - NoPtrBssAddr: uint64(md.Noptrbss), - NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), - TypesAddr: uint64(md.Types), - TypesLen: uint64(md.Etypes - md.Types), - TypelinkAddr: uint64(md.Typelinks), - TypelinkLen: uint64(md.Typelinkslen), - ITabLinkAddr: uint64(md.Itablinks), - ITabLinkLen: uint64(md.Itablinkslen), - FuncTabAddr: uint64(md.Ftab), - FuncTabLen: uint64(md.Ftablen), - PCLNTabAddr: uint64(md.Pclntable), - PCLNTabLen: uint64(md.Pclntablelen), - GoFuncVal: uint64(md.Gofunc), + TextAddr: uint64(md.text), + TextLen: uint64(md.etext - md.text), + NoPtrDataAddr: uint64(md.noptrdata), + NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), + DataAddr: uint64(md.data), + DataLen: uint64(md.edata - md.data), + BssAddr: uint64(md.bss), + BssLen: uint64(md.ebss - md.bss), + NoPtrBssAddr: uint64(md.noptrbss), + NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), + TypesAddr: uint64(md.types), + TypesLen: uint64(md.etypes - md.types), + TypelinkAddr: uint64(md.typelinks), + TypelinkLen: uint64(md.typelinkslen), + ITabLinkAddr: uint64(md.itablinks), + ITabLinkLen: uint64(md.itablinkslen), + FuncTabAddr: uint64(md.ftab), + FuncTabLen: uint64(md.ftablen), + PCLNTabAddr: uint64(md.pclntable), + PCLNTabLen: uint64(md.pclntablelen), } } -type moduledata_1_20_64 struct { - PcHeader uint64 - Funcnametab, Funcnametablen, Funcnametabcap uint64 - Cutab, Cutablen, Cutabcap uint64 - Filetab, Filetablen, Filetabcap uint64 - Pctab, Pctablen, Pctabcap uint64 - Pclntable, Pclntablelen, Pclntablecap uint64 - Ftab, Ftablen, Ftabcap uint64 - Findfunctab uint64 - Minpc uint64 - Maxpc uint64 - Text uint64 - Etext uint64 - Noptrdata uint64 - Enoptrdata uint64 - Data uint64 - Edata uint64 - Bss uint64 - Ebss uint64 - Noptrbss uint64 - Enoptrbss uint64 - Covctrs uint64 - Ecovctrs uint64 - End uint64 - Gcdata uint64 - Gcbss uint64 - Types uint64 - Etypes uint64 - Rodata uint64 - Gofunc uint64 - Textsectmap, Textsectmaplen, Textsectmapcap uint64 - Typelinks, Typelinkslen, Typelinkscap uint64 - Itablinks, Itablinkslen, Itablinkscap uint64 - Ptab, Ptablen, Ptabcap uint64 - Pluginpath, Pluginpathlen uint64 - Pkghashes, Pkghasheslen, Pkghashescap uint64 +type moduledata_1_7_64 struct { + pclntable, pclntablelen, pclntablecap uint64 + ftab, ftablen, ftabcap uint64 + filetab, filetablen, filetabcap uint64 + findfunctab uint64 + minpc uint64 + maxpc uint64 + text uint64 + etext uint64 + noptrdata uint64 + enoptrdata uint64 + data uint64 + edata uint64 + bss uint64 + ebss uint64 + noptrbss uint64 + enoptrbss uint64 + end uint64 + gcdata uint64 + gcbss uint64 + types uint64 + etypes uint64 + typelinks, typelinkslen, typelinkscap uint64 + itablinks, itablinkslen, itablinkscap uint64 } -func (md moduledata_1_20_64) toModuledata() moduledata { +func (md moduledata_1_7_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.Text, - TextLen: md.Etext - md.Text, - NoPtrDataAddr: md.Noptrdata, - NoPtrDataLen: md.Enoptrdata - md.Noptrdata, - DataAddr: md.Data, - DataLen: md.Edata - md.Data, - BssAddr: md.Bss, - BssLen: md.Ebss - md.Bss, - NoPtrBssAddr: md.Noptrbss, - NoPtrBssLen: md.Enoptrbss - md.Noptrbss, - TypesAddr: md.Types, - TypesLen: md.Etypes - md.Types, - TypelinkAddr: md.Typelinks, - TypelinkLen: md.Typelinkslen, - ITabLinkAddr: md.Itablinks, - ITabLinkLen: md.Itablinkslen, - FuncTabAddr: md.Ftab, - FuncTabLen: md.Ftablen, - PCLNTabAddr: md.Pclntable, - PCLNTabLen: md.Pclntablelen, - GoFuncVal: md.Gofunc, + TextAddr: md.text, + TextLen: md.etext - md.text, + NoPtrDataAddr: md.noptrdata, + NoPtrDataLen: md.enoptrdata - md.noptrdata, + DataAddr: md.data, + DataLen: md.edata - md.data, + BssAddr: md.bss, + BssLen: md.ebss - md.bss, + NoPtrBssAddr: md.noptrbss, + NoPtrBssLen: md.enoptrbss - md.noptrbss, + TypesAddr: md.types, + TypesLen: md.etypes - md.types, + TypelinkAddr: md.typelinks, + TypelinkLen: md.typelinkslen, + ITabLinkAddr: md.itablinks, + ITabLinkLen: md.itablinkslen, + FuncTabAddr: md.ftab, + FuncTabLen: md.ftablen, + PCLNTabAddr: md.pclntable, + PCLNTabLen: md.pclntablelen, } } -type moduledata_1_21_32 struct { - PcHeader uint32 - Funcnametab, Funcnametablen, Funcnametabcap uint32 - Cutab, Cutablen, Cutabcap uint32 - Filetab, Filetablen, Filetabcap uint32 - Pctab, Pctablen, Pctabcap uint32 - Pclntable, Pclntablelen, Pclntablecap uint32 - Ftab, Ftablen, Ftabcap uint32 - Findfunctab uint32 - Minpc uint32 - Maxpc uint32 - Text uint32 - Etext uint32 - Noptrdata uint32 - Enoptrdata uint32 - Data uint32 - Edata uint32 - Bss uint32 - Ebss uint32 - Noptrbss uint32 - Enoptrbss uint32 - Covctrs uint32 - Ecovctrs uint32 - End uint32 - Gcdata uint32 - Gcbss uint32 - Types uint32 - Etypes uint32 - Rodata uint32 - Gofunc uint32 - Textsectmap, Textsectmaplen, Textsectmapcap uint32 - Typelinks, Typelinkslen, Typelinkscap uint32 - Itablinks, Itablinkslen, Itablinkscap uint32 - Ptab, Ptablen, Ptabcap uint32 - Pluginpath, Pluginpathlen uint32 - Pkghashes, Pkghasheslen, Pkghashescap uint32 - Inittasks, Inittaskslen, Inittaskscap uint32 +type moduledata_1_6_32 struct { + pclntable, pclntablelen, pclntablecap uint32 + ftab, ftablen, ftabcap uint32 + filetab, filetablen, filetabcap uint32 + findfunctab uint32 + minpc uint32 + maxpc uint32 + text uint32 + etext uint32 + noptrdata uint32 + enoptrdata uint32 + data uint32 + edata uint32 + bss uint32 + ebss uint32 + noptrbss uint32 + enoptrbss uint32 + end uint32 + gcdata uint32 + gcbss uint32 + typelinks, typelinkslen, typelinkscap uint32 } -func (md moduledata_1_21_32) toModuledata() moduledata { +func (md moduledata_1_6_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.Text), - TextLen: uint64(md.Etext - md.Text), - NoPtrDataAddr: uint64(md.Noptrdata), - NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), - DataAddr: uint64(md.Data), - DataLen: uint64(md.Edata - md.Data), - BssAddr: uint64(md.Bss), - BssLen: uint64(md.Ebss - md.Bss), - NoPtrBssAddr: uint64(md.Noptrbss), - NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), - TypesAddr: uint64(md.Types), - TypesLen: uint64(md.Etypes - md.Types), - TypelinkAddr: uint64(md.Typelinks), - TypelinkLen: uint64(md.Typelinkslen), - ITabLinkAddr: uint64(md.Itablinks), - ITabLinkLen: uint64(md.Itablinkslen), - FuncTabAddr: uint64(md.Ftab), - FuncTabLen: uint64(md.Ftablen), - PCLNTabAddr: uint64(md.Pclntable), - PCLNTabLen: uint64(md.Pclntablelen), - GoFuncVal: uint64(md.Gofunc), + TextAddr: uint64(md.text), + TextLen: uint64(md.etext - md.text), + NoPtrDataAddr: uint64(md.noptrdata), + NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), + DataAddr: uint64(md.data), + DataLen: uint64(md.edata - md.data), + BssAddr: uint64(md.bss), + BssLen: uint64(md.ebss - md.bss), + NoPtrBssAddr: uint64(md.noptrbss), + NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), + TypelinkAddr: uint64(md.typelinks), + TypelinkLen: uint64(md.typelinkslen), + FuncTabAddr: uint64(md.ftab), + FuncTabLen: uint64(md.ftablen), + PCLNTabAddr: uint64(md.pclntable), + PCLNTabLen: uint64(md.pclntablelen), } } -type moduledata_1_21_64 struct { - PcHeader uint64 - Funcnametab, Funcnametablen, Funcnametabcap uint64 - Cutab, Cutablen, Cutabcap uint64 - Filetab, Filetablen, Filetabcap uint64 - Pctab, Pctablen, Pctabcap uint64 - Pclntable, Pclntablelen, Pclntablecap uint64 - Ftab, Ftablen, Ftabcap uint64 - Findfunctab uint64 - Minpc uint64 - Maxpc uint64 - Text uint64 - Etext uint64 - Noptrdata uint64 - Enoptrdata uint64 - Data uint64 - Edata uint64 - Bss uint64 - Ebss uint64 - Noptrbss uint64 - Enoptrbss uint64 - Covctrs uint64 - Ecovctrs uint64 - End uint64 - Gcdata uint64 - Gcbss uint64 - Types uint64 - Etypes uint64 - Rodata uint64 - Gofunc uint64 - Textsectmap, Textsectmaplen, Textsectmapcap uint64 - Typelinks, Typelinkslen, Typelinkscap uint64 - Itablinks, Itablinkslen, Itablinkscap uint64 - Ptab, Ptablen, Ptabcap uint64 - Pluginpath, Pluginpathlen uint64 - Pkghashes, Pkghasheslen, Pkghashescap uint64 - Inittasks, Inittaskslen, Inittaskscap uint64 +type moduledata_1_6_64 struct { + pclntable, pclntablelen, pclntablecap uint64 + ftab, ftablen, ftabcap uint64 + filetab, filetablen, filetabcap uint64 + findfunctab uint64 + minpc uint64 + maxpc uint64 + text uint64 + etext uint64 + noptrdata uint64 + enoptrdata uint64 + data uint64 + edata uint64 + bss uint64 + ebss uint64 + noptrbss uint64 + enoptrbss uint64 + end uint64 + gcdata uint64 + gcbss uint64 + typelinks, typelinkslen, typelinkscap uint64 } -func (md moduledata_1_21_64) toModuledata() moduledata { +func (md moduledata_1_6_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.Text, - TextLen: md.Etext - md.Text, - NoPtrDataAddr: md.Noptrdata, - NoPtrDataLen: md.Enoptrdata - md.Noptrdata, - DataAddr: md.Data, - DataLen: md.Edata - md.Data, - BssAddr: md.Bss, - BssLen: md.Ebss - md.Bss, - NoPtrBssAddr: md.Noptrbss, - NoPtrBssLen: md.Enoptrbss - md.Noptrbss, - TypesAddr: md.Types, - TypesLen: md.Etypes - md.Types, - TypelinkAddr: md.Typelinks, - TypelinkLen: md.Typelinkslen, - ITabLinkAddr: md.Itablinks, - ITabLinkLen: md.Itablinkslen, - FuncTabAddr: md.Ftab, - FuncTabLen: md.Ftablen, - PCLNTabAddr: md.Pclntable, - PCLNTabLen: md.Pclntablelen, - GoFuncVal: md.Gofunc, + TextAddr: md.text, + TextLen: md.etext - md.text, + NoPtrDataAddr: md.noptrdata, + NoPtrDataLen: md.enoptrdata - md.noptrdata, + DataAddr: md.data, + DataLen: md.edata - md.data, + BssAddr: md.bss, + BssLen: md.ebss - md.bss, + NoPtrBssAddr: md.noptrbss, + NoPtrBssLen: md.enoptrbss - md.noptrbss, + TypelinkAddr: md.typelinks, + TypelinkLen: md.typelinkslen, + FuncTabAddr: md.ftab, + FuncTabLen: md.ftablen, + PCLNTabAddr: md.pclntable, + PCLNTabLen: md.pclntablelen, } } -type moduledata_1_22_32 struct { - PcHeader uint32 - Funcnametab, Funcnametablen, Funcnametabcap uint32 - Cutab, Cutablen, Cutabcap uint32 - Filetab, Filetablen, Filetabcap uint32 - Pctab, Pctablen, Pctabcap uint32 - Pclntable, Pclntablelen, Pclntablecap uint32 - Ftab, Ftablen, Ftabcap uint32 - Findfunctab uint32 - Minpc uint32 - Maxpc uint32 - Text uint32 - Etext uint32 - Noptrdata uint32 - Enoptrdata uint32 - Data uint32 - Edata uint32 - Bss uint32 - Ebss uint32 - Noptrbss uint32 - Enoptrbss uint32 - Covctrs uint32 - Ecovctrs uint32 - End uint32 - Gcdata uint32 - Gcbss uint32 - Types uint32 - Etypes uint32 - Rodata uint32 - Gofunc uint32 - Textsectmap, Textsectmaplen, Textsectmapcap uint32 - Typelinks, Typelinkslen, Typelinkscap uint32 - Itablinks, Itablinkslen, Itablinkscap uint32 - Ptab, Ptablen, Ptabcap uint32 - Pluginpath, Pluginpathlen uint32 - Pkghashes, Pkghasheslen, Pkghashescap uint32 - Inittasks, Inittaskslen, Inittaskscap uint32 +type moduledata_1_5_32 struct { + pclntable, pclntablelen, pclntablecap uint32 + ftab, ftablen, ftabcap uint32 + filetab, filetablen, filetabcap uint32 + findfunctab uint32 + minpc uint32 + maxpc uint32 + text uint32 + etext uint32 + noptrdata uint32 + enoptrdata uint32 + data uint32 + edata uint32 + bss uint32 + ebss uint32 + noptrbss uint32 + enoptrbss uint32 + end uint32 + gcdata uint32 + gcbss uint32 + typelinks, typelinkslen, typelinkscap uint32 } -func (md moduledata_1_22_32) toModuledata() moduledata { +func (md moduledata_1_5_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.Text), - TextLen: uint64(md.Etext - md.Text), - NoPtrDataAddr: uint64(md.Noptrdata), - NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), - DataAddr: uint64(md.Data), - DataLen: uint64(md.Edata - md.Data), - BssAddr: uint64(md.Bss), - BssLen: uint64(md.Ebss - md.Bss), - NoPtrBssAddr: uint64(md.Noptrbss), - NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), - TypesAddr: uint64(md.Types), - TypesLen: uint64(md.Etypes - md.Types), - TypelinkAddr: uint64(md.Typelinks), - TypelinkLen: uint64(md.Typelinkslen), - ITabLinkAddr: uint64(md.Itablinks), - ITabLinkLen: uint64(md.Itablinkslen), - FuncTabAddr: uint64(md.Ftab), - FuncTabLen: uint64(md.Ftablen), - PCLNTabAddr: uint64(md.Pclntable), - PCLNTabLen: uint64(md.Pclntablelen), - GoFuncVal: uint64(md.Gofunc), + TextAddr: uint64(md.text), + TextLen: uint64(md.etext - md.text), + NoPtrDataAddr: uint64(md.noptrdata), + NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), + DataAddr: uint64(md.data), + DataLen: uint64(md.edata - md.data), + BssAddr: uint64(md.bss), + BssLen: uint64(md.ebss - md.bss), + NoPtrBssAddr: uint64(md.noptrbss), + NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), + TypelinkAddr: uint64(md.typelinks), + TypelinkLen: uint64(md.typelinkslen), + FuncTabAddr: uint64(md.ftab), + FuncTabLen: uint64(md.ftablen), + PCLNTabAddr: uint64(md.pclntable), + PCLNTabLen: uint64(md.pclntablelen), } } -type moduledata_1_22_64 struct { - PcHeader uint64 - Funcnametab, Funcnametablen, Funcnametabcap uint64 - Cutab, Cutablen, Cutabcap uint64 - Filetab, Filetablen, Filetabcap uint64 - Pctab, Pctablen, Pctabcap uint64 - Pclntable, Pclntablelen, Pclntablecap uint64 - Ftab, Ftablen, Ftabcap uint64 - Findfunctab uint64 - Minpc uint64 - Maxpc uint64 - Text uint64 - Etext uint64 - Noptrdata uint64 - Enoptrdata uint64 - Data uint64 - Edata uint64 - Bss uint64 - Ebss uint64 - Noptrbss uint64 - Enoptrbss uint64 - Covctrs uint64 - Ecovctrs uint64 - End uint64 - Gcdata uint64 - Gcbss uint64 - Types uint64 - Etypes uint64 - Rodata uint64 - Gofunc uint64 - Textsectmap, Textsectmaplen, Textsectmapcap uint64 - Typelinks, Typelinkslen, Typelinkscap uint64 - Itablinks, Itablinkslen, Itablinkscap uint64 - Ptab, Ptablen, Ptabcap uint64 - Pluginpath, Pluginpathlen uint64 - Pkghashes, Pkghasheslen, Pkghashescap uint64 - Inittasks, Inittaskslen, Inittaskscap uint64 +type moduledata_1_5_64 struct { + pclntable, pclntablelen, pclntablecap uint64 + ftab, ftablen, ftabcap uint64 + filetab, filetablen, filetabcap uint64 + findfunctab uint64 + minpc uint64 + maxpc uint64 + text uint64 + etext uint64 + noptrdata uint64 + enoptrdata uint64 + data uint64 + edata uint64 + bss uint64 + ebss uint64 + noptrbss uint64 + enoptrbss uint64 + end uint64 + gcdata uint64 + gcbss uint64 + typelinks, typelinkslen, typelinkscap uint64 } -func (md moduledata_1_22_64) toModuledata() moduledata { +func (md moduledata_1_5_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.Text, - TextLen: md.Etext - md.Text, - NoPtrDataAddr: md.Noptrdata, - NoPtrDataLen: md.Enoptrdata - md.Noptrdata, - DataAddr: md.Data, - DataLen: md.Edata - md.Data, - BssAddr: md.Bss, - BssLen: md.Ebss - md.Bss, - NoPtrBssAddr: md.Noptrbss, - NoPtrBssLen: md.Enoptrbss - md.Noptrbss, - TypesAddr: md.Types, - TypesLen: md.Etypes - md.Types, - TypelinkAddr: md.Typelinks, - TypelinkLen: md.Typelinkslen, - ITabLinkAddr: md.Itablinks, - ITabLinkLen: md.Itablinkslen, - FuncTabAddr: md.Ftab, - FuncTabLen: md.Ftablen, - PCLNTabAddr: md.Pclntable, - PCLNTabLen: md.Pclntablelen, - GoFuncVal: md.Gofunc, + TextAddr: md.text, + TextLen: md.etext - md.text, + NoPtrDataAddr: md.noptrdata, + NoPtrDataLen: md.enoptrdata - md.noptrdata, + DataAddr: md.data, + DataLen: md.edata - md.data, + BssAddr: md.bss, + BssLen: md.ebss - md.bss, + NoPtrBssAddr: md.noptrbss, + NoPtrBssLen: md.enoptrbss - md.noptrbss, + TypelinkAddr: md.typelinks, + TypelinkLen: md.typelinkslen, + FuncTabAddr: md.ftab, + FuncTabLen: md.ftablen, + PCLNTabAddr: md.pclntable, + PCLNTabLen: md.pclntablelen, } } func selectModuleData(v int, bits int) (modulable, error) { switch { - case v == 5 && bits == 32: - return &moduledata_1_5_32{}, nil - case v == 5 && bits == 64: - return &moduledata_1_5_64{}, nil - case v == 6 && bits == 32: - return &moduledata_1_6_32{}, nil - case v == 6 && bits == 64: - return &moduledata_1_6_64{}, nil - case v == 7 && bits == 32: - return &moduledata_1_7_32{}, nil - case v == 7 && bits == 64: - return &moduledata_1_7_64{}, nil - case v == 8 && bits == 32: - return &moduledata_1_8_32{}, nil - case v == 8 && bits == 64: - return &moduledata_1_8_64{}, nil - case v == 9 && bits == 32: - return &moduledata_1_9_32{}, nil - case v == 9 && bits == 64: - return &moduledata_1_9_64{}, nil - case v == 10 && bits == 32: - return &moduledata_1_10_32{}, nil - case v == 10 && bits == 64: - return &moduledata_1_10_64{}, nil - case v == 11 && bits == 32: - return &moduledata_1_11_32{}, nil - case v == 11 && bits == 64: - return &moduledata_1_11_64{}, nil - case v == 12 && bits == 32: - return &moduledata_1_12_32{}, nil - case v == 12 && bits == 64: - return &moduledata_1_12_64{}, nil - case v == 13 && bits == 32: - return &moduledata_1_13_32{}, nil - case v == 13 && bits == 64: - return &moduledata_1_13_64{}, nil - case v == 14 && bits == 32: - return &moduledata_1_14_32{}, nil - case v == 14 && bits == 64: - return &moduledata_1_14_64{}, nil - case v == 15 && bits == 32: - return &moduledata_1_15_32{}, nil - case v == 15 && bits == 64: - return &moduledata_1_15_64{}, nil - case v == 16 && bits == 32: - return &moduledata_1_16_32{}, nil - case v == 16 && bits == 64: - return &moduledata_1_16_64{}, nil - case v == 17 && bits == 32: - return &moduledata_1_17_32{}, nil - case v == 17 && bits == 64: - return &moduledata_1_17_64{}, nil - case v == 18 && bits == 32: - return &moduledata_1_18_32{}, nil - case v == 18 && bits == 64: - return &moduledata_1_18_64{}, nil - case v == 19 && bits == 32: - return &moduledata_1_19_32{}, nil - case v == 19 && bits == 64: - return &moduledata_1_19_64{}, nil - case v == 20 && bits == 32: - return &moduledata_1_20_32{}, nil - case v == 20 && bits == 64: - return &moduledata_1_20_64{}, nil - case v == 21 && bits == 32: - return &moduledata_1_21_32{}, nil - case v == 21 && bits == 64: - return &moduledata_1_21_64{}, nil case v == 22 && bits == 32: return &moduledata_1_22_32{}, nil case v == 22 && bits == 64: return &moduledata_1_22_64{}, nil + case v == 21 && bits == 32: + return &moduledata_1_21_32{}, nil + case v == 21 && bits == 64: + return &moduledata_1_21_64{}, nil + case v == 20 && bits == 32: + return &moduledata_1_20_32{}, nil + case v == 20 && bits == 64: + return &moduledata_1_20_64{}, nil + case v == 19 && bits == 32: + return &moduledata_1_19_32{}, nil + case v == 19 && bits == 64: + return &moduledata_1_19_64{}, nil + case v == 18 && bits == 32: + return &moduledata_1_18_32{}, nil + case v == 18 && bits == 64: + return &moduledata_1_18_64{}, nil + case v == 17 && bits == 32: + return &moduledata_1_17_32{}, nil + case v == 17 && bits == 64: + return &moduledata_1_17_64{}, nil + case v == 16 && bits == 32: + return &moduledata_1_16_32{}, nil + case v == 16 && bits == 64: + return &moduledata_1_16_64{}, nil + case v == 15 && bits == 32: + return &moduledata_1_15_32{}, nil + case v == 15 && bits == 64: + return &moduledata_1_15_64{}, nil + case v == 14 && bits == 32: + return &moduledata_1_14_32{}, nil + case v == 14 && bits == 64: + return &moduledata_1_14_64{}, nil + case v == 13 && bits == 32: + return &moduledata_1_13_32{}, nil + case v == 13 && bits == 64: + return &moduledata_1_13_64{}, nil + case v == 12 && bits == 32: + return &moduledata_1_12_32{}, nil + case v == 12 && bits == 64: + return &moduledata_1_12_64{}, nil + case v == 11 && bits == 32: + return &moduledata_1_11_32{}, nil + case v == 11 && bits == 64: + return &moduledata_1_11_64{}, nil + case v == 10 && bits == 32: + return &moduledata_1_10_32{}, nil + case v == 10 && bits == 64: + return &moduledata_1_10_64{}, nil + case v == 9 && bits == 32: + return &moduledata_1_9_32{}, nil + case v == 9 && bits == 64: + return &moduledata_1_9_64{}, nil + case v == 8 && bits == 32: + return &moduledata_1_8_32{}, nil + case v == 8 && bits == 64: + return &moduledata_1_8_64{}, nil + case v == 7 && bits == 32: + return &moduledata_1_7_32{}, nil + case v == 7 && bits == 64: + return &moduledata_1_7_64{}, nil + case v == 6 && bits == 32: + return &moduledata_1_6_32{}, nil + case v == 6 && bits == 64: + return &moduledata_1_6_64{}, nil + case v == 5 && bits == 32: + return &moduledata_1_5_32{}, nil + case v == 5 && bits == 64: + return &moduledata_1_5_64{}, nil default: return nil, fmt.Errorf("unsupported version %d and bits %d", v, bits) } } + +func getModuleDataList(bits int) ([]modulable, error) { + if bits != 32 && bits != 64 { + return nil, fmt.Errorf("unsupported bits %!d(MISSING)", bits) + } + if bits == 32 { + return []modulable{ + &moduledata_1_22_32{}, + &moduledata_1_21_32{}, + &moduledata_1_20_32{}, + &moduledata_1_19_32{}, + &moduledata_1_18_32{}, + &moduledata_1_17_32{}, + &moduledata_1_16_32{}, + &moduledata_1_15_32{}, + &moduledata_1_14_32{}, + &moduledata_1_13_32{}, + &moduledata_1_12_32{}, + &moduledata_1_11_32{}, + &moduledata_1_10_32{}, + &moduledata_1_9_32{}, + &moduledata_1_8_32{}, + &moduledata_1_7_32{}, + &moduledata_1_6_32{}, + &moduledata_1_5_32{}, + }, nil + } else { + return []modulable{ + &moduledata_1_22_64{}, + &moduledata_1_21_64{}, + &moduledata_1_20_64{}, + &moduledata_1_19_64{}, + &moduledata_1_18_64{}, + &moduledata_1_17_64{}, + &moduledata_1_16_64{}, + &moduledata_1_15_64{}, + &moduledata_1_14_64{}, + &moduledata_1_13_64{}, + &moduledata_1_12_64{}, + &moduledata_1_11_64{}, + &moduledata_1_10_64{}, + &moduledata_1_9_64{}, + &moduledata_1_8_64{}, + &moduledata_1_7_64{}, + &moduledata_1_6_64{}, + &moduledata_1_5_64{}, + }, nil + } +} From 8799837ddfb9231fdded1ffcc607f530a904479e Mon Sep 17 00:00:00 2001 From: Zxilly Date: Fri, 23 Feb 2024 02:20:22 +0800 Subject: [PATCH 10/18] fix: fix moduledata generate --- gen/moduledata.go | 114 +++++++++++++++++++++++++--------------------- gen/stdpkgs.go | 2 +- moduledata_gen.go | 2 +- 3 files changed, 65 insertions(+), 53 deletions(-) diff --git a/gen/moduledata.go b/gen/moduledata.go index 5d3af13..10dc170 100644 --- a/gen/moduledata.go +++ b/gen/moduledata.go @@ -130,7 +130,7 @@ func getModuleDataSources() (map[int]string, error) { return nil, err } - if currentMaxMinor == maxMinor { + if currentMaxMinor == maxMinor && !*forceUpdate { return nil, nil } @@ -201,39 +201,39 @@ func (g *moduleDataGenerator) add(versionCode int, code string) error { } func (g *moduleDataGenerator) writeSelector() { - g.writeln("func selectModuleData(v int, bits int) (modulable,error) {") - g.writeln("switch {") + g.writefln("func selectModuleData(v int, bits int) (modulable,error) {") + g.writefln("switch {") for _, versionCode := range g.knownVersions { for _, bits := range []int{32, 64} { - g.writeln("case v == %d && bits == %d:", versionCode, bits) - g.writeln("return &%s{}, nil", g.generateTypeName(versionCode, bits)) + g.writefln("case v == %d && bits == %d:", versionCode, bits) + g.writefln("return &%s{}, nil", g.generateTypeName(versionCode, bits)) } } - g.writeln("default:") - g.writeln(`return nil, fmt.Errorf("unsupported version %%d and bits %%d", v, bits)`) + g.writefln("default:") + g.writefln(`return nil, fmt.Errorf("unsupported version %%d and bits %%d", v, bits)`) - g.writeln("}\n}\n") + g.writefln("}\n}\n") } func (g *moduleDataGenerator) writeModuleListGetter() { - g.writeln("func getModuleDataList(bits int) ([]modulable, error) {") + g.writefln("func getModuleDataList(bits int) ([]modulable, error) {") g.writeln("if bits != 32 && bits != 64 { return nil, fmt.Errorf(\"unsupported bits %d\", bits)}") - g.writeln("if bits == 32 {") - g.writeln("return []modulable{") + g.writefln("if bits == 32 {") + g.writefln("return []modulable{") for _, versionCode := range g.knownVersions { - g.writeln("&%s{},", g.generateTypeName(versionCode, 32)) + g.writefln("&%s{},", g.generateTypeName(versionCode, 32)) } - g.writeln("}, nil") - g.writeln("} else {") - g.writeln("return []modulable{") + g.writefln("}, nil") + g.writefln("} else {") + g.writefln("return []modulable{") for _, versionCode := range g.knownVersions { - g.writeln("&%s{},", g.generateTypeName(versionCode, 64)) + g.writefln("&%s{},", g.generateTypeName(versionCode, 64)) } - g.writeln("}, nil") - g.writeln("}") - g.writeln("}\n") + g.writefln("}, nil") + g.writefln("}") + g.writefln("}\n") } @@ -248,10 +248,22 @@ func (*moduleDataGenerator) wrapValue(name string, bits int) string { return name } -func (g *moduleDataGenerator) writeln(format string, a ...interface{}) { +func (g *moduleDataGenerator) writefln(format string, a ...interface{}) { _, _ = fmt.Fprintf(g.buf, format+"\n", a...) } +func (g *moduleDataGenerator) writef(format string, a ...interface{}) { + _, _ = fmt.Fprintf(g.buf, format, a...) +} + +func (g *moduleDataGenerator) writeln(s string) { + _, _ = g.buf.WriteString(s + "\n") +} + +func (g *moduleDataGenerator) write(s string) { + _, _ = g.buf.WriteString(s) +} + func (g *moduleDataGenerator) writeVersionedModuleData(versionCode int, code string) error { expr, err := parser.ParseExpr(code) if err != nil { @@ -263,7 +275,7 @@ func (g *moduleDataGenerator) writeVersionedModuleData(versionCode int, code str } writeCode := func(bits int) { - g.writeln("type %s struct {\n", g.generateTypeName(versionCode, bits)) + g.writefln("type %s struct {\n", g.generateTypeName(versionCode, bits)) knownFields := make(map[string]struct{}) search: @@ -283,17 +295,17 @@ func (g *moduleDataGenerator) writeVersionedModuleData(versionCode int, code str switch t := field.Type.(type) { case *ast.StarExpr: - g.writeln("%s uint%d", name.Name, bits) + g.writefln("%s uint%d", name.Name, bits) case *ast.ArrayType: - g.writeln("%s, %[1]slen, %[1]scap uint%d", name.Name, bits) + g.writefln("%s, %[1]slen, %[1]scap uint%d", name.Name, bits) case *ast.Ident: switch t.Name { case "uintptr": - g.writeln("%s uint%d", name.Name, bits) + g.writefln("%s uint%d", name.Name, bits) case "string": - g.writeln("%s, %[1]slen uint%d", name.Name, bits) + g.writefln("%s, %[1]slen uint%d", name.Name, bits) case "uint8": - g.writeln("%s uint8", name.Name) + g.writefln("%s uint8", name.Name) default: panic(fmt.Sprintf("unhandled type: %+v", t)) } @@ -303,7 +315,7 @@ func (g *moduleDataGenerator) writeVersionedModuleData(versionCode int, code str } } - g.writeln("}\n\n") + g.writefln("}\n\n") // generate toModuledata method exist := func(name ...string) bool { @@ -315,64 +327,64 @@ func (g *moduleDataGenerator) writeVersionedModuleData(versionCode int, code str return true } - g.writeln("func (md %s) toModuledata() moduledata {", g.generateTypeName(versionCode, bits)) - g.writeln("return moduledata{") + g.writefln("func (md %s) toModuledata() moduledata {", g.generateTypeName(versionCode, bits)) + g.writefln("return moduledata{") if exist("text", "etext") { - g.writeln("TextAddr: %s,", g.wrapValue("md.text", bits)) - g.writeln("TextLen: %s,", g.wrapValue("md.etext - md.text", bits)) + g.writefln("TextAddr: %s,", g.wrapValue("md.text", bits)) + g.writefln("TextLen: %s,", g.wrapValue("md.etext - md.text", bits)) } if exist("noptrdata", "enoptrdata") { - g.writeln("NoPtrDataAddr: %s,", g.wrapValue("md.noptrdata", bits)) - g.writeln("NoPtrDataLen: %s,", g.wrapValue("md.enoptrdata - md.noptrdata", bits)) + g.writefln("NoPtrDataAddr: %s,", g.wrapValue("md.noptrdata", bits)) + g.writefln("NoPtrDataLen: %s,", g.wrapValue("md.enoptrdata - md.noptrdata", bits)) } if exist("data", "edata") { - g.writeln("DataAddr: %s,", g.wrapValue("md.data", bits)) - g.writeln("DataLen: %s,", g.wrapValue("md.edata - md.data", bits)) + g.writefln("DataAddr: %s,", g.wrapValue("md.data", bits)) + g.writefln("DataLen: %s,", g.wrapValue("md.edata - md.data", bits)) } if exist("bss", "ebss") { - g.writeln("BssAddr: %s,", g.wrapValue("md.bss", bits)) - g.writeln("BssLen: %s,", g.wrapValue("md.ebss - md.bss", bits)) + g.writefln("BssAddr: %s,", g.wrapValue("md.bss", bits)) + g.writefln("BssLen: %s,", g.wrapValue("md.ebss - md.bss", bits)) } if exist("noptrbss", "enoptrbss") { - g.writeln("NoPtrBssAddr: %s,", g.wrapValue("md.noptrbss", bits)) - g.writeln("NoPtrBssLen: %s,", g.wrapValue("md.enoptrbss - md.noptrbss", bits)) + g.writefln("NoPtrBssAddr: %s,", g.wrapValue("md.noptrbss", bits)) + g.writefln("NoPtrBssLen: %s,", g.wrapValue("md.enoptrbss - md.noptrbss", bits)) } if exist("types", "etypes") { - g.writeln("TypesAddr: %s,", g.wrapValue("md.types", bits)) - g.writeln("TypesLen: %s,", g.wrapValue("md.etypes - md.types", bits)) + g.writefln("TypesAddr: %s,", g.wrapValue("md.types", bits)) + g.writefln("TypesLen: %s,", g.wrapValue("md.etypes - md.types", bits)) } if exist("typelinks") { - g.writeln("TypelinkAddr: %s,", g.wrapValue("md.typelinks", bits)) - g.writeln("TypelinkLen: %s,", g.wrapValue("md.typelinkslen", bits)) + g.writefln("TypelinkAddr: %s,", g.wrapValue("md.typelinks", bits)) + g.writefln("TypelinkLen: %s,", g.wrapValue("md.typelinkslen", bits)) } if exist("itablinks") { - g.writeln("ITabLinkAddr: %s,", g.wrapValue("md.itablinks", bits)) - g.writeln("ITabLinkLen: %s,", g.wrapValue("md.itablinkslen", bits)) + g.writefln("ITabLinkAddr: %s,", g.wrapValue("md.itablinks", bits)) + g.writefln("ITabLinkLen: %s,", g.wrapValue("md.itablinkslen", bits)) } if exist("ftab") { - g.writeln("FuncTabAddr: %s,", g.wrapValue("md.ftab", bits)) - g.writeln("FuncTabLen: %s,", g.wrapValue("md.ftablen", bits)) + g.writefln("FuncTabAddr: %s,", g.wrapValue("md.ftab", bits)) + g.writefln("FuncTabLen: %s,", g.wrapValue("md.ftablen", bits)) } if exist("pclntable") { - g.writeln("PCLNTabAddr: %s,", g.wrapValue("md.pclntable", bits)) - g.writeln("PCLNTabLen: %s,", g.wrapValue("md.pclntablelen", bits)) + g.writefln("PCLNTabAddr: %s,", g.wrapValue("md.pclntable", bits)) + g.writefln("PCLNTabLen: %s,", g.wrapValue("md.pclntablelen", bits)) } if exist("gofunc") { - g.writeln("GoFuncVal: %s,", g.wrapValue("md.gofunc", bits)) + g.writefln("GoFuncVal: %s,", g.wrapValue("md.gofunc", bits)) } - g.writeln("}\n}\n") + g.writefln("}\n}\n") } writeCode(32) diff --git a/gen/stdpkgs.go b/gen/stdpkgs.go index c6a1a9e..6194443 100644 --- a/gen/stdpkgs.go +++ b/gen/stdpkgs.go @@ -153,7 +153,7 @@ func generateStdPkgs() { return } - if hash == currentHash { + if hash == currentHash && !*forceUpdate { fmt.Println("No need to update " + stdpkgOutputFile) return } diff --git a/moduledata_gen.go b/moduledata_gen.go index ddacae9..777c3b8 100644 --- a/moduledata_gen.go +++ b/moduledata_gen.go @@ -2132,7 +2132,7 @@ func selectModuleData(v int, bits int) (modulable, error) { func getModuleDataList(bits int) ([]modulable, error) { if bits != 32 && bits != 64 { - return nil, fmt.Errorf("unsupported bits %!d(MISSING)", bits) + return nil, fmt.Errorf("unsupported bits %d", bits) } if bits == 32 { return []modulable{ From f744e210563b16983718bef57e90a9e2054d9030 Mon Sep 17 00:00:00 2001 From: Zxilly Date: Fri, 23 Feb 2024 02:45:31 +0800 Subject: [PATCH 11/18] fix: export fields to work with reflect --- gen/gen.go | 14 +- gen/moduledata.go | 58 +- moduledata_gen.go | 3484 ++++++++++++++++++++++----------------------- 3 files changed, 1783 insertions(+), 1773 deletions(-) diff --git a/gen/gen.go b/gen/gen.go index a89fdd7..827d015 100644 --- a/gen/gen.go +++ b/gen/gen.go @@ -21,17 +21,23 @@ package main import ( + "flag" "fmt" - "os" ) +var forceUpdate = flag.Bool("force", false, "force update") + func main() { - if len(os.Args) != 2 { - fmt.Println("go run ./gen [stdpkgs|goversion|moduledata]") + flag.Parse() + + print("forceUpdate: ", *forceUpdate) + + if flag.NArg() < 1 { + fmt.Println("go run ./gen [--force] [stdpkgs|goversion|moduledata]") return } - switch os.Args[1] { + switch flag.Arg(0) { case "stdpkgs": generateStdPkgs() case "goversion": diff --git a/gen/moduledata.go b/gen/moduledata.go index 10dc170..fea95e5 100644 --- a/gen/moduledata.go +++ b/gen/moduledata.go @@ -211,7 +211,7 @@ func (g *moduleDataGenerator) writeSelector() { } } g.writefln("default:") - g.writefln(`return nil, fmt.Errorf("unsupported version %%d and bits %%d", v, bits)`) + g.writeln(`return nil, fmt.Errorf("unsupported version %d and bits %d", v, bits)`) g.writefln("}\n}\n") } @@ -264,6 +264,10 @@ func (g *moduleDataGenerator) write(s string) { _, _ = g.buf.WriteString(s) } +func (*moduleDataGenerator) title(s string) string { + return strings.ToUpper(s[:1]) + s[1:] +} + func (g *moduleDataGenerator) writeVersionedModuleData(versionCode int, code string) error { expr, err := parser.ParseExpr(code) if err != nil { @@ -295,17 +299,17 @@ func (g *moduleDataGenerator) writeVersionedModuleData(versionCode int, code str switch t := field.Type.(type) { case *ast.StarExpr: - g.writefln("%s uint%d", name.Name, bits) + g.writefln("%s uint%d", g.title(name.Name), bits) case *ast.ArrayType: - g.writefln("%s, %[1]slen, %[1]scap uint%d", name.Name, bits) + g.writefln("%s, %[1]slen, %[1]scap uint%d", g.title(name.Name), bits) case *ast.Ident: switch t.Name { case "uintptr": - g.writefln("%s uint%d", name.Name, bits) + g.writefln("%s uint%d", g.title(name.Name), bits) case "string": - g.writefln("%s, %[1]slen uint%d", name.Name, bits) + g.writefln("%s, %[1]slen uint%d", g.title(name.Name), bits) case "uint8": - g.writefln("%s uint8", name.Name) + g.writefln("%s uint8", g.title(name.Name)) default: panic(fmt.Sprintf("unhandled type: %+v", t)) } @@ -331,57 +335,57 @@ func (g *moduleDataGenerator) writeVersionedModuleData(versionCode int, code str g.writefln("return moduledata{") if exist("text", "etext") { - g.writefln("TextAddr: %s,", g.wrapValue("md.text", bits)) - g.writefln("TextLen: %s,", g.wrapValue("md.etext - md.text", bits)) + g.writefln("TextAddr: %s,", g.wrapValue("md.Text", bits)) + g.writefln("TextLen: %s,", g.wrapValue("md.Etext - md.Text", bits)) } if exist("noptrdata", "enoptrdata") { - g.writefln("NoPtrDataAddr: %s,", g.wrapValue("md.noptrdata", bits)) - g.writefln("NoPtrDataLen: %s,", g.wrapValue("md.enoptrdata - md.noptrdata", bits)) + g.writefln("NoPtrDataAddr: %s,", g.wrapValue("md.Noptrdata", bits)) + g.writefln("NoPtrDataLen: %s,", g.wrapValue("md.Enoptrdata - md.Noptrdata", bits)) } if exist("data", "edata") { - g.writefln("DataAddr: %s,", g.wrapValue("md.data", bits)) - g.writefln("DataLen: %s,", g.wrapValue("md.edata - md.data", bits)) + g.writefln("DataAddr: %s,", g.wrapValue("md.Data", bits)) + g.writefln("DataLen: %s,", g.wrapValue("md.Edata - md.Data", bits)) } if exist("bss", "ebss") { - g.writefln("BssAddr: %s,", g.wrapValue("md.bss", bits)) - g.writefln("BssLen: %s,", g.wrapValue("md.ebss - md.bss", bits)) + g.writefln("BssAddr: %s,", g.wrapValue("md.Bss", bits)) + g.writefln("BssLen: %s,", g.wrapValue("md.Ebss - md.Bss", bits)) } if exist("noptrbss", "enoptrbss") { - g.writefln("NoPtrBssAddr: %s,", g.wrapValue("md.noptrbss", bits)) - g.writefln("NoPtrBssLen: %s,", g.wrapValue("md.enoptrbss - md.noptrbss", bits)) + g.writefln("NoPtrBssAddr: %s,", g.wrapValue("md.Noptrbss", bits)) + g.writefln("NoPtrBssLen: %s,", g.wrapValue("md.Enoptrbss - md.Noptrbss", bits)) } if exist("types", "etypes") { - g.writefln("TypesAddr: %s,", g.wrapValue("md.types", bits)) - g.writefln("TypesLen: %s,", g.wrapValue("md.etypes - md.types", bits)) + g.writefln("TypesAddr: %s,", g.wrapValue("md.Types", bits)) + g.writefln("TypesLen: %s,", g.wrapValue("md.Etypes - md.Types", bits)) } if exist("typelinks") { - g.writefln("TypelinkAddr: %s,", g.wrapValue("md.typelinks", bits)) - g.writefln("TypelinkLen: %s,", g.wrapValue("md.typelinkslen", bits)) + g.writefln("TypelinkAddr: %s,", g.wrapValue("md.Typelinks", bits)) + g.writefln("TypelinkLen: %s,", g.wrapValue("md.Typelinkslen", bits)) } if exist("itablinks") { - g.writefln("ITabLinkAddr: %s,", g.wrapValue("md.itablinks", bits)) - g.writefln("ITabLinkLen: %s,", g.wrapValue("md.itablinkslen", bits)) + g.writefln("ITabLinkAddr: %s,", g.wrapValue("md.Itablinks", bits)) + g.writefln("ITabLinkLen: %s,", g.wrapValue("md.Itablinkslen", bits)) } if exist("ftab") { - g.writefln("FuncTabAddr: %s,", g.wrapValue("md.ftab", bits)) - g.writefln("FuncTabLen: %s,", g.wrapValue("md.ftablen", bits)) + g.writefln("FuncTabAddr: %s,", g.wrapValue("md.Ftab", bits)) + g.writefln("FuncTabLen: %s,", g.wrapValue("md.Ftablen", bits)) } if exist("pclntable") { - g.writefln("PCLNTabAddr: %s,", g.wrapValue("md.pclntable", bits)) - g.writefln("PCLNTabLen: %s,", g.wrapValue("md.pclntablelen", bits)) + g.writefln("PCLNTabAddr: %s,", g.wrapValue("md.Pclntable", bits)) + g.writefln("PCLNTabLen: %s,", g.wrapValue("md.Pclntablelen", bits)) } if exist("gofunc") { - g.writefln("GoFuncVal: %s,", g.wrapValue("md.gofunc", bits)) + g.writefln("GoFuncVal: %s,", g.wrapValue("md.Gofunc", bits)) } g.writefln("}\n}\n") diff --git a/moduledata_gen.go b/moduledata_gen.go index 777c3b8..366e65a 100644 --- a/moduledata_gen.go +++ b/moduledata_gen.go @@ -22,2032 +22,2032 @@ package gore import "fmt" type moduledata_1_22_32 struct { - pcHeader uint32 - funcnametab, funcnametablen, funcnametabcap uint32 - cutab, cutablen, cutabcap uint32 - filetab, filetablen, filetabcap uint32 - pctab, pctablen, pctabcap uint32 - pclntable, pclntablelen, pclntablecap uint32 - ftab, ftablen, ftabcap uint32 - findfunctab uint32 - minpc uint32 - maxpc uint32 - text uint32 - etext uint32 - noptrdata uint32 - enoptrdata uint32 - data uint32 - edata uint32 - bss uint32 - ebss uint32 - noptrbss uint32 - enoptrbss uint32 - covctrs uint32 - ecovctrs uint32 - end uint32 - gcdata uint32 - gcbss uint32 - types uint32 - etypes uint32 - rodata uint32 - gofunc uint32 - textsectmap, textsectmaplen, textsectmapcap uint32 - typelinks, typelinkslen, typelinkscap uint32 - itablinks, itablinkslen, itablinkscap uint32 - ptab, ptablen, ptabcap uint32 - pluginpath, pluginpathlen uint32 - pkghashes, pkghasheslen, pkghashescap uint32 - inittasks, inittaskslen, inittaskscap uint32 + PcHeader uint32 + Funcnametab, Funcnametablen, Funcnametabcap uint32 + Cutab, Cutablen, Cutabcap uint32 + Filetab, Filetablen, Filetabcap uint32 + Pctab, Pctablen, Pctabcap uint32 + Pclntable, Pclntablelen, Pclntablecap uint32 + Ftab, Ftablen, Ftabcap uint32 + Findfunctab uint32 + Minpc uint32 + Maxpc uint32 + Text uint32 + Etext uint32 + Noptrdata uint32 + Enoptrdata uint32 + Data uint32 + Edata uint32 + Bss uint32 + Ebss uint32 + Noptrbss uint32 + Enoptrbss uint32 + Covctrs uint32 + Ecovctrs uint32 + End uint32 + Gcdata uint32 + Gcbss uint32 + Types uint32 + Etypes uint32 + Rodata uint32 + Gofunc uint32 + Textsectmap, Textsectmaplen, Textsectmapcap uint32 + Typelinks, Typelinkslen, Typelinkscap uint32 + Itablinks, Itablinkslen, Itablinkscap uint32 + Ptab, Ptablen, Ptabcap uint32 + Pluginpath, Pluginpathlen uint32 + Pkghashes, Pkghasheslen, Pkghashescap uint32 + Inittasks, Inittaskslen, Inittaskscap uint32 } func (md moduledata_1_22_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.text), - TextLen: uint64(md.etext - md.text), - NoPtrDataAddr: uint64(md.noptrdata), - NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), - DataAddr: uint64(md.data), - DataLen: uint64(md.edata - md.data), - BssAddr: uint64(md.bss), - BssLen: uint64(md.ebss - md.bss), - NoPtrBssAddr: uint64(md.noptrbss), - NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), - TypesAddr: uint64(md.types), - TypesLen: uint64(md.etypes - md.types), - TypelinkAddr: uint64(md.typelinks), - TypelinkLen: uint64(md.typelinkslen), - ITabLinkAddr: uint64(md.itablinks), - ITabLinkLen: uint64(md.itablinkslen), - FuncTabAddr: uint64(md.ftab), - FuncTabLen: uint64(md.ftablen), - PCLNTabAddr: uint64(md.pclntable), - PCLNTabLen: uint64(md.pclntablelen), - GoFuncVal: uint64(md.gofunc), + TextAddr: uint64(md.Text), + TextLen: uint64(md.Etext - md.Text), + NoPtrDataAddr: uint64(md.Noptrdata), + NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), + DataAddr: uint64(md.Data), + DataLen: uint64(md.Edata - md.Data), + BssAddr: uint64(md.Bss), + BssLen: uint64(md.Ebss - md.Bss), + NoPtrBssAddr: uint64(md.Noptrbss), + NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), + TypesAddr: uint64(md.Types), + TypesLen: uint64(md.Etypes - md.Types), + TypelinkAddr: uint64(md.Typelinks), + TypelinkLen: uint64(md.Typelinkslen), + ITabLinkAddr: uint64(md.Itablinks), + ITabLinkLen: uint64(md.Itablinkslen), + FuncTabAddr: uint64(md.Ftab), + FuncTabLen: uint64(md.Ftablen), + PCLNTabAddr: uint64(md.Pclntable), + PCLNTabLen: uint64(md.Pclntablelen), + GoFuncVal: uint64(md.Gofunc), } } type moduledata_1_22_64 struct { - pcHeader uint64 - funcnametab, funcnametablen, funcnametabcap uint64 - cutab, cutablen, cutabcap uint64 - filetab, filetablen, filetabcap uint64 - pctab, pctablen, pctabcap uint64 - pclntable, pclntablelen, pclntablecap uint64 - ftab, ftablen, ftabcap uint64 - findfunctab uint64 - minpc uint64 - maxpc uint64 - text uint64 - etext uint64 - noptrdata uint64 - enoptrdata uint64 - data uint64 - edata uint64 - bss uint64 - ebss uint64 - noptrbss uint64 - enoptrbss uint64 - covctrs uint64 - ecovctrs uint64 - end uint64 - gcdata uint64 - gcbss uint64 - types uint64 - etypes uint64 - rodata uint64 - gofunc uint64 - textsectmap, textsectmaplen, textsectmapcap uint64 - typelinks, typelinkslen, typelinkscap uint64 - itablinks, itablinkslen, itablinkscap uint64 - ptab, ptablen, ptabcap uint64 - pluginpath, pluginpathlen uint64 - pkghashes, pkghasheslen, pkghashescap uint64 - inittasks, inittaskslen, inittaskscap uint64 + PcHeader uint64 + Funcnametab, Funcnametablen, Funcnametabcap uint64 + Cutab, Cutablen, Cutabcap uint64 + Filetab, Filetablen, Filetabcap uint64 + Pctab, Pctablen, Pctabcap uint64 + Pclntable, Pclntablelen, Pclntablecap uint64 + Ftab, Ftablen, Ftabcap uint64 + Findfunctab uint64 + Minpc uint64 + Maxpc uint64 + Text uint64 + Etext uint64 + Noptrdata uint64 + Enoptrdata uint64 + Data uint64 + Edata uint64 + Bss uint64 + Ebss uint64 + Noptrbss uint64 + Enoptrbss uint64 + Covctrs uint64 + Ecovctrs uint64 + End uint64 + Gcdata uint64 + Gcbss uint64 + Types uint64 + Etypes uint64 + Rodata uint64 + Gofunc uint64 + Textsectmap, Textsectmaplen, Textsectmapcap uint64 + Typelinks, Typelinkslen, Typelinkscap uint64 + Itablinks, Itablinkslen, Itablinkscap uint64 + Ptab, Ptablen, Ptabcap uint64 + Pluginpath, Pluginpathlen uint64 + Pkghashes, Pkghasheslen, Pkghashescap uint64 + Inittasks, Inittaskslen, Inittaskscap uint64 } func (md moduledata_1_22_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.text, - TextLen: md.etext - md.text, - NoPtrDataAddr: md.noptrdata, - NoPtrDataLen: md.enoptrdata - md.noptrdata, - DataAddr: md.data, - DataLen: md.edata - md.data, - BssAddr: md.bss, - BssLen: md.ebss - md.bss, - NoPtrBssAddr: md.noptrbss, - NoPtrBssLen: md.enoptrbss - md.noptrbss, - TypesAddr: md.types, - TypesLen: md.etypes - md.types, - TypelinkAddr: md.typelinks, - TypelinkLen: md.typelinkslen, - ITabLinkAddr: md.itablinks, - ITabLinkLen: md.itablinkslen, - FuncTabAddr: md.ftab, - FuncTabLen: md.ftablen, - PCLNTabAddr: md.pclntable, - PCLNTabLen: md.pclntablelen, - GoFuncVal: md.gofunc, + TextAddr: md.Text, + TextLen: md.Etext - md.Text, + NoPtrDataAddr: md.Noptrdata, + NoPtrDataLen: md.Enoptrdata - md.Noptrdata, + DataAddr: md.Data, + DataLen: md.Edata - md.Data, + BssAddr: md.Bss, + BssLen: md.Ebss - md.Bss, + NoPtrBssAddr: md.Noptrbss, + NoPtrBssLen: md.Enoptrbss - md.Noptrbss, + TypesAddr: md.Types, + TypesLen: md.Etypes - md.Types, + TypelinkAddr: md.Typelinks, + TypelinkLen: md.Typelinkslen, + ITabLinkAddr: md.Itablinks, + ITabLinkLen: md.Itablinkslen, + FuncTabAddr: md.Ftab, + FuncTabLen: md.Ftablen, + PCLNTabAddr: md.Pclntable, + PCLNTabLen: md.Pclntablelen, + GoFuncVal: md.Gofunc, } } type moduledata_1_21_32 struct { - pcHeader uint32 - funcnametab, funcnametablen, funcnametabcap uint32 - cutab, cutablen, cutabcap uint32 - filetab, filetablen, filetabcap uint32 - pctab, pctablen, pctabcap uint32 - pclntable, pclntablelen, pclntablecap uint32 - ftab, ftablen, ftabcap uint32 - findfunctab uint32 - minpc uint32 - maxpc uint32 - text uint32 - etext uint32 - noptrdata uint32 - enoptrdata uint32 - data uint32 - edata uint32 - bss uint32 - ebss uint32 - noptrbss uint32 - enoptrbss uint32 - covctrs uint32 - ecovctrs uint32 - end uint32 - gcdata uint32 - gcbss uint32 - types uint32 - etypes uint32 - rodata uint32 - gofunc uint32 - textsectmap, textsectmaplen, textsectmapcap uint32 - typelinks, typelinkslen, typelinkscap uint32 - itablinks, itablinkslen, itablinkscap uint32 - ptab, ptablen, ptabcap uint32 - pluginpath, pluginpathlen uint32 - pkghashes, pkghasheslen, pkghashescap uint32 - inittasks, inittaskslen, inittaskscap uint32 + PcHeader uint32 + Funcnametab, Funcnametablen, Funcnametabcap uint32 + Cutab, Cutablen, Cutabcap uint32 + Filetab, Filetablen, Filetabcap uint32 + Pctab, Pctablen, Pctabcap uint32 + Pclntable, Pclntablelen, Pclntablecap uint32 + Ftab, Ftablen, Ftabcap uint32 + Findfunctab uint32 + Minpc uint32 + Maxpc uint32 + Text uint32 + Etext uint32 + Noptrdata uint32 + Enoptrdata uint32 + Data uint32 + Edata uint32 + Bss uint32 + Ebss uint32 + Noptrbss uint32 + Enoptrbss uint32 + Covctrs uint32 + Ecovctrs uint32 + End uint32 + Gcdata uint32 + Gcbss uint32 + Types uint32 + Etypes uint32 + Rodata uint32 + Gofunc uint32 + Textsectmap, Textsectmaplen, Textsectmapcap uint32 + Typelinks, Typelinkslen, Typelinkscap uint32 + Itablinks, Itablinkslen, Itablinkscap uint32 + Ptab, Ptablen, Ptabcap uint32 + Pluginpath, Pluginpathlen uint32 + Pkghashes, Pkghasheslen, Pkghashescap uint32 + Inittasks, Inittaskslen, Inittaskscap uint32 } func (md moduledata_1_21_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.text), - TextLen: uint64(md.etext - md.text), - NoPtrDataAddr: uint64(md.noptrdata), - NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), - DataAddr: uint64(md.data), - DataLen: uint64(md.edata - md.data), - BssAddr: uint64(md.bss), - BssLen: uint64(md.ebss - md.bss), - NoPtrBssAddr: uint64(md.noptrbss), - NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), - TypesAddr: uint64(md.types), - TypesLen: uint64(md.etypes - md.types), - TypelinkAddr: uint64(md.typelinks), - TypelinkLen: uint64(md.typelinkslen), - ITabLinkAddr: uint64(md.itablinks), - ITabLinkLen: uint64(md.itablinkslen), - FuncTabAddr: uint64(md.ftab), - FuncTabLen: uint64(md.ftablen), - PCLNTabAddr: uint64(md.pclntable), - PCLNTabLen: uint64(md.pclntablelen), - GoFuncVal: uint64(md.gofunc), + TextAddr: uint64(md.Text), + TextLen: uint64(md.Etext - md.Text), + NoPtrDataAddr: uint64(md.Noptrdata), + NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), + DataAddr: uint64(md.Data), + DataLen: uint64(md.Edata - md.Data), + BssAddr: uint64(md.Bss), + BssLen: uint64(md.Ebss - md.Bss), + NoPtrBssAddr: uint64(md.Noptrbss), + NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), + TypesAddr: uint64(md.Types), + TypesLen: uint64(md.Etypes - md.Types), + TypelinkAddr: uint64(md.Typelinks), + TypelinkLen: uint64(md.Typelinkslen), + ITabLinkAddr: uint64(md.Itablinks), + ITabLinkLen: uint64(md.Itablinkslen), + FuncTabAddr: uint64(md.Ftab), + FuncTabLen: uint64(md.Ftablen), + PCLNTabAddr: uint64(md.Pclntable), + PCLNTabLen: uint64(md.Pclntablelen), + GoFuncVal: uint64(md.Gofunc), } } type moduledata_1_21_64 struct { - pcHeader uint64 - funcnametab, funcnametablen, funcnametabcap uint64 - cutab, cutablen, cutabcap uint64 - filetab, filetablen, filetabcap uint64 - pctab, pctablen, pctabcap uint64 - pclntable, pclntablelen, pclntablecap uint64 - ftab, ftablen, ftabcap uint64 - findfunctab uint64 - minpc uint64 - maxpc uint64 - text uint64 - etext uint64 - noptrdata uint64 - enoptrdata uint64 - data uint64 - edata uint64 - bss uint64 - ebss uint64 - noptrbss uint64 - enoptrbss uint64 - covctrs uint64 - ecovctrs uint64 - end uint64 - gcdata uint64 - gcbss uint64 - types uint64 - etypes uint64 - rodata uint64 - gofunc uint64 - textsectmap, textsectmaplen, textsectmapcap uint64 - typelinks, typelinkslen, typelinkscap uint64 - itablinks, itablinkslen, itablinkscap uint64 - ptab, ptablen, ptabcap uint64 - pluginpath, pluginpathlen uint64 - pkghashes, pkghasheslen, pkghashescap uint64 - inittasks, inittaskslen, inittaskscap uint64 + PcHeader uint64 + Funcnametab, Funcnametablen, Funcnametabcap uint64 + Cutab, Cutablen, Cutabcap uint64 + Filetab, Filetablen, Filetabcap uint64 + Pctab, Pctablen, Pctabcap uint64 + Pclntable, Pclntablelen, Pclntablecap uint64 + Ftab, Ftablen, Ftabcap uint64 + Findfunctab uint64 + Minpc uint64 + Maxpc uint64 + Text uint64 + Etext uint64 + Noptrdata uint64 + Enoptrdata uint64 + Data uint64 + Edata uint64 + Bss uint64 + Ebss uint64 + Noptrbss uint64 + Enoptrbss uint64 + Covctrs uint64 + Ecovctrs uint64 + End uint64 + Gcdata uint64 + Gcbss uint64 + Types uint64 + Etypes uint64 + Rodata uint64 + Gofunc uint64 + Textsectmap, Textsectmaplen, Textsectmapcap uint64 + Typelinks, Typelinkslen, Typelinkscap uint64 + Itablinks, Itablinkslen, Itablinkscap uint64 + Ptab, Ptablen, Ptabcap uint64 + Pluginpath, Pluginpathlen uint64 + Pkghashes, Pkghasheslen, Pkghashescap uint64 + Inittasks, Inittaskslen, Inittaskscap uint64 } func (md moduledata_1_21_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.text, - TextLen: md.etext - md.text, - NoPtrDataAddr: md.noptrdata, - NoPtrDataLen: md.enoptrdata - md.noptrdata, - DataAddr: md.data, - DataLen: md.edata - md.data, - BssAddr: md.bss, - BssLen: md.ebss - md.bss, - NoPtrBssAddr: md.noptrbss, - NoPtrBssLen: md.enoptrbss - md.noptrbss, - TypesAddr: md.types, - TypesLen: md.etypes - md.types, - TypelinkAddr: md.typelinks, - TypelinkLen: md.typelinkslen, - ITabLinkAddr: md.itablinks, - ITabLinkLen: md.itablinkslen, - FuncTabAddr: md.ftab, - FuncTabLen: md.ftablen, - PCLNTabAddr: md.pclntable, - PCLNTabLen: md.pclntablelen, - GoFuncVal: md.gofunc, + TextAddr: md.Text, + TextLen: md.Etext - md.Text, + NoPtrDataAddr: md.Noptrdata, + NoPtrDataLen: md.Enoptrdata - md.Noptrdata, + DataAddr: md.Data, + DataLen: md.Edata - md.Data, + BssAddr: md.Bss, + BssLen: md.Ebss - md.Bss, + NoPtrBssAddr: md.Noptrbss, + NoPtrBssLen: md.Enoptrbss - md.Noptrbss, + TypesAddr: md.Types, + TypesLen: md.Etypes - md.Types, + TypelinkAddr: md.Typelinks, + TypelinkLen: md.Typelinkslen, + ITabLinkAddr: md.Itablinks, + ITabLinkLen: md.Itablinkslen, + FuncTabAddr: md.Ftab, + FuncTabLen: md.Ftablen, + PCLNTabAddr: md.Pclntable, + PCLNTabLen: md.Pclntablelen, + GoFuncVal: md.Gofunc, } } type moduledata_1_20_32 struct { - pcHeader uint32 - funcnametab, funcnametablen, funcnametabcap uint32 - cutab, cutablen, cutabcap uint32 - filetab, filetablen, filetabcap uint32 - pctab, pctablen, pctabcap uint32 - pclntable, pclntablelen, pclntablecap uint32 - ftab, ftablen, ftabcap uint32 - findfunctab uint32 - minpc uint32 - maxpc uint32 - text uint32 - etext uint32 - noptrdata uint32 - enoptrdata uint32 - data uint32 - edata uint32 - bss uint32 - ebss uint32 - noptrbss uint32 - enoptrbss uint32 - covctrs uint32 - ecovctrs uint32 - end uint32 - gcdata uint32 - gcbss uint32 - types uint32 - etypes uint32 - rodata uint32 - gofunc uint32 - textsectmap, textsectmaplen, textsectmapcap uint32 - typelinks, typelinkslen, typelinkscap uint32 - itablinks, itablinkslen, itablinkscap uint32 - ptab, ptablen, ptabcap uint32 - pluginpath, pluginpathlen uint32 - pkghashes, pkghasheslen, pkghashescap uint32 + PcHeader uint32 + Funcnametab, Funcnametablen, Funcnametabcap uint32 + Cutab, Cutablen, Cutabcap uint32 + Filetab, Filetablen, Filetabcap uint32 + Pctab, Pctablen, Pctabcap uint32 + Pclntable, Pclntablelen, Pclntablecap uint32 + Ftab, Ftablen, Ftabcap uint32 + Findfunctab uint32 + Minpc uint32 + Maxpc uint32 + Text uint32 + Etext uint32 + Noptrdata uint32 + Enoptrdata uint32 + Data uint32 + Edata uint32 + Bss uint32 + Ebss uint32 + Noptrbss uint32 + Enoptrbss uint32 + Covctrs uint32 + Ecovctrs uint32 + End uint32 + Gcdata uint32 + Gcbss uint32 + Types uint32 + Etypes uint32 + Rodata uint32 + Gofunc uint32 + Textsectmap, Textsectmaplen, Textsectmapcap uint32 + Typelinks, Typelinkslen, Typelinkscap uint32 + Itablinks, Itablinkslen, Itablinkscap uint32 + Ptab, Ptablen, Ptabcap uint32 + Pluginpath, Pluginpathlen uint32 + Pkghashes, Pkghasheslen, Pkghashescap uint32 } func (md moduledata_1_20_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.text), - TextLen: uint64(md.etext - md.text), - NoPtrDataAddr: uint64(md.noptrdata), - NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), - DataAddr: uint64(md.data), - DataLen: uint64(md.edata - md.data), - BssAddr: uint64(md.bss), - BssLen: uint64(md.ebss - md.bss), - NoPtrBssAddr: uint64(md.noptrbss), - NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), - TypesAddr: uint64(md.types), - TypesLen: uint64(md.etypes - md.types), - TypelinkAddr: uint64(md.typelinks), - TypelinkLen: uint64(md.typelinkslen), - ITabLinkAddr: uint64(md.itablinks), - ITabLinkLen: uint64(md.itablinkslen), - FuncTabAddr: uint64(md.ftab), - FuncTabLen: uint64(md.ftablen), - PCLNTabAddr: uint64(md.pclntable), - PCLNTabLen: uint64(md.pclntablelen), - GoFuncVal: uint64(md.gofunc), + TextAddr: uint64(md.Text), + TextLen: uint64(md.Etext - md.Text), + NoPtrDataAddr: uint64(md.Noptrdata), + NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), + DataAddr: uint64(md.Data), + DataLen: uint64(md.Edata - md.Data), + BssAddr: uint64(md.Bss), + BssLen: uint64(md.Ebss - md.Bss), + NoPtrBssAddr: uint64(md.Noptrbss), + NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), + TypesAddr: uint64(md.Types), + TypesLen: uint64(md.Etypes - md.Types), + TypelinkAddr: uint64(md.Typelinks), + TypelinkLen: uint64(md.Typelinkslen), + ITabLinkAddr: uint64(md.Itablinks), + ITabLinkLen: uint64(md.Itablinkslen), + FuncTabAddr: uint64(md.Ftab), + FuncTabLen: uint64(md.Ftablen), + PCLNTabAddr: uint64(md.Pclntable), + PCLNTabLen: uint64(md.Pclntablelen), + GoFuncVal: uint64(md.Gofunc), } } type moduledata_1_20_64 struct { - pcHeader uint64 - funcnametab, funcnametablen, funcnametabcap uint64 - cutab, cutablen, cutabcap uint64 - filetab, filetablen, filetabcap uint64 - pctab, pctablen, pctabcap uint64 - pclntable, pclntablelen, pclntablecap uint64 - ftab, ftablen, ftabcap uint64 - findfunctab uint64 - minpc uint64 - maxpc uint64 - text uint64 - etext uint64 - noptrdata uint64 - enoptrdata uint64 - data uint64 - edata uint64 - bss uint64 - ebss uint64 - noptrbss uint64 - enoptrbss uint64 - covctrs uint64 - ecovctrs uint64 - end uint64 - gcdata uint64 - gcbss uint64 - types uint64 - etypes uint64 - rodata uint64 - gofunc uint64 - textsectmap, textsectmaplen, textsectmapcap uint64 - typelinks, typelinkslen, typelinkscap uint64 - itablinks, itablinkslen, itablinkscap uint64 - ptab, ptablen, ptabcap uint64 - pluginpath, pluginpathlen uint64 - pkghashes, pkghasheslen, pkghashescap uint64 + PcHeader uint64 + Funcnametab, Funcnametablen, Funcnametabcap uint64 + Cutab, Cutablen, Cutabcap uint64 + Filetab, Filetablen, Filetabcap uint64 + Pctab, Pctablen, Pctabcap uint64 + Pclntable, Pclntablelen, Pclntablecap uint64 + Ftab, Ftablen, Ftabcap uint64 + Findfunctab uint64 + Minpc uint64 + Maxpc uint64 + Text uint64 + Etext uint64 + Noptrdata uint64 + Enoptrdata uint64 + Data uint64 + Edata uint64 + Bss uint64 + Ebss uint64 + Noptrbss uint64 + Enoptrbss uint64 + Covctrs uint64 + Ecovctrs uint64 + End uint64 + Gcdata uint64 + Gcbss uint64 + Types uint64 + Etypes uint64 + Rodata uint64 + Gofunc uint64 + Textsectmap, Textsectmaplen, Textsectmapcap uint64 + Typelinks, Typelinkslen, Typelinkscap uint64 + Itablinks, Itablinkslen, Itablinkscap uint64 + Ptab, Ptablen, Ptabcap uint64 + Pluginpath, Pluginpathlen uint64 + Pkghashes, Pkghasheslen, Pkghashescap uint64 } func (md moduledata_1_20_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.text, - TextLen: md.etext - md.text, - NoPtrDataAddr: md.noptrdata, - NoPtrDataLen: md.enoptrdata - md.noptrdata, - DataAddr: md.data, - DataLen: md.edata - md.data, - BssAddr: md.bss, - BssLen: md.ebss - md.bss, - NoPtrBssAddr: md.noptrbss, - NoPtrBssLen: md.enoptrbss - md.noptrbss, - TypesAddr: md.types, - TypesLen: md.etypes - md.types, - TypelinkAddr: md.typelinks, - TypelinkLen: md.typelinkslen, - ITabLinkAddr: md.itablinks, - ITabLinkLen: md.itablinkslen, - FuncTabAddr: md.ftab, - FuncTabLen: md.ftablen, - PCLNTabAddr: md.pclntable, - PCLNTabLen: md.pclntablelen, - GoFuncVal: md.gofunc, + TextAddr: md.Text, + TextLen: md.Etext - md.Text, + NoPtrDataAddr: md.Noptrdata, + NoPtrDataLen: md.Enoptrdata - md.Noptrdata, + DataAddr: md.Data, + DataLen: md.Edata - md.Data, + BssAddr: md.Bss, + BssLen: md.Ebss - md.Bss, + NoPtrBssAddr: md.Noptrbss, + NoPtrBssLen: md.Enoptrbss - md.Noptrbss, + TypesAddr: md.Types, + TypesLen: md.Etypes - md.Types, + TypelinkAddr: md.Typelinks, + TypelinkLen: md.Typelinkslen, + ITabLinkAddr: md.Itablinks, + ITabLinkLen: md.Itablinkslen, + FuncTabAddr: md.Ftab, + FuncTabLen: md.Ftablen, + PCLNTabAddr: md.Pclntable, + PCLNTabLen: md.Pclntablelen, + GoFuncVal: md.Gofunc, } } type moduledata_1_19_32 struct { - pcHeader uint32 - funcnametab, funcnametablen, funcnametabcap uint32 - cutab, cutablen, cutabcap uint32 - filetab, filetablen, filetabcap uint32 - pctab, pctablen, pctabcap uint32 - pclntable, pclntablelen, pclntablecap uint32 - ftab, ftablen, ftabcap uint32 - findfunctab uint32 - minpc uint32 - maxpc uint32 - text uint32 - etext uint32 - noptrdata uint32 - enoptrdata uint32 - data uint32 - edata uint32 - bss uint32 - ebss uint32 - noptrbss uint32 - enoptrbss uint32 - end uint32 - gcdata uint32 - gcbss uint32 - types uint32 - etypes uint32 - rodata uint32 - gofunc uint32 - textsectmap, textsectmaplen, textsectmapcap uint32 - typelinks, typelinkslen, typelinkscap uint32 - itablinks, itablinkslen, itablinkscap uint32 - ptab, ptablen, ptabcap uint32 - pluginpath, pluginpathlen uint32 - pkghashes, pkghasheslen, pkghashescap uint32 + PcHeader uint32 + Funcnametab, Funcnametablen, Funcnametabcap uint32 + Cutab, Cutablen, Cutabcap uint32 + Filetab, Filetablen, Filetabcap uint32 + Pctab, Pctablen, Pctabcap uint32 + Pclntable, Pclntablelen, Pclntablecap uint32 + Ftab, Ftablen, Ftabcap uint32 + Findfunctab uint32 + Minpc uint32 + Maxpc uint32 + Text uint32 + Etext uint32 + Noptrdata uint32 + Enoptrdata uint32 + Data uint32 + Edata uint32 + Bss uint32 + Ebss uint32 + Noptrbss uint32 + Enoptrbss uint32 + End uint32 + Gcdata uint32 + Gcbss uint32 + Types uint32 + Etypes uint32 + Rodata uint32 + Gofunc uint32 + Textsectmap, Textsectmaplen, Textsectmapcap uint32 + Typelinks, Typelinkslen, Typelinkscap uint32 + Itablinks, Itablinkslen, Itablinkscap uint32 + Ptab, Ptablen, Ptabcap uint32 + Pluginpath, Pluginpathlen uint32 + Pkghashes, Pkghasheslen, Pkghashescap uint32 } func (md moduledata_1_19_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.text), - TextLen: uint64(md.etext - md.text), - NoPtrDataAddr: uint64(md.noptrdata), - NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), - DataAddr: uint64(md.data), - DataLen: uint64(md.edata - md.data), - BssAddr: uint64(md.bss), - BssLen: uint64(md.ebss - md.bss), - NoPtrBssAddr: uint64(md.noptrbss), - NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), - TypesAddr: uint64(md.types), - TypesLen: uint64(md.etypes - md.types), - TypelinkAddr: uint64(md.typelinks), - TypelinkLen: uint64(md.typelinkslen), - ITabLinkAddr: uint64(md.itablinks), - ITabLinkLen: uint64(md.itablinkslen), - FuncTabAddr: uint64(md.ftab), - FuncTabLen: uint64(md.ftablen), - PCLNTabAddr: uint64(md.pclntable), - PCLNTabLen: uint64(md.pclntablelen), - GoFuncVal: uint64(md.gofunc), + TextAddr: uint64(md.Text), + TextLen: uint64(md.Etext - md.Text), + NoPtrDataAddr: uint64(md.Noptrdata), + NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), + DataAddr: uint64(md.Data), + DataLen: uint64(md.Edata - md.Data), + BssAddr: uint64(md.Bss), + BssLen: uint64(md.Ebss - md.Bss), + NoPtrBssAddr: uint64(md.Noptrbss), + NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), + TypesAddr: uint64(md.Types), + TypesLen: uint64(md.Etypes - md.Types), + TypelinkAddr: uint64(md.Typelinks), + TypelinkLen: uint64(md.Typelinkslen), + ITabLinkAddr: uint64(md.Itablinks), + ITabLinkLen: uint64(md.Itablinkslen), + FuncTabAddr: uint64(md.Ftab), + FuncTabLen: uint64(md.Ftablen), + PCLNTabAddr: uint64(md.Pclntable), + PCLNTabLen: uint64(md.Pclntablelen), + GoFuncVal: uint64(md.Gofunc), } } type moduledata_1_19_64 struct { - pcHeader uint64 - funcnametab, funcnametablen, funcnametabcap uint64 - cutab, cutablen, cutabcap uint64 - filetab, filetablen, filetabcap uint64 - pctab, pctablen, pctabcap uint64 - pclntable, pclntablelen, pclntablecap uint64 - ftab, ftablen, ftabcap uint64 - findfunctab uint64 - minpc uint64 - maxpc uint64 - text uint64 - etext uint64 - noptrdata uint64 - enoptrdata uint64 - data uint64 - edata uint64 - bss uint64 - ebss uint64 - noptrbss uint64 - enoptrbss uint64 - end uint64 - gcdata uint64 - gcbss uint64 - types uint64 - etypes uint64 - rodata uint64 - gofunc uint64 - textsectmap, textsectmaplen, textsectmapcap uint64 - typelinks, typelinkslen, typelinkscap uint64 - itablinks, itablinkslen, itablinkscap uint64 - ptab, ptablen, ptabcap uint64 - pluginpath, pluginpathlen uint64 - pkghashes, pkghasheslen, pkghashescap uint64 + PcHeader uint64 + Funcnametab, Funcnametablen, Funcnametabcap uint64 + Cutab, Cutablen, Cutabcap uint64 + Filetab, Filetablen, Filetabcap uint64 + Pctab, Pctablen, Pctabcap uint64 + Pclntable, Pclntablelen, Pclntablecap uint64 + Ftab, Ftablen, Ftabcap uint64 + Findfunctab uint64 + Minpc uint64 + Maxpc uint64 + Text uint64 + Etext uint64 + Noptrdata uint64 + Enoptrdata uint64 + Data uint64 + Edata uint64 + Bss uint64 + Ebss uint64 + Noptrbss uint64 + Enoptrbss uint64 + End uint64 + Gcdata uint64 + Gcbss uint64 + Types uint64 + Etypes uint64 + Rodata uint64 + Gofunc uint64 + Textsectmap, Textsectmaplen, Textsectmapcap uint64 + Typelinks, Typelinkslen, Typelinkscap uint64 + Itablinks, Itablinkslen, Itablinkscap uint64 + Ptab, Ptablen, Ptabcap uint64 + Pluginpath, Pluginpathlen uint64 + Pkghashes, Pkghasheslen, Pkghashescap uint64 } func (md moduledata_1_19_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.text, - TextLen: md.etext - md.text, - NoPtrDataAddr: md.noptrdata, - NoPtrDataLen: md.enoptrdata - md.noptrdata, - DataAddr: md.data, - DataLen: md.edata - md.data, - BssAddr: md.bss, - BssLen: md.ebss - md.bss, - NoPtrBssAddr: md.noptrbss, - NoPtrBssLen: md.enoptrbss - md.noptrbss, - TypesAddr: md.types, - TypesLen: md.etypes - md.types, - TypelinkAddr: md.typelinks, - TypelinkLen: md.typelinkslen, - ITabLinkAddr: md.itablinks, - ITabLinkLen: md.itablinkslen, - FuncTabAddr: md.ftab, - FuncTabLen: md.ftablen, - PCLNTabAddr: md.pclntable, - PCLNTabLen: md.pclntablelen, - GoFuncVal: md.gofunc, + TextAddr: md.Text, + TextLen: md.Etext - md.Text, + NoPtrDataAddr: md.Noptrdata, + NoPtrDataLen: md.Enoptrdata - md.Noptrdata, + DataAddr: md.Data, + DataLen: md.Edata - md.Data, + BssAddr: md.Bss, + BssLen: md.Ebss - md.Bss, + NoPtrBssAddr: md.Noptrbss, + NoPtrBssLen: md.Enoptrbss - md.Noptrbss, + TypesAddr: md.Types, + TypesLen: md.Etypes - md.Types, + TypelinkAddr: md.Typelinks, + TypelinkLen: md.Typelinkslen, + ITabLinkAddr: md.Itablinks, + ITabLinkLen: md.Itablinkslen, + FuncTabAddr: md.Ftab, + FuncTabLen: md.Ftablen, + PCLNTabAddr: md.Pclntable, + PCLNTabLen: md.Pclntablelen, + GoFuncVal: md.Gofunc, } } type moduledata_1_18_32 struct { - pcHeader uint32 - funcnametab, funcnametablen, funcnametabcap uint32 - cutab, cutablen, cutabcap uint32 - filetab, filetablen, filetabcap uint32 - pctab, pctablen, pctabcap uint32 - pclntable, pclntablelen, pclntablecap uint32 - ftab, ftablen, ftabcap uint32 - findfunctab uint32 - minpc uint32 - maxpc uint32 - text uint32 - etext uint32 - noptrdata uint32 - enoptrdata uint32 - data uint32 - edata uint32 - bss uint32 - ebss uint32 - noptrbss uint32 - enoptrbss uint32 - end uint32 - gcdata uint32 - gcbss uint32 - types uint32 - etypes uint32 - rodata uint32 - gofunc uint32 - textsectmap, textsectmaplen, textsectmapcap uint32 - typelinks, typelinkslen, typelinkscap uint32 - itablinks, itablinkslen, itablinkscap uint32 - ptab, ptablen, ptabcap uint32 - pluginpath, pluginpathlen uint32 - pkghashes, pkghasheslen, pkghashescap uint32 + PcHeader uint32 + Funcnametab, Funcnametablen, Funcnametabcap uint32 + Cutab, Cutablen, Cutabcap uint32 + Filetab, Filetablen, Filetabcap uint32 + Pctab, Pctablen, Pctabcap uint32 + Pclntable, Pclntablelen, Pclntablecap uint32 + Ftab, Ftablen, Ftabcap uint32 + Findfunctab uint32 + Minpc uint32 + Maxpc uint32 + Text uint32 + Etext uint32 + Noptrdata uint32 + Enoptrdata uint32 + Data uint32 + Edata uint32 + Bss uint32 + Ebss uint32 + Noptrbss uint32 + Enoptrbss uint32 + End uint32 + Gcdata uint32 + Gcbss uint32 + Types uint32 + Etypes uint32 + Rodata uint32 + Gofunc uint32 + Textsectmap, Textsectmaplen, Textsectmapcap uint32 + Typelinks, Typelinkslen, Typelinkscap uint32 + Itablinks, Itablinkslen, Itablinkscap uint32 + Ptab, Ptablen, Ptabcap uint32 + Pluginpath, Pluginpathlen uint32 + Pkghashes, Pkghasheslen, Pkghashescap uint32 } func (md moduledata_1_18_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.text), - TextLen: uint64(md.etext - md.text), - NoPtrDataAddr: uint64(md.noptrdata), - NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), - DataAddr: uint64(md.data), - DataLen: uint64(md.edata - md.data), - BssAddr: uint64(md.bss), - BssLen: uint64(md.ebss - md.bss), - NoPtrBssAddr: uint64(md.noptrbss), - NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), - TypesAddr: uint64(md.types), - TypesLen: uint64(md.etypes - md.types), - TypelinkAddr: uint64(md.typelinks), - TypelinkLen: uint64(md.typelinkslen), - ITabLinkAddr: uint64(md.itablinks), - ITabLinkLen: uint64(md.itablinkslen), - FuncTabAddr: uint64(md.ftab), - FuncTabLen: uint64(md.ftablen), - PCLNTabAddr: uint64(md.pclntable), - PCLNTabLen: uint64(md.pclntablelen), - GoFuncVal: uint64(md.gofunc), + TextAddr: uint64(md.Text), + TextLen: uint64(md.Etext - md.Text), + NoPtrDataAddr: uint64(md.Noptrdata), + NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), + DataAddr: uint64(md.Data), + DataLen: uint64(md.Edata - md.Data), + BssAddr: uint64(md.Bss), + BssLen: uint64(md.Ebss - md.Bss), + NoPtrBssAddr: uint64(md.Noptrbss), + NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), + TypesAddr: uint64(md.Types), + TypesLen: uint64(md.Etypes - md.Types), + TypelinkAddr: uint64(md.Typelinks), + TypelinkLen: uint64(md.Typelinkslen), + ITabLinkAddr: uint64(md.Itablinks), + ITabLinkLen: uint64(md.Itablinkslen), + FuncTabAddr: uint64(md.Ftab), + FuncTabLen: uint64(md.Ftablen), + PCLNTabAddr: uint64(md.Pclntable), + PCLNTabLen: uint64(md.Pclntablelen), + GoFuncVal: uint64(md.Gofunc), } } type moduledata_1_18_64 struct { - pcHeader uint64 - funcnametab, funcnametablen, funcnametabcap uint64 - cutab, cutablen, cutabcap uint64 - filetab, filetablen, filetabcap uint64 - pctab, pctablen, pctabcap uint64 - pclntable, pclntablelen, pclntablecap uint64 - ftab, ftablen, ftabcap uint64 - findfunctab uint64 - minpc uint64 - maxpc uint64 - text uint64 - etext uint64 - noptrdata uint64 - enoptrdata uint64 - data uint64 - edata uint64 - bss uint64 - ebss uint64 - noptrbss uint64 - enoptrbss uint64 - end uint64 - gcdata uint64 - gcbss uint64 - types uint64 - etypes uint64 - rodata uint64 - gofunc uint64 - textsectmap, textsectmaplen, textsectmapcap uint64 - typelinks, typelinkslen, typelinkscap uint64 - itablinks, itablinkslen, itablinkscap uint64 - ptab, ptablen, ptabcap uint64 - pluginpath, pluginpathlen uint64 - pkghashes, pkghasheslen, pkghashescap uint64 + PcHeader uint64 + Funcnametab, Funcnametablen, Funcnametabcap uint64 + Cutab, Cutablen, Cutabcap uint64 + Filetab, Filetablen, Filetabcap uint64 + Pctab, Pctablen, Pctabcap uint64 + Pclntable, Pclntablelen, Pclntablecap uint64 + Ftab, Ftablen, Ftabcap uint64 + Findfunctab uint64 + Minpc uint64 + Maxpc uint64 + Text uint64 + Etext uint64 + Noptrdata uint64 + Enoptrdata uint64 + Data uint64 + Edata uint64 + Bss uint64 + Ebss uint64 + Noptrbss uint64 + Enoptrbss uint64 + End uint64 + Gcdata uint64 + Gcbss uint64 + Types uint64 + Etypes uint64 + Rodata uint64 + Gofunc uint64 + Textsectmap, Textsectmaplen, Textsectmapcap uint64 + Typelinks, Typelinkslen, Typelinkscap uint64 + Itablinks, Itablinkslen, Itablinkscap uint64 + Ptab, Ptablen, Ptabcap uint64 + Pluginpath, Pluginpathlen uint64 + Pkghashes, Pkghasheslen, Pkghashescap uint64 } func (md moduledata_1_18_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.text, - TextLen: md.etext - md.text, - NoPtrDataAddr: md.noptrdata, - NoPtrDataLen: md.enoptrdata - md.noptrdata, - DataAddr: md.data, - DataLen: md.edata - md.data, - BssAddr: md.bss, - BssLen: md.ebss - md.bss, - NoPtrBssAddr: md.noptrbss, - NoPtrBssLen: md.enoptrbss - md.noptrbss, - TypesAddr: md.types, - TypesLen: md.etypes - md.types, - TypelinkAddr: md.typelinks, - TypelinkLen: md.typelinkslen, - ITabLinkAddr: md.itablinks, - ITabLinkLen: md.itablinkslen, - FuncTabAddr: md.ftab, - FuncTabLen: md.ftablen, - PCLNTabAddr: md.pclntable, - PCLNTabLen: md.pclntablelen, - GoFuncVal: md.gofunc, + TextAddr: md.Text, + TextLen: md.Etext - md.Text, + NoPtrDataAddr: md.Noptrdata, + NoPtrDataLen: md.Enoptrdata - md.Noptrdata, + DataAddr: md.Data, + DataLen: md.Edata - md.Data, + BssAddr: md.Bss, + BssLen: md.Ebss - md.Bss, + NoPtrBssAddr: md.Noptrbss, + NoPtrBssLen: md.Enoptrbss - md.Noptrbss, + TypesAddr: md.Types, + TypesLen: md.Etypes - md.Types, + TypelinkAddr: md.Typelinks, + TypelinkLen: md.Typelinkslen, + ITabLinkAddr: md.Itablinks, + ITabLinkLen: md.Itablinkslen, + FuncTabAddr: md.Ftab, + FuncTabLen: md.Ftablen, + PCLNTabAddr: md.Pclntable, + PCLNTabLen: md.Pclntablelen, + GoFuncVal: md.Gofunc, } } type moduledata_1_17_32 struct { - pcHeader uint32 - funcnametab, funcnametablen, funcnametabcap uint32 - cutab, cutablen, cutabcap uint32 - filetab, filetablen, filetabcap uint32 - pctab, pctablen, pctabcap uint32 - pclntable, pclntablelen, pclntablecap uint32 - ftab, ftablen, ftabcap uint32 - findfunctab uint32 - minpc uint32 - maxpc uint32 - text uint32 - etext uint32 - noptrdata uint32 - enoptrdata uint32 - data uint32 - edata uint32 - bss uint32 - ebss uint32 - noptrbss uint32 - enoptrbss uint32 - end uint32 - gcdata uint32 - gcbss uint32 - types uint32 - etypes uint32 - textsectmap, textsectmaplen, textsectmapcap uint32 - typelinks, typelinkslen, typelinkscap uint32 - itablinks, itablinkslen, itablinkscap uint32 - ptab, ptablen, ptabcap uint32 - pluginpath, pluginpathlen uint32 - pkghashes, pkghasheslen, pkghashescap uint32 + PcHeader uint32 + Funcnametab, Funcnametablen, Funcnametabcap uint32 + Cutab, Cutablen, Cutabcap uint32 + Filetab, Filetablen, Filetabcap uint32 + Pctab, Pctablen, Pctabcap uint32 + Pclntable, Pclntablelen, Pclntablecap uint32 + Ftab, Ftablen, Ftabcap uint32 + Findfunctab uint32 + Minpc uint32 + Maxpc uint32 + Text uint32 + Etext uint32 + Noptrdata uint32 + Enoptrdata uint32 + Data uint32 + Edata uint32 + Bss uint32 + Ebss uint32 + Noptrbss uint32 + Enoptrbss uint32 + End uint32 + Gcdata uint32 + Gcbss uint32 + Types uint32 + Etypes uint32 + Textsectmap, Textsectmaplen, Textsectmapcap uint32 + Typelinks, Typelinkslen, Typelinkscap uint32 + Itablinks, Itablinkslen, Itablinkscap uint32 + Ptab, Ptablen, Ptabcap uint32 + Pluginpath, Pluginpathlen uint32 + Pkghashes, Pkghasheslen, Pkghashescap uint32 } func (md moduledata_1_17_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.text), - TextLen: uint64(md.etext - md.text), - NoPtrDataAddr: uint64(md.noptrdata), - NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), - DataAddr: uint64(md.data), - DataLen: uint64(md.edata - md.data), - BssAddr: uint64(md.bss), - BssLen: uint64(md.ebss - md.bss), - NoPtrBssAddr: uint64(md.noptrbss), - NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), - TypesAddr: uint64(md.types), - TypesLen: uint64(md.etypes - md.types), - TypelinkAddr: uint64(md.typelinks), - TypelinkLen: uint64(md.typelinkslen), - ITabLinkAddr: uint64(md.itablinks), - ITabLinkLen: uint64(md.itablinkslen), - FuncTabAddr: uint64(md.ftab), - FuncTabLen: uint64(md.ftablen), - PCLNTabAddr: uint64(md.pclntable), - PCLNTabLen: uint64(md.pclntablelen), + TextAddr: uint64(md.Text), + TextLen: uint64(md.Etext - md.Text), + NoPtrDataAddr: uint64(md.Noptrdata), + NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), + DataAddr: uint64(md.Data), + DataLen: uint64(md.Edata - md.Data), + BssAddr: uint64(md.Bss), + BssLen: uint64(md.Ebss - md.Bss), + NoPtrBssAddr: uint64(md.Noptrbss), + NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), + TypesAddr: uint64(md.Types), + TypesLen: uint64(md.Etypes - md.Types), + TypelinkAddr: uint64(md.Typelinks), + TypelinkLen: uint64(md.Typelinkslen), + ITabLinkAddr: uint64(md.Itablinks), + ITabLinkLen: uint64(md.Itablinkslen), + FuncTabAddr: uint64(md.Ftab), + FuncTabLen: uint64(md.Ftablen), + PCLNTabAddr: uint64(md.Pclntable), + PCLNTabLen: uint64(md.Pclntablelen), } } type moduledata_1_17_64 struct { - pcHeader uint64 - funcnametab, funcnametablen, funcnametabcap uint64 - cutab, cutablen, cutabcap uint64 - filetab, filetablen, filetabcap uint64 - pctab, pctablen, pctabcap uint64 - pclntable, pclntablelen, pclntablecap uint64 - ftab, ftablen, ftabcap uint64 - findfunctab uint64 - minpc uint64 - maxpc uint64 - text uint64 - etext uint64 - noptrdata uint64 - enoptrdata uint64 - data uint64 - edata uint64 - bss uint64 - ebss uint64 - noptrbss uint64 - enoptrbss uint64 - end uint64 - gcdata uint64 - gcbss uint64 - types uint64 - etypes uint64 - textsectmap, textsectmaplen, textsectmapcap uint64 - typelinks, typelinkslen, typelinkscap uint64 - itablinks, itablinkslen, itablinkscap uint64 - ptab, ptablen, ptabcap uint64 - pluginpath, pluginpathlen uint64 - pkghashes, pkghasheslen, pkghashescap uint64 + PcHeader uint64 + Funcnametab, Funcnametablen, Funcnametabcap uint64 + Cutab, Cutablen, Cutabcap uint64 + Filetab, Filetablen, Filetabcap uint64 + Pctab, Pctablen, Pctabcap uint64 + Pclntable, Pclntablelen, Pclntablecap uint64 + Ftab, Ftablen, Ftabcap uint64 + Findfunctab uint64 + Minpc uint64 + Maxpc uint64 + Text uint64 + Etext uint64 + Noptrdata uint64 + Enoptrdata uint64 + Data uint64 + Edata uint64 + Bss uint64 + Ebss uint64 + Noptrbss uint64 + Enoptrbss uint64 + End uint64 + Gcdata uint64 + Gcbss uint64 + Types uint64 + Etypes uint64 + Textsectmap, Textsectmaplen, Textsectmapcap uint64 + Typelinks, Typelinkslen, Typelinkscap uint64 + Itablinks, Itablinkslen, Itablinkscap uint64 + Ptab, Ptablen, Ptabcap uint64 + Pluginpath, Pluginpathlen uint64 + Pkghashes, Pkghasheslen, Pkghashescap uint64 } func (md moduledata_1_17_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.text, - TextLen: md.etext - md.text, - NoPtrDataAddr: md.noptrdata, - NoPtrDataLen: md.enoptrdata - md.noptrdata, - DataAddr: md.data, - DataLen: md.edata - md.data, - BssAddr: md.bss, - BssLen: md.ebss - md.bss, - NoPtrBssAddr: md.noptrbss, - NoPtrBssLen: md.enoptrbss - md.noptrbss, - TypesAddr: md.types, - TypesLen: md.etypes - md.types, - TypelinkAddr: md.typelinks, - TypelinkLen: md.typelinkslen, - ITabLinkAddr: md.itablinks, - ITabLinkLen: md.itablinkslen, - FuncTabAddr: md.ftab, - FuncTabLen: md.ftablen, - PCLNTabAddr: md.pclntable, - PCLNTabLen: md.pclntablelen, + TextAddr: md.Text, + TextLen: md.Etext - md.Text, + NoPtrDataAddr: md.Noptrdata, + NoPtrDataLen: md.Enoptrdata - md.Noptrdata, + DataAddr: md.Data, + DataLen: md.Edata - md.Data, + BssAddr: md.Bss, + BssLen: md.Ebss - md.Bss, + NoPtrBssAddr: md.Noptrbss, + NoPtrBssLen: md.Enoptrbss - md.Noptrbss, + TypesAddr: md.Types, + TypesLen: md.Etypes - md.Types, + TypelinkAddr: md.Typelinks, + TypelinkLen: md.Typelinkslen, + ITabLinkAddr: md.Itablinks, + ITabLinkLen: md.Itablinkslen, + FuncTabAddr: md.Ftab, + FuncTabLen: md.Ftablen, + PCLNTabAddr: md.Pclntable, + PCLNTabLen: md.Pclntablelen, } } type moduledata_1_16_32 struct { - pcHeader uint32 - funcnametab, funcnametablen, funcnametabcap uint32 - cutab, cutablen, cutabcap uint32 - filetab, filetablen, filetabcap uint32 - pctab, pctablen, pctabcap uint32 - pclntable, pclntablelen, pclntablecap uint32 - ftab, ftablen, ftabcap uint32 - findfunctab uint32 - minpc uint32 - maxpc uint32 - text uint32 - etext uint32 - noptrdata uint32 - enoptrdata uint32 - data uint32 - edata uint32 - bss uint32 - ebss uint32 - noptrbss uint32 - enoptrbss uint32 - end uint32 - gcdata uint32 - gcbss uint32 - types uint32 - etypes uint32 - textsectmap, textsectmaplen, textsectmapcap uint32 - typelinks, typelinkslen, typelinkscap uint32 - itablinks, itablinkslen, itablinkscap uint32 - ptab, ptablen, ptabcap uint32 - pluginpath, pluginpathlen uint32 - pkghashes, pkghasheslen, pkghashescap uint32 + PcHeader uint32 + Funcnametab, Funcnametablen, Funcnametabcap uint32 + Cutab, Cutablen, Cutabcap uint32 + Filetab, Filetablen, Filetabcap uint32 + Pctab, Pctablen, Pctabcap uint32 + Pclntable, Pclntablelen, Pclntablecap uint32 + Ftab, Ftablen, Ftabcap uint32 + Findfunctab uint32 + Minpc uint32 + Maxpc uint32 + Text uint32 + Etext uint32 + Noptrdata uint32 + Enoptrdata uint32 + Data uint32 + Edata uint32 + Bss uint32 + Ebss uint32 + Noptrbss uint32 + Enoptrbss uint32 + End uint32 + Gcdata uint32 + Gcbss uint32 + Types uint32 + Etypes uint32 + Textsectmap, Textsectmaplen, Textsectmapcap uint32 + Typelinks, Typelinkslen, Typelinkscap uint32 + Itablinks, Itablinkslen, Itablinkscap uint32 + Ptab, Ptablen, Ptabcap uint32 + Pluginpath, Pluginpathlen uint32 + Pkghashes, Pkghasheslen, Pkghashescap uint32 } func (md moduledata_1_16_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.text), - TextLen: uint64(md.etext - md.text), - NoPtrDataAddr: uint64(md.noptrdata), - NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), - DataAddr: uint64(md.data), - DataLen: uint64(md.edata - md.data), - BssAddr: uint64(md.bss), - BssLen: uint64(md.ebss - md.bss), - NoPtrBssAddr: uint64(md.noptrbss), - NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), - TypesAddr: uint64(md.types), - TypesLen: uint64(md.etypes - md.types), - TypelinkAddr: uint64(md.typelinks), - TypelinkLen: uint64(md.typelinkslen), - ITabLinkAddr: uint64(md.itablinks), - ITabLinkLen: uint64(md.itablinkslen), - FuncTabAddr: uint64(md.ftab), - FuncTabLen: uint64(md.ftablen), - PCLNTabAddr: uint64(md.pclntable), - PCLNTabLen: uint64(md.pclntablelen), + TextAddr: uint64(md.Text), + TextLen: uint64(md.Etext - md.Text), + NoPtrDataAddr: uint64(md.Noptrdata), + NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), + DataAddr: uint64(md.Data), + DataLen: uint64(md.Edata - md.Data), + BssAddr: uint64(md.Bss), + BssLen: uint64(md.Ebss - md.Bss), + NoPtrBssAddr: uint64(md.Noptrbss), + NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), + TypesAddr: uint64(md.Types), + TypesLen: uint64(md.Etypes - md.Types), + TypelinkAddr: uint64(md.Typelinks), + TypelinkLen: uint64(md.Typelinkslen), + ITabLinkAddr: uint64(md.Itablinks), + ITabLinkLen: uint64(md.Itablinkslen), + FuncTabAddr: uint64(md.Ftab), + FuncTabLen: uint64(md.Ftablen), + PCLNTabAddr: uint64(md.Pclntable), + PCLNTabLen: uint64(md.Pclntablelen), } } type moduledata_1_16_64 struct { - pcHeader uint64 - funcnametab, funcnametablen, funcnametabcap uint64 - cutab, cutablen, cutabcap uint64 - filetab, filetablen, filetabcap uint64 - pctab, pctablen, pctabcap uint64 - pclntable, pclntablelen, pclntablecap uint64 - ftab, ftablen, ftabcap uint64 - findfunctab uint64 - minpc uint64 - maxpc uint64 - text uint64 - etext uint64 - noptrdata uint64 - enoptrdata uint64 - data uint64 - edata uint64 - bss uint64 - ebss uint64 - noptrbss uint64 - enoptrbss uint64 - end uint64 - gcdata uint64 - gcbss uint64 - types uint64 - etypes uint64 - textsectmap, textsectmaplen, textsectmapcap uint64 - typelinks, typelinkslen, typelinkscap uint64 - itablinks, itablinkslen, itablinkscap uint64 - ptab, ptablen, ptabcap uint64 - pluginpath, pluginpathlen uint64 - pkghashes, pkghasheslen, pkghashescap uint64 + PcHeader uint64 + Funcnametab, Funcnametablen, Funcnametabcap uint64 + Cutab, Cutablen, Cutabcap uint64 + Filetab, Filetablen, Filetabcap uint64 + Pctab, Pctablen, Pctabcap uint64 + Pclntable, Pclntablelen, Pclntablecap uint64 + Ftab, Ftablen, Ftabcap uint64 + Findfunctab uint64 + Minpc uint64 + Maxpc uint64 + Text uint64 + Etext uint64 + Noptrdata uint64 + Enoptrdata uint64 + Data uint64 + Edata uint64 + Bss uint64 + Ebss uint64 + Noptrbss uint64 + Enoptrbss uint64 + End uint64 + Gcdata uint64 + Gcbss uint64 + Types uint64 + Etypes uint64 + Textsectmap, Textsectmaplen, Textsectmapcap uint64 + Typelinks, Typelinkslen, Typelinkscap uint64 + Itablinks, Itablinkslen, Itablinkscap uint64 + Ptab, Ptablen, Ptabcap uint64 + Pluginpath, Pluginpathlen uint64 + Pkghashes, Pkghasheslen, Pkghashescap uint64 } func (md moduledata_1_16_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.text, - TextLen: md.etext - md.text, - NoPtrDataAddr: md.noptrdata, - NoPtrDataLen: md.enoptrdata - md.noptrdata, - DataAddr: md.data, - DataLen: md.edata - md.data, - BssAddr: md.bss, - BssLen: md.ebss - md.bss, - NoPtrBssAddr: md.noptrbss, - NoPtrBssLen: md.enoptrbss - md.noptrbss, - TypesAddr: md.types, - TypesLen: md.etypes - md.types, - TypelinkAddr: md.typelinks, - TypelinkLen: md.typelinkslen, - ITabLinkAddr: md.itablinks, - ITabLinkLen: md.itablinkslen, - FuncTabAddr: md.ftab, - FuncTabLen: md.ftablen, - PCLNTabAddr: md.pclntable, - PCLNTabLen: md.pclntablelen, + TextAddr: md.Text, + TextLen: md.Etext - md.Text, + NoPtrDataAddr: md.Noptrdata, + NoPtrDataLen: md.Enoptrdata - md.Noptrdata, + DataAddr: md.Data, + DataLen: md.Edata - md.Data, + BssAddr: md.Bss, + BssLen: md.Ebss - md.Bss, + NoPtrBssAddr: md.Noptrbss, + NoPtrBssLen: md.Enoptrbss - md.Noptrbss, + TypesAddr: md.Types, + TypesLen: md.Etypes - md.Types, + TypelinkAddr: md.Typelinks, + TypelinkLen: md.Typelinkslen, + ITabLinkAddr: md.Itablinks, + ITabLinkLen: md.Itablinkslen, + FuncTabAddr: md.Ftab, + FuncTabLen: md.Ftablen, + PCLNTabAddr: md.Pclntable, + PCLNTabLen: md.Pclntablelen, } } type moduledata_1_15_32 struct { - pclntable, pclntablelen, pclntablecap uint32 - ftab, ftablen, ftabcap uint32 - filetab, filetablen, filetabcap uint32 - findfunctab uint32 - minpc uint32 - maxpc uint32 - text uint32 - etext uint32 - noptrdata uint32 - enoptrdata uint32 - data uint32 - edata uint32 - bss uint32 - ebss uint32 - noptrbss uint32 - enoptrbss uint32 - end uint32 - gcdata uint32 - gcbss uint32 - types uint32 - etypes uint32 - textsectmap, textsectmaplen, textsectmapcap uint32 - typelinks, typelinkslen, typelinkscap uint32 - itablinks, itablinkslen, itablinkscap uint32 - ptab, ptablen, ptabcap uint32 - pluginpath, pluginpathlen uint32 - pkghashes, pkghasheslen, pkghashescap uint32 + Pclntable, Pclntablelen, Pclntablecap uint32 + Ftab, Ftablen, Ftabcap uint32 + Filetab, Filetablen, Filetabcap uint32 + Findfunctab uint32 + Minpc uint32 + Maxpc uint32 + Text uint32 + Etext uint32 + Noptrdata uint32 + Enoptrdata uint32 + Data uint32 + Edata uint32 + Bss uint32 + Ebss uint32 + Noptrbss uint32 + Enoptrbss uint32 + End uint32 + Gcdata uint32 + Gcbss uint32 + Types uint32 + Etypes uint32 + Textsectmap, Textsectmaplen, Textsectmapcap uint32 + Typelinks, Typelinkslen, Typelinkscap uint32 + Itablinks, Itablinkslen, Itablinkscap uint32 + Ptab, Ptablen, Ptabcap uint32 + Pluginpath, Pluginpathlen uint32 + Pkghashes, Pkghasheslen, Pkghashescap uint32 } func (md moduledata_1_15_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.text), - TextLen: uint64(md.etext - md.text), - NoPtrDataAddr: uint64(md.noptrdata), - NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), - DataAddr: uint64(md.data), - DataLen: uint64(md.edata - md.data), - BssAddr: uint64(md.bss), - BssLen: uint64(md.ebss - md.bss), - NoPtrBssAddr: uint64(md.noptrbss), - NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), - TypesAddr: uint64(md.types), - TypesLen: uint64(md.etypes - md.types), - TypelinkAddr: uint64(md.typelinks), - TypelinkLen: uint64(md.typelinkslen), - ITabLinkAddr: uint64(md.itablinks), - ITabLinkLen: uint64(md.itablinkslen), - FuncTabAddr: uint64(md.ftab), - FuncTabLen: uint64(md.ftablen), - PCLNTabAddr: uint64(md.pclntable), - PCLNTabLen: uint64(md.pclntablelen), + TextAddr: uint64(md.Text), + TextLen: uint64(md.Etext - md.Text), + NoPtrDataAddr: uint64(md.Noptrdata), + NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), + DataAddr: uint64(md.Data), + DataLen: uint64(md.Edata - md.Data), + BssAddr: uint64(md.Bss), + BssLen: uint64(md.Ebss - md.Bss), + NoPtrBssAddr: uint64(md.Noptrbss), + NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), + TypesAddr: uint64(md.Types), + TypesLen: uint64(md.Etypes - md.Types), + TypelinkAddr: uint64(md.Typelinks), + TypelinkLen: uint64(md.Typelinkslen), + ITabLinkAddr: uint64(md.Itablinks), + ITabLinkLen: uint64(md.Itablinkslen), + FuncTabAddr: uint64(md.Ftab), + FuncTabLen: uint64(md.Ftablen), + PCLNTabAddr: uint64(md.Pclntable), + PCLNTabLen: uint64(md.Pclntablelen), } } type moduledata_1_15_64 struct { - pclntable, pclntablelen, pclntablecap uint64 - ftab, ftablen, ftabcap uint64 - filetab, filetablen, filetabcap uint64 - findfunctab uint64 - minpc uint64 - maxpc uint64 - text uint64 - etext uint64 - noptrdata uint64 - enoptrdata uint64 - data uint64 - edata uint64 - bss uint64 - ebss uint64 - noptrbss uint64 - enoptrbss uint64 - end uint64 - gcdata uint64 - gcbss uint64 - types uint64 - etypes uint64 - textsectmap, textsectmaplen, textsectmapcap uint64 - typelinks, typelinkslen, typelinkscap uint64 - itablinks, itablinkslen, itablinkscap uint64 - ptab, ptablen, ptabcap uint64 - pluginpath, pluginpathlen uint64 - pkghashes, pkghasheslen, pkghashescap uint64 + Pclntable, Pclntablelen, Pclntablecap uint64 + Ftab, Ftablen, Ftabcap uint64 + Filetab, Filetablen, Filetabcap uint64 + Findfunctab uint64 + Minpc uint64 + Maxpc uint64 + Text uint64 + Etext uint64 + Noptrdata uint64 + Enoptrdata uint64 + Data uint64 + Edata uint64 + Bss uint64 + Ebss uint64 + Noptrbss uint64 + Enoptrbss uint64 + End uint64 + Gcdata uint64 + Gcbss uint64 + Types uint64 + Etypes uint64 + Textsectmap, Textsectmaplen, Textsectmapcap uint64 + Typelinks, Typelinkslen, Typelinkscap uint64 + Itablinks, Itablinkslen, Itablinkscap uint64 + Ptab, Ptablen, Ptabcap uint64 + Pluginpath, Pluginpathlen uint64 + Pkghashes, Pkghasheslen, Pkghashescap uint64 } func (md moduledata_1_15_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.text, - TextLen: md.etext - md.text, - NoPtrDataAddr: md.noptrdata, - NoPtrDataLen: md.enoptrdata - md.noptrdata, - DataAddr: md.data, - DataLen: md.edata - md.data, - BssAddr: md.bss, - BssLen: md.ebss - md.bss, - NoPtrBssAddr: md.noptrbss, - NoPtrBssLen: md.enoptrbss - md.noptrbss, - TypesAddr: md.types, - TypesLen: md.etypes - md.types, - TypelinkAddr: md.typelinks, - TypelinkLen: md.typelinkslen, - ITabLinkAddr: md.itablinks, - ITabLinkLen: md.itablinkslen, - FuncTabAddr: md.ftab, - FuncTabLen: md.ftablen, - PCLNTabAddr: md.pclntable, - PCLNTabLen: md.pclntablelen, + TextAddr: md.Text, + TextLen: md.Etext - md.Text, + NoPtrDataAddr: md.Noptrdata, + NoPtrDataLen: md.Enoptrdata - md.Noptrdata, + DataAddr: md.Data, + DataLen: md.Edata - md.Data, + BssAddr: md.Bss, + BssLen: md.Ebss - md.Bss, + NoPtrBssAddr: md.Noptrbss, + NoPtrBssLen: md.Enoptrbss - md.Noptrbss, + TypesAddr: md.Types, + TypesLen: md.Etypes - md.Types, + TypelinkAddr: md.Typelinks, + TypelinkLen: md.Typelinkslen, + ITabLinkAddr: md.Itablinks, + ITabLinkLen: md.Itablinkslen, + FuncTabAddr: md.Ftab, + FuncTabLen: md.Ftablen, + PCLNTabAddr: md.Pclntable, + PCLNTabLen: md.Pclntablelen, } } type moduledata_1_14_32 struct { - pclntable, pclntablelen, pclntablecap uint32 - ftab, ftablen, ftabcap uint32 - filetab, filetablen, filetabcap uint32 - findfunctab uint32 - minpc uint32 - maxpc uint32 - text uint32 - etext uint32 - noptrdata uint32 - enoptrdata uint32 - data uint32 - edata uint32 - bss uint32 - ebss uint32 - noptrbss uint32 - enoptrbss uint32 - end uint32 - gcdata uint32 - gcbss uint32 - types uint32 - etypes uint32 - textsectmap, textsectmaplen, textsectmapcap uint32 - typelinks, typelinkslen, typelinkscap uint32 - itablinks, itablinkslen, itablinkscap uint32 - ptab, ptablen, ptabcap uint32 - pluginpath, pluginpathlen uint32 - pkghashes, pkghasheslen, pkghashescap uint32 + Pclntable, Pclntablelen, Pclntablecap uint32 + Ftab, Ftablen, Ftabcap uint32 + Filetab, Filetablen, Filetabcap uint32 + Findfunctab uint32 + Minpc uint32 + Maxpc uint32 + Text uint32 + Etext uint32 + Noptrdata uint32 + Enoptrdata uint32 + Data uint32 + Edata uint32 + Bss uint32 + Ebss uint32 + Noptrbss uint32 + Enoptrbss uint32 + End uint32 + Gcdata uint32 + Gcbss uint32 + Types uint32 + Etypes uint32 + Textsectmap, Textsectmaplen, Textsectmapcap uint32 + Typelinks, Typelinkslen, Typelinkscap uint32 + Itablinks, Itablinkslen, Itablinkscap uint32 + Ptab, Ptablen, Ptabcap uint32 + Pluginpath, Pluginpathlen uint32 + Pkghashes, Pkghasheslen, Pkghashescap uint32 } func (md moduledata_1_14_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.text), - TextLen: uint64(md.etext - md.text), - NoPtrDataAddr: uint64(md.noptrdata), - NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), - DataAddr: uint64(md.data), - DataLen: uint64(md.edata - md.data), - BssAddr: uint64(md.bss), - BssLen: uint64(md.ebss - md.bss), - NoPtrBssAddr: uint64(md.noptrbss), - NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), - TypesAddr: uint64(md.types), - TypesLen: uint64(md.etypes - md.types), - TypelinkAddr: uint64(md.typelinks), - TypelinkLen: uint64(md.typelinkslen), - ITabLinkAddr: uint64(md.itablinks), - ITabLinkLen: uint64(md.itablinkslen), - FuncTabAddr: uint64(md.ftab), - FuncTabLen: uint64(md.ftablen), - PCLNTabAddr: uint64(md.pclntable), - PCLNTabLen: uint64(md.pclntablelen), + TextAddr: uint64(md.Text), + TextLen: uint64(md.Etext - md.Text), + NoPtrDataAddr: uint64(md.Noptrdata), + NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), + DataAddr: uint64(md.Data), + DataLen: uint64(md.Edata - md.Data), + BssAddr: uint64(md.Bss), + BssLen: uint64(md.Ebss - md.Bss), + NoPtrBssAddr: uint64(md.Noptrbss), + NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), + TypesAddr: uint64(md.Types), + TypesLen: uint64(md.Etypes - md.Types), + TypelinkAddr: uint64(md.Typelinks), + TypelinkLen: uint64(md.Typelinkslen), + ITabLinkAddr: uint64(md.Itablinks), + ITabLinkLen: uint64(md.Itablinkslen), + FuncTabAddr: uint64(md.Ftab), + FuncTabLen: uint64(md.Ftablen), + PCLNTabAddr: uint64(md.Pclntable), + PCLNTabLen: uint64(md.Pclntablelen), } } type moduledata_1_14_64 struct { - pclntable, pclntablelen, pclntablecap uint64 - ftab, ftablen, ftabcap uint64 - filetab, filetablen, filetabcap uint64 - findfunctab uint64 - minpc uint64 - maxpc uint64 - text uint64 - etext uint64 - noptrdata uint64 - enoptrdata uint64 - data uint64 - edata uint64 - bss uint64 - ebss uint64 - noptrbss uint64 - enoptrbss uint64 - end uint64 - gcdata uint64 - gcbss uint64 - types uint64 - etypes uint64 - textsectmap, textsectmaplen, textsectmapcap uint64 - typelinks, typelinkslen, typelinkscap uint64 - itablinks, itablinkslen, itablinkscap uint64 - ptab, ptablen, ptabcap uint64 - pluginpath, pluginpathlen uint64 - pkghashes, pkghasheslen, pkghashescap uint64 + Pclntable, Pclntablelen, Pclntablecap uint64 + Ftab, Ftablen, Ftabcap uint64 + Filetab, Filetablen, Filetabcap uint64 + Findfunctab uint64 + Minpc uint64 + Maxpc uint64 + Text uint64 + Etext uint64 + Noptrdata uint64 + Enoptrdata uint64 + Data uint64 + Edata uint64 + Bss uint64 + Ebss uint64 + Noptrbss uint64 + Enoptrbss uint64 + End uint64 + Gcdata uint64 + Gcbss uint64 + Types uint64 + Etypes uint64 + Textsectmap, Textsectmaplen, Textsectmapcap uint64 + Typelinks, Typelinkslen, Typelinkscap uint64 + Itablinks, Itablinkslen, Itablinkscap uint64 + Ptab, Ptablen, Ptabcap uint64 + Pluginpath, Pluginpathlen uint64 + Pkghashes, Pkghasheslen, Pkghashescap uint64 } func (md moduledata_1_14_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.text, - TextLen: md.etext - md.text, - NoPtrDataAddr: md.noptrdata, - NoPtrDataLen: md.enoptrdata - md.noptrdata, - DataAddr: md.data, - DataLen: md.edata - md.data, - BssAddr: md.bss, - BssLen: md.ebss - md.bss, - NoPtrBssAddr: md.noptrbss, - NoPtrBssLen: md.enoptrbss - md.noptrbss, - TypesAddr: md.types, - TypesLen: md.etypes - md.types, - TypelinkAddr: md.typelinks, - TypelinkLen: md.typelinkslen, - ITabLinkAddr: md.itablinks, - ITabLinkLen: md.itablinkslen, - FuncTabAddr: md.ftab, - FuncTabLen: md.ftablen, - PCLNTabAddr: md.pclntable, - PCLNTabLen: md.pclntablelen, + TextAddr: md.Text, + TextLen: md.Etext - md.Text, + NoPtrDataAddr: md.Noptrdata, + NoPtrDataLen: md.Enoptrdata - md.Noptrdata, + DataAddr: md.Data, + DataLen: md.Edata - md.Data, + BssAddr: md.Bss, + BssLen: md.Ebss - md.Bss, + NoPtrBssAddr: md.Noptrbss, + NoPtrBssLen: md.Enoptrbss - md.Noptrbss, + TypesAddr: md.Types, + TypesLen: md.Etypes - md.Types, + TypelinkAddr: md.Typelinks, + TypelinkLen: md.Typelinkslen, + ITabLinkAddr: md.Itablinks, + ITabLinkLen: md.Itablinkslen, + FuncTabAddr: md.Ftab, + FuncTabLen: md.Ftablen, + PCLNTabAddr: md.Pclntable, + PCLNTabLen: md.Pclntablelen, } } type moduledata_1_13_32 struct { - pclntable, pclntablelen, pclntablecap uint32 - ftab, ftablen, ftabcap uint32 - filetab, filetablen, filetabcap uint32 - findfunctab uint32 - minpc uint32 - maxpc uint32 - text uint32 - etext uint32 - noptrdata uint32 - enoptrdata uint32 - data uint32 - edata uint32 - bss uint32 - ebss uint32 - noptrbss uint32 - enoptrbss uint32 - end uint32 - gcdata uint32 - gcbss uint32 - types uint32 - etypes uint32 - textsectmap, textsectmaplen, textsectmapcap uint32 - typelinks, typelinkslen, typelinkscap uint32 - itablinks, itablinkslen, itablinkscap uint32 - ptab, ptablen, ptabcap uint32 - pluginpath, pluginpathlen uint32 - pkghashes, pkghasheslen, pkghashescap uint32 + Pclntable, Pclntablelen, Pclntablecap uint32 + Ftab, Ftablen, Ftabcap uint32 + Filetab, Filetablen, Filetabcap uint32 + Findfunctab uint32 + Minpc uint32 + Maxpc uint32 + Text uint32 + Etext uint32 + Noptrdata uint32 + Enoptrdata uint32 + Data uint32 + Edata uint32 + Bss uint32 + Ebss uint32 + Noptrbss uint32 + Enoptrbss uint32 + End uint32 + Gcdata uint32 + Gcbss uint32 + Types uint32 + Etypes uint32 + Textsectmap, Textsectmaplen, Textsectmapcap uint32 + Typelinks, Typelinkslen, Typelinkscap uint32 + Itablinks, Itablinkslen, Itablinkscap uint32 + Ptab, Ptablen, Ptabcap uint32 + Pluginpath, Pluginpathlen uint32 + Pkghashes, Pkghasheslen, Pkghashescap uint32 } func (md moduledata_1_13_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.text), - TextLen: uint64(md.etext - md.text), - NoPtrDataAddr: uint64(md.noptrdata), - NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), - DataAddr: uint64(md.data), - DataLen: uint64(md.edata - md.data), - BssAddr: uint64(md.bss), - BssLen: uint64(md.ebss - md.bss), - NoPtrBssAddr: uint64(md.noptrbss), - NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), - TypesAddr: uint64(md.types), - TypesLen: uint64(md.etypes - md.types), - TypelinkAddr: uint64(md.typelinks), - TypelinkLen: uint64(md.typelinkslen), - ITabLinkAddr: uint64(md.itablinks), - ITabLinkLen: uint64(md.itablinkslen), - FuncTabAddr: uint64(md.ftab), - FuncTabLen: uint64(md.ftablen), - PCLNTabAddr: uint64(md.pclntable), - PCLNTabLen: uint64(md.pclntablelen), + TextAddr: uint64(md.Text), + TextLen: uint64(md.Etext - md.Text), + NoPtrDataAddr: uint64(md.Noptrdata), + NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), + DataAddr: uint64(md.Data), + DataLen: uint64(md.Edata - md.Data), + BssAddr: uint64(md.Bss), + BssLen: uint64(md.Ebss - md.Bss), + NoPtrBssAddr: uint64(md.Noptrbss), + NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), + TypesAddr: uint64(md.Types), + TypesLen: uint64(md.Etypes - md.Types), + TypelinkAddr: uint64(md.Typelinks), + TypelinkLen: uint64(md.Typelinkslen), + ITabLinkAddr: uint64(md.Itablinks), + ITabLinkLen: uint64(md.Itablinkslen), + FuncTabAddr: uint64(md.Ftab), + FuncTabLen: uint64(md.Ftablen), + PCLNTabAddr: uint64(md.Pclntable), + PCLNTabLen: uint64(md.Pclntablelen), } } type moduledata_1_13_64 struct { - pclntable, pclntablelen, pclntablecap uint64 - ftab, ftablen, ftabcap uint64 - filetab, filetablen, filetabcap uint64 - findfunctab uint64 - minpc uint64 - maxpc uint64 - text uint64 - etext uint64 - noptrdata uint64 - enoptrdata uint64 - data uint64 - edata uint64 - bss uint64 - ebss uint64 - noptrbss uint64 - enoptrbss uint64 - end uint64 - gcdata uint64 - gcbss uint64 - types uint64 - etypes uint64 - textsectmap, textsectmaplen, textsectmapcap uint64 - typelinks, typelinkslen, typelinkscap uint64 - itablinks, itablinkslen, itablinkscap uint64 - ptab, ptablen, ptabcap uint64 - pluginpath, pluginpathlen uint64 - pkghashes, pkghasheslen, pkghashescap uint64 + Pclntable, Pclntablelen, Pclntablecap uint64 + Ftab, Ftablen, Ftabcap uint64 + Filetab, Filetablen, Filetabcap uint64 + Findfunctab uint64 + Minpc uint64 + Maxpc uint64 + Text uint64 + Etext uint64 + Noptrdata uint64 + Enoptrdata uint64 + Data uint64 + Edata uint64 + Bss uint64 + Ebss uint64 + Noptrbss uint64 + Enoptrbss uint64 + End uint64 + Gcdata uint64 + Gcbss uint64 + Types uint64 + Etypes uint64 + Textsectmap, Textsectmaplen, Textsectmapcap uint64 + Typelinks, Typelinkslen, Typelinkscap uint64 + Itablinks, Itablinkslen, Itablinkscap uint64 + Ptab, Ptablen, Ptabcap uint64 + Pluginpath, Pluginpathlen uint64 + Pkghashes, Pkghasheslen, Pkghashescap uint64 } func (md moduledata_1_13_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.text, - TextLen: md.etext - md.text, - NoPtrDataAddr: md.noptrdata, - NoPtrDataLen: md.enoptrdata - md.noptrdata, - DataAddr: md.data, - DataLen: md.edata - md.data, - BssAddr: md.bss, - BssLen: md.ebss - md.bss, - NoPtrBssAddr: md.noptrbss, - NoPtrBssLen: md.enoptrbss - md.noptrbss, - TypesAddr: md.types, - TypesLen: md.etypes - md.types, - TypelinkAddr: md.typelinks, - TypelinkLen: md.typelinkslen, - ITabLinkAddr: md.itablinks, - ITabLinkLen: md.itablinkslen, - FuncTabAddr: md.ftab, - FuncTabLen: md.ftablen, - PCLNTabAddr: md.pclntable, - PCLNTabLen: md.pclntablelen, + TextAddr: md.Text, + TextLen: md.Etext - md.Text, + NoPtrDataAddr: md.Noptrdata, + NoPtrDataLen: md.Enoptrdata - md.Noptrdata, + DataAddr: md.Data, + DataLen: md.Edata - md.Data, + BssAddr: md.Bss, + BssLen: md.Ebss - md.Bss, + NoPtrBssAddr: md.Noptrbss, + NoPtrBssLen: md.Enoptrbss - md.Noptrbss, + TypesAddr: md.Types, + TypesLen: md.Etypes - md.Types, + TypelinkAddr: md.Typelinks, + TypelinkLen: md.Typelinkslen, + ITabLinkAddr: md.Itablinks, + ITabLinkLen: md.Itablinkslen, + FuncTabAddr: md.Ftab, + FuncTabLen: md.Ftablen, + PCLNTabAddr: md.Pclntable, + PCLNTabLen: md.Pclntablelen, } } type moduledata_1_12_32 struct { - pclntable, pclntablelen, pclntablecap uint32 - ftab, ftablen, ftabcap uint32 - filetab, filetablen, filetabcap uint32 - findfunctab uint32 - minpc uint32 - maxpc uint32 - text uint32 - etext uint32 - noptrdata uint32 - enoptrdata uint32 - data uint32 - edata uint32 - bss uint32 - ebss uint32 - noptrbss uint32 - enoptrbss uint32 - end uint32 - gcdata uint32 - gcbss uint32 - types uint32 - etypes uint32 - textsectmap, textsectmaplen, textsectmapcap uint32 - typelinks, typelinkslen, typelinkscap uint32 - itablinks, itablinkslen, itablinkscap uint32 - ptab, ptablen, ptabcap uint32 - pluginpath, pluginpathlen uint32 - pkghashes, pkghasheslen, pkghashescap uint32 + Pclntable, Pclntablelen, Pclntablecap uint32 + Ftab, Ftablen, Ftabcap uint32 + Filetab, Filetablen, Filetabcap uint32 + Findfunctab uint32 + Minpc uint32 + Maxpc uint32 + Text uint32 + Etext uint32 + Noptrdata uint32 + Enoptrdata uint32 + Data uint32 + Edata uint32 + Bss uint32 + Ebss uint32 + Noptrbss uint32 + Enoptrbss uint32 + End uint32 + Gcdata uint32 + Gcbss uint32 + Types uint32 + Etypes uint32 + Textsectmap, Textsectmaplen, Textsectmapcap uint32 + Typelinks, Typelinkslen, Typelinkscap uint32 + Itablinks, Itablinkslen, Itablinkscap uint32 + Ptab, Ptablen, Ptabcap uint32 + Pluginpath, Pluginpathlen uint32 + Pkghashes, Pkghasheslen, Pkghashescap uint32 } func (md moduledata_1_12_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.text), - TextLen: uint64(md.etext - md.text), - NoPtrDataAddr: uint64(md.noptrdata), - NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), - DataAddr: uint64(md.data), - DataLen: uint64(md.edata - md.data), - BssAddr: uint64(md.bss), - BssLen: uint64(md.ebss - md.bss), - NoPtrBssAddr: uint64(md.noptrbss), - NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), - TypesAddr: uint64(md.types), - TypesLen: uint64(md.etypes - md.types), - TypelinkAddr: uint64(md.typelinks), - TypelinkLen: uint64(md.typelinkslen), - ITabLinkAddr: uint64(md.itablinks), - ITabLinkLen: uint64(md.itablinkslen), - FuncTabAddr: uint64(md.ftab), - FuncTabLen: uint64(md.ftablen), - PCLNTabAddr: uint64(md.pclntable), - PCLNTabLen: uint64(md.pclntablelen), + TextAddr: uint64(md.Text), + TextLen: uint64(md.Etext - md.Text), + NoPtrDataAddr: uint64(md.Noptrdata), + NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), + DataAddr: uint64(md.Data), + DataLen: uint64(md.Edata - md.Data), + BssAddr: uint64(md.Bss), + BssLen: uint64(md.Ebss - md.Bss), + NoPtrBssAddr: uint64(md.Noptrbss), + NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), + TypesAddr: uint64(md.Types), + TypesLen: uint64(md.Etypes - md.Types), + TypelinkAddr: uint64(md.Typelinks), + TypelinkLen: uint64(md.Typelinkslen), + ITabLinkAddr: uint64(md.Itablinks), + ITabLinkLen: uint64(md.Itablinkslen), + FuncTabAddr: uint64(md.Ftab), + FuncTabLen: uint64(md.Ftablen), + PCLNTabAddr: uint64(md.Pclntable), + PCLNTabLen: uint64(md.Pclntablelen), } } type moduledata_1_12_64 struct { - pclntable, pclntablelen, pclntablecap uint64 - ftab, ftablen, ftabcap uint64 - filetab, filetablen, filetabcap uint64 - findfunctab uint64 - minpc uint64 - maxpc uint64 - text uint64 - etext uint64 - noptrdata uint64 - enoptrdata uint64 - data uint64 - edata uint64 - bss uint64 - ebss uint64 - noptrbss uint64 - enoptrbss uint64 - end uint64 - gcdata uint64 - gcbss uint64 - types uint64 - etypes uint64 - textsectmap, textsectmaplen, textsectmapcap uint64 - typelinks, typelinkslen, typelinkscap uint64 - itablinks, itablinkslen, itablinkscap uint64 - ptab, ptablen, ptabcap uint64 - pluginpath, pluginpathlen uint64 - pkghashes, pkghasheslen, pkghashescap uint64 + Pclntable, Pclntablelen, Pclntablecap uint64 + Ftab, Ftablen, Ftabcap uint64 + Filetab, Filetablen, Filetabcap uint64 + Findfunctab uint64 + Minpc uint64 + Maxpc uint64 + Text uint64 + Etext uint64 + Noptrdata uint64 + Enoptrdata uint64 + Data uint64 + Edata uint64 + Bss uint64 + Ebss uint64 + Noptrbss uint64 + Enoptrbss uint64 + End uint64 + Gcdata uint64 + Gcbss uint64 + Types uint64 + Etypes uint64 + Textsectmap, Textsectmaplen, Textsectmapcap uint64 + Typelinks, Typelinkslen, Typelinkscap uint64 + Itablinks, Itablinkslen, Itablinkscap uint64 + Ptab, Ptablen, Ptabcap uint64 + Pluginpath, Pluginpathlen uint64 + Pkghashes, Pkghasheslen, Pkghashescap uint64 } func (md moduledata_1_12_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.text, - TextLen: md.etext - md.text, - NoPtrDataAddr: md.noptrdata, - NoPtrDataLen: md.enoptrdata - md.noptrdata, - DataAddr: md.data, - DataLen: md.edata - md.data, - BssAddr: md.bss, - BssLen: md.ebss - md.bss, - NoPtrBssAddr: md.noptrbss, - NoPtrBssLen: md.enoptrbss - md.noptrbss, - TypesAddr: md.types, - TypesLen: md.etypes - md.types, - TypelinkAddr: md.typelinks, - TypelinkLen: md.typelinkslen, - ITabLinkAddr: md.itablinks, - ITabLinkLen: md.itablinkslen, - FuncTabAddr: md.ftab, - FuncTabLen: md.ftablen, - PCLNTabAddr: md.pclntable, - PCLNTabLen: md.pclntablelen, + TextAddr: md.Text, + TextLen: md.Etext - md.Text, + NoPtrDataAddr: md.Noptrdata, + NoPtrDataLen: md.Enoptrdata - md.Noptrdata, + DataAddr: md.Data, + DataLen: md.Edata - md.Data, + BssAddr: md.Bss, + BssLen: md.Ebss - md.Bss, + NoPtrBssAddr: md.Noptrbss, + NoPtrBssLen: md.Enoptrbss - md.Noptrbss, + TypesAddr: md.Types, + TypesLen: md.Etypes - md.Types, + TypelinkAddr: md.Typelinks, + TypelinkLen: md.Typelinkslen, + ITabLinkAddr: md.Itablinks, + ITabLinkLen: md.Itablinkslen, + FuncTabAddr: md.Ftab, + FuncTabLen: md.Ftablen, + PCLNTabAddr: md.Pclntable, + PCLNTabLen: md.Pclntablelen, } } type moduledata_1_11_32 struct { - pclntable, pclntablelen, pclntablecap uint32 - ftab, ftablen, ftabcap uint32 - filetab, filetablen, filetabcap uint32 - findfunctab uint32 - minpc uint32 - maxpc uint32 - text uint32 - etext uint32 - noptrdata uint32 - enoptrdata uint32 - data uint32 - edata uint32 - bss uint32 - ebss uint32 - noptrbss uint32 - enoptrbss uint32 - end uint32 - gcdata uint32 - gcbss uint32 - types uint32 - etypes uint32 - textsectmap, textsectmaplen, textsectmapcap uint32 - typelinks, typelinkslen, typelinkscap uint32 - itablinks, itablinkslen, itablinkscap uint32 - ptab, ptablen, ptabcap uint32 - pluginpath, pluginpathlen uint32 - pkghashes, pkghasheslen, pkghashescap uint32 + Pclntable, Pclntablelen, Pclntablecap uint32 + Ftab, Ftablen, Ftabcap uint32 + Filetab, Filetablen, Filetabcap uint32 + Findfunctab uint32 + Minpc uint32 + Maxpc uint32 + Text uint32 + Etext uint32 + Noptrdata uint32 + Enoptrdata uint32 + Data uint32 + Edata uint32 + Bss uint32 + Ebss uint32 + Noptrbss uint32 + Enoptrbss uint32 + End uint32 + Gcdata uint32 + Gcbss uint32 + Types uint32 + Etypes uint32 + Textsectmap, Textsectmaplen, Textsectmapcap uint32 + Typelinks, Typelinkslen, Typelinkscap uint32 + Itablinks, Itablinkslen, Itablinkscap uint32 + Ptab, Ptablen, Ptabcap uint32 + Pluginpath, Pluginpathlen uint32 + Pkghashes, Pkghasheslen, Pkghashescap uint32 } func (md moduledata_1_11_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.text), - TextLen: uint64(md.etext - md.text), - NoPtrDataAddr: uint64(md.noptrdata), - NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), - DataAddr: uint64(md.data), - DataLen: uint64(md.edata - md.data), - BssAddr: uint64(md.bss), - BssLen: uint64(md.ebss - md.bss), - NoPtrBssAddr: uint64(md.noptrbss), - NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), - TypesAddr: uint64(md.types), - TypesLen: uint64(md.etypes - md.types), - TypelinkAddr: uint64(md.typelinks), - TypelinkLen: uint64(md.typelinkslen), - ITabLinkAddr: uint64(md.itablinks), - ITabLinkLen: uint64(md.itablinkslen), - FuncTabAddr: uint64(md.ftab), - FuncTabLen: uint64(md.ftablen), - PCLNTabAddr: uint64(md.pclntable), - PCLNTabLen: uint64(md.pclntablelen), + TextAddr: uint64(md.Text), + TextLen: uint64(md.Etext - md.Text), + NoPtrDataAddr: uint64(md.Noptrdata), + NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), + DataAddr: uint64(md.Data), + DataLen: uint64(md.Edata - md.Data), + BssAddr: uint64(md.Bss), + BssLen: uint64(md.Ebss - md.Bss), + NoPtrBssAddr: uint64(md.Noptrbss), + NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), + TypesAddr: uint64(md.Types), + TypesLen: uint64(md.Etypes - md.Types), + TypelinkAddr: uint64(md.Typelinks), + TypelinkLen: uint64(md.Typelinkslen), + ITabLinkAddr: uint64(md.Itablinks), + ITabLinkLen: uint64(md.Itablinkslen), + FuncTabAddr: uint64(md.Ftab), + FuncTabLen: uint64(md.Ftablen), + PCLNTabAddr: uint64(md.Pclntable), + PCLNTabLen: uint64(md.Pclntablelen), } } type moduledata_1_11_64 struct { - pclntable, pclntablelen, pclntablecap uint64 - ftab, ftablen, ftabcap uint64 - filetab, filetablen, filetabcap uint64 - findfunctab uint64 - minpc uint64 - maxpc uint64 - text uint64 - etext uint64 - noptrdata uint64 - enoptrdata uint64 - data uint64 - edata uint64 - bss uint64 - ebss uint64 - noptrbss uint64 - enoptrbss uint64 - end uint64 - gcdata uint64 - gcbss uint64 - types uint64 - etypes uint64 - textsectmap, textsectmaplen, textsectmapcap uint64 - typelinks, typelinkslen, typelinkscap uint64 - itablinks, itablinkslen, itablinkscap uint64 - ptab, ptablen, ptabcap uint64 - pluginpath, pluginpathlen uint64 - pkghashes, pkghasheslen, pkghashescap uint64 + Pclntable, Pclntablelen, Pclntablecap uint64 + Ftab, Ftablen, Ftabcap uint64 + Filetab, Filetablen, Filetabcap uint64 + Findfunctab uint64 + Minpc uint64 + Maxpc uint64 + Text uint64 + Etext uint64 + Noptrdata uint64 + Enoptrdata uint64 + Data uint64 + Edata uint64 + Bss uint64 + Ebss uint64 + Noptrbss uint64 + Enoptrbss uint64 + End uint64 + Gcdata uint64 + Gcbss uint64 + Types uint64 + Etypes uint64 + Textsectmap, Textsectmaplen, Textsectmapcap uint64 + Typelinks, Typelinkslen, Typelinkscap uint64 + Itablinks, Itablinkslen, Itablinkscap uint64 + Ptab, Ptablen, Ptabcap uint64 + Pluginpath, Pluginpathlen uint64 + Pkghashes, Pkghasheslen, Pkghashescap uint64 } func (md moduledata_1_11_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.text, - TextLen: md.etext - md.text, - NoPtrDataAddr: md.noptrdata, - NoPtrDataLen: md.enoptrdata - md.noptrdata, - DataAddr: md.data, - DataLen: md.edata - md.data, - BssAddr: md.bss, - BssLen: md.ebss - md.bss, - NoPtrBssAddr: md.noptrbss, - NoPtrBssLen: md.enoptrbss - md.noptrbss, - TypesAddr: md.types, - TypesLen: md.etypes - md.types, - TypelinkAddr: md.typelinks, - TypelinkLen: md.typelinkslen, - ITabLinkAddr: md.itablinks, - ITabLinkLen: md.itablinkslen, - FuncTabAddr: md.ftab, - FuncTabLen: md.ftablen, - PCLNTabAddr: md.pclntable, - PCLNTabLen: md.pclntablelen, + TextAddr: md.Text, + TextLen: md.Etext - md.Text, + NoPtrDataAddr: md.Noptrdata, + NoPtrDataLen: md.Enoptrdata - md.Noptrdata, + DataAddr: md.Data, + DataLen: md.Edata - md.Data, + BssAddr: md.Bss, + BssLen: md.Ebss - md.Bss, + NoPtrBssAddr: md.Noptrbss, + NoPtrBssLen: md.Enoptrbss - md.Noptrbss, + TypesAddr: md.Types, + TypesLen: md.Etypes - md.Types, + TypelinkAddr: md.Typelinks, + TypelinkLen: md.Typelinkslen, + ITabLinkAddr: md.Itablinks, + ITabLinkLen: md.Itablinkslen, + FuncTabAddr: md.Ftab, + FuncTabLen: md.Ftablen, + PCLNTabAddr: md.Pclntable, + PCLNTabLen: md.Pclntablelen, } } type moduledata_1_10_32 struct { - pclntable, pclntablelen, pclntablecap uint32 - ftab, ftablen, ftabcap uint32 - filetab, filetablen, filetabcap uint32 - findfunctab uint32 - minpc uint32 - maxpc uint32 - text uint32 - etext uint32 - noptrdata uint32 - enoptrdata uint32 - data uint32 - edata uint32 - bss uint32 - ebss uint32 - noptrbss uint32 - enoptrbss uint32 - end uint32 - gcdata uint32 - gcbss uint32 - types uint32 - etypes uint32 - textsectmap, textsectmaplen, textsectmapcap uint32 - typelinks, typelinkslen, typelinkscap uint32 - itablinks, itablinkslen, itablinkscap uint32 - ptab, ptablen, ptabcap uint32 - pluginpath, pluginpathlen uint32 - pkghashes, pkghasheslen, pkghashescap uint32 + Pclntable, Pclntablelen, Pclntablecap uint32 + Ftab, Ftablen, Ftabcap uint32 + Filetab, Filetablen, Filetabcap uint32 + Findfunctab uint32 + Minpc uint32 + Maxpc uint32 + Text uint32 + Etext uint32 + Noptrdata uint32 + Enoptrdata uint32 + Data uint32 + Edata uint32 + Bss uint32 + Ebss uint32 + Noptrbss uint32 + Enoptrbss uint32 + End uint32 + Gcdata uint32 + Gcbss uint32 + Types uint32 + Etypes uint32 + Textsectmap, Textsectmaplen, Textsectmapcap uint32 + Typelinks, Typelinkslen, Typelinkscap uint32 + Itablinks, Itablinkslen, Itablinkscap uint32 + Ptab, Ptablen, Ptabcap uint32 + Pluginpath, Pluginpathlen uint32 + Pkghashes, Pkghasheslen, Pkghashescap uint32 } func (md moduledata_1_10_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.text), - TextLen: uint64(md.etext - md.text), - NoPtrDataAddr: uint64(md.noptrdata), - NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), - DataAddr: uint64(md.data), - DataLen: uint64(md.edata - md.data), - BssAddr: uint64(md.bss), - BssLen: uint64(md.ebss - md.bss), - NoPtrBssAddr: uint64(md.noptrbss), - NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), - TypesAddr: uint64(md.types), - TypesLen: uint64(md.etypes - md.types), - TypelinkAddr: uint64(md.typelinks), - TypelinkLen: uint64(md.typelinkslen), - ITabLinkAddr: uint64(md.itablinks), - ITabLinkLen: uint64(md.itablinkslen), - FuncTabAddr: uint64(md.ftab), - FuncTabLen: uint64(md.ftablen), - PCLNTabAddr: uint64(md.pclntable), - PCLNTabLen: uint64(md.pclntablelen), + TextAddr: uint64(md.Text), + TextLen: uint64(md.Etext - md.Text), + NoPtrDataAddr: uint64(md.Noptrdata), + NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), + DataAddr: uint64(md.Data), + DataLen: uint64(md.Edata - md.Data), + BssAddr: uint64(md.Bss), + BssLen: uint64(md.Ebss - md.Bss), + NoPtrBssAddr: uint64(md.Noptrbss), + NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), + TypesAddr: uint64(md.Types), + TypesLen: uint64(md.Etypes - md.Types), + TypelinkAddr: uint64(md.Typelinks), + TypelinkLen: uint64(md.Typelinkslen), + ITabLinkAddr: uint64(md.Itablinks), + ITabLinkLen: uint64(md.Itablinkslen), + FuncTabAddr: uint64(md.Ftab), + FuncTabLen: uint64(md.Ftablen), + PCLNTabAddr: uint64(md.Pclntable), + PCLNTabLen: uint64(md.Pclntablelen), } } type moduledata_1_10_64 struct { - pclntable, pclntablelen, pclntablecap uint64 - ftab, ftablen, ftabcap uint64 - filetab, filetablen, filetabcap uint64 - findfunctab uint64 - minpc uint64 - maxpc uint64 - text uint64 - etext uint64 - noptrdata uint64 - enoptrdata uint64 - data uint64 - edata uint64 - bss uint64 - ebss uint64 - noptrbss uint64 - enoptrbss uint64 - end uint64 - gcdata uint64 - gcbss uint64 - types uint64 - etypes uint64 - textsectmap, textsectmaplen, textsectmapcap uint64 - typelinks, typelinkslen, typelinkscap uint64 - itablinks, itablinkslen, itablinkscap uint64 - ptab, ptablen, ptabcap uint64 - pluginpath, pluginpathlen uint64 - pkghashes, pkghasheslen, pkghashescap uint64 + Pclntable, Pclntablelen, Pclntablecap uint64 + Ftab, Ftablen, Ftabcap uint64 + Filetab, Filetablen, Filetabcap uint64 + Findfunctab uint64 + Minpc uint64 + Maxpc uint64 + Text uint64 + Etext uint64 + Noptrdata uint64 + Enoptrdata uint64 + Data uint64 + Edata uint64 + Bss uint64 + Ebss uint64 + Noptrbss uint64 + Enoptrbss uint64 + End uint64 + Gcdata uint64 + Gcbss uint64 + Types uint64 + Etypes uint64 + Textsectmap, Textsectmaplen, Textsectmapcap uint64 + Typelinks, Typelinkslen, Typelinkscap uint64 + Itablinks, Itablinkslen, Itablinkscap uint64 + Ptab, Ptablen, Ptabcap uint64 + Pluginpath, Pluginpathlen uint64 + Pkghashes, Pkghasheslen, Pkghashescap uint64 } func (md moduledata_1_10_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.text, - TextLen: md.etext - md.text, - NoPtrDataAddr: md.noptrdata, - NoPtrDataLen: md.enoptrdata - md.noptrdata, - DataAddr: md.data, - DataLen: md.edata - md.data, - BssAddr: md.bss, - BssLen: md.ebss - md.bss, - NoPtrBssAddr: md.noptrbss, - NoPtrBssLen: md.enoptrbss - md.noptrbss, - TypesAddr: md.types, - TypesLen: md.etypes - md.types, - TypelinkAddr: md.typelinks, - TypelinkLen: md.typelinkslen, - ITabLinkAddr: md.itablinks, - ITabLinkLen: md.itablinkslen, - FuncTabAddr: md.ftab, - FuncTabLen: md.ftablen, - PCLNTabAddr: md.pclntable, - PCLNTabLen: md.pclntablelen, + TextAddr: md.Text, + TextLen: md.Etext - md.Text, + NoPtrDataAddr: md.Noptrdata, + NoPtrDataLen: md.Enoptrdata - md.Noptrdata, + DataAddr: md.Data, + DataLen: md.Edata - md.Data, + BssAddr: md.Bss, + BssLen: md.Ebss - md.Bss, + NoPtrBssAddr: md.Noptrbss, + NoPtrBssLen: md.Enoptrbss - md.Noptrbss, + TypesAddr: md.Types, + TypesLen: md.Etypes - md.Types, + TypelinkAddr: md.Typelinks, + TypelinkLen: md.Typelinkslen, + ITabLinkAddr: md.Itablinks, + ITabLinkLen: md.Itablinkslen, + FuncTabAddr: md.Ftab, + FuncTabLen: md.Ftablen, + PCLNTabAddr: md.Pclntable, + PCLNTabLen: md.Pclntablelen, } } type moduledata_1_9_32 struct { - pclntable, pclntablelen, pclntablecap uint32 - ftab, ftablen, ftabcap uint32 - filetab, filetablen, filetabcap uint32 - findfunctab uint32 - minpc uint32 - maxpc uint32 - text uint32 - etext uint32 - noptrdata uint32 - enoptrdata uint32 - data uint32 - edata uint32 - bss uint32 - ebss uint32 - noptrbss uint32 - enoptrbss uint32 - end uint32 - gcdata uint32 - gcbss uint32 - types uint32 - etypes uint32 - textsectmap, textsectmaplen, textsectmapcap uint32 - typelinks, typelinkslen, typelinkscap uint32 - itablinks, itablinkslen, itablinkscap uint32 - ptab, ptablen, ptabcap uint32 - pluginpath, pluginpathlen uint32 - pkghashes, pkghasheslen, pkghashescap uint32 + Pclntable, Pclntablelen, Pclntablecap uint32 + Ftab, Ftablen, Ftabcap uint32 + Filetab, Filetablen, Filetabcap uint32 + Findfunctab uint32 + Minpc uint32 + Maxpc uint32 + Text uint32 + Etext uint32 + Noptrdata uint32 + Enoptrdata uint32 + Data uint32 + Edata uint32 + Bss uint32 + Ebss uint32 + Noptrbss uint32 + Enoptrbss uint32 + End uint32 + Gcdata uint32 + Gcbss uint32 + Types uint32 + Etypes uint32 + Textsectmap, Textsectmaplen, Textsectmapcap uint32 + Typelinks, Typelinkslen, Typelinkscap uint32 + Itablinks, Itablinkslen, Itablinkscap uint32 + Ptab, Ptablen, Ptabcap uint32 + Pluginpath, Pluginpathlen uint32 + Pkghashes, Pkghasheslen, Pkghashescap uint32 } func (md moduledata_1_9_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.text), - TextLen: uint64(md.etext - md.text), - NoPtrDataAddr: uint64(md.noptrdata), - NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), - DataAddr: uint64(md.data), - DataLen: uint64(md.edata - md.data), - BssAddr: uint64(md.bss), - BssLen: uint64(md.ebss - md.bss), - NoPtrBssAddr: uint64(md.noptrbss), - NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), - TypesAddr: uint64(md.types), - TypesLen: uint64(md.etypes - md.types), - TypelinkAddr: uint64(md.typelinks), - TypelinkLen: uint64(md.typelinkslen), - ITabLinkAddr: uint64(md.itablinks), - ITabLinkLen: uint64(md.itablinkslen), - FuncTabAddr: uint64(md.ftab), - FuncTabLen: uint64(md.ftablen), - PCLNTabAddr: uint64(md.pclntable), - PCLNTabLen: uint64(md.pclntablelen), + TextAddr: uint64(md.Text), + TextLen: uint64(md.Etext - md.Text), + NoPtrDataAddr: uint64(md.Noptrdata), + NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), + DataAddr: uint64(md.Data), + DataLen: uint64(md.Edata - md.Data), + BssAddr: uint64(md.Bss), + BssLen: uint64(md.Ebss - md.Bss), + NoPtrBssAddr: uint64(md.Noptrbss), + NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), + TypesAddr: uint64(md.Types), + TypesLen: uint64(md.Etypes - md.Types), + TypelinkAddr: uint64(md.Typelinks), + TypelinkLen: uint64(md.Typelinkslen), + ITabLinkAddr: uint64(md.Itablinks), + ITabLinkLen: uint64(md.Itablinkslen), + FuncTabAddr: uint64(md.Ftab), + FuncTabLen: uint64(md.Ftablen), + PCLNTabAddr: uint64(md.Pclntable), + PCLNTabLen: uint64(md.Pclntablelen), } } type moduledata_1_9_64 struct { - pclntable, pclntablelen, pclntablecap uint64 - ftab, ftablen, ftabcap uint64 - filetab, filetablen, filetabcap uint64 - findfunctab uint64 - minpc uint64 - maxpc uint64 - text uint64 - etext uint64 - noptrdata uint64 - enoptrdata uint64 - data uint64 - edata uint64 - bss uint64 - ebss uint64 - noptrbss uint64 - enoptrbss uint64 - end uint64 - gcdata uint64 - gcbss uint64 - types uint64 - etypes uint64 - textsectmap, textsectmaplen, textsectmapcap uint64 - typelinks, typelinkslen, typelinkscap uint64 - itablinks, itablinkslen, itablinkscap uint64 - ptab, ptablen, ptabcap uint64 - pluginpath, pluginpathlen uint64 - pkghashes, pkghasheslen, pkghashescap uint64 + Pclntable, Pclntablelen, Pclntablecap uint64 + Ftab, Ftablen, Ftabcap uint64 + Filetab, Filetablen, Filetabcap uint64 + Findfunctab uint64 + Minpc uint64 + Maxpc uint64 + Text uint64 + Etext uint64 + Noptrdata uint64 + Enoptrdata uint64 + Data uint64 + Edata uint64 + Bss uint64 + Ebss uint64 + Noptrbss uint64 + Enoptrbss uint64 + End uint64 + Gcdata uint64 + Gcbss uint64 + Types uint64 + Etypes uint64 + Textsectmap, Textsectmaplen, Textsectmapcap uint64 + Typelinks, Typelinkslen, Typelinkscap uint64 + Itablinks, Itablinkslen, Itablinkscap uint64 + Ptab, Ptablen, Ptabcap uint64 + Pluginpath, Pluginpathlen uint64 + Pkghashes, Pkghasheslen, Pkghashescap uint64 } func (md moduledata_1_9_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.text, - TextLen: md.etext - md.text, - NoPtrDataAddr: md.noptrdata, - NoPtrDataLen: md.enoptrdata - md.noptrdata, - DataAddr: md.data, - DataLen: md.edata - md.data, - BssAddr: md.bss, - BssLen: md.ebss - md.bss, - NoPtrBssAddr: md.noptrbss, - NoPtrBssLen: md.enoptrbss - md.noptrbss, - TypesAddr: md.types, - TypesLen: md.etypes - md.types, - TypelinkAddr: md.typelinks, - TypelinkLen: md.typelinkslen, - ITabLinkAddr: md.itablinks, - ITabLinkLen: md.itablinkslen, - FuncTabAddr: md.ftab, - FuncTabLen: md.ftablen, - PCLNTabAddr: md.pclntable, - PCLNTabLen: md.pclntablelen, + TextAddr: md.Text, + TextLen: md.Etext - md.Text, + NoPtrDataAddr: md.Noptrdata, + NoPtrDataLen: md.Enoptrdata - md.Noptrdata, + DataAddr: md.Data, + DataLen: md.Edata - md.Data, + BssAddr: md.Bss, + BssLen: md.Ebss - md.Bss, + NoPtrBssAddr: md.Noptrbss, + NoPtrBssLen: md.Enoptrbss - md.Noptrbss, + TypesAddr: md.Types, + TypesLen: md.Etypes - md.Types, + TypelinkAddr: md.Typelinks, + TypelinkLen: md.Typelinkslen, + ITabLinkAddr: md.Itablinks, + ITabLinkLen: md.Itablinkslen, + FuncTabAddr: md.Ftab, + FuncTabLen: md.Ftablen, + PCLNTabAddr: md.Pclntable, + PCLNTabLen: md.Pclntablelen, } } type moduledata_1_8_32 struct { - pclntable, pclntablelen, pclntablecap uint32 - ftab, ftablen, ftabcap uint32 - filetab, filetablen, filetabcap uint32 - findfunctab uint32 - minpc uint32 - maxpc uint32 - text uint32 - etext uint32 - noptrdata uint32 - enoptrdata uint32 - data uint32 - edata uint32 - bss uint32 - ebss uint32 - noptrbss uint32 - enoptrbss uint32 - end uint32 - gcdata uint32 - gcbss uint32 - types uint32 - etypes uint32 - textsectmap, textsectmaplen, textsectmapcap uint32 - typelinks, typelinkslen, typelinkscap uint32 - itablinks, itablinkslen, itablinkscap uint32 - ptab, ptablen, ptabcap uint32 - pluginpath, pluginpathlen uint32 - pkghashes, pkghasheslen, pkghashescap uint32 + Pclntable, Pclntablelen, Pclntablecap uint32 + Ftab, Ftablen, Ftabcap uint32 + Filetab, Filetablen, Filetabcap uint32 + Findfunctab uint32 + Minpc uint32 + Maxpc uint32 + Text uint32 + Etext uint32 + Noptrdata uint32 + Enoptrdata uint32 + Data uint32 + Edata uint32 + Bss uint32 + Ebss uint32 + Noptrbss uint32 + Enoptrbss uint32 + End uint32 + Gcdata uint32 + Gcbss uint32 + Types uint32 + Etypes uint32 + Textsectmap, Textsectmaplen, Textsectmapcap uint32 + Typelinks, Typelinkslen, Typelinkscap uint32 + Itablinks, Itablinkslen, Itablinkscap uint32 + Ptab, Ptablen, Ptabcap uint32 + Pluginpath, Pluginpathlen uint32 + Pkghashes, Pkghasheslen, Pkghashescap uint32 } func (md moduledata_1_8_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.text), - TextLen: uint64(md.etext - md.text), - NoPtrDataAddr: uint64(md.noptrdata), - NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), - DataAddr: uint64(md.data), - DataLen: uint64(md.edata - md.data), - BssAddr: uint64(md.bss), - BssLen: uint64(md.ebss - md.bss), - NoPtrBssAddr: uint64(md.noptrbss), - NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), - TypesAddr: uint64(md.types), - TypesLen: uint64(md.etypes - md.types), - TypelinkAddr: uint64(md.typelinks), - TypelinkLen: uint64(md.typelinkslen), - ITabLinkAddr: uint64(md.itablinks), - ITabLinkLen: uint64(md.itablinkslen), - FuncTabAddr: uint64(md.ftab), - FuncTabLen: uint64(md.ftablen), - PCLNTabAddr: uint64(md.pclntable), - PCLNTabLen: uint64(md.pclntablelen), + TextAddr: uint64(md.Text), + TextLen: uint64(md.Etext - md.Text), + NoPtrDataAddr: uint64(md.Noptrdata), + NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), + DataAddr: uint64(md.Data), + DataLen: uint64(md.Edata - md.Data), + BssAddr: uint64(md.Bss), + BssLen: uint64(md.Ebss - md.Bss), + NoPtrBssAddr: uint64(md.Noptrbss), + NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), + TypesAddr: uint64(md.Types), + TypesLen: uint64(md.Etypes - md.Types), + TypelinkAddr: uint64(md.Typelinks), + TypelinkLen: uint64(md.Typelinkslen), + ITabLinkAddr: uint64(md.Itablinks), + ITabLinkLen: uint64(md.Itablinkslen), + FuncTabAddr: uint64(md.Ftab), + FuncTabLen: uint64(md.Ftablen), + PCLNTabAddr: uint64(md.Pclntable), + PCLNTabLen: uint64(md.Pclntablelen), } } type moduledata_1_8_64 struct { - pclntable, pclntablelen, pclntablecap uint64 - ftab, ftablen, ftabcap uint64 - filetab, filetablen, filetabcap uint64 - findfunctab uint64 - minpc uint64 - maxpc uint64 - text uint64 - etext uint64 - noptrdata uint64 - enoptrdata uint64 - data uint64 - edata uint64 - bss uint64 - ebss uint64 - noptrbss uint64 - enoptrbss uint64 - end uint64 - gcdata uint64 - gcbss uint64 - types uint64 - etypes uint64 - textsectmap, textsectmaplen, textsectmapcap uint64 - typelinks, typelinkslen, typelinkscap uint64 - itablinks, itablinkslen, itablinkscap uint64 - ptab, ptablen, ptabcap uint64 - pluginpath, pluginpathlen uint64 - pkghashes, pkghasheslen, pkghashescap uint64 + Pclntable, Pclntablelen, Pclntablecap uint64 + Ftab, Ftablen, Ftabcap uint64 + Filetab, Filetablen, Filetabcap uint64 + Findfunctab uint64 + Minpc uint64 + Maxpc uint64 + Text uint64 + Etext uint64 + Noptrdata uint64 + Enoptrdata uint64 + Data uint64 + Edata uint64 + Bss uint64 + Ebss uint64 + Noptrbss uint64 + Enoptrbss uint64 + End uint64 + Gcdata uint64 + Gcbss uint64 + Types uint64 + Etypes uint64 + Textsectmap, Textsectmaplen, Textsectmapcap uint64 + Typelinks, Typelinkslen, Typelinkscap uint64 + Itablinks, Itablinkslen, Itablinkscap uint64 + Ptab, Ptablen, Ptabcap uint64 + Pluginpath, Pluginpathlen uint64 + Pkghashes, Pkghasheslen, Pkghashescap uint64 } func (md moduledata_1_8_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.text, - TextLen: md.etext - md.text, - NoPtrDataAddr: md.noptrdata, - NoPtrDataLen: md.enoptrdata - md.noptrdata, - DataAddr: md.data, - DataLen: md.edata - md.data, - BssAddr: md.bss, - BssLen: md.ebss - md.bss, - NoPtrBssAddr: md.noptrbss, - NoPtrBssLen: md.enoptrbss - md.noptrbss, - TypesAddr: md.types, - TypesLen: md.etypes - md.types, - TypelinkAddr: md.typelinks, - TypelinkLen: md.typelinkslen, - ITabLinkAddr: md.itablinks, - ITabLinkLen: md.itablinkslen, - FuncTabAddr: md.ftab, - FuncTabLen: md.ftablen, - PCLNTabAddr: md.pclntable, - PCLNTabLen: md.pclntablelen, + TextAddr: md.Text, + TextLen: md.Etext - md.Text, + NoPtrDataAddr: md.Noptrdata, + NoPtrDataLen: md.Enoptrdata - md.Noptrdata, + DataAddr: md.Data, + DataLen: md.Edata - md.Data, + BssAddr: md.Bss, + BssLen: md.Ebss - md.Bss, + NoPtrBssAddr: md.Noptrbss, + NoPtrBssLen: md.Enoptrbss - md.Noptrbss, + TypesAddr: md.Types, + TypesLen: md.Etypes - md.Types, + TypelinkAddr: md.Typelinks, + TypelinkLen: md.Typelinkslen, + ITabLinkAddr: md.Itablinks, + ITabLinkLen: md.Itablinkslen, + FuncTabAddr: md.Ftab, + FuncTabLen: md.Ftablen, + PCLNTabAddr: md.Pclntable, + PCLNTabLen: md.Pclntablelen, } } type moduledata_1_7_32 struct { - pclntable, pclntablelen, pclntablecap uint32 - ftab, ftablen, ftabcap uint32 - filetab, filetablen, filetabcap uint32 - findfunctab uint32 - minpc uint32 - maxpc uint32 - text uint32 - etext uint32 - noptrdata uint32 - enoptrdata uint32 - data uint32 - edata uint32 - bss uint32 - ebss uint32 - noptrbss uint32 - enoptrbss uint32 - end uint32 - gcdata uint32 - gcbss uint32 - types uint32 - etypes uint32 - typelinks, typelinkslen, typelinkscap uint32 - itablinks, itablinkslen, itablinkscap uint32 + Pclntable, Pclntablelen, Pclntablecap uint32 + Ftab, Ftablen, Ftabcap uint32 + Filetab, Filetablen, Filetabcap uint32 + Findfunctab uint32 + Minpc uint32 + Maxpc uint32 + Text uint32 + Etext uint32 + Noptrdata uint32 + Enoptrdata uint32 + Data uint32 + Edata uint32 + Bss uint32 + Ebss uint32 + Noptrbss uint32 + Enoptrbss uint32 + End uint32 + Gcdata uint32 + Gcbss uint32 + Types uint32 + Etypes uint32 + Typelinks, Typelinkslen, Typelinkscap uint32 + Itablinks, Itablinkslen, Itablinkscap uint32 } func (md moduledata_1_7_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.text), - TextLen: uint64(md.etext - md.text), - NoPtrDataAddr: uint64(md.noptrdata), - NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), - DataAddr: uint64(md.data), - DataLen: uint64(md.edata - md.data), - BssAddr: uint64(md.bss), - BssLen: uint64(md.ebss - md.bss), - NoPtrBssAddr: uint64(md.noptrbss), - NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), - TypesAddr: uint64(md.types), - TypesLen: uint64(md.etypes - md.types), - TypelinkAddr: uint64(md.typelinks), - TypelinkLen: uint64(md.typelinkslen), - ITabLinkAddr: uint64(md.itablinks), - ITabLinkLen: uint64(md.itablinkslen), - FuncTabAddr: uint64(md.ftab), - FuncTabLen: uint64(md.ftablen), - PCLNTabAddr: uint64(md.pclntable), - PCLNTabLen: uint64(md.pclntablelen), + TextAddr: uint64(md.Text), + TextLen: uint64(md.Etext - md.Text), + NoPtrDataAddr: uint64(md.Noptrdata), + NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), + DataAddr: uint64(md.Data), + DataLen: uint64(md.Edata - md.Data), + BssAddr: uint64(md.Bss), + BssLen: uint64(md.Ebss - md.Bss), + NoPtrBssAddr: uint64(md.Noptrbss), + NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), + TypesAddr: uint64(md.Types), + TypesLen: uint64(md.Etypes - md.Types), + TypelinkAddr: uint64(md.Typelinks), + TypelinkLen: uint64(md.Typelinkslen), + ITabLinkAddr: uint64(md.Itablinks), + ITabLinkLen: uint64(md.Itablinkslen), + FuncTabAddr: uint64(md.Ftab), + FuncTabLen: uint64(md.Ftablen), + PCLNTabAddr: uint64(md.Pclntable), + PCLNTabLen: uint64(md.Pclntablelen), } } type moduledata_1_7_64 struct { - pclntable, pclntablelen, pclntablecap uint64 - ftab, ftablen, ftabcap uint64 - filetab, filetablen, filetabcap uint64 - findfunctab uint64 - minpc uint64 - maxpc uint64 - text uint64 - etext uint64 - noptrdata uint64 - enoptrdata uint64 - data uint64 - edata uint64 - bss uint64 - ebss uint64 - noptrbss uint64 - enoptrbss uint64 - end uint64 - gcdata uint64 - gcbss uint64 - types uint64 - etypes uint64 - typelinks, typelinkslen, typelinkscap uint64 - itablinks, itablinkslen, itablinkscap uint64 + Pclntable, Pclntablelen, Pclntablecap uint64 + Ftab, Ftablen, Ftabcap uint64 + Filetab, Filetablen, Filetabcap uint64 + Findfunctab uint64 + Minpc uint64 + Maxpc uint64 + Text uint64 + Etext uint64 + Noptrdata uint64 + Enoptrdata uint64 + Data uint64 + Edata uint64 + Bss uint64 + Ebss uint64 + Noptrbss uint64 + Enoptrbss uint64 + End uint64 + Gcdata uint64 + Gcbss uint64 + Types uint64 + Etypes uint64 + Typelinks, Typelinkslen, Typelinkscap uint64 + Itablinks, Itablinkslen, Itablinkscap uint64 } func (md moduledata_1_7_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.text, - TextLen: md.etext - md.text, - NoPtrDataAddr: md.noptrdata, - NoPtrDataLen: md.enoptrdata - md.noptrdata, - DataAddr: md.data, - DataLen: md.edata - md.data, - BssAddr: md.bss, - BssLen: md.ebss - md.bss, - NoPtrBssAddr: md.noptrbss, - NoPtrBssLen: md.enoptrbss - md.noptrbss, - TypesAddr: md.types, - TypesLen: md.etypes - md.types, - TypelinkAddr: md.typelinks, - TypelinkLen: md.typelinkslen, - ITabLinkAddr: md.itablinks, - ITabLinkLen: md.itablinkslen, - FuncTabAddr: md.ftab, - FuncTabLen: md.ftablen, - PCLNTabAddr: md.pclntable, - PCLNTabLen: md.pclntablelen, + TextAddr: md.Text, + TextLen: md.Etext - md.Text, + NoPtrDataAddr: md.Noptrdata, + NoPtrDataLen: md.Enoptrdata - md.Noptrdata, + DataAddr: md.Data, + DataLen: md.Edata - md.Data, + BssAddr: md.Bss, + BssLen: md.Ebss - md.Bss, + NoPtrBssAddr: md.Noptrbss, + NoPtrBssLen: md.Enoptrbss - md.Noptrbss, + TypesAddr: md.Types, + TypesLen: md.Etypes - md.Types, + TypelinkAddr: md.Typelinks, + TypelinkLen: md.Typelinkslen, + ITabLinkAddr: md.Itablinks, + ITabLinkLen: md.Itablinkslen, + FuncTabAddr: md.Ftab, + FuncTabLen: md.Ftablen, + PCLNTabAddr: md.Pclntable, + PCLNTabLen: md.Pclntablelen, } } type moduledata_1_6_32 struct { - pclntable, pclntablelen, pclntablecap uint32 - ftab, ftablen, ftabcap uint32 - filetab, filetablen, filetabcap uint32 - findfunctab uint32 - minpc uint32 - maxpc uint32 - text uint32 - etext uint32 - noptrdata uint32 - enoptrdata uint32 - data uint32 - edata uint32 - bss uint32 - ebss uint32 - noptrbss uint32 - enoptrbss uint32 - end uint32 - gcdata uint32 - gcbss uint32 - typelinks, typelinkslen, typelinkscap uint32 + Pclntable, Pclntablelen, Pclntablecap uint32 + Ftab, Ftablen, Ftabcap uint32 + Filetab, Filetablen, Filetabcap uint32 + Findfunctab uint32 + Minpc uint32 + Maxpc uint32 + Text uint32 + Etext uint32 + Noptrdata uint32 + Enoptrdata uint32 + Data uint32 + Edata uint32 + Bss uint32 + Ebss uint32 + Noptrbss uint32 + Enoptrbss uint32 + End uint32 + Gcdata uint32 + Gcbss uint32 + Typelinks, Typelinkslen, Typelinkscap uint32 } func (md moduledata_1_6_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.text), - TextLen: uint64(md.etext - md.text), - NoPtrDataAddr: uint64(md.noptrdata), - NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), - DataAddr: uint64(md.data), - DataLen: uint64(md.edata - md.data), - BssAddr: uint64(md.bss), - BssLen: uint64(md.ebss - md.bss), - NoPtrBssAddr: uint64(md.noptrbss), - NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), - TypelinkAddr: uint64(md.typelinks), - TypelinkLen: uint64(md.typelinkslen), - FuncTabAddr: uint64(md.ftab), - FuncTabLen: uint64(md.ftablen), - PCLNTabAddr: uint64(md.pclntable), - PCLNTabLen: uint64(md.pclntablelen), + TextAddr: uint64(md.Text), + TextLen: uint64(md.Etext - md.Text), + NoPtrDataAddr: uint64(md.Noptrdata), + NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), + DataAddr: uint64(md.Data), + DataLen: uint64(md.Edata - md.Data), + BssAddr: uint64(md.Bss), + BssLen: uint64(md.Ebss - md.Bss), + NoPtrBssAddr: uint64(md.Noptrbss), + NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), + TypelinkAddr: uint64(md.Typelinks), + TypelinkLen: uint64(md.Typelinkslen), + FuncTabAddr: uint64(md.Ftab), + FuncTabLen: uint64(md.Ftablen), + PCLNTabAddr: uint64(md.Pclntable), + PCLNTabLen: uint64(md.Pclntablelen), } } type moduledata_1_6_64 struct { - pclntable, pclntablelen, pclntablecap uint64 - ftab, ftablen, ftabcap uint64 - filetab, filetablen, filetabcap uint64 - findfunctab uint64 - minpc uint64 - maxpc uint64 - text uint64 - etext uint64 - noptrdata uint64 - enoptrdata uint64 - data uint64 - edata uint64 - bss uint64 - ebss uint64 - noptrbss uint64 - enoptrbss uint64 - end uint64 - gcdata uint64 - gcbss uint64 - typelinks, typelinkslen, typelinkscap uint64 + Pclntable, Pclntablelen, Pclntablecap uint64 + Ftab, Ftablen, Ftabcap uint64 + Filetab, Filetablen, Filetabcap uint64 + Findfunctab uint64 + Minpc uint64 + Maxpc uint64 + Text uint64 + Etext uint64 + Noptrdata uint64 + Enoptrdata uint64 + Data uint64 + Edata uint64 + Bss uint64 + Ebss uint64 + Noptrbss uint64 + Enoptrbss uint64 + End uint64 + Gcdata uint64 + Gcbss uint64 + Typelinks, Typelinkslen, Typelinkscap uint64 } func (md moduledata_1_6_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.text, - TextLen: md.etext - md.text, - NoPtrDataAddr: md.noptrdata, - NoPtrDataLen: md.enoptrdata - md.noptrdata, - DataAddr: md.data, - DataLen: md.edata - md.data, - BssAddr: md.bss, - BssLen: md.ebss - md.bss, - NoPtrBssAddr: md.noptrbss, - NoPtrBssLen: md.enoptrbss - md.noptrbss, - TypelinkAddr: md.typelinks, - TypelinkLen: md.typelinkslen, - FuncTabAddr: md.ftab, - FuncTabLen: md.ftablen, - PCLNTabAddr: md.pclntable, - PCLNTabLen: md.pclntablelen, + TextAddr: md.Text, + TextLen: md.Etext - md.Text, + NoPtrDataAddr: md.Noptrdata, + NoPtrDataLen: md.Enoptrdata - md.Noptrdata, + DataAddr: md.Data, + DataLen: md.Edata - md.Data, + BssAddr: md.Bss, + BssLen: md.Ebss - md.Bss, + NoPtrBssAddr: md.Noptrbss, + NoPtrBssLen: md.Enoptrbss - md.Noptrbss, + TypelinkAddr: md.Typelinks, + TypelinkLen: md.Typelinkslen, + FuncTabAddr: md.Ftab, + FuncTabLen: md.Ftablen, + PCLNTabAddr: md.Pclntable, + PCLNTabLen: md.Pclntablelen, } } type moduledata_1_5_32 struct { - pclntable, pclntablelen, pclntablecap uint32 - ftab, ftablen, ftabcap uint32 - filetab, filetablen, filetabcap uint32 - findfunctab uint32 - minpc uint32 - maxpc uint32 - text uint32 - etext uint32 - noptrdata uint32 - enoptrdata uint32 - data uint32 - edata uint32 - bss uint32 - ebss uint32 - noptrbss uint32 - enoptrbss uint32 - end uint32 - gcdata uint32 - gcbss uint32 - typelinks, typelinkslen, typelinkscap uint32 + Pclntable, Pclntablelen, Pclntablecap uint32 + Ftab, Ftablen, Ftabcap uint32 + Filetab, Filetablen, Filetabcap uint32 + Findfunctab uint32 + Minpc uint32 + Maxpc uint32 + Text uint32 + Etext uint32 + Noptrdata uint32 + Enoptrdata uint32 + Data uint32 + Edata uint32 + Bss uint32 + Ebss uint32 + Noptrbss uint32 + Enoptrbss uint32 + End uint32 + Gcdata uint32 + Gcbss uint32 + Typelinks, Typelinkslen, Typelinkscap uint32 } func (md moduledata_1_5_32) toModuledata() moduledata { return moduledata{ - TextAddr: uint64(md.text), - TextLen: uint64(md.etext - md.text), - NoPtrDataAddr: uint64(md.noptrdata), - NoPtrDataLen: uint64(md.enoptrdata - md.noptrdata), - DataAddr: uint64(md.data), - DataLen: uint64(md.edata - md.data), - BssAddr: uint64(md.bss), - BssLen: uint64(md.ebss - md.bss), - NoPtrBssAddr: uint64(md.noptrbss), - NoPtrBssLen: uint64(md.enoptrbss - md.noptrbss), - TypelinkAddr: uint64(md.typelinks), - TypelinkLen: uint64(md.typelinkslen), - FuncTabAddr: uint64(md.ftab), - FuncTabLen: uint64(md.ftablen), - PCLNTabAddr: uint64(md.pclntable), - PCLNTabLen: uint64(md.pclntablelen), + TextAddr: uint64(md.Text), + TextLen: uint64(md.Etext - md.Text), + NoPtrDataAddr: uint64(md.Noptrdata), + NoPtrDataLen: uint64(md.Enoptrdata - md.Noptrdata), + DataAddr: uint64(md.Data), + DataLen: uint64(md.Edata - md.Data), + BssAddr: uint64(md.Bss), + BssLen: uint64(md.Ebss - md.Bss), + NoPtrBssAddr: uint64(md.Noptrbss), + NoPtrBssLen: uint64(md.Enoptrbss - md.Noptrbss), + TypelinkAddr: uint64(md.Typelinks), + TypelinkLen: uint64(md.Typelinkslen), + FuncTabAddr: uint64(md.Ftab), + FuncTabLen: uint64(md.Ftablen), + PCLNTabAddr: uint64(md.Pclntable), + PCLNTabLen: uint64(md.Pclntablelen), } } type moduledata_1_5_64 struct { - pclntable, pclntablelen, pclntablecap uint64 - ftab, ftablen, ftabcap uint64 - filetab, filetablen, filetabcap uint64 - findfunctab uint64 - minpc uint64 - maxpc uint64 - text uint64 - etext uint64 - noptrdata uint64 - enoptrdata uint64 - data uint64 - edata uint64 - bss uint64 - ebss uint64 - noptrbss uint64 - enoptrbss uint64 - end uint64 - gcdata uint64 - gcbss uint64 - typelinks, typelinkslen, typelinkscap uint64 + Pclntable, Pclntablelen, Pclntablecap uint64 + Ftab, Ftablen, Ftabcap uint64 + Filetab, Filetablen, Filetabcap uint64 + Findfunctab uint64 + Minpc uint64 + Maxpc uint64 + Text uint64 + Etext uint64 + Noptrdata uint64 + Enoptrdata uint64 + Data uint64 + Edata uint64 + Bss uint64 + Ebss uint64 + Noptrbss uint64 + Enoptrbss uint64 + End uint64 + Gcdata uint64 + Gcbss uint64 + Typelinks, Typelinkslen, Typelinkscap uint64 } func (md moduledata_1_5_64) toModuledata() moduledata { return moduledata{ - TextAddr: md.text, - TextLen: md.etext - md.text, - NoPtrDataAddr: md.noptrdata, - NoPtrDataLen: md.enoptrdata - md.noptrdata, - DataAddr: md.data, - DataLen: md.edata - md.data, - BssAddr: md.bss, - BssLen: md.ebss - md.bss, - NoPtrBssAddr: md.noptrbss, - NoPtrBssLen: md.enoptrbss - md.noptrbss, - TypelinkAddr: md.typelinks, - TypelinkLen: md.typelinkslen, - FuncTabAddr: md.ftab, - FuncTabLen: md.ftablen, - PCLNTabAddr: md.pclntable, - PCLNTabLen: md.pclntablelen, + TextAddr: md.Text, + TextLen: md.Etext - md.Text, + NoPtrDataAddr: md.Noptrdata, + NoPtrDataLen: md.Enoptrdata - md.Noptrdata, + DataAddr: md.Data, + DataLen: md.Edata - md.Data, + BssAddr: md.Bss, + BssLen: md.Ebss - md.Bss, + NoPtrBssAddr: md.Noptrbss, + NoPtrBssLen: md.Enoptrbss - md.Noptrbss, + TypelinkAddr: md.Typelinks, + TypelinkLen: md.Typelinkslen, + FuncTabAddr: md.Ftab, + FuncTabLen: md.Ftablen, + PCLNTabAddr: md.Pclntable, + PCLNTabLen: md.Pclntablelen, } } From 029108d008c83476729f75c8f97a8adaee23f04d Mon Sep 17 00:00:00 2001 From: Zxilly Date: Fri, 23 Feb 2024 05:00:32 +0800 Subject: [PATCH 12/18] feat: add fallback for no version found case --- elf.go | 50 ++++++++++-- file.go | 8 +- file_test.go | 5 ++ macho.go | 78 ++++++++++++------- moduledata.go | 211 ++++++++++++++++++++++++++++++++++++++------------ pe.go | 99 +++++++++++++---------- symbol.go | 25 ++++++ 7 files changed, 346 insertions(+), 130 deletions(-) create mode 100644 symbol.go diff --git a/elf.go b/elf.go index 2ec684d..b0ed3a4 100644 --- a/elf.go +++ b/elf.go @@ -35,7 +35,12 @@ func openELF(fp string) (*elfFile, error) { if err != nil { return nil, fmt.Errorf("error when parsing the ELF file: %w", err) } - return &elfFile{file: f, osFile: osFile, pcln: newPclnTabOnce()}, nil + return &elfFile{ + file: f, + osFile: osFile, + pcln: newPclnTabOnce(), + symtab: newSymbolTableOnce(), + }, nil } var _ fileHandler = (*elfFile)(nil) @@ -44,19 +49,48 @@ type elfFile struct { file *elf.File osFile *os.File pcln *pclntabOnce + symtab *symbolTableOnce +} + +func (e *elfFile) initSymTab() error { + e.symtab.Do(func() { + syms, err := e.file.Symbols() + if err != nil { + // If the error is ErrNoSymbols, we just ignore it. + if !errors.Is(err, elf.ErrNoSymbols) { + e.symtab.err = fmt.Errorf("error when getting the symbols: %w", err) + } + return + } + for _, sym := range syms { + e.symtab.table[sym.Name] = symbol{ + Name: sym.Name, + Value: sym.Value, + Size: sym.Size, + } + } + }) + return e.symtab.err +} + +func (e *elfFile) hasSymbolTable() (bool, error) { + err := e.initSymTab() + if err != nil { + return false, err + } + return len(e.symtab.table) > 0, nil } func (e *elfFile) getSymbol(name string) (uint64, uint64, error) { - syms, err := e.file.Symbols() + err := e.initSymTab() if err != nil { - return 0, 0, fmt.Errorf("error when getting the symbols: %w", err) + return 0, 0, err } - for _, sym := range syms { - if sym.Name == name { - return sym.Size, sym.Value, nil - } + sym, ok := e.symtab.table[name] + if !ok { + return 0, 0, ErrSymbolNotFound } - return 0, 0, fmt.Errorf("symbol %s not found", name) + return sym.Value, sym.Size, nil } func (e *elfFile) getParsedFile() any { diff --git a/file.go b/file.go index fbfd2a9..2244acb 100644 --- a/file.go +++ b/file.go @@ -140,11 +140,8 @@ type GoFile struct { func (f *GoFile) initModuleData() error { f.initModuleDataOnce.Do(func() { - err := f.ensureCompilerVersion() - if err != nil { - f.initModuleDataError = err - return - } + // since we can traverse moduledata now, no goversion no longer an unrecoverable error + _ = f.ensureCompilerVersion() f.moduledata, f.initModuleDataError = extractModuledata(f.FileInfo, f.fh) }) return f.initModuleDataError @@ -451,6 +448,7 @@ type fileHandler interface { io.Closer // returns the size, value and error getSymbol(name string) (uint64, uint64, error) + hasSymbolTable() (bool, error) getPCLNTABData() (uint64, []byte, error) getRData() ([]byte, error) getCodeSection() (uint64, []byte, error) diff --git a/file_test.go b/file_test.go index 5ba5dd6..8416315 100644 --- a/file_test.go +++ b/file_test.go @@ -174,6 +174,11 @@ type mockFileHandler struct { mGetSectionDataFromAddress func(uint64) (uint64, []byte, error) } +func (m *mockFileHandler) hasSymbolTable() (bool, error) { + //TODO implement me + panic("implement me") +} + func (m *mockFileHandler) getSymbol(name string) (uint64, uint64, error) { panic("implement me") } diff --git a/macho.go b/macho.go index a360751..1e7435a 100644 --- a/macho.go +++ b/macho.go @@ -20,11 +20,10 @@ package gore import ( "debug/dwarf" "debug/macho" - "errors" "fmt" - "math" "os" "slices" + "sort" ) func openMachO(fp string) (*machoFile, error) { @@ -37,7 +36,7 @@ func openMachO(fp string) (*machoFile, error) { if err != nil { return nil, fmt.Errorf("error when parsing the Mach-O file: %w", err) } - return &machoFile{file: f, osFile: osFile}, nil + return &machoFile{file: f, osFile: osFile, symtab: newSymbolTableOnce()}, nil } var _ fileHandler = (*machoFile)(nil) @@ -45,39 +44,62 @@ var _ fileHandler = (*machoFile)(nil) type machoFile struct { file *macho.File osFile *os.File + symtab *symbolTableOnce } -func (m *machoFile) getSymbol(name string) (uint64, uint64, error) { - var addrs []uint64 - - foundedAddr := uint64(math.MaxUint64) - - const stabTypeMask = 0xe0 - - for _, s := range m.file.Symtab.Syms { - if s.Type&stabTypeMask != 0 || s.Sect == 0 { - continue +func (m *machoFile) initSymtab() error { + m.symtab.Do(func() { + if m.file.Symtab == nil { + // just do nothing, keep err nil and table empty + return } - - addrs = append(addrs, s.Value) - - if s.Name == name { - foundedAddr = s.Value + const stabTypeMask = 0xe0 + // Build a sorted list of addresses of all symbols. + // We infer the size of a symbol by looking at where the next symbol begins. + var addrs []uint64 + for _, s := range m.file.Symtab.Syms { + // Skip stab debug info. + if s.Type&stabTypeMask == 0 { + addrs = append(addrs, s.Value) + } + } + slices.Sort(addrs) + + var syms []symbol + for _, s := range m.file.Symtab.Syms { + if s.Type&stabTypeMask != 0 { + // Skip stab debug info. + continue + } + sym := symbol{Name: s.Name, Value: s.Value} + i := sort.Search(len(addrs), func(x int) bool { return addrs[x] > s.Value }) + if i < len(addrs) { + sym.Size = addrs[i] - s.Value + } + syms = append(syms, sym) } - } - - if foundedAddr == math.MaxUint64 { - return 0, 0, fmt.Errorf("symbol %s not found", name) - } - slices.Sort(addrs) + for _, sym := range syms { + m.symtab.table[sym.Name] = sym + } + }) + return m.symtab.err +} - index, _ := slices.BinarySearch(addrs, foundedAddr) +func (m *machoFile) hasSymbolTable() (bool, error) { + return m.file.Symtab != nil, nil +} - if index == len(addrs)-1 { - return foundedAddr, 0, errors.New("size not available") +func (m *machoFile) getSymbol(name string) (uint64, uint64, error) { + err := m.initSymtab() + if err != nil { + return 0, 0, err + } + sym, ok := m.symtab.table[name] + if !ok { + return 0, 0, ErrSymbolNotFound } - return foundedAddr, addrs[index+1] - foundedAddr, nil + return sym.Value, sym.Size, nil } func (m *machoFile) getParsedFile() any { diff --git a/moduledata.go b/moduledata.go index d7b4956..3ed0ad9 100644 --- a/moduledata.go +++ b/moduledata.go @@ -31,6 +31,9 @@ import ( "github.com/goretk/gore/extern/gover" ) +var ErrInvalidModuledata = errors.New("invalid moduledata") +var ErrNoEnoughDataForVMD = errors.New("no enough data to read moduledata") + // Moduledata holds information about the layout of the executable image in memory. type Moduledata interface { // Text returns the text secion. @@ -238,6 +241,10 @@ func pickVersionedModuleData(info *FileInfo) (modulable, error) { bits = 64 } + if info.goversion == nil { + return nil, ErrNoGoVersionFound + } + ver := gover.Parse(extern.StripGo(info.goversion.Name)) zero := gover.Version{} if ver == zero { @@ -256,9 +263,23 @@ func pickVersionedModuleData(info *FileInfo) (modulable, error) { return buf, nil } -func searchModuledata(vmd modulable, fileInfo *FileInfo, f fileHandler) (moduledata, error) { - vmdSize := binary.Size(vmd) +func validateModuledata(md Moduledata, fileInfo *FileInfo, f fileHandler) (bool, error) { + // Take a simple validation step to ensure that the moduledata is valid. + text := md.Text() + textSectAddr, textSect, err := f.getCodeSection() + if err != nil { + // this is not a failed validation, but a real error needs to be resolved + return false, err + } + + mdTextStart := text.Address + mdTextEnd := text.Address + text.Length + + return textSectAddr <= mdTextStart && mdTextEnd <= textSectAddr+uint64(len(textSect)), nil +} + +func searchModuledata(vmd modulable, fileInfo *FileInfo, f fileHandler) (moduledata, error) { _, secData, err := f.getSectionData(f.moduledataSection()) if err != nil { return moduledata{}, err @@ -273,50 +294,102 @@ func searchModuledata(vmd modulable, fileInfo *FileInfo, f fileHandler) (moduled return moduledata{}, err } -search: - off := bytes.Index(secData, magic) - if off == -1 || len(secData) < off+vmdSize { - return moduledata{}, errors.New("could not find moduledata") + // If we have a versioned moduledata, we can skip the search. + var candidates []modulable + if vmd == nil { + bits := 32 + if fileInfo.WordSize == intSize64 { + bits = 64 + } + candidates, _ = getModuleDataList(bits) } - data := secData[off : off+vmdSize] - - // Read the module struct from the file. - r := bytes.NewReader(data) - err = binary.Read(r, fileInfo.ByteOrder, vmd) - if err != nil { - return moduledata{}, fmt.Errorf("error when reading module data from file: %w", err) + // Mark a recoverable error with position information. + type offsetInvalidError struct { + error + offset int } - // Convert the read struct to the type we return to the caller. - md := vmd.toModuledata() + // for search, we always need validation, so the behavior here is different from readModuledataFromSymbol + trySearch := func(vmd modulable, data []byte) (moduledata, error) { + off := bytes.Index(secData, magic) - // Take a simple validation step to ensure that the moduledata is valid. - text := md.TextAddr - etext := md.TextAddr + md.TextLen + if off == -1 { + return moduledata{}, errors.New("could not find pclntab address") + } - textSectAddr, textSect, err := f.getCodeSection() - if err != nil { - return moduledata{}, err - } - if text > etext { - goto invalidMD - } + tryLoad := func(vmd modulable, off int) (moduledata, error) { + vmdSize := binary.Size(vmd) + if len(secData) < off+vmdSize { + return moduledata{}, ErrNoEnoughDataForVMD + } + + mdData := secData[off : off+vmdSize] + + // Read the module struct from the file. + r := bytes.NewReader(mdData) + err = binary.Read(r, fileInfo.ByteOrder, vmd) + if err != nil { + return moduledata{}, fmt.Errorf("error when reading module data: %w", err) + } + + // Convert the read struct to the type we return to the caller. + md := vmd.toModuledata() + + valid, err := validateModuledata(md, fileInfo, f) + if err != nil { + return moduledata{}, err + } + if !valid { + return moduledata{}, offsetInvalidError{ErrInvalidModuledata, off} + } + return md, nil + } - if !(textSectAddr <= text && text < textSectAddr+uint64(len(textSect))) { - goto invalidMD - } + if vmd != nil { + return tryLoad(vmd, off) + } else { + minVmdSize := binary.Size(candidates[0]) + for _, candidateVmd := range candidates { + minVmdSize = min(minVmdSize, binary.Size(candidateVmd)) + } + + for _, candidateVmd := range candidates { + md, err := tryLoad(candidateVmd, off) + if err == nil { + return md, nil + } + } + + if len(secData) < off+minVmdSize { + return moduledata{}, ErrNoEnoughDataForVMD + } + + return moduledata{}, offsetInvalidError{errors.New("could not find moduledata with this match"), off} + } - return md, nil + } -invalidMD: - secData = secData[off+1:] - goto search + var offErr offsetInvalidError + current := secData + for { + md, err := trySearch(vmd, current) + if err == nil { + md.fh = f + return md, nil + } + if !errors.As(err, &offErr) { + return moduledata{}, err + } + current = current[offErr.offset+1:] + } } +// Normally, we believe the info read from symbol +// is always correct, so no validation is needed. +// But without the goversion a brute force search is needed. +// And the moduledata can be malformed. func readModuledataFromSymbol(vmd modulable, fileInfo *FileInfo, f fileHandler) (moduledata, error) { - vmdSize := binary.Size(vmd) - _, addr, err := f.getSymbol("runtime.firstmoduledata") if err != nil { return moduledata{}, err @@ -327,33 +400,75 @@ func readModuledataFromSymbol(vmd modulable, fileInfo *FileInfo, f fileHandler) return moduledata{}, err } - if addr-base+uint64(vmdSize) > uint64(len(data)) { - return moduledata{}, errors.New("moduledata is too big") + tryLoad := func(vmd modulable, validate bool) (moduledata, error) { + vmdSize := binary.Size(vmd) + if addr-base+uint64(vmdSize) > uint64(len(data)) { + return moduledata{}, errors.New("moduledata is too big") + } + r := bytes.NewReader(data[addr-base : addr-base+uint64(vmdSize)]) + err = binary.Read(r, fileInfo.ByteOrder, vmd) + if err != nil { + return moduledata{}, fmt.Errorf("error when reading module data from file: %w", err) + } + md := vmd.toModuledata() + + if validate { + valid, err := validateModuledata(md, fileInfo, f) + if err != nil { + return moduledata{}, err + } + if !valid { + return moduledata{}, errors.New("moduledata is invalid") + } + } + return md, nil } - r := bytes.NewReader(data[addr-base : addr-base+uint64(vmdSize)]) - err = binary.Read(r, fileInfo.ByteOrder, vmd) - if err != nil { - return moduledata{}, fmt.Errorf("error when reading module data from file: %w", err) + if vmd != nil { + return tryLoad(vmd, true) + } else { + // cannot determine the version, so we have to traverse it + var bits int + if fileInfo.WordSize == intSize32 { + bits = 32 + } else { + bits = 64 + } + + candidates, _ := getModuleDataList(bits) + for _, candidateVmd := range candidates { + // can have error result, need to validate + md, err := tryLoad(candidateVmd, true) + if err == nil { + return md, nil + } + } + return moduledata{}, errors.New("could not find moduledata") } - // Believe the symbol is correct, so no validation is needed. - return vmd.toModuledata(), nil } func extractModuledata(fileInfo *FileInfo, f fileHandler) (moduledata, error) { vmd, err := pickVersionedModuleData(fileInfo) if err != nil { - return moduledata{}, err + if !errors.Is(err, ErrNoGoVersionFound) { + return moduledata{}, err + } } - md, err := readModuledataFromSymbol(vmd, fileInfo, f) - if err == nil { - md.fh = f - return md, nil + hasSymbol, err := f.hasSymbolTable() + if err != nil { + return moduledata{}, err + } + if hasSymbol { + md, err := readModuledataFromSymbol(vmd, fileInfo, f) + if err == nil { + md.fh = f + return md, nil + } } - md, err = searchModuledata(vmd, fileInfo, f) + md, err := searchModuledata(vmd, fileInfo, f) if err != nil { return moduledata{}, err } diff --git a/pe.go b/pe.go index c858440..fe89645 100644 --- a/pe.go +++ b/pe.go @@ -23,9 +23,9 @@ import ( "encoding/binary" "errors" "fmt" - "math" "os" "slices" + "sort" ) func openPE(fp string) (peF *peFile, err error) { @@ -62,7 +62,13 @@ func openPE(fp string) (peF *peFile, err error) { return } - peF = &peFile{file: f, osFile: osFile, imageBase: imageBase, pcln: newPclnTabOnce()} + peF = &peFile{ + file: f, + osFile: osFile, + imageBase: imageBase, + pcln: newPclnTabOnce(), + symtab: newSymbolTableOnce(), + } return } @@ -73,57 +79,68 @@ type peFile struct { osFile *os.File imageBase uint64 pcln *pclntabOnce + symtab *symbolTableOnce } -func (p *peFile) getSymbol(name string) (uint64, uint64, error) { - var addrs []uint64 - - const ( - NUndef = 0 // An undefined (extern) symbol - NAbs = -1 // An absolute symbol (e_value is a constant, not an address) - NDebug = -2 // A debugging symbol - ) - - foundedAddr := uint64(math.MaxUint64) - - for _, s := range p.file.Symbols { - switch s.SectionNumber { - case NUndef, NDebug: - continue - case NAbs: - if s.Name == name { - // for absolute symbols, we don't care about the size - return uint64(s.Value), 0, nil +func (p *peFile) initSymTab() error { + p.symtab.Do(func() { + var addrs []uint64 + + var syms []symbol + for _, s := range p.file.Symbols { + const ( + NUndef = 0 // An undefined (extern) symbol + NAbs = -1 // An absolute symbol (e_value is a constant, not an address) + NDebug = -2 // A debugging symbol + ) + sym := symbol{Name: s.Name, Value: uint64(s.Value), Size: 0} + switch s.SectionNumber { + case NUndef, NAbs, NDebug: // do nothing + default: + if s.SectionNumber < 0 || len(p.file.Sections) < int(s.SectionNumber) { + p.symtab.err = fmt.Errorf("invalid section number in symbol table") + return + } + sect := p.file.Sections[s.SectionNumber-1] + sym.Value += p.imageBase + uint64(sect.VirtualAddress) } - continue + syms = append(syms, sym) + addrs = append(addrs, sym.Value) } - if s.SectionNumber < 0 || len(p.file.Sections) < int(s.SectionNumber) { - return 0, 0, fmt.Errorf("invalid section number in symbol table") + slices.Sort(addrs) + for i := range syms { + j := sort.Search(len(addrs), func(x int) bool { return addrs[x] > syms[i].Value }) + if j < len(addrs) { + syms[i].Size = addrs[j] - syms[i].Value + } } - sect := p.file.Sections[s.SectionNumber-1] - addr := p.imageBase + uint64(sect.VirtualAddress) + uint64(s.Value) - - addrs = append(addrs, addr) - - if s.Name == name { - foundedAddr = addr + for _, sym := range syms { + p.symtab.table[sym.Name] = sym } - } + }) + return p.symtab.err +} - if foundedAddr == math.MaxUint64 { - return 0, 0, fmt.Errorf("symbol not found") +func (p *peFile) hasSymbolTable() (bool, error) { + err := p.initSymTab() + if err != nil { + return false, err } + return len(p.symtab.table) > 0, nil +} - slices.Sort(addrs) - - index, _ := slices.BinarySearch(addrs, foundedAddr) - - if index == len(addrs)-1 { - return foundedAddr, 0, errors.New("size not available") +func (p *peFile) getSymbol(name string) (uint64, uint64, error) { + err := p.initSymTab() + if err != nil { + return 0, 0, err + } + sym, ok := p.symtab.table[name] + if !ok { + return 0, 0, ErrSymbolNotFound } - return foundedAddr, addrs[index+1] - foundedAddr, nil + return sym.Value, sym.Size, nil } func (p *peFile) getParsedFile() any { diff --git a/symbol.go b/symbol.go new file mode 100644 index 0000000..93ef123 --- /dev/null +++ b/symbol.go @@ -0,0 +1,25 @@ +package gore + +import ( + "errors" + "sync" +) + +var ErrSymbolNotFound = errors.New("symbol not found") + +// symbol A primitive representation of a symbol. +type symbol struct { + Name string + Value uint64 + Size uint64 +} + +type symbolTableOnce struct { + *sync.Once + table map[string]symbol + err error +} + +func newSymbolTableOnce() *symbolTableOnce { + return &symbolTableOnce{Once: &sync.Once{}, table: make(map[string]symbol)} +} From cbd9d5af2ad246347cc3218ea6a7e9ffd6582f7d Mon Sep 17 00:00:00 2001 From: Zxilly Date: Fri, 23 Feb 2024 05:02:57 +0800 Subject: [PATCH 13/18] chore: remove debug statement --- gen/gen.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/gen/gen.go b/gen/gen.go index 827d015..eaa1157 100644 --- a/gen/gen.go +++ b/gen/gen.go @@ -30,8 +30,6 @@ var forceUpdate = flag.Bool("force", false, "force update") func main() { flag.Parse() - print("forceUpdate: ", *forceUpdate) - if flag.NArg() < 1 { fmt.Println("go run ./gen [--force] [stdpkgs|goversion|moduledata]") return From 70d70b8251e5902b76a0d4079209e8874bce2035 Mon Sep 17 00:00:00 2001 From: Zxilly Date: Sat, 24 Feb 2024 00:25:34 +0800 Subject: [PATCH 14/18] fix: set correct behavior for windows --- slow_test.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/slow_test.go b/slow_test.go index 4510307..668dad5 100644 --- a/slow_test.go +++ b/slow_test.go @@ -503,6 +503,9 @@ func buildTestResource(body, goos, arch string, pie, stripped bool) (string, str args := []string{"build", "-o", exe, "-ldflags", ldFlags} if pie { args = append(args, "-buildmode=pie") + } else { + // Windows use pie by default + args = append(args, "-buildmode=exe") } args = append(args, src) From 33028dbcaae2be12bd2f26aa4280925a4ffb5aa8 Mon Sep 17 00:00:00 2001 From: Zxilly Date: Sat, 24 Feb 2024 02:02:42 +0800 Subject: [PATCH 15/18] perf: make build simultaneously --- slow_test.go | 57 +++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 43 insertions(+), 14 deletions(-) diff --git a/slow_test.go b/slow_test.go index 668dad5..ba628a0 100644 --- a/slow_test.go +++ b/slow_test.go @@ -67,36 +67,53 @@ func TestMain(m *testing.M) { fmt.Println("Creating test resources, this can take some time...") var tmpDirs []string fs := make(map[string]string) + + resultChan := make(chan buildResult) + wg := &sync.WaitGroup{} + + go func() { + for r := range resultChan { + tmpDirs = append(tmpDirs, r.dir) + name := r.os + r.arch + if r.pie { + name += "-pie" + } + if !r.strip { + name += "-nostrip" + } + fs[name] = r.exe + } + }() + for _, r := range dynResources { fmt.Printf("Building resource file for %s_%s\n", r.os, r.arch) - exe, dir := buildTestResource(testresourcesrc, r.os, r.arch, false, true) - tmpDirs = append(tmpDirs, dir) - fs[r.os+r.arch] = exe + go buildTestResource(testresourcesrc, r.os, r.arch, false, true, wg, resultChan) - // Build PIE version of the file. Not all host systems, particular macOS, appears to be able + // Build a PIE version of the file. Not all host systems, particular macOS, appears to be able // to compile a PIE build of linux-386. In this case, we skip this combination. if !(r.arch == "386" && r.os == "linux") { - exe, dir = buildTestResource(testresourcesrc, r.os, r.arch, true, true) - tmpDirs = append(tmpDirs, dir) - fs[r.os+r.arch+"-pie"] = exe + go buildTestResource(testresourcesrc, r.os, r.arch, true, true, wg, resultChan) } // build unstripped binary; needs separate source file with reference to GOROOT // for test trying to access it to pass - exe, dir = buildTestResource(nostripSrc, r.os, r.arch, false, false) - tmpDirs = append(tmpDirs, dir) - fs[r.os+r.arch+"-nostrip"] = exe - + go buildTestResource(nostripSrc, r.os, r.arch, false, false, wg, resultChan) } + + wg.Wait() + close(resultChan) + dynResourceFiles = &testFiles{files: fs} fmt.Println("Launching tests") code := m.Run() fmt.Println("Clean up test resources") + for _, d := range tmpDirs { os.RemoveAll(d) } + os.Exit(code) } @@ -473,7 +490,18 @@ func TestDwarfString(t *testing.T) { } } -func buildTestResource(body, goos, arch string, pie, stripped bool) (string, string) { +type buildResult struct { + exe string + dir string + strip bool + pie bool + os string + arch string +} + +func buildTestResource(body, goos, arch string, pie, stripped bool, wg *sync.WaitGroup, result chan buildResult) { + wg.Add(1) + defer wg.Done() goBin, err := exec.LookPath("go") if err != nil { panic("No go tool chain found: " + err.Error()) @@ -518,10 +546,11 @@ func buildTestResource(body, goos, arch string, pie, stripped bool) (string, str cmd.Env = append(cmd.Env, "GOCACHE="+tmpdir, "GOARCH="+arch, "GOOS="+goos, "GOPATH="+gopath, "GOTMPDIR="+gopath, "PATH="+os.Getenv("PATH")) out, err := cmd.CombinedOutput() if err != nil { - panic("building test executable failed: " + string(out)) + fmt.Printf("building test executable failed: %s\n", string(out)) + os.Exit(1) } - return exe, tmpdir + result <- buildResult{exe: exe, dir: tmpdir, strip: stripped, pie: pie, os: goos, arch: arch} } func testCompilerVersion() string { From 983ee3be0c953cc599db15b043bd050572f4b65f Mon Sep 17 00:00:00 2001 From: Zxilly Date: Sat, 24 Feb 2024 02:08:37 +0800 Subject: [PATCH 16/18] fix: waitgroup race --- slow_test.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/slow_test.go b/slow_test.go index ba628a0..032b90f 100644 --- a/slow_test.go +++ b/slow_test.go @@ -87,16 +87,19 @@ func TestMain(m *testing.M) { for _, r := range dynResources { fmt.Printf("Building resource file for %s_%s\n", r.os, r.arch) + wg.Add(1) go buildTestResource(testresourcesrc, r.os, r.arch, false, true, wg, resultChan) // Build a PIE version of the file. Not all host systems, particular macOS, appears to be able // to compile a PIE build of linux-386. In this case, we skip this combination. if !(r.arch == "386" && r.os == "linux") { + wg.Add(1) go buildTestResource(testresourcesrc, r.os, r.arch, true, true, wg, resultChan) } // build unstripped binary; needs separate source file with reference to GOROOT // for test trying to access it to pass + wg.Add(1) go buildTestResource(nostripSrc, r.os, r.arch, false, false, wg, resultChan) } @@ -500,7 +503,6 @@ type buildResult struct { } func buildTestResource(body, goos, arch string, pie, stripped bool, wg *sync.WaitGroup, result chan buildResult) { - wg.Add(1) defer wg.Done() goBin, err := exec.LookPath("go") if err != nil { From d6e290957b1357dfab70dabcd3964004c1e62faa Mon Sep 17 00:00:00 2001 From: Zxilly Date: Sun, 25 Feb 2024 02:33:37 +0800 Subject: [PATCH 17/18] feat: make tests simultaneously --- file_test.go | 18 +- slow_test.go | 567 +++++++++++++++++++-------------------------------- 2 files changed, 213 insertions(+), 372 deletions(-) diff --git a/file_test.go b/file_test.go index 8416315..11e67b6 100644 --- a/file_test.go +++ b/file_test.go @@ -283,6 +283,11 @@ func getGoldenResources() ([]string, error) { const testresourcesrc = ` package main +import ( + "fmt" + "runtime" +) + //go:noinline func getData() string { return "Name: GoRE" @@ -291,18 +296,7 @@ func getData() string { func main() { data := getData() data += " | Test" -} -` - -const nostripSrc = ` -package main - -import ( - "fmt" - "runtime" -) - -func main() { fmt.Println(runtime.GOROOT()) + fmt.Println(data) } ` diff --git a/slow_test.go b/slow_test.go index 032b90f..dd17293 100644 --- a/slow_test.go +++ b/slow_test.go @@ -15,7 +15,6 @@ // You should have received a copy of the GNU Affero General Public License // along with this program. If not, see . //go:build slow_test -// +build slow_test package gore @@ -47,67 +46,104 @@ var dynResources = []struct { var dynResourceFiles *testFiles type testFiles struct { - files map[string]string - filesMu sync.RWMutex + files sync.Map } func (f *testFiles) get(os, arch string, pie, stripped bool) string { - f.filesMu.Lock() - defer f.filesMu.Unlock() + name := os + "-" + arch if pie { - return f.files[os+arch+"-pie"] + name += "-pie" } if !stripped { - return f.files[os+arch+"-nostrip"] + name += "-nostrip" + } + exe, ok := f.files.Load(name) + if !ok { + return "" + } + return exe.(string) +} + +// pass nil to check means all combinations +func getMatrix(t *testing.T, checkPie, checkStrip *bool, prefix string, cb func(*testing.T, string)) { + t.Helper() + for _, r := range dynResources { + var pieCases []bool + if checkPie != nil { + pieCases = append(pieCases, *checkPie) + } else { + pieCases = append(pieCases, true, false) + } + for _, pie := range pieCases { + var strippedCases []bool + if checkStrip != nil { + strippedCases = append(strippedCases, *checkStrip) + } else { + strippedCases = append(strippedCases, true, false) + } + for _, stripped := range strippedCases { + exe := dynResourceFiles.get(r.os, r.arch, pie, stripped) + name := r.os + "-" + r.arch + if pie { + name += "-pie" + } + if !stripped { + name += "-nostrip" + } + t.Run(prefix+"-"+name, func(tt *testing.T) { + tt.Parallel() + if exe == "" { + tt.Skip("no executable available") + } + cb(tt, exe) + }) + } + } + } - return f.files[os+arch] } func TestMain(m *testing.M) { fmt.Println("Creating test resources, this can take some time...") var tmpDirs []string - fs := make(map[string]string) resultChan := make(chan buildResult) wg := &sync.WaitGroup{} + dynResourceFiles = &testFiles{files: sync.Map{}} + go func() { for r := range resultChan { tmpDirs = append(tmpDirs, r.dir) - name := r.os + r.arch + name := r.os + "-" + r.arch if r.pie { name += "-pie" } if !r.strip { name += "-nostrip" } - fs[name] = r.exe + dynResourceFiles.files.Store(name, r.exe) } }() for _, r := range dynResources { fmt.Printf("Building resource file for %s_%s\n", r.os, r.arch) - wg.Add(1) - go buildTestResource(testresourcesrc, r.os, r.arch, false, true, wg, resultChan) - - // Build a PIE version of the file. Not all host systems, particular macOS, appears to be able - // to compile a PIE build of linux-386. In this case, we skip this combination. - if !(r.arch == "386" && r.os == "linux") { - wg.Add(1) - go buildTestResource(testresourcesrc, r.os, r.arch, true, true, wg, resultChan) - } - // build unstripped binary; needs separate source file with reference to GOROOT - // for test trying to access it to pass - wg.Add(1) - go buildTestResource(nostripSrc, r.os, r.arch, false, false, wg, resultChan) + for _, pie := range []bool{false, true} { + for _, stripped := range []bool{false, true} { + if pie && r.arch == "386" && r.os == "linux" { + // seems impossible + continue + } + wg.Add(1) + go buildTestResource(testresourcesrc, r.os, r.arch, pie, stripped, wg, resultChan) + } + } } wg.Wait() close(resultChan) - dynResourceFiles = &testFiles{files: fs} - fmt.Println("Launching tests") code := m.Run() @@ -121,200 +157,94 @@ func TestMain(m *testing.M) { } func TestOpenAndCloseFile(t *testing.T) { - for _, test := range dynResources { - t.Run("open_"+test.os+"-"+test.arch, func(t *testing.T) { - assert := assert.New(t) - exe := dynResourceFiles.get(test.os, test.arch, false, true) - - f, err := Open(exe) - assert.NoError(err) - assert.NotNil(f) - assert.NoError(f.Close()) - }) - - t.Run("open_"+test.os+"-"+test.arch+"-pie", func(t *testing.T) { - assert := assert.New(t) - exe := dynResourceFiles.get(test.os, test.arch, true, true) - if exe == "" { - t.Skip("no PIE available") - } - - f, err := Open(exe) - assert.NoError(err) - assert.NotNil(f) - assert.NoError(f.Close()) - }) - } + getMatrix(t, nil, nil, "open", func(tt *testing.T, exe string) { + a := assert.New(tt) + + f, err := Open(exe) + a.NoError(err) + a.NotNil(f) + a.NoError(f.Close()) + }) } func TestGetPackages(t *testing.T) { - for _, test := range dynResources { - t.Run("open_"+test.os+"-"+test.arch, func(t *testing.T) { - assert := assert.New(t) - require := require.New(t) - exe := dynResourceFiles.get(test.os, test.arch, false, true) - if exe == "" { - t.Skip("no PIE available") - } - - f, err := Open(exe) - require.NoError(err) - require.NotNil(f) - defer f.Close() - - std, err := f.GetSTDLib() - assert.NoError(err) - assert.NotEmpty(std, "Should have a list of standard library packages.") - - _, err = f.GetGeneratedPackages() - assert.NoError(err) - // XXX: This check appears to be unstable. Sometimes files for unknown reason. - // assert.NotEmpty(gen, "Should have a list of generated packages.") - - ven, err := f.GetVendors() - assert.NoError(err) - assert.Empty(ven, "Should not have a list of vendor packages.") - - _, err = f.GetUnknown() - assert.NoError(err) - // XXX: This check appears to be unstable. Sometimes files for unknown reason. - // assert.Empty(unk, "Should not have a list of unknown packages") - - pkgs, err := f.GetPackages() - assert.NoError(err) - - var mainpkg *Package - for _, p := range pkgs { - if p.Name == "main" { - mainpkg = p - break - } - } - - mp := false - gd := false - assert.NotNil(mainpkg, "Should include main package") - for _, f := range mainpkg.Functions { - if f.Name == "main" { - mp = true - } else if f.Name == "getData" { - gd = true - } else { - assert.Fail("Unexpected function") - } - } - assert.True(mp, "No main function found") - assert.True(gd, "getData function not found") - }) - - t.Run("open_"+test.os+"-"+test.arch+"-pie", func(t *testing.T) { - assert := assert.New(t) - require := require.New(t) - exe := dynResourceFiles.get(test.os, test.arch, false, true) - f, err := Open(exe) - require.NoError(err) - require.NotNil(f) - defer f.Close() - - std, err := f.GetSTDLib() - assert.NoError(err) - assert.NotEmpty(std, "Should have a list of standard library packages.") - - _, err = f.GetGeneratedPackages() - assert.NoError(err) - // XXX: This check appears to be unstable. Sometimes files for unknown reason. - // assert.NotEmpty(gen, "Should have a list of generated packages.") - - ven, err := f.GetVendors() - assert.NoError(err) - assert.Empty(ven, "Should not have a list of vendor packages.") - - _, err = f.GetUnknown() - assert.NoError(err) - // XXX: This check appears to be unstable. Sometimes files for unknown reason. - // assert.Empty(unk, "Should not have a list of unknown packages") - - pkgs, err := f.GetPackages() - assert.NoError(err) - - var mainpkg *Package - for _, p := range pkgs { - if p.Name == "main" { - mainpkg = p - break - } + getMatrix(t, nil, nil, "getPackages", func(tt *testing.T, exe string) { + a := assert.New(tt) + r := require.New(tt) + + f, err := Open(exe) + r.NoError(err) + r.NotNil(f) + defer f.Close() + + std, err := f.GetSTDLib() + a.NoError(err) + a.NotEmpty(std, "Should have a list of standard library packages.") + + _, err = f.GetGeneratedPackages() + a.NoError(err) + // XXX: This check appears to be unstable. Sometimes files for unknown reason. + // assert.NotEmpty(gen, "Should have a list of generated packages.") + + ven, err := f.GetVendors() + a.NoError(err) + a.Empty(ven, "Should not have a list of vendor packages.") + + _, err = f.GetUnknown() + a.NoError(err) + // XXX: This check appears to be unstable. Sometimes files for unknown reason. + // assert.Empty(unk, "Should not have a list of unknown packages") + + pkgs, err := f.GetPackages() + a.NoError(err) + + var mainpkg *Package + for _, p := range pkgs { + if p.Name == "main" { + mainpkg = p + break } + } - mp := false - gd := false - assert.NotNil(mainpkg, "Should include main package") - for _, f := range mainpkg.Functions { - if f.Name == "main" { - mp = true - } else if f.Name == "getData" { - gd = true - } else { - assert.Fail("Unexpected function") - } + mainPackageFound := false + getDataFuncFound := false + a.NotNil(mainpkg, "Should include main package") + for _, f := range mainpkg.Functions { + if f.Name == "main" { + mainPackageFound = true + } else if f.Name == "getData" { + getDataFuncFound = true + } else { + a.Fail("Unexpected function") } - assert.True(mp, "No main function found") - assert.True(gd, "getData function not found") - }) - } + } + a.True(mainPackageFound, "No main function found") + a.True(getDataFuncFound, "getData function not found") + }) } func TestGetTypesFromDynamicBuiltResources(t *testing.T) { - for _, test := range dynResources { - t.Run("open_"+test.os+"-"+test.arch, func(t *testing.T) { - assert := assert.New(t) - require := require.New(t) - exe := dynResourceFiles.get(test.os, test.arch, false, true) - f, err := Open(exe) - require.NoError(err) - require.NotNil(f) - defer f.Close() - - typs, err := f.GetTypes() - require.NoError(err) - - var stringer *GoType - for _, t := range typs { - if t.PackagePath == "runtime" && t.Name == "runtime.g" { - stringer = t - break - } - } - - assert.NotNil(stringer, "the g type from runtime not found") - }) - - t.Run("open_"+test.os+"-"+test.arch+"-pie", func(t *testing.T) { - assert := assert.New(t) - require := require.New(t) - exe := dynResourceFiles.get(test.os, test.arch, true, true) - if exe == "" { - t.Skip(("PIE file not available")) - } - - f, err := Open(exe) - require.NoError(err) - require.NotNil(f) - defer f.Close() - - typs, err := f.GetTypes() - require.NoError(err) - - var stringer *GoType - for _, t := range typs { - if t.PackagePath == "runtime" && t.Name == "runtime.g" { - stringer = t - break - } + getMatrix(t, nil, nil, "getTypes", func(tt *testing.T, exe string) { + a := assert.New(t) + r := require.New(t) + f, err := Open(exe) + r.NoError(err) + r.NotNil(f) + defer f.Close() + + typs, err := f.GetTypes() + r.NoError(err) + + var stringer *GoType + for _, t := range typs { + if t.PackagePath == "runtime" && t.Name == "runtime.g" { + stringer = t + break } + } - assert.NotNil(stringer, "the g type from runtime not found") - }) - } + a.NotNil(stringer, "the g type from runtime not found") + }) } func TestGetCompilerVersion(t *testing.T) { @@ -323,174 +253,91 @@ func TestGetCompilerVersion(t *testing.T) { // If the version could not be resolved, the version is new // and the library doesn't know about it. Use the version string - // to created a new version. + // to create a new version. if expectedVersion == nil { expectedVersion = &GoVersion{Name: testVersion} } - for _, test := range dynResources { - t.Run("parsing_"+test.os+"-"+test.arch, func(t *testing.T) { - assert := assert.New(t) - require := require.New(t) - exe := dynResourceFiles.get(test.os, test.arch, false, true) - f, err := Open(exe) - require.NoError(err) - require.NotNil(f) - defer f.Close() - - // Test - version, err := f.GetCompilerVersion() - assert.NoError(err) - assert.Equal(expectedVersion, version) - }) - - t.Run("parsing_"+test.os+"-"+test.arch+"-pie", func(t *testing.T) { - assert := assert.New(t) - require := require.New(t) - exe := dynResourceFiles.get(test.os, test.arch, true, true) - if exe == "" { - t.Skip("no PIE available") - } - - f, err := Open(exe) - require.NoError(err) - require.NotNil(f) - defer f.Close() - - // Test - version, err := f.GetCompilerVersion() - assert.NoError(err) - assert.Equal(expectedVersion, version) - }) - } + getMatrix(t, nil, nil, "compiler-version", func(t *testing.T, exe string) { + a := assert.New(t) + r := require.New(t) + f, err := Open(exe) + r.NoError(err) + r.NotNil(f) + defer f.Close() + + // Test + version, err := f.GetCompilerVersion() + a.NoError(err) + a.Equal(expectedVersion, version) + }) } func TestGetBuildID(t *testing.T) { - for _, test := range dynResources { - t.Run("buildID_"+test.os+"-"+test.arch, func(t *testing.T) { - assert := assert.New(t) - require := require.New(t) - exe := dynResourceFiles.get(test.os, test.arch, false, true) - f, err := Open(exe) - require.NoError(err) - require.NotNil(f) - defer f.Close() - - assert.Equal(fixedBuildID, f.BuildID, "BuildID extracted doesn't match expected value.") - }) - - t.Run("buildID_"+test.os+"-"+test.arch+"-pie", func(t *testing.T) { - assert := assert.New(t) - require := require.New(t) - exe := dynResourceFiles.get(test.os, test.arch, true, true) - if exe == "" { - t.Skip("no PIE available") - } - - f, err := Open(exe) - require.NoError(err) - require.NotNil(f) - defer f.Close() - - assert.Equal(fixedBuildID, f.BuildID, "BuildID extracted doesn't match expected value.") - }) - } + getMatrix(t, nil, nil, "buildID", func(t *testing.T, exe string) { + a := assert.New(t) + r := require.New(t) + f, err := Open(exe) + r.NoError(err) + r.NotNil(f) + defer f.Close() + + a.Equal(fixedBuildID, f.BuildID, "BuildID extracted doesn't match expected value.") + }) } func TestSourceInfo(t *testing.T) { - for _, test := range dynResources { - t.Run("buildID_"+test.os+"-"+test.arch, func(t *testing.T) { - assert := assert.New(t) - require := require.New(t) - exe := dynResourceFiles.get(test.os, test.arch, false, true) - f, err := Open(exe) - require.NoError(err) - require.NotNil(f) - defer f.Close() - - var testFn *Function - pkgs, err := f.GetPackages() - require.NoError(err) - for _, pkg := range pkgs { - if pkg.Name != "main" { - continue - } - for _, fn := range pkg.Functions { - if fn.Name != "getData" { - continue - } - testFn = fn - break - } - } - require.NotNil(testFn) - - file, start, end := f.SourceInfo(testFn) - - assert.NotEqual(0, start) - assert.NotEqual(0, end) - assert.NotEqual("", file) - }) - - t.Run("buildID_"+test.os+"-"+test.arch+"-pie", func(t *testing.T) { - assert := assert.New(t) - require := require.New(t) - exe := dynResourceFiles.get(test.os, test.arch, true, true) - if exe == "" { - t.Skip("no PIE available") + getMatrix(t, nil, nil, "sourceInfo", func(t *testing.T, exe string) { + a := assert.New(t) + r := require.New(t) + f, err := Open(exe) + r.NoError(err) + r.NotNil(f) + defer f.Close() + + var testFn *Function + pkgs, err := f.GetPackages() + r.NoError(err) + for _, pkg := range pkgs { + if pkg.Name != "main" { + continue } - - f, err := Open(exe) - require.NoError(err) - require.NotNil(f) - defer f.Close() - - var testFn *Function - pkgs, err := f.GetPackages() - require.NoError(err) - for _, pkg := range pkgs { - if pkg.Name != "main" { + for _, fn := range pkg.Functions { + if fn.Name != "getData" { continue } - for _, fn := range pkg.Functions { - if fn.Name != "getData" { - continue - } - testFn = fn - break - } + testFn = fn + break } - require.NotNil(testFn) + } + r.NotNil(testFn) - file, start, end := f.SourceInfo(testFn) + file, start, end := f.SourceInfo(testFn) - assert.NotEqual(0, start) - assert.NotEqual(0, end) - assert.NotEqual("", file) - }) - } + a.NotEqual(0, start) + a.NotEqual(0, end) + a.NotEqual("", file) + }) } func TestDwarfString(t *testing.T) { - for _, test := range dynResources { - t.Run("dwarfString_"+test.os+"-"+test.arch, func(t *testing.T) { - require := require.New(t) - - exe := dynResourceFiles.get(test.os, test.arch, false, false) - f, err := Open(exe) - require.NoError(err) - require.NotNil(f) - defer f.Close() - - gover, ok := getBuildVersionFromDwarf(f.fh) - require.True(ok) - require.Equal(gover, runtime.Version()) - - goroot, ok := getGoRootFromDwarf(f.fh) - require.True(ok) - require.Equal(goroot, runtime.GOROOT()) - }) - } + noStrip := false + getMatrix(t, nil, &noStrip, "dwarfString", func(t *testing.T, exe string) { + r := require.New(t) + + f, err := Open(exe) + r.NoError(err) + r.NotNil(f) + defer f.Close() + + gover, ok := getBuildVersionFromDwarf(f.fh) + r.True(ok) + r.Equal(gover, runtime.Version()) + + goroot, ok := getGoRootFromDwarf(f.fh) + r.True(ok) + r.Equal(goroot, runtime.GOROOT()) + }) } type buildResult struct { @@ -521,8 +368,8 @@ func buildTestResource(body, goos, arch string, pie, stripped bool, wg *sync.Wai } exe := filepath.Join(tmpdir, "a") - if pie { - exe = exe + "-pie" + if runtime.GOOS == "windows" { + exe += ".exe" } var ldFlags string From 92fd146abff86484a3b588868ddd7fb1421b70ce Mon Sep 17 00:00:00 2001 From: Zxilly Date: Sun, 25 Feb 2024 14:19:52 +0800 Subject: [PATCH 18/18] fix: fix wrong t instance --- slow_test.go | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/slow_test.go b/slow_test.go index dd17293..3df5e9d 100644 --- a/slow_test.go +++ b/slow_test.go @@ -157,8 +157,8 @@ func TestMain(m *testing.M) { } func TestOpenAndCloseFile(t *testing.T) { - getMatrix(t, nil, nil, "open", func(tt *testing.T, exe string) { - a := assert.New(tt) + getMatrix(t, nil, nil, "open", func(t *testing.T, exe string) { + a := assert.New(t) f, err := Open(exe) a.NoError(err) @@ -168,9 +168,9 @@ func TestOpenAndCloseFile(t *testing.T) { } func TestGetPackages(t *testing.T) { - getMatrix(t, nil, nil, "getPackages", func(tt *testing.T, exe string) { - a := assert.New(tt) - r := require.New(tt) + getMatrix(t, nil, nil, "getPackages", func(t *testing.T, exe string) { + a := assert.New(t) + r := require.New(t) f, err := Open(exe) r.NoError(err) @@ -224,7 +224,7 @@ func TestGetPackages(t *testing.T) { } func TestGetTypesFromDynamicBuiltResources(t *testing.T) { - getMatrix(t, nil, nil, "getTypes", func(tt *testing.T, exe string) { + getMatrix(t, nil, nil, "getTypes", func(t *testing.T, exe string) { a := assert.New(t) r := require.New(t) f, err := Open(exe)