From 5a17ddd6e8a3f0cf0ff441c94064df3cb669b2c2 Mon Sep 17 00:00:00 2001 From: Zxilly Date: Fri, 2 Feb 2024 06:00:03 +0800 Subject: [PATCH] refactor: rewrite moduledata generate --- gen/moduledata.go | 496 +++++++------- gen/static.go | 2 + moduledata.go | 57 +- moduledata_gen.go | 1619 +++++++++++++++++++++++++++++++++++++++++---- 4 files changed, 1744 insertions(+), 430 deletions(-) diff --git a/gen/moduledata.go b/gen/moduledata.go index d6c1b30..2dca22d 100644 --- a/gen/moduledata.go +++ b/gen/moduledata.go @@ -19,293 +19,299 @@ package main import ( "bytes" + "context" "fmt" + "github.com/google/go-github/v58/github" + "go/ast" "go/format" + "go/parser" + "golang.org/x/mod/semver" "os" - "reflect" + "regexp" + "sort" + "strconv" "strings" ) -func typeDef(b *bytes.Buffer, st reflect.Type, bits int) { - typeName := "uint64" - if bits == 32 { - typeName = "uint32" +var moduleDataMatcher = regexp.MustCompile(`(?m:type moduledata struct {[^}]+})`) + +// generateModuleDataSources +// returns a map of moduledata sources for each go version, from 1.5 to the latest we know so far. +func getModuleDataSources() (map[int]string, error) { + ret := make(map[int]string) + + f, err := os.OpenFile(goversionCsv, os.O_CREATE|os.O_RDWR, 0664) + if err != nil { + return nil, fmt.Errorf("error when opening goversions.csv: %w", err) + } + knownVersion, err := getCsvStoredGoversions(f) + if err != nil { + return nil, fmt.Errorf("error when getting stored go versions: %w", err) } - _, _ = fmt.Fprintf(b, "type %s%d struct {\n", st.Name(), bits) - - for i := 0; i < st.NumField(); i++ { - field := st.Field(i) - fieldName := strings.ToUpper(field.Name[:1]) + field.Name[1:] - t := field.Type.Kind() - switch t { - case reflect.Uintptr: - _, _ = fmt.Fprintf(b, "%s %s\n", fieldName, typeName) - case reflect.String: - _, _ = fmt.Fprintf(b, "%s, %[1]slen %s\n", fieldName, typeName) - case reflect.Pointer: - _, _ = fmt.Fprintf(b, "%s %s\n", fieldName, typeName) - case reflect.Slice: - _, _ = fmt.Fprintf(b, "%s, %[1]slen, %[1]scap %s\n", fieldName, typeName) - - default: - panic(fmt.Sprintf("unhandled type: %+v", t)) + knownVersionSlice := make([]string, 0, len(knownVersion)) + + matcher := regexp.MustCompile(`[a-zA-Z]`) + for ver := range knownVersion { + // rc/beta version not in consideration + if matcher.MatchString(ver[2:]) { + continue } + + knownVersionSlice = append(knownVersionSlice, semver.MajorMinor("v"+strings.TrimPrefix(ver, "go"))) } + semver.Sort(knownVersionSlice) - _, _ = fmt.Fprint(b, "}\n\n") -} + latest := knownVersionSlice[len(knownVersionSlice)-1] -func toModuledata(b *bytes.Buffer, st reflect.Type, bits int) { - _, _ = fmt.Fprintf(b, "func (md %s%d) toModuledata() moduledata {\n", st.Name(), bits) - _, _ = fmt.Fprint(b, "return moduledata{\n") - - for _, names := range [][2]string{ - {"Text", "Text"}, - {"NoPtrData", "Noptrdata"}, - {"Data", "Data"}, - {"Bss", "Bss"}, - {"NoPtrBss", "Noptrbss"}, - {"Types", "Types"}, - } { - modFieldE(b, st, bits, names[0], names[1]) + maxMinor, err := strconv.Atoi(strings.Split(latest, ".")[1]) + if err != nil { + return nil, fmt.Errorf("error when getting latest go version: %w, %s", err, latest) } - for _, names := range [][2]string{ - {"Typelink", "Typelinks"}, - {"ITabLink", "Itablinks"}, - {"FuncTab", "Ftab"}, - {"PCLNTab", "Pclntable"}, - } { - modFieldLen(b, st, bits, names[0], names[1]) - } + for i := 5; i <= maxMinor; i++ { + fmt.Println("Fetching moduledata for go1." + strconv.Itoa(i) + "...") + branch := fmt.Sprintf("release-branch.go1.%d", i) + contents, _, _, err := githubClient.Repositories.GetContents( + context.Background(), + "golang", "go", + "src/runtime/symtab.go", + &github.RepositoryContentGetOptions{Ref: branch}) + if err != nil { + return nil, err + } - modFieldVal(b, st, bits, "GoFunc", "Gofunc") + content, err := contents.GetContent() + if err != nil { + return nil, err + } - _, _ = fmt.Fprint(b, "}\n}\n\n") -} + structStr := moduleDataMatcher.FindString(content) + if structStr == "" { + return nil, fmt.Errorf("moduledata struct not found in symtab.go") + } -func modFieldE(b *bytes.Buffer, st reflect.Type, bits int, modName, parsedName string) { - endName := "E" + strings.ToLower(parsedName) - if _, ok := st.FieldByName(strings.ToLower(parsedName)); !ok { - return - } - if bits == 32 { - _, _ = fmt.Fprintf(b, "%sAddr: uint64(md.%[3]s),\n%[1]sLen: uint64(md.%s - md.%s),\n", modName, endName, parsedName) - } else { - _, _ = fmt.Fprintf(b, "%sAddr: md.%[3]s,\n%[1]sLen: md.%s - md.%s,\n", modName, endName, parsedName) + // make it an expression for further parse + structStr = strings.TrimPrefix(structStr, "type moduledata ") + + ret[i] = structStr } + + return ret, nil } -func modFieldLen(b *bytes.Buffer, st reflect.Type, bits int, modName, parsedName string) { - lenName := parsedName + "len" - if _, ok := st.FieldByName(strings.ToLower(parsedName)); !ok { - return - } - if bits == 32 { - _, _ = fmt.Fprintf(b, "%sAddr: uint64(md.%s),\n%[1]sLen: uint64(md.%[3]s),\n", modName, parsedName, lenName) - } else { - _, _ = fmt.Fprintf(b, "%sAddr: md.%s,\n%[1]sLen: md.%[3]s,\n", modName, parsedName, lenName) - } +type moduleDataGenerator struct { + buf *bytes.Buffer + + knownVersions []int } -func modFieldVal(b *bytes.Buffer, st reflect.Type, bits int, modName, parsedName string) { - if _, ok := st.FieldByName(strings.ToLower(parsedName)); !ok { - return - } - if bits == 32 { - _, _ = fmt.Fprintf(b, "%sVal: uint64(md.%s),\n", modName, parsedName) - } else { - _, _ = fmt.Fprintf(b, "%sVal: md.%s,\n", modName, parsedName) - } +func (g *moduleDataGenerator) init() { + g.buf = &bytes.Buffer{} + g.buf.WriteString(moduleDataHeader) } -func generateModuleData() { - b := &bytes.Buffer{} - b.WriteString(moduleDataHeader) - - for _, iface := range []any{ - moduledata20{}, - moduledata18{}, - moduledata16{}, - moduledata8{}, - moduledata7{}, - moduledata5{}, - } { - o := reflect.TypeOf(iface) - typeDef(b, o, 64) - toModuledata(b, o, 64) - typeDef(b, o, 32) - toModuledata(b, o, 32) - } +func (g *moduleDataGenerator) add(versionCode int, code string) error { + g.knownVersions = append(g.knownVersions, versionCode) - out, err := format.Source(b.Bytes()) + err := g.writeVersionedModuleData(versionCode, code) if err != nil { - panic(err) + return err } - err = os.WriteFile(moduleDataOutputFile, out, 0o666) - if err != nil { - panic(err) - } + return nil } -/* - Internal module structures from Go's runtime. - TODO: auto extract from golang source runtime package. -*/ - -// Moduledata structure for Go 1.20 and newer (at least up to the last field covered here) - -type moduledata20 struct { - pcHeader *pcHeader - funcnametab []byte - cutab []uint32 - filetab []byte - pctab []byte - pclntable []byte - ftab []functab - findfunctab uintptr - minpc, maxpc uintptr - - text, etext uintptr - noptrdata, enoptrdata uintptr - data, edata uintptr - bss, ebss uintptr - noptrbss, enoptrbss uintptr - covctrs, ecovctrs uintptr - end, gcdata, gcbss uintptr - types, etypes uintptr - rodata uintptr - gofunc uintptr // go.func.* - - textsectmap []textsect - typelinks []int32 // offsets from types - itablinks []*itab +func (g *moduleDataGenerator) writeSelector() { + g.writeln("func selectModuleData(v int, bits int) modulable {") + g.writeln("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{}", g.generateTypeName(versionCode, bits)) + } + } + g.writeln("default:") + g.writeln(`panic(fmt.Sprintf("unsupported go version %%d", v))`) + + g.writeln("}\n}\n") + } -// Moduledata structure for Go 1.18 and Go 1.19 - -type moduledata18 struct { - pcHeader *pcHeader - funcnametab []byte - cutab []uint32 - filetab []byte - pctab []byte - pclntable []byte - ftab []functab - findfunctab uintptr - minpc, maxpc uintptr - - text, etext uintptr - noptrdata, enoptrdata uintptr - data, edata uintptr - bss, ebss uintptr - noptrbss, enoptrbss uintptr - end, gcdata, gcbss uintptr - types, etypes uintptr - rodata uintptr - gofunc uintptr // go.func.* - - textsectmap []textsect - typelinks []int32 // offsets from types - itablinks []*itab +func (*moduleDataGenerator) generateTypeName(versionCode int, bits int) string { + return fmt.Sprintf("moduledata_1_%d_%d", versionCode, bits) } -// Moduledata structure for Go 1.16 to 1.17 - -type moduledata16 struct { - pcHeader *pcHeader - funcnametab []byte - cutab []uint32 - filetab []byte - pctab []byte - pclntable []byte - ftab []functab - findfunctab uintptr - minpc, maxpc uintptr - - text, etext uintptr - noptrdata, enoptrdata uintptr - data, edata uintptr - bss, ebss uintptr - noptrbss, enoptrbss uintptr - end, gcdata, gcbss uintptr - types, etypes uintptr - - textsectmap []textsect - typelinks []int32 // offsets from types - itablinks []*itab +func (*moduleDataGenerator) wrapValue(name string, bits int) string { + if bits == 32 { + return fmt.Sprintf("uint64(%s)", name) + } + return name } -// Moduledata structure for Go 1.8 to 1.15 - -type moduledata8 struct { - pclntable []byte - ftab []functab - filetab []uint32 - findfunctab uintptr - minpc, maxpc uintptr - - text, etext uintptr - noptrdata, enoptrdata uintptr - data, edata uintptr - bss, ebss uintptr - noptrbss, enoptrbss uintptr - end, gcdata, gcbss uintptr - types, etypes uintptr - - textsectmap []textsect - typelinks []int32 // offsets from types - itablinks []*itab +func (*moduleDataGenerator) title(s string) string { + return strings.ToUpper(s[:1]) + s[1:] } -// Moduledata structure for Go 1.7 - -type moduledata7 struct { - pclntable []byte - ftab []functab - filetab []uint32 - findfunctab uintptr - minpc, maxpc uintptr - - text, etext uintptr - noptrdata, enoptrdata uintptr - data, edata uintptr - bss, ebss uintptr - noptrbss, enoptrbss uintptr - end, gcdata, gcbss uintptr - types, etypes uintptr - - typelinks []int32 // offsets from types - itablinks []*itab +func (g *moduleDataGenerator) writeln(format string, a ...interface{}) { + _, _ = fmt.Fprintf(g.buf, format+"\n", a...) } -// Moduledata structure for Go 1.5 to 1.6 +func (g *moduleDataGenerator) writeVersionedModuleData(versionCode int, code string) error { + expr, err := parser.ParseExpr(code) + if err != nil { + return fmt.Errorf("failed to parse moduledata expression: %w", err) + } -type moduledata5 struct { - pclntable []byte - ftab []functab - filetab []uint32 - findfunctab uintptr - minpc, maxpc uintptr + writeCode := func(bits int) { + g.writeln("type %s struct {\n", g.generateTypeName(versionCode, bits)) + + fields := make(map[string]struct{}) + expr := expr.(*ast.StructType) + search: + for _, field := range expr.Fields.List { + if len(field.Names) == 0 { + // skip anonymous field + // currently only sys.NotInHeap + continue + } + + for _, name := range field.Names { + if name.Name == "modulename" { + // no more data needed + break search + } + fields[name.Name] = struct{}{} + + switch t := field.Type.(type) { + case *ast.StarExpr: + g.writeln("%s uint%d", g.title(name.Name), bits) + case *ast.ArrayType: + g.writeln("%s, %[1]slen, %[1]scap uint%d", g.title(name.Name), bits) + case *ast.Ident: + switch t.Name { + case "uintptr": + g.writeln("%s uint%d", g.title(name.Name), bits) + case "string": + g.writeln("%s, %[1]slen uint%d", g.title(name.Name), bits) + case "uint8": + g.writeln("%s uint8", g.title(name.Name)) + default: + panic(fmt.Sprintf("unhandled type: %+v", t)) + } + default: + panic(fmt.Sprintf("unhandled type: %+v", t)) + } + } + } + + g.writeln("}\n\n") - text, etext uintptr - noptrdata, enoptrdata uintptr - data, edata uintptr - bss, ebss uintptr - noptrbss, enoptrbss uintptr - end, gcdata, gcbss uintptr + // generate toModuledata method + exist := func(name string) bool { + _, ok := fields[name] + return ok + } - typelinks []*_type + g.writeln("func (md %s) toModuledata() moduledata {", g.generateTypeName(versionCode, bits)) + g.writeln("return moduledata{") + + if exist("text") && exist("etext") { + g.writeln("TextAddr: %s,", g.wrapValue("md.Text", bits)) + g.writeln("TextLen: %s,", g.wrapValue("md.Etext - md.Text", bits)) + } + + if exist("noptrdata") && exist("enoptrdata") { + g.writeln("NoPtrDataAddr: %s,", g.wrapValue("md.Noptrdata", bits)) + g.writeln("NoPtrDataLen: %s,", g.wrapValue("md.Enoptrdata - md.Noptrdata", bits)) + } + + if exist("data") && exist("edata") { + g.writeln("DataAddr: %s,", g.wrapValue("md.Data", bits)) + g.writeln("DataLen: %s,", g.wrapValue("md.Edata - md.Data", bits)) + } + + if exist("bss") && exist("ebss") { + g.writeln("BssAddr: %s,", g.wrapValue("md.Bss", bits)) + g.writeln("BssLen: %s,", g.wrapValue("md.Ebss - md.Bss", bits)) + } + + if exist("noptrbss") && exist("enoptrbss") { + g.writeln("NoPtrBssAddr: %s,", g.wrapValue("md.Noptrbss", bits)) + g.writeln("NoPtrBssLen: %s,", g.wrapValue("md.Enoptrbss - md.Noptrbss", bits)) + } + + if exist("types") && exist("etypes") { + 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)) + } + + if exist("itablinks") { + 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)) + } + + if exist("pclntable") { + 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("}\n}\n") + } + + writeCode(32) + writeCode(64) + + return nil } -// dummy definitions -type initTask struct{} -type pcHeader struct{} -type functab struct{} -type textsect struct{} -type itab struct{} -type ptabEntry struct{} -type modulehash struct{} -type _type struct{} +func generateModuleData() { + sources, err := getModuleDataSources() + if err != nil { + panic(err) + } + + g := moduleDataGenerator{} + g.init() + + versionCodes := make([]int, 0, len(sources)) + for versionCode := range sources { + versionCodes = append(versionCodes, versionCode) + } + + sort.Ints(versionCodes) + + for _, versionCode := range versionCodes { + err = g.add(versionCode, sources[versionCode]) + if err != nil { + panic(err) + } + } + + g.writeSelector() + + out, err := format.Source(g.buf.Bytes()) + if err != nil { + panic(err) + } + + err = os.WriteFile(moduleDataOutputFile, out, 0o666) + if err != nil { + panic(err) + } +} diff --git a/gen/static.go b/gen/static.go index 225d8e7..aebc26b 100644 --- a/gen/static.go +++ b/gen/static.go @@ -104,6 +104,8 @@ const moduleDataHeader = ` package gore +import "fmt" + ` var ( diff --git a/moduledata.go b/moduledata.go index 21731ba..9e11ea0 100644 --- a/moduledata.go +++ b/moduledata.go @@ -24,7 +24,10 @@ import ( "encoding/binary" "errors" "fmt" + "golang.org/x/mod/semver" "io" + "strconv" + "strings" ) // Moduledata extracts the file's moduledata. @@ -256,49 +259,21 @@ func parseModuledata(fileInfo *FileInfo, f fileHandler) (moduledata, error) { return moduledata{}, err } - // buf will hold the struct type that represents the data in the file we are processing. - var buf modulable - is32bit := fileInfo.WordSize == intSize32 - - // Determine what kind of struct we need to extract the module data from the file. - - if GoVersionCompare("go1.20rc1", fileInfo.goversion.Name) <= 0 { - if is32bit { - buf = &moduledata2032{} - } else { - buf = &moduledata2064{} - } - } else if GoVersionCompare("go1.18beta1", fileInfo.goversion.Name) <= 0 { - if is32bit { - buf = &moduledata1832{} - } else { - buf = &moduledata1864{} - } - } else if GoVersionCompare("go1.16beta1", fileInfo.goversion.Name) <= 0 { - if is32bit { - buf = &moduledata1632{} - } else { - buf = &moduledata1664{} - } - } else if GoVersionCompare("go1.8beta1", fileInfo.goversion.Name) <= 0 { - if is32bit { - buf = &moduledata832{} - } else { - buf = &moduledata864{} - } - } else if GoVersionCompare("go1.7beta1", fileInfo.goversion.Name) <= 0 { - if is32bit { - buf = &moduledata732{} - } else { - buf = &moduledata764{} - } + var bits int + if fileInfo.WordSize == intSize32 { + bits = 32 } else { - if is32bit { - buf = &moduledata532{} - } else { - buf = &moduledata564{} - } + bits = 64 + } + + ver := buildSemVerString(fileInfo.goversion.Name) + m := semver.MajorMinor(ver) + verBit, err := strconv.Atoi(strings.Split(m, ".")[1]) + if err != nil { + return moduledata{}, fmt.Errorf("error when parsing the Go version: %w", err) } + // buf will hold the struct type that represents the data in the file we are processing. + buf := selectModuleData(verBit, bits) // Read the module struct from the file. r := bytes.NewReader(data) diff --git a/moduledata_gen.go b/moduledata_gen.go index 0dc96fc..b97782c 100644 --- a/moduledata_gen.go +++ b/moduledata_gen.go @@ -19,7 +19,1226 @@ package gore -type moduledata2064 struct { +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 +} + +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), + } +} + +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_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, + } +} + +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_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), + } +} + +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_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, + } +} + +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_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), + } +} + +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_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, + } +} + +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_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), + } +} + +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_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, + } +} + +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_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), + } +} + +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_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, + } +} + +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_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), + } +} + +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_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, + } +} + +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_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), + } +} + +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_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, + } +} + +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_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), + } +} + +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_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, + } +} + +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_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), + } +} + +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_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, + } +} + +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_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), + } +} + +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_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, + } +} + +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_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), + } +} + +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_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, + } +} + +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_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), + } +} + +type moduledata_1_16_64 struct { PcHeader uint64 Funcnametab, Funcnametablen, Funcnametabcap uint64 Cutab, Cutablen, Cutabcap uint64 @@ -40,21 +1259,20 @@ type moduledata2064 struct { 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 moduledata2064) toModuledata() moduledata { +func (md moduledata_1_16_64) toModuledata() moduledata { return moduledata{ TextAddr: md.Text, TextLen: md.Etext - md.Text, @@ -76,11 +1294,10 @@ func (md moduledata2064) toModuledata() moduledata { FuncTabLen: md.Ftablen, PCLNTabAddr: md.Pclntable, PCLNTabLen: md.Pclntablelen, - GoFuncVal: md.Gofunc, } } -type moduledata2032 struct { +type moduledata_1_17_32 struct { PcHeader uint32 Funcnametab, Funcnametablen, Funcnametabcap uint32 Cutab, Cutablen, Cutabcap uint32 @@ -101,21 +1318,20 @@ type moduledata2032 struct { 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 moduledata2032) toModuledata() moduledata { +func (md moduledata_1_17_32) toModuledata() moduledata { return moduledata{ TextAddr: uint64(md.Text), TextLen: uint64(md.Etext - md.Text), @@ -137,11 +1353,10 @@ func (md moduledata2032) toModuledata() moduledata { FuncTabLen: uint64(md.Ftablen), PCLNTabAddr: uint64(md.Pclntable), PCLNTabLen: uint64(md.Pclntablelen), - GoFuncVal: uint64(md.Gofunc), } } -type moduledata1864 struct { +type moduledata_1_17_64 struct { PcHeader uint64 Funcnametab, Funcnametablen, Funcnametabcap uint64 Cutab, Cutablen, Cutabcap uint64 @@ -167,14 +1382,15 @@ type moduledata1864 struct { 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 moduledata1864) toModuledata() moduledata { +func (md moduledata_1_17_64) toModuledata() moduledata { return moduledata{ TextAddr: md.Text, TextLen: md.Etext - md.Text, @@ -196,11 +1412,10 @@ func (md moduledata1864) toModuledata() moduledata { FuncTabLen: md.Ftablen, PCLNTabAddr: md.Pclntable, PCLNTabLen: md.Pclntablelen, - GoFuncVal: md.Gofunc, } } -type moduledata1832 struct { +type moduledata_1_18_32 struct { PcHeader uint32 Funcnametab, Funcnametablen, Funcnametabcap uint32 Cutab, Cutablen, Cutabcap uint32 @@ -231,9 +1446,12 @@ type moduledata1832 struct { 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 moduledata1832) toModuledata() moduledata { +func (md moduledata_1_18_32) toModuledata() moduledata { return moduledata{ TextAddr: uint64(md.Text), TextLen: uint64(md.Etext - md.Text), @@ -259,7 +1477,7 @@ func (md moduledata1832) toModuledata() moduledata { } } -type moduledata1664 struct { +type moduledata_1_18_64 struct { PcHeader uint64 Funcnametab, Funcnametablen, Funcnametabcap uint64 Cutab, Cutablen, Cutabcap uint64 @@ -285,12 +1503,17 @@ type moduledata1664 struct { 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 moduledata1664) toModuledata() moduledata { +func (md moduledata_1_18_64) toModuledata() moduledata { return moduledata{ TextAddr: md.Text, TextLen: md.Etext - md.Text, @@ -312,10 +1535,11 @@ func (md moduledata1664) toModuledata() moduledata { FuncTabLen: md.Ftablen, PCLNTabAddr: md.Pclntable, PCLNTabLen: md.Pclntablelen, + GoFuncVal: md.Gofunc, } } -type moduledata1632 struct { +type moduledata_1_19_32 struct { PcHeader uint32 Funcnametab, Funcnametablen, Funcnametabcap uint32 Cutab, Cutablen, Cutabcap uint32 @@ -341,12 +1565,17 @@ type moduledata1632 struct { 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 moduledata1632) toModuledata() moduledata { +func (md moduledata_1_19_32) toModuledata() moduledata { return moduledata{ TextAddr: uint64(md.Text), TextLen: uint64(md.Etext - md.Text), @@ -368,13 +1597,18 @@ func (md moduledata1632) toModuledata() moduledata { FuncTabLen: uint64(md.Ftablen), PCLNTabAddr: uint64(md.Pclntable), PCLNTabLen: uint64(md.Pclntablelen), + GoFuncVal: uint64(md.Gofunc), } } -type moduledata864 struct { +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 - Filetab, Filetablen, Filetabcap uint64 Findfunctab uint64 Minpc uint64 Maxpc uint64 @@ -393,12 +1627,17 @@ type moduledata864 struct { 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 moduledata864) toModuledata() moduledata { +func (md moduledata_1_19_64) toModuledata() moduledata { return moduledata{ TextAddr: md.Text, TextLen: md.Etext - md.Text, @@ -420,13 +1659,18 @@ func (md moduledata864) toModuledata() moduledata { FuncTabLen: md.Ftablen, PCLNTabAddr: md.Pclntable, PCLNTabLen: md.Pclntablelen, + GoFuncVal: md.Gofunc, } } -type moduledata832 struct { +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 - Filetab, Filetablen, Filetabcap uint32 Findfunctab uint32 Minpc uint32 Maxpc uint32 @@ -440,17 +1684,24 @@ type moduledata832 struct { 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 moduledata832) toModuledata() moduledata { +func (md moduledata_1_20_32) toModuledata() moduledata { return moduledata{ TextAddr: uint64(md.Text), TextLen: uint64(md.Etext - md.Text), @@ -472,36 +1723,49 @@ func (md moduledata832) toModuledata() moduledata { FuncTabLen: uint64(md.Ftablen), PCLNTabAddr: uint64(md.Pclntable), PCLNTabLen: uint64(md.Pclntablelen), + GoFuncVal: uint64(md.Gofunc), } } -type moduledata764 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 moduledata764) toModuledata() moduledata { +func (md moduledata_1_20_64) toModuledata() moduledata { return moduledata{ TextAddr: md.Text, TextLen: md.Etext - md.Text, @@ -523,36 +1787,50 @@ func (md moduledata764) toModuledata() moduledata { FuncTabLen: md.Ftablen, PCLNTabAddr: md.Pclntable, PCLNTabLen: md.Pclntablelen, + GoFuncVal: md.Gofunc, } } -type moduledata732 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_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 moduledata732) toModuledata() moduledata { +func (md moduledata_1_21_32) toModuledata() moduledata { return moduledata{ TextAddr: uint64(md.Text), TextLen: uint64(md.Etext - md.Text), @@ -574,33 +1852,50 @@ func (md moduledata732) toModuledata() moduledata { FuncTabLen: uint64(md.Ftablen), PCLNTabAddr: uint64(md.Pclntable), PCLNTabLen: uint64(md.Pclntablelen), + GoFuncVal: uint64(md.Gofunc), } } -type moduledata564 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 moduledata564) toModuledata() moduledata { +func (md moduledata_1_21_64) toModuledata() moduledata { return moduledata{ TextAddr: md.Text, TextLen: md.Etext - md.Text, @@ -612,55 +1907,91 @@ func (md moduledata564) toModuledata() moduledata { 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 moduledata532 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 moduledata532) 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), +func selectModuleData(v int, bits int) modulable { + switch { + case v == 5 && bits == 32: + return &moduledata_1_5_32{} + case v == 5 && bits == 64: + return &moduledata_1_5_64{} + case v == 6 && bits == 32: + return &moduledata_1_6_32{} + case v == 6 && bits == 64: + return &moduledata_1_6_64{} + case v == 7 && bits == 32: + return &moduledata_1_7_32{} + case v == 7 && bits == 64: + return &moduledata_1_7_64{} + case v == 8 && bits == 32: + return &moduledata_1_8_32{} + case v == 8 && bits == 64: + return &moduledata_1_8_64{} + case v == 9 && bits == 32: + return &moduledata_1_9_32{} + case v == 9 && bits == 64: + return &moduledata_1_9_64{} + case v == 10 && bits == 32: + return &moduledata_1_10_32{} + case v == 10 && bits == 64: + return &moduledata_1_10_64{} + case v == 11 && bits == 32: + return &moduledata_1_11_32{} + case v == 11 && bits == 64: + return &moduledata_1_11_64{} + case v == 12 && bits == 32: + return &moduledata_1_12_32{} + case v == 12 && bits == 64: + return &moduledata_1_12_64{} + case v == 13 && bits == 32: + return &moduledata_1_13_32{} + case v == 13 && bits == 64: + return &moduledata_1_13_64{} + case v == 14 && bits == 32: + return &moduledata_1_14_32{} + case v == 14 && bits == 64: + return &moduledata_1_14_64{} + case v == 15 && bits == 32: + return &moduledata_1_15_32{} + case v == 15 && bits == 64: + return &moduledata_1_15_64{} + case v == 16 && bits == 32: + return &moduledata_1_16_32{} + case v == 16 && bits == 64: + return &moduledata_1_16_64{} + case v == 17 && bits == 32: + return &moduledata_1_17_32{} + case v == 17 && bits == 64: + return &moduledata_1_17_64{} + case v == 18 && bits == 32: + return &moduledata_1_18_32{} + case v == 18 && bits == 64: + return &moduledata_1_18_64{} + case v == 19 && bits == 32: + return &moduledata_1_19_32{} + case v == 19 && bits == 64: + return &moduledata_1_19_64{} + case v == 20 && bits == 32: + return &moduledata_1_20_32{} + case v == 20 && bits == 64: + return &moduledata_1_20_64{} + case v == 21 && bits == 32: + return &moduledata_1_21_32{} + case v == 21 && bits == 64: + return &moduledata_1_21_64{} + default: + panic(fmt.Sprintf("unsupported go version %d", v)) } }