| // Copyright 2019 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // TODO/NICETOHAVE: |
| // - eliminate DW_CLS_ if not used |
| // - package info in compilation units |
| // - assign types to their packages |
| // - gdb uses c syntax, meaning clumsy quoting is needed for go identifiers. eg |
| // ptype struct '[]uint8' and qualifiers need to be quoted away |
| // - file:line info for variables |
| // - make strings a typedef so prettyprinters can see the underlying string type |
| |
| package ld |
| |
| import ( |
| "cmd/internal/dwarf" |
| "cmd/internal/obj" |
| "cmd/internal/objabi" |
| "cmd/internal/src" |
| "cmd/internal/sys" |
| "cmd/link/internal/loader" |
| "cmd/link/internal/sym" |
| "fmt" |
| "log" |
| "path" |
| "runtime" |
| "sort" |
| "strings" |
| "sync" |
| ) |
| |
| // dwctxt is a wrapper intended to satisfy the method set of |
| // dwarf.Context, so that functions like dwarf.PutAttrs will work with |
| // DIEs that use loader.Sym as opposed to *sym.Symbol. It is also |
| // being used as a place to store tables/maps that are useful as part |
| // of type conversion (this is just a convenience; it would be easy to |
| // split these things out into another type if need be). |
| type dwctxt struct { |
| linkctxt *Link |
| ldr *loader.Loader |
| arch *sys.Arch |
| |
| // This maps type name string (e.g. "uintptr") to loader symbol for |
| // the DWARF DIE for that type (e.g. "go.info.type.uintptr") |
| tmap map[string]loader.Sym |
| |
| // This maps loader symbol for the DWARF DIE symbol generated for |
| // a type (e.g. "go.info.uintptr") to the type symbol itself |
| // ("type.uintptr"). |
| // FIXME: try converting this map (and the next one) to a single |
| // array indexed by loader.Sym -- this may perform better. |
| rtmap map[loader.Sym]loader.Sym |
| |
| // This maps Go type symbol (e.g. "type.XXX") to loader symbol for |
| // the typedef DIE for that type (e.g. "go.info.XXX..def") |
| tdmap map[loader.Sym]loader.Sym |
| |
| // Cache these type symbols, so as to avoid repeatedly looking them up |
| typeRuntimeEface loader.Sym |
| typeRuntimeIface loader.Sym |
| uintptrInfoSym loader.Sym |
| |
| // Used at various points in that parallel portion of DWARF gen to |
| // protect against conflicting updates to globals (such as "gdbscript") |
| dwmu *sync.Mutex |
| } |
| |
| func newdwctxt(linkctxt *Link, forTypeGen bool) dwctxt { |
| d := dwctxt{ |
| linkctxt: linkctxt, |
| ldr: linkctxt.loader, |
| arch: linkctxt.Arch, |
| tmap: make(map[string]loader.Sym), |
| tdmap: make(map[loader.Sym]loader.Sym), |
| rtmap: make(map[loader.Sym]loader.Sym), |
| } |
| d.typeRuntimeEface = d.lookupOrDiag("type.runtime.eface") |
| d.typeRuntimeIface = d.lookupOrDiag("type.runtime.iface") |
| return d |
| } |
| |
| // dwSym wraps a loader.Sym; this type is meant to obey the interface |
| // rules for dwarf.Sym from the cmd/internal/dwarf package. DwDie and |
| // DwAttr objects contain references to symbols via this type. |
| type dwSym loader.Sym |
| |
| func (s dwSym) Length(dwarfContext interface{}) int64 { |
| l := dwarfContext.(dwctxt).ldr |
| return int64(len(l.Data(loader.Sym(s)))) |
| } |
| |
| func (c dwctxt) PtrSize() int { |
| return c.arch.PtrSize |
| } |
| |
| func (c dwctxt) AddInt(s dwarf.Sym, size int, i int64) { |
| ds := loader.Sym(s.(dwSym)) |
| dsu := c.ldr.MakeSymbolUpdater(ds) |
| dsu.AddUintXX(c.arch, uint64(i), size) |
| } |
| |
| func (c dwctxt) AddBytes(s dwarf.Sym, b []byte) { |
| ds := loader.Sym(s.(dwSym)) |
| dsu := c.ldr.MakeSymbolUpdater(ds) |
| dsu.AddBytes(b) |
| } |
| |
| func (c dwctxt) AddString(s dwarf.Sym, v string) { |
| ds := loader.Sym(s.(dwSym)) |
| dsu := c.ldr.MakeSymbolUpdater(ds) |
| dsu.Addstring(v) |
| } |
| |
| func (c dwctxt) AddAddress(s dwarf.Sym, data interface{}, value int64) { |
| ds := loader.Sym(s.(dwSym)) |
| dsu := c.ldr.MakeSymbolUpdater(ds) |
| if value != 0 { |
| value -= dsu.Value() |
| } |
| tgtds := loader.Sym(data.(dwSym)) |
| dsu.AddAddrPlus(c.arch, tgtds, value) |
| } |
| |
| func (c dwctxt) AddCURelativeAddress(s dwarf.Sym, data interface{}, value int64) { |
| ds := loader.Sym(s.(dwSym)) |
| dsu := c.ldr.MakeSymbolUpdater(ds) |
| if value != 0 { |
| value -= dsu.Value() |
| } |
| tgtds := loader.Sym(data.(dwSym)) |
| dsu.AddCURelativeAddrPlus(c.arch, tgtds, value) |
| } |
| |
| func (c dwctxt) AddSectionOffset(s dwarf.Sym, size int, t interface{}, ofs int64) { |
| ds := loader.Sym(s.(dwSym)) |
| dsu := c.ldr.MakeSymbolUpdater(ds) |
| tds := loader.Sym(t.(dwSym)) |
| switch size { |
| default: |
| c.linkctxt.Errorf(ds, "invalid size %d in adddwarfref\n", size) |
| case c.arch.PtrSize, 4: |
| } |
| dsu.AddSymRef(c.arch, tds, ofs, objabi.R_ADDROFF, size) |
| } |
| |
| func (c dwctxt) AddDWARFAddrSectionOffset(s dwarf.Sym, t interface{}, ofs int64) { |
| size := 4 |
| if isDwarf64(c.linkctxt) { |
| size = 8 |
| } |
| ds := loader.Sym(s.(dwSym)) |
| dsu := c.ldr.MakeSymbolUpdater(ds) |
| tds := loader.Sym(t.(dwSym)) |
| switch size { |
| default: |
| c.linkctxt.Errorf(ds, "invalid size %d in adddwarfref\n", size) |
| case c.arch.PtrSize, 4: |
| } |
| dsu.AddSymRef(c.arch, tds, ofs, objabi.R_DWARFSECREF, size) |
| } |
| |
| func (c dwctxt) Logf(format string, args ...interface{}) { |
| c.linkctxt.Logf(format, args...) |
| } |
| |
| // At the moment these interfaces are only used in the compiler. |
| |
| func (c dwctxt) AddFileRef(s dwarf.Sym, f interface{}) { |
| panic("should be used only in the compiler") |
| } |
| |
| func (c dwctxt) CurrentOffset(s dwarf.Sym) int64 { |
| panic("should be used only in the compiler") |
| } |
| |
| func (c dwctxt) RecordDclReference(s dwarf.Sym, t dwarf.Sym, dclIdx int, inlIndex int) { |
| panic("should be used only in the compiler") |
| } |
| |
| func (c dwctxt) RecordChildDieOffsets(s dwarf.Sym, vars []*dwarf.Var, offsets []int32) { |
| panic("should be used only in the compiler") |
| } |
| |
| func isDwarf64(ctxt *Link) bool { |
| return ctxt.HeadType == objabi.Haix |
| } |
| |
| var gdbscript string |
| |
| // dwarfSecInfo holds information about a DWARF output section, |
| // specifically a section symbol and a list of symbols contained in |
| // that section. On the syms list, the first symbol will always be the |
| // section symbol, then any remaining symbols (if any) will be |
| // sub-symbols in that section. Note that for some sections (eg: |
| // .debug_abbrev), the section symbol is all there is (all content is |
| // contained in it). For other sections (eg: .debug_info), the section |
| // symbol is empty and all the content is in the sub-symbols. Finally |
| // there are some sections (eg: .debug_ranges) where it is a mix (both |
| // the section symbol and the sub-symbols have content) |
| type dwarfSecInfo struct { |
| syms []loader.Sym |
| } |
| |
| // secSym returns the section symbol for the section. |
| func (dsi *dwarfSecInfo) secSym() loader.Sym { |
| if len(dsi.syms) == 0 { |
| return 0 |
| } |
| return dsi.syms[0] |
| } |
| |
| // subSyms returns a list of sub-symbols for the section. |
| func (dsi *dwarfSecInfo) subSyms() []loader.Sym { |
| if len(dsi.syms) == 0 { |
| return []loader.Sym{} |
| } |
| return dsi.syms[1:] |
| } |
| |
| // dwarfp stores the collected DWARF symbols created during |
| // dwarf generation. |
| var dwarfp []dwarfSecInfo |
| |
| func (d *dwctxt) writeabbrev() dwarfSecInfo { |
| abrvs := d.ldr.CreateSymForUpdate(".debug_abbrev", 0) |
| abrvs.SetType(sym.SDWARFSECT) |
| abrvs.AddBytes(dwarf.GetAbbrev()) |
| return dwarfSecInfo{syms: []loader.Sym{abrvs.Sym()}} |
| } |
| |
| var dwtypes dwarf.DWDie |
| |
| // newattr attaches a new attribute to the specified DIE. |
| // |
| // FIXME: at the moment attributes are stored in a linked list in a |
| // fairly space-inefficient way -- it might be better to instead look |
| // up all attrs in a single large table, then store indices into the |
| // table in the DIE. This would allow us to common up storage for |
| // attributes that are shared by many DIEs (ex: byte size of N). |
| func newattr(die *dwarf.DWDie, attr uint16, cls int, value int64, data interface{}) *dwarf.DWAttr { |
| a := new(dwarf.DWAttr) |
| a.Link = die.Attr |
| die.Attr = a |
| a.Atr = attr |
| a.Cls = uint8(cls) |
| a.Value = value |
| a.Data = data |
| return a |
| } |
| |
| // Each DIE (except the root ones) has at least 1 attribute: its |
| // name. getattr moves the desired one to the front so |
| // frequently searched ones are found faster. |
| func getattr(die *dwarf.DWDie, attr uint16) *dwarf.DWAttr { |
| if die.Attr.Atr == attr { |
| return die.Attr |
| } |
| |
| a := die.Attr |
| b := a.Link |
| for b != nil { |
| if b.Atr == attr { |
| a.Link = b.Link |
| b.Link = die.Attr |
| die.Attr = b |
| return b |
| } |
| |
| a = b |
| b = b.Link |
| } |
| |
| return nil |
| } |
| |
| // Every DIE manufactured by the linker has at least an AT_name |
| // attribute (but it will only be written out if it is listed in the abbrev). |
| // The compiler does create nameless DWARF DIEs (ex: concrete subprogram |
| // instance). |
| // FIXME: it would be more efficient to bulk-allocate DIEs. |
| func (d *dwctxt) newdie(parent *dwarf.DWDie, abbrev int, name string, version int) *dwarf.DWDie { |
| die := new(dwarf.DWDie) |
| die.Abbrev = abbrev |
| die.Link = parent.Child |
| parent.Child = die |
| |
| newattr(die, dwarf.DW_AT_name, dwarf.DW_CLS_STRING, int64(len(name)), name) |
| |
| // Sanity check: all DIEs created in the linker should have a non-empty |
| // name and be version zero. |
| if name == "" || version != 0 { |
| panic("nameless or version non-zero DWARF DIE") |
| } |
| |
| var st sym.SymKind |
| switch abbrev { |
| case dwarf.DW_ABRV_FUNCTYPEPARAM, dwarf.DW_ABRV_DOTDOTDOT, dwarf.DW_ABRV_STRUCTFIELD, dwarf.DW_ABRV_ARRAYRANGE: |
| // There are no relocations against these dies, and their names |
| // are not unique, so don't create a symbol. |
| return die |
| case dwarf.DW_ABRV_COMPUNIT, dwarf.DW_ABRV_COMPUNIT_TEXTLESS: |
| // Avoid collisions with "real" symbol names. |
| name = fmt.Sprintf(".pkg.%s.%d", name, len(d.linkctxt.compUnits)) |
| st = sym.SDWARFCUINFO |
| case dwarf.DW_ABRV_VARIABLE: |
| st = sym.SDWARFVAR |
| default: |
| // Everything else is assigned a type of SDWARFTYPE. that |
| // this also includes loose ends such as STRUCT_FIELD. |
| st = sym.SDWARFTYPE |
| } |
| ds := d.ldr.LookupOrCreateSym(dwarf.InfoPrefix+name, version) |
| dsu := d.ldr.MakeSymbolUpdater(ds) |
| dsu.SetType(st) |
| d.ldr.SetAttrNotInSymbolTable(ds, true) |
| d.ldr.SetAttrReachable(ds, true) |
| die.Sym = dwSym(ds) |
| if abbrev >= dwarf.DW_ABRV_NULLTYPE && abbrev <= dwarf.DW_ABRV_TYPEDECL { |
| d.tmap[name] = ds |
| } |
| |
| return die |
| } |
| |
| func walktypedef(die *dwarf.DWDie) *dwarf.DWDie { |
| if die == nil { |
| return nil |
| } |
| // Resolve typedef if present. |
| if die.Abbrev == dwarf.DW_ABRV_TYPEDECL { |
| for attr := die.Attr; attr != nil; attr = attr.Link { |
| if attr.Atr == dwarf.DW_AT_type && attr.Cls == dwarf.DW_CLS_REFERENCE && attr.Data != nil { |
| return attr.Data.(*dwarf.DWDie) |
| } |
| } |
| } |
| |
| return die |
| } |
| |
| func (d *dwctxt) walksymtypedef(symIdx loader.Sym) loader.Sym { |
| |
| // We're being given the loader symbol for the type DIE, e.g. |
| // "go.info.type.uintptr". Map that first to the type symbol (e.g. |
| // "type.uintptr") and then to the typedef DIE for the type. |
| // FIXME: this seems clunky, maybe there is a better way to do this. |
| |
| if ts, ok := d.rtmap[symIdx]; ok { |
| if def, ok := d.tdmap[ts]; ok { |
| return def |
| } |
| d.linkctxt.Errorf(ts, "internal error: no entry for sym %d in tdmap\n", ts) |
| return 0 |
| } |
| d.linkctxt.Errorf(symIdx, "internal error: no entry for sym %d in rtmap\n", symIdx) |
| return 0 |
| } |
| |
| // Find child by AT_name using hashtable if available or linear scan |
| // if not. |
| func findchild(die *dwarf.DWDie, name string) *dwarf.DWDie { |
| var prev *dwarf.DWDie |
| for ; die != prev; prev, die = die, walktypedef(die) { |
| for a := die.Child; a != nil; a = a.Link { |
| if name == getattr(a, dwarf.DW_AT_name).Data { |
| return a |
| } |
| } |
| continue |
| } |
| return nil |
| } |
| |
| // find looks up the loader symbol for the DWARF DIE generated for the |
| // type with the specified name. |
| func (d *dwctxt) find(name string) loader.Sym { |
| return d.tmap[name] |
| } |
| |
| func (d *dwctxt) mustFind(name string) loader.Sym { |
| r := d.find(name) |
| if r == 0 { |
| Exitf("dwarf find: cannot find %s", name) |
| } |
| return r |
| } |
| |
| func (d *dwctxt) adddwarfref(sb *loader.SymbolBuilder, t loader.Sym, size int) int64 { |
| var result int64 |
| switch size { |
| default: |
| d.linkctxt.Errorf(sb.Sym(), "invalid size %d in adddwarfref\n", size) |
| case d.arch.PtrSize, 4: |
| } |
| result = sb.AddSymRef(d.arch, t, 0, objabi.R_DWARFSECREF, size) |
| return result |
| } |
| |
| func (d *dwctxt) newrefattr(die *dwarf.DWDie, attr uint16, ref loader.Sym) *dwarf.DWAttr { |
| if ref == 0 { |
| return nil |
| } |
| return newattr(die, attr, dwarf.DW_CLS_REFERENCE, 0, dwSym(ref)) |
| } |
| |
| func (d *dwctxt) dtolsym(s dwarf.Sym) loader.Sym { |
| if s == nil { |
| return 0 |
| } |
| dws := loader.Sym(s.(dwSym)) |
| return dws |
| } |
| |
| func (d *dwctxt) putdie(syms []loader.Sym, die *dwarf.DWDie) []loader.Sym { |
| s := d.dtolsym(die.Sym) |
| if s == 0 { |
| s = syms[len(syms)-1] |
| } else { |
| syms = append(syms, s) |
| } |
| sDwsym := dwSym(s) |
| dwarf.Uleb128put(d, sDwsym, int64(die.Abbrev)) |
| dwarf.PutAttrs(d, sDwsym, die.Abbrev, die.Attr) |
| if dwarf.HasChildren(die) { |
| for die := die.Child; die != nil; die = die.Link { |
| syms = d.putdie(syms, die) |
| } |
| dsu := d.ldr.MakeSymbolUpdater(syms[len(syms)-1]) |
| dsu.AddUint8(0) |
| } |
| return syms |
| } |
| |
| func reverselist(list **dwarf.DWDie) { |
| curr := *list |
| var prev *dwarf.DWDie |
| for curr != nil { |
| next := curr.Link |
| curr.Link = prev |
| prev = curr |
| curr = next |
| } |
| |
| *list = prev |
| } |
| |
| func reversetree(list **dwarf.DWDie) { |
| reverselist(list) |
| for die := *list; die != nil; die = die.Link { |
| if dwarf.HasChildren(die) { |
| reversetree(&die.Child) |
| } |
| } |
| } |
| |
| func newmemberoffsetattr(die *dwarf.DWDie, offs int32) { |
| newattr(die, dwarf.DW_AT_data_member_location, dwarf.DW_CLS_CONSTANT, int64(offs), nil) |
| } |
| |
| // GDB doesn't like FORM_addr for AT_location, so emit a |
| // location expression that evals to a const. |
| func (d *dwctxt) newabslocexprattr(die *dwarf.DWDie, addr int64, symIdx loader.Sym) { |
| newattr(die, dwarf.DW_AT_location, dwarf.DW_CLS_ADDRESS, addr, dwSym(symIdx)) |
| } |
| |
| func (d *dwctxt) lookupOrDiag(n string) loader.Sym { |
| symIdx := d.ldr.Lookup(n, 0) |
| if symIdx == 0 { |
| Exitf("dwarf: missing type: %s", n) |
| } |
| if len(d.ldr.Data(symIdx)) == 0 { |
| Exitf("dwarf: missing type (no data): %s", n) |
| } |
| |
| return symIdx |
| } |
| |
| func (d *dwctxt) dotypedef(parent *dwarf.DWDie, gotype loader.Sym, name string, def *dwarf.DWDie) *dwarf.DWDie { |
| // Only emit typedefs for real names. |
| if strings.HasPrefix(name, "map[") { |
| return nil |
| } |
| if strings.HasPrefix(name, "struct {") { |
| return nil |
| } |
| if strings.HasPrefix(name, "chan ") { |
| return nil |
| } |
| if name[0] == '[' || name[0] == '*' { |
| return nil |
| } |
| if def == nil { |
| Errorf(nil, "dwarf: bad def in dotypedef") |
| } |
| |
| // Create a new loader symbol for the typedef. We no longer |
| // do lookups of typedef symbols by name, so this is going |
| // to be an anonymous symbol (we want this for perf reasons). |
| tds := d.ldr.CreateExtSym("", 0) |
| tdsu := d.ldr.MakeSymbolUpdater(tds) |
| tdsu.SetType(sym.SDWARFTYPE) |
| def.Sym = dwSym(tds) |
| d.ldr.SetAttrNotInSymbolTable(tds, true) |
| d.ldr.SetAttrReachable(tds, true) |
| |
| // The typedef entry must be created after the def, |
| // so that future lookups will find the typedef instead |
| // of the real definition. This hooks the typedef into any |
| // circular definition loops, so that gdb can understand them. |
| die := d.newdie(parent, dwarf.DW_ABRV_TYPEDECL, name, 0) |
| |
| d.newrefattr(die, dwarf.DW_AT_type, tds) |
| |
| return die |
| } |
| |
| // Define gotype, for composite ones recurse into constituents. |
| func (d *dwctxt) defgotype(gotype loader.Sym) loader.Sym { |
| if gotype == 0 { |
| return d.mustFind("<unspecified>") |
| } |
| |
| // If we already have a tdmap entry for the gotype, return it. |
| if ds, ok := d.tdmap[gotype]; ok { |
| return ds |
| } |
| |
| sn := d.ldr.SymName(gotype) |
| if !strings.HasPrefix(sn, "type.") { |
| d.linkctxt.Errorf(gotype, "dwarf: type name doesn't start with \"type.\"") |
| return d.mustFind("<unspecified>") |
| } |
| name := sn[5:] // could also decode from Type.string |
| |
| sdie := d.find(name) |
| if sdie != 0 { |
| return sdie |
| } |
| |
| gtdwSym := d.newtype(gotype) |
| d.tdmap[gotype] = loader.Sym(gtdwSym.Sym.(dwSym)) |
| return loader.Sym(gtdwSym.Sym.(dwSym)) |
| } |
| |
| func (d *dwctxt) newtype(gotype loader.Sym) *dwarf.DWDie { |
| sn := d.ldr.SymName(gotype) |
| name := sn[5:] // could also decode from Type.string |
| tdata := d.ldr.Data(gotype) |
| kind := decodetypeKind(d.arch, tdata) |
| bytesize := decodetypeSize(d.arch, tdata) |
| |
| var die, typedefdie *dwarf.DWDie |
| switch kind { |
| case objabi.KindBool: |
| die = d.newdie(&dwtypes, dwarf.DW_ABRV_BASETYPE, name, 0) |
| newattr(die, dwarf.DW_AT_encoding, dwarf.DW_CLS_CONSTANT, dwarf.DW_ATE_boolean, 0) |
| newattr(die, dwarf.DW_AT_byte_size, dwarf.DW_CLS_CONSTANT, bytesize, 0) |
| |
| case objabi.KindInt, |
| objabi.KindInt8, |
| objabi.KindInt16, |
| objabi.KindInt32, |
| objabi.KindInt64: |
| die = d.newdie(&dwtypes, dwarf.DW_ABRV_BASETYPE, name, 0) |
| newattr(die, dwarf.DW_AT_encoding, dwarf.DW_CLS_CONSTANT, dwarf.DW_ATE_signed, 0) |
| newattr(die, dwarf.DW_AT_byte_size, dwarf.DW_CLS_CONSTANT, bytesize, 0) |
| |
| case objabi.KindUint, |
| objabi.KindUint8, |
| objabi.KindUint16, |
| objabi.KindUint32, |
| objabi.KindUint64, |
| objabi.KindUintptr: |
| die = d.newdie(&dwtypes, dwarf.DW_ABRV_BASETYPE, name, 0) |
| newattr(die, dwarf.DW_AT_encoding, dwarf.DW_CLS_CONSTANT, dwarf.DW_ATE_unsigned, 0) |
| newattr(die, dwarf.DW_AT_byte_size, dwarf.DW_CLS_CONSTANT, bytesize, 0) |
| |
| case objabi.KindFloat32, |
| objabi.KindFloat64: |
| die = d.newdie(&dwtypes, dwarf.DW_ABRV_BASETYPE, name, 0) |
| newattr(die, dwarf.DW_AT_encoding, dwarf.DW_CLS_CONSTANT, dwarf.DW_ATE_float, 0) |
| newattr(die, dwarf.DW_AT_byte_size, dwarf.DW_CLS_CONSTANT, bytesize, 0) |
| |
| case objabi.KindComplex64, |
| objabi.KindComplex128: |
| die = d.newdie(&dwtypes, dwarf.DW_ABRV_BASETYPE, name, 0) |
| newattr(die, dwarf.DW_AT_encoding, dwarf.DW_CLS_CONSTANT, dwarf.DW_ATE_complex_float, 0) |
| newattr(die, dwarf.DW_AT_byte_size, dwarf.DW_CLS_CONSTANT, bytesize, 0) |
| |
| case objabi.KindArray: |
| die = d.newdie(&dwtypes, dwarf.DW_ABRV_ARRAYTYPE, name, 0) |
| typedefdie = d.dotypedef(&dwtypes, gotype, name, die) |
| newattr(die, dwarf.DW_AT_byte_size, dwarf.DW_CLS_CONSTANT, bytesize, 0) |
| s := decodetypeArrayElem(d.ldr, d.arch, gotype) |
| d.newrefattr(die, dwarf.DW_AT_type, d.defgotype(s)) |
| fld := d.newdie(die, dwarf.DW_ABRV_ARRAYRANGE, "range", 0) |
| |
| // use actual length not upper bound; correct for 0-length arrays. |
| newattr(fld, dwarf.DW_AT_count, dwarf.DW_CLS_CONSTANT, decodetypeArrayLen(d.ldr, d.arch, gotype), 0) |
| |
| d.newrefattr(fld, dwarf.DW_AT_type, d.uintptrInfoSym) |
| |
| case objabi.KindChan: |
| die = d.newdie(&dwtypes, dwarf.DW_ABRV_CHANTYPE, name, 0) |
| s := decodetypeChanElem(d.ldr, d.arch, gotype) |
| d.newrefattr(die, dwarf.DW_AT_go_elem, d.defgotype(s)) |
| // Save elem type for synthesizechantypes. We could synthesize here |
| // but that would change the order of DIEs we output. |
| d.newrefattr(die, dwarf.DW_AT_type, s) |
| |
| case objabi.KindFunc: |
| die = d.newdie(&dwtypes, dwarf.DW_ABRV_FUNCTYPE, name, 0) |
| newattr(die, dwarf.DW_AT_byte_size, dwarf.DW_CLS_CONSTANT, bytesize, 0) |
| typedefdie = d.dotypedef(&dwtypes, gotype, name, die) |
| data := d.ldr.Data(gotype) |
| // FIXME: add caching or reuse reloc slice. |
| relocs := d.ldr.Relocs(gotype) |
| nfields := decodetypeFuncInCount(d.arch, data) |
| for i := 0; i < nfields; i++ { |
| s := decodetypeFuncInType(d.ldr, d.arch, gotype, &relocs, i) |
| sn := d.ldr.SymName(s) |
| fld := d.newdie(die, dwarf.DW_ABRV_FUNCTYPEPARAM, sn[5:], 0) |
| d.newrefattr(fld, dwarf.DW_AT_type, d.defgotype(s)) |
| } |
| |
| if decodetypeFuncDotdotdot(d.arch, data) { |
| d.newdie(die, dwarf.DW_ABRV_DOTDOTDOT, "...", 0) |
| } |
| nfields = decodetypeFuncOutCount(d.arch, data) |
| for i := 0; i < nfields; i++ { |
| s := decodetypeFuncOutType(d.ldr, d.arch, gotype, &relocs, i) |
| sn := d.ldr.SymName(s) |
| fld := d.newdie(die, dwarf.DW_ABRV_FUNCTYPEPARAM, sn[5:], 0) |
| d.newrefattr(fld, dwarf.DW_AT_type, d.defptrto(d.defgotype(s))) |
| } |
| |
| case objabi.KindInterface: |
| die = d.newdie(&dwtypes, dwarf.DW_ABRV_IFACETYPE, name, 0) |
| typedefdie = d.dotypedef(&dwtypes, gotype, name, die) |
| data := d.ldr.Data(gotype) |
| nfields := int(decodetypeIfaceMethodCount(d.arch, data)) |
| var s loader.Sym |
| if nfields == 0 { |
| s = d.typeRuntimeEface |
| } else { |
| s = d.typeRuntimeIface |
| } |
| d.newrefattr(die, dwarf.DW_AT_type, d.defgotype(s)) |
| |
| case objabi.KindMap: |
| die = d.newdie(&dwtypes, dwarf.DW_ABRV_MAPTYPE, name, 0) |
| s := decodetypeMapKey(d.ldr, d.arch, gotype) |
| d.newrefattr(die, dwarf.DW_AT_go_key, d.defgotype(s)) |
| s = decodetypeMapValue(d.ldr, d.arch, gotype) |
| d.newrefattr(die, dwarf.DW_AT_go_elem, d.defgotype(s)) |
| // Save gotype for use in synthesizemaptypes. We could synthesize here, |
| // but that would change the order of the DIEs. |
| d.newrefattr(die, dwarf.DW_AT_type, gotype) |
| |
| case objabi.KindPtr: |
| die = d.newdie(&dwtypes, dwarf.DW_ABRV_PTRTYPE, name, 0) |
| typedefdie = d.dotypedef(&dwtypes, gotype, name, die) |
| s := decodetypePtrElem(d.ldr, d.arch, gotype) |
| d.newrefattr(die, dwarf.DW_AT_type, d.defgotype(s)) |
| |
| case objabi.KindSlice: |
| die = d.newdie(&dwtypes, dwarf.DW_ABRV_SLICETYPE, name, 0) |
| typedefdie = d.dotypedef(&dwtypes, gotype, name, die) |
| newattr(die, dwarf.DW_AT_byte_size, dwarf.DW_CLS_CONSTANT, bytesize, 0) |
| s := decodetypeArrayElem(d.ldr, d.arch, gotype) |
| elem := d.defgotype(s) |
| d.newrefattr(die, dwarf.DW_AT_go_elem, elem) |
| |
| case objabi.KindString: |
| die = d.newdie(&dwtypes, dwarf.DW_ABRV_STRINGTYPE, name, 0) |
| newattr(die, dwarf.DW_AT_byte_size, dwarf.DW_CLS_CONSTANT, bytesize, 0) |
| |
| case objabi.KindStruct: |
| die = d.newdie(&dwtypes, dwarf.DW_ABRV_STRUCTTYPE, name, 0) |
| typedefdie = d.dotypedef(&dwtypes, gotype, name, die) |
| newattr(die, dwarf.DW_AT_byte_size, dwarf.DW_CLS_CONSTANT, bytesize, 0) |
| nfields := decodetypeStructFieldCount(d.ldr, d.arch, gotype) |
| for i := 0; i < nfields; i++ { |
| f := decodetypeStructFieldName(d.ldr, d.arch, gotype, i) |
| s := decodetypeStructFieldType(d.ldr, d.arch, gotype, i) |
| if f == "" { |
| sn := d.ldr.SymName(s) |
| f = sn[5:] // skip "type." |
| } |
| fld := d.newdie(die, dwarf.DW_ABRV_STRUCTFIELD, f, 0) |
| d.newrefattr(fld, dwarf.DW_AT_type, d.defgotype(s)) |
| offsetAnon := decodetypeStructFieldOffsAnon(d.ldr, d.arch, gotype, i) |
| newmemberoffsetattr(fld, int32(offsetAnon>>1)) |
| if offsetAnon&1 != 0 { // is embedded field |
| newattr(fld, dwarf.DW_AT_go_embedded_field, dwarf.DW_CLS_FLAG, 1, 0) |
| } |
| } |
| |
| case objabi.KindUnsafePointer: |
| die = d.newdie(&dwtypes, dwarf.DW_ABRV_BARE_PTRTYPE, name, 0) |
| |
| default: |
| d.linkctxt.Errorf(gotype, "dwarf: definition of unknown kind %d", kind) |
| die = d.newdie(&dwtypes, dwarf.DW_ABRV_TYPEDECL, name, 0) |
| d.newrefattr(die, dwarf.DW_AT_type, d.mustFind("<unspecified>")) |
| } |
| |
| newattr(die, dwarf.DW_AT_go_kind, dwarf.DW_CLS_CONSTANT, int64(kind), 0) |
| |
| if d.ldr.AttrReachable(gotype) { |
| newattr(die, dwarf.DW_AT_go_runtime_type, dwarf.DW_CLS_GO_TYPEREF, 0, dwSym(gotype)) |
| } |
| |
| // Sanity check. |
| if _, ok := d.rtmap[gotype]; ok { |
| log.Fatalf("internal error: rtmap entry already installed\n") |
| } |
| |
| ds := loader.Sym(die.Sym.(dwSym)) |
| if typedefdie != nil { |
| ds = loader.Sym(typedefdie.Sym.(dwSym)) |
| } |
| d.rtmap[ds] = gotype |
| |
| if _, ok := prototypedies[sn]; ok { |
| prototypedies[sn] = die |
| } |
| |
| if typedefdie != nil { |
| return typedefdie |
| } |
| return die |
| } |
| |
| func (d *dwctxt) nameFromDIESym(dwtypeDIESym loader.Sym) string { |
| sn := d.ldr.SymName(dwtypeDIESym) |
| return sn[len(dwarf.InfoPrefix):] |
| } |
| |
| func (d *dwctxt) defptrto(dwtype loader.Sym) loader.Sym { |
| |
| // FIXME: it would be nice if the compiler attached an aux symbol |
| // ref from the element type to the pointer type -- it would be |
| // more efficient to do it this way as opposed to via name lookups. |
| |
| ptrname := "*" + d.nameFromDIESym(dwtype) |
| if die := d.find(ptrname); die != 0 { |
| return die |
| } |
| |
| pdie := d.newdie(&dwtypes, dwarf.DW_ABRV_PTRTYPE, ptrname, 0) |
| d.newrefattr(pdie, dwarf.DW_AT_type, dwtype) |
| |
| // The DWARF info synthesizes pointer types that don't exist at the |
| // language level, like *hash<...> and *bucket<...>, and the data |
| // pointers of slices. Link to the ones we can find. |
| gts := d.ldr.Lookup("type."+ptrname, 0) |
| if gts != 0 && d.ldr.AttrReachable(gts) { |
| newattr(pdie, dwarf.DW_AT_go_runtime_type, dwarf.DW_CLS_GO_TYPEREF, 0, dwSym(gts)) |
| } |
| |
| if gts != 0 { |
| ds := loader.Sym(pdie.Sym.(dwSym)) |
| d.rtmap[ds] = gts |
| d.tdmap[gts] = ds |
| } |
| |
| return d.dtolsym(pdie.Sym) |
| } |
| |
| // Copies src's children into dst. Copies attributes by value. |
| // DWAttr.data is copied as pointer only. If except is one of |
| // the top-level children, it will not be copied. |
| func (d *dwctxt) copychildrenexcept(ctxt *Link, dst *dwarf.DWDie, src *dwarf.DWDie, except *dwarf.DWDie) { |
| for src = src.Child; src != nil; src = src.Link { |
| if src == except { |
| continue |
| } |
| c := d.newdie(dst, src.Abbrev, getattr(src, dwarf.DW_AT_name).Data.(string), 0) |
| for a := src.Attr; a != nil; a = a.Link { |
| newattr(c, a.Atr, int(a.Cls), a.Value, a.Data) |
| } |
| d.copychildrenexcept(ctxt, c, src, nil) |
| } |
| |
| reverselist(&dst.Child) |
| } |
| |
| func (d *dwctxt) copychildren(ctxt *Link, dst *dwarf.DWDie, src *dwarf.DWDie) { |
| d.copychildrenexcept(ctxt, dst, src, nil) |
| } |
| |
| // Search children (assumed to have TAG_member) for the one named |
| // field and set its AT_type to dwtype |
| func (d *dwctxt) substitutetype(structdie *dwarf.DWDie, field string, dwtype loader.Sym) { |
| child := findchild(structdie, field) |
| if child == nil { |
| Exitf("dwarf substitutetype: %s does not have member %s", |
| getattr(structdie, dwarf.DW_AT_name).Data, field) |
| return |
| } |
| |
| a := getattr(child, dwarf.DW_AT_type) |
| if a != nil { |
| a.Data = dwSym(dwtype) |
| } else { |
| d.newrefattr(child, dwarf.DW_AT_type, dwtype) |
| } |
| } |
| |
| func (d *dwctxt) findprotodie(ctxt *Link, name string) *dwarf.DWDie { |
| die, ok := prototypedies[name] |
| if ok && die == nil { |
| d.defgotype(d.lookupOrDiag(name)) |
| die = prototypedies[name] |
| } |
| if die == nil { |
| log.Fatalf("internal error: DIE generation failed for %s\n", name) |
| } |
| return die |
| } |
| |
| func (d *dwctxt) synthesizestringtypes(ctxt *Link, die *dwarf.DWDie) { |
| prototype := walktypedef(d.findprotodie(ctxt, "type.runtime.stringStructDWARF")) |
| if prototype == nil { |
| return |
| } |
| |
| for ; die != nil; die = die.Link { |
| if die.Abbrev != dwarf.DW_ABRV_STRINGTYPE { |
| continue |
| } |
| d.copychildren(ctxt, die, prototype) |
| } |
| } |
| |
| func (d *dwctxt) synthesizeslicetypes(ctxt *Link, die *dwarf.DWDie) { |
| prototype := walktypedef(d.findprotodie(ctxt, "type.runtime.slice")) |
| if prototype == nil { |
| return |
| } |
| |
| for ; die != nil; die = die.Link { |
| if die.Abbrev != dwarf.DW_ABRV_SLICETYPE { |
| continue |
| } |
| d.copychildren(ctxt, die, prototype) |
| elem := loader.Sym(getattr(die, dwarf.DW_AT_go_elem).Data.(dwSym)) |
| d.substitutetype(die, "array", d.defptrto(elem)) |
| } |
| } |
| |
| func mkinternaltypename(base string, arg1 string, arg2 string) string { |
| if arg2 == "" { |
| return fmt.Sprintf("%s<%s>", base, arg1) |
| } |
| return fmt.Sprintf("%s<%s,%s>", base, arg1, arg2) |
| } |
| |
| // synthesizemaptypes is way too closely married to runtime/hashmap.c |
| const ( |
| MaxKeySize = 128 |
| MaxValSize = 128 |
| BucketSize = 8 |
| ) |
| |
| func (d *dwctxt) mkinternaltype(ctxt *Link, abbrev int, typename, keyname, valname string, f func(*dwarf.DWDie)) loader.Sym { |
| name := mkinternaltypename(typename, keyname, valname) |
| symname := dwarf.InfoPrefix + name |
| s := d.ldr.Lookup(symname, 0) |
| if s != 0 && d.ldr.SymType(s) == sym.SDWARFTYPE { |
| return s |
| } |
| die := d.newdie(&dwtypes, abbrev, name, 0) |
| f(die) |
| return d.dtolsym(die.Sym) |
| } |
| |
| func (d *dwctxt) synthesizemaptypes(ctxt *Link, die *dwarf.DWDie) { |
| hash := walktypedef(d.findprotodie(ctxt, "type.runtime.hmap")) |
| bucket := walktypedef(d.findprotodie(ctxt, "type.runtime.bmap")) |
| |
| if hash == nil { |
| return |
| } |
| |
| for ; die != nil; die = die.Link { |
| if die.Abbrev != dwarf.DW_ABRV_MAPTYPE { |
| continue |
| } |
| gotype := loader.Sym(getattr(die, dwarf.DW_AT_type).Data.(dwSym)) |
| keytype := decodetypeMapKey(d.ldr, d.arch, gotype) |
| valtype := decodetypeMapValue(d.ldr, d.arch, gotype) |
| keydata := d.ldr.Data(keytype) |
| valdata := d.ldr.Data(valtype) |
| keysize, valsize := decodetypeSize(d.arch, keydata), decodetypeSize(d.arch, valdata) |
| keytype, valtype = d.walksymtypedef(d.defgotype(keytype)), d.walksymtypedef(d.defgotype(valtype)) |
| |
| // compute size info like hashmap.c does. |
| indirectKey, indirectVal := false, false |
| if keysize > MaxKeySize { |
| keysize = int64(d.arch.PtrSize) |
| indirectKey = true |
| } |
| if valsize > MaxValSize { |
| valsize = int64(d.arch.PtrSize) |
| indirectVal = true |
| } |
| |
| // Construct type to represent an array of BucketSize keys |
| keyname := d.nameFromDIESym(keytype) |
| dwhks := d.mkinternaltype(ctxt, dwarf.DW_ABRV_ARRAYTYPE, "[]key", keyname, "", func(dwhk *dwarf.DWDie) { |
| newattr(dwhk, dwarf.DW_AT_byte_size, dwarf.DW_CLS_CONSTANT, BucketSize*keysize, 0) |
| t := keytype |
| if indirectKey { |
| t = d.defptrto(keytype) |
| } |
| d.newrefattr(dwhk, dwarf.DW_AT_type, t) |
| fld := d.newdie(dwhk, dwarf.DW_ABRV_ARRAYRANGE, "size", 0) |
| newattr(fld, dwarf.DW_AT_count, dwarf.DW_CLS_CONSTANT, BucketSize, 0) |
| d.newrefattr(fld, dwarf.DW_AT_type, d.uintptrInfoSym) |
| }) |
| |
| // Construct type to represent an array of BucketSize values |
| valname := d.nameFromDIESym(valtype) |
| dwhvs := d.mkinternaltype(ctxt, dwarf.DW_ABRV_ARRAYTYPE, "[]val", valname, "", func(dwhv *dwarf.DWDie) { |
| newattr(dwhv, dwarf.DW_AT_byte_size, dwarf.DW_CLS_CONSTANT, BucketSize*valsize, 0) |
| t := valtype |
| if indirectVal { |
| t = d.defptrto(valtype) |
| } |
| d.newrefattr(dwhv, dwarf.DW_AT_type, t) |
| fld := d.newdie(dwhv, dwarf.DW_ABRV_ARRAYRANGE, "size", 0) |
| newattr(fld, dwarf.DW_AT_count, dwarf.DW_CLS_CONSTANT, BucketSize, 0) |
| d.newrefattr(fld, dwarf.DW_AT_type, d.uintptrInfoSym) |
| }) |
| |
| // Construct bucket<K,V> |
| dwhbs := d.mkinternaltype(ctxt, dwarf.DW_ABRV_STRUCTTYPE, "bucket", keyname, valname, func(dwhb *dwarf.DWDie) { |
| // Copy over all fields except the field "data" from the generic |
| // bucket. "data" will be replaced with keys/values below. |
| d.copychildrenexcept(ctxt, dwhb, bucket, findchild(bucket, "data")) |
| |
| fld := d.newdie(dwhb, dwarf.DW_ABRV_STRUCTFIELD, "keys", 0) |
| d.newrefattr(fld, dwarf.DW_AT_type, dwhks) |
| newmemberoffsetattr(fld, BucketSize) |
| fld = d.newdie(dwhb, dwarf.DW_ABRV_STRUCTFIELD, "values", 0) |
| d.newrefattr(fld, dwarf.DW_AT_type, dwhvs) |
| newmemberoffsetattr(fld, BucketSize+BucketSize*int32(keysize)) |
| fld = d.newdie(dwhb, dwarf.DW_ABRV_STRUCTFIELD, "overflow", 0) |
| d.newrefattr(fld, dwarf.DW_AT_type, d.defptrto(d.dtolsym(dwhb.Sym))) |
| newmemberoffsetattr(fld, BucketSize+BucketSize*(int32(keysize)+int32(valsize))) |
| if d.arch.RegSize > d.arch.PtrSize { |
| fld = d.newdie(dwhb, dwarf.DW_ABRV_STRUCTFIELD, "pad", 0) |
| d.newrefattr(fld, dwarf.DW_AT_type, d.uintptrInfoSym) |
| newmemberoffsetattr(fld, BucketSize+BucketSize*(int32(keysize)+int32(valsize))+int32(d.arch.PtrSize)) |
| } |
| |
| newattr(dwhb, dwarf.DW_AT_byte_size, dwarf.DW_CLS_CONSTANT, BucketSize+BucketSize*keysize+BucketSize*valsize+int64(d.arch.RegSize), 0) |
| }) |
| |
| // Construct hash<K,V> |
| dwhs := d.mkinternaltype(ctxt, dwarf.DW_ABRV_STRUCTTYPE, "hash", keyname, valname, func(dwh *dwarf.DWDie) { |
| d.copychildren(ctxt, dwh, hash) |
| d.substitutetype(dwh, "buckets", d.defptrto(dwhbs)) |
| d.substitutetype(dwh, "oldbuckets", d.defptrto(dwhbs)) |
| newattr(dwh, dwarf.DW_AT_byte_size, dwarf.DW_CLS_CONSTANT, getattr(hash, dwarf.DW_AT_byte_size).Value, nil) |
| }) |
| |
| // make map type a pointer to hash<K,V> |
| d.newrefattr(die, dwarf.DW_AT_type, d.defptrto(dwhs)) |
| } |
| } |
| |
| func (d *dwctxt) synthesizechantypes(ctxt *Link, die *dwarf.DWDie) { |
| sudog := walktypedef(d.findprotodie(ctxt, "type.runtime.sudog")) |
| waitq := walktypedef(d.findprotodie(ctxt, "type.runtime.waitq")) |
| hchan := walktypedef(d.findprotodie(ctxt, "type.runtime.hchan")) |
| if sudog == nil || waitq == nil || hchan == nil { |
| return |
| } |
| |
| sudogsize := int(getattr(sudog, dwarf.DW_AT_byte_size).Value) |
| |
| for ; die != nil; die = die.Link { |
| if die.Abbrev != dwarf.DW_ABRV_CHANTYPE { |
| continue |
| } |
| elemgotype := loader.Sym(getattr(die, dwarf.DW_AT_type).Data.(dwSym)) |
| tname := d.ldr.SymName(elemgotype) |
| elemname := tname[5:] |
| elemtype := d.walksymtypedef(d.defgotype(d.lookupOrDiag(tname))) |
| |
| // sudog<T> |
| dwss := d.mkinternaltype(ctxt, dwarf.DW_ABRV_STRUCTTYPE, "sudog", elemname, "", func(dws *dwarf.DWDie) { |
| d.copychildren(ctxt, dws, sudog) |
| d.substitutetype(dws, "elem", d.defptrto(elemtype)) |
| newattr(dws, dwarf.DW_AT_byte_size, dwarf.DW_CLS_CONSTANT, int64(sudogsize), nil) |
| }) |
| |
| // waitq<T> |
| dwws := d.mkinternaltype(ctxt, dwarf.DW_ABRV_STRUCTTYPE, "waitq", elemname, "", func(dww *dwarf.DWDie) { |
| |
| d.copychildren(ctxt, dww, waitq) |
| d.substitutetype(dww, "first", d.defptrto(dwss)) |
| d.substitutetype(dww, "last", d.defptrto(dwss)) |
| newattr(dww, dwarf.DW_AT_byte_size, dwarf.DW_CLS_CONSTANT, getattr(waitq, dwarf.DW_AT_byte_size).Value, nil) |
| }) |
| |
| // hchan<T> |
| dwhs := d.mkinternaltype(ctxt, dwarf.DW_ABRV_STRUCTTYPE, "hchan", elemname, "", func(dwh *dwarf.DWDie) { |
| d.copychildren(ctxt, dwh, hchan) |
| d.substitutetype(dwh, "recvq", dwws) |
| d.substitutetype(dwh, "sendq", dwws) |
| newattr(dwh, dwarf.DW_AT_byte_size, dwarf.DW_CLS_CONSTANT, getattr(hchan, dwarf.DW_AT_byte_size).Value, nil) |
| }) |
| |
| d.newrefattr(die, dwarf.DW_AT_type, d.defptrto(dwhs)) |
| } |
| } |
| |
| func (d *dwctxt) dwarfDefineGlobal(ctxt *Link, symIdx loader.Sym, str string, v int64, gotype loader.Sym) { |
| // Find a suitable CU DIE to include the global. |
| // One would think it's as simple as just looking at the unit, but that might |
| // not have any reachable code. So, we go to the runtime's CU if our unit |
| // isn't otherwise reachable. |
| unit := d.ldr.SymUnit(symIdx) |
| if unit == nil { |
| unit = ctxt.runtimeCU |
| } |
| ver := d.ldr.SymVersion(symIdx) |
| dv := d.newdie(unit.DWInfo, dwarf.DW_ABRV_VARIABLE, str, int(ver)) |
| d.newabslocexprattr(dv, v, symIdx) |
| if d.ldr.SymVersion(symIdx) < sym.SymVerStatic { |
| newattr(dv, dwarf.DW_AT_external, dwarf.DW_CLS_FLAG, 1, 0) |
| } |
| dt := d.defgotype(gotype) |
| d.newrefattr(dv, dwarf.DW_AT_type, dt) |
| } |
| |
| // createUnitLength creates the initial length field with value v and update |
| // offset of unit_length if needed. |
| func (d *dwctxt) createUnitLength(su *loader.SymbolBuilder, v uint64) { |
| if isDwarf64(d.linkctxt) { |
| su.AddUint32(d.arch, 0xFFFFFFFF) |
| } |
| d.addDwarfAddrField(su, v) |
| } |
| |
| // addDwarfAddrField adds a DWARF field in DWARF 64bits or 32bits. |
| func (d *dwctxt) addDwarfAddrField(sb *loader.SymbolBuilder, v uint64) { |
| if isDwarf64(d.linkctxt) { |
| sb.AddUint(d.arch, v) |
| } else { |
| sb.AddUint32(d.arch, uint32(v)) |
| } |
| } |
| |
| // addDwarfAddrRef adds a DWARF pointer in DWARF 64bits or 32bits. |
| func (d *dwctxt) addDwarfAddrRef(sb *loader.SymbolBuilder, t loader.Sym) { |
| if isDwarf64(d.linkctxt) { |
| d.adddwarfref(sb, t, 8) |
| } else { |
| d.adddwarfref(sb, t, 4) |
| } |
| } |
| |
| // calcCompUnitRanges calculates the PC ranges of the compilation units. |
| func (d *dwctxt) calcCompUnitRanges() { |
| var prevUnit *sym.CompilationUnit |
| for _, s := range d.linkctxt.Textp { |
| sym := loader.Sym(s) |
| |
| fi := d.ldr.FuncInfo(sym) |
| if !fi.Valid() { |
| continue |
| } |
| |
| // Skip linker-created functions (ex: runtime.addmoduledata), since they |
| // don't have DWARF to begin with. |
| unit := d.ldr.SymUnit(sym) |
| if unit == nil { |
| continue |
| } |
| |
| // Update PC ranges. |
| // |
| // We don't simply compare the end of the previous |
| // symbol with the start of the next because there's |
| // often a little padding between them. Instead, we |
| // only create boundaries between symbols from |
| // different units. |
| sval := d.ldr.SymValue(sym) |
| u0val := d.ldr.SymValue(loader.Sym(unit.Textp[0])) |
| if prevUnit != unit { |
| unit.PCs = append(unit.PCs, dwarf.Range{Start: sval - u0val}) |
| prevUnit = unit |
| } |
| unit.PCs[len(unit.PCs)-1].End = sval - u0val + int64(len(d.ldr.Data(sym))) |
| } |
| } |
| |
| func movetomodule(ctxt *Link, parent *dwarf.DWDie) { |
| die := ctxt.runtimeCU.DWInfo.Child |
| if die == nil { |
| ctxt.runtimeCU.DWInfo.Child = parent.Child |
| return |
| } |
| for die.Link != nil { |
| die = die.Link |
| } |
| die.Link = parent.Child |
| } |
| |
| /* |
| * Generate a sequence of opcodes that is as short as possible. |
| * See section 6.2.5 |
| */ |
| const ( |
| LINE_BASE = -4 |
| LINE_RANGE = 10 |
| PC_RANGE = (255 - OPCODE_BASE) / LINE_RANGE |
| OPCODE_BASE = 11 |
| ) |
| |
| /* |
| * Walk prog table, emit line program and build DIE tree. |
| */ |
| |
| func getCompilationDir() string { |
| // OSX requires this be set to something, but it's not easy to choose |
| // a value. Linking takes place in a temporary directory, so there's |
| // no point including it here. Paths in the file table are usually |
| // absolute, in which case debuggers will ignore this value. -trimpath |
| // produces relative paths, but we don't know where they start, so |
| // all we can do here is try not to make things worse. |
| return "." |
| } |
| |
| func (d *dwctxt) importInfoSymbol(dsym loader.Sym) { |
| d.ldr.SetAttrReachable(dsym, true) |
| d.ldr.SetAttrNotInSymbolTable(dsym, true) |
| dst := d.ldr.SymType(dsym) |
| if dst != sym.SDWARFCONST && dst != sym.SDWARFABSFCN { |
| log.Fatalf("error: DWARF info sym %d/%s with incorrect type %s", dsym, d.ldr.SymName(dsym), d.ldr.SymType(dsym).String()) |
| } |
| relocs := d.ldr.Relocs(dsym) |
| for i := 0; i < relocs.Count(); i++ { |
| r := relocs.At(i) |
| if r.Type() != objabi.R_DWARFSECREF { |
| continue |
| } |
| rsym := r.Sym() |
| // If there is an entry for the symbol in our rtmap, then it |
| // means we've processed the type already, and can skip this one. |
| if _, ok := d.rtmap[rsym]; ok { |
| // type already generated |
| continue |
| } |
| // FIXME: is there a way we could avoid materializing the |
| // symbol name here? |
| sn := d.ldr.SymName(rsym) |
| tn := sn[len(dwarf.InfoPrefix):] |
| ts := d.ldr.Lookup("type."+tn, 0) |
| d.defgotype(ts) |
| } |
| } |
| |
| func expandFile(fname string) string { |
| if strings.HasPrefix(fname, src.FileSymPrefix) { |
| fname = fname[len(src.FileSymPrefix):] |
| } |
| return expandGoroot(fname) |
| } |
| |
| // writeDirFileTables emits the portion of the DWARF line table |
| // prologue containing the include directories and file names, |
| // described in section 6.2.4 of the DWARF 4 standard. It walks the |
| // filepaths for the unit to discover any common directories, which |
| // are emitted to the directory table first, then the file table is |
| // emitted after that. |
| func (d *dwctxt) writeDirFileTables(unit *sym.CompilationUnit, lsu *loader.SymbolBuilder) { |
| type fileDir struct { |
| base string |
| dir int |
| } |
| dirNums := make(map[string]int) |
| dirs := []string{""} |
| files := []fileDir{} |
| |
| // Preprocess files to collect directories. This assumes that the |
| // file table is already de-duped. |
| for i, name := range unit.FileTable { |
| name := expandFile(name) |
| if len(name) == 0 { |
| // Can't have empty filenames, and having a unique |
| // filename is quite useful for debugging. |
| name = fmt.Sprintf("<missing>_%d", i) |
| } |
| // Note the use of "path" here and not "filepath". The compiler |
| // hard-codes to use "/" in DWARF paths (even for Windows), so we |
| // want to maintain that here. |
| file := path.Base(name) |
| dir := path.Dir(name) |
| dirIdx, ok := dirNums[dir] |
| if !ok && dir != "." { |
| dirIdx = len(dirNums) + 1 |
| dirNums[dir] = dirIdx |
| dirs = append(dirs, dir) |
| } |
| files = append(files, fileDir{base: file, dir: dirIdx}) |
| |
| // We can't use something that may be dead-code |
| // eliminated from a binary here. proc.go contains |
| // main and the scheduler, so it's not going anywhere. |
| if i := strings.Index(name, "runtime/proc.go"); i >= 0 { |
| d.dwmu.Lock() |
| if gdbscript == "" { |
| k := strings.Index(name, "runtime/proc.go") |
| gdbscript = name[:k] + "runtime/runtime-gdb.py" |
| } |
| d.dwmu.Unlock() |
| } |
| } |
| |
| // Emit directory section. This is a series of nul terminated |
| // strings, followed by a single zero byte. |
| lsDwsym := dwSym(lsu.Sym()) |
| for k := 1; k < len(dirs); k++ { |
| d.AddString(lsDwsym, dirs[k]) |
| } |
| lsu.AddUint8(0) // terminator |
| |
| // Emit file section. |
| for k := 0; k < len(files); k++ { |
| d.AddString(lsDwsym, files[k].base) |
| dwarf.Uleb128put(d, lsDwsym, int64(files[k].dir)) |
| lsu.AddUint8(0) // mtime |
| lsu.AddUint8(0) // length |
| } |
| lsu.AddUint8(0) // terminator |
| } |
| |
| // writelines collects up and chains together the symbols needed to |
| // form the DWARF line table for the specified compilation unit, |
| // returning a list of symbols. The returned list will include an |
| // initial symbol containing the line table header and prologue (with |
| // file table), then a series of compiler-emitted line table symbols |
| // (one per live function), and finally an epilog symbol containing an |
| // end-of-sequence operator. The prologue and epilog symbols are passed |
| // in (having been created earlier); here we add content to them. |
| func (d *dwctxt) writelines(unit *sym.CompilationUnit, lineProlog loader.Sym) []loader.Sym { |
| is_stmt := uint8(1) // initially = recommended default_is_stmt = 1, tracks is_stmt toggles. |
| |
| unitstart := int64(-1) |
| headerstart := int64(-1) |
| headerend := int64(-1) |
| |
| syms := make([]loader.Sym, 0, len(unit.Textp)+2) |
| syms = append(syms, lineProlog) |
| lsu := d.ldr.MakeSymbolUpdater(lineProlog) |
| lsDwsym := dwSym(lineProlog) |
| newattr(unit.DWInfo, dwarf.DW_AT_stmt_list, dwarf.DW_CLS_PTR, 0, lsDwsym) |
| |
| // Write .debug_line Line Number Program Header (sec 6.2.4) |
| // Fields marked with (*) must be changed for 64-bit dwarf |
| unitLengthOffset := lsu.Size() |
| d.createUnitLength(lsu, 0) // unit_length (*), filled in at end |
| unitstart = lsu.Size() |
| lsu.AddUint16(d.arch, 2) // dwarf version (appendix F) -- version 3 is incompatible w/ XCode 9.0's dsymutil, latest supported on OSX 10.12 as of 2018-05 |
| headerLengthOffset := lsu.Size() |
| d.addDwarfAddrField(lsu, 0) // header_length (*), filled in at end |
| headerstart = lsu.Size() |
| |
| // cpos == unitstart + 4 + 2 + 4 |
| lsu.AddUint8(1) // minimum_instruction_length |
| lsu.AddUint8(is_stmt) // default_is_stmt |
| lsu.AddUint8(LINE_BASE & 0xFF) // line_base |
| lsu.AddUint8(LINE_RANGE) // line_range |
| lsu.AddUint8(OPCODE_BASE) // opcode_base |
| lsu.AddUint8(0) // standard_opcode_lengths[1] |
| lsu.AddUint8(1) // standard_opcode_lengths[2] |
| lsu.AddUint8(1) // standard_opcode_lengths[3] |
| lsu.AddUint8(1) // standard_opcode_lengths[4] |
| lsu.AddUint8(1) // standard_opcode_lengths[5] |
| lsu.AddUint8(0) // standard_opcode_lengths[6] |
| lsu.AddUint8(0) // standard_opcode_lengths[7] |
| lsu.AddUint8(0) // standard_opcode_lengths[8] |
| lsu.AddUint8(1) // standard_opcode_lengths[9] |
| lsu.AddUint8(0) // standard_opcode_lengths[10] |
| |
| // Call helper to emit dir and file sections. |
| d.writeDirFileTables(unit, lsu) |
| |
| // capture length at end of file names. |
| headerend = lsu.Size() |
| unitlen := lsu.Size() - unitstart |
| |
| // Output the state machine for each function remaining. |
| for _, s := range unit.Textp { |
| fnSym := loader.Sym(s) |
| _, _, _, lines := d.ldr.GetFuncDwarfAuxSyms(fnSym) |
| |
| // Chain the line symbol onto the list. |
| if lines != 0 { |
| syms = append(syms, lines) |
| unitlen += int64(len(d.ldr.Data(lines))) |
| } |
| } |
| |
| if d.linkctxt.HeadType == objabi.Haix { |
| addDwsectCUSize(".debug_line", unit.Lib.Pkg, uint64(unitlen)) |
| } |
| |
| if isDwarf64(d.linkctxt) { |
| lsu.SetUint(d.arch, unitLengthOffset+4, uint64(unitlen)) // +4 because of 0xFFFFFFFF |
| lsu.SetUint(d.arch, headerLengthOffset, uint64(headerend-headerstart)) |
| } else { |
| lsu.SetUint32(d.arch, unitLengthOffset, uint32(unitlen)) |
| lsu.SetUint32(d.arch, headerLengthOffset, uint32(headerend-headerstart)) |
| } |
| |
| return syms |
| } |
| |
| // writepcranges generates the DW_AT_ranges table for compilation unit |
| // "unit", and returns a collection of ranges symbols (one for the |
| // compilation unit DIE itself and the remainder from functions in the unit). |
| func (d *dwctxt) writepcranges(unit *sym.CompilationUnit, base loader.Sym, pcs []dwarf.Range, rangeProlog loader.Sym) []loader.Sym { |
| |
| syms := make([]loader.Sym, 0, len(unit.RangeSyms)+1) |
| syms = append(syms, rangeProlog) |
| rsu := d.ldr.MakeSymbolUpdater(rangeProlog) |
| rDwSym := dwSym(rangeProlog) |
| |
| // Create PC ranges for the compilation unit DIE. |
| newattr(unit.DWInfo, dwarf.DW_AT_ranges, dwarf.DW_CLS_PTR, rsu.Size(), rDwSym) |
| newattr(unit.DWInfo, dwarf.DW_AT_low_pc, dwarf.DW_CLS_ADDRESS, 0, dwSym(base)) |
| dwarf.PutBasedRanges(d, rDwSym, pcs) |
| |
| // Collect up the ranges for functions in the unit. |
| rsize := uint64(rsu.Size()) |
| for _, ls := range unit.RangeSyms { |
| s := loader.Sym(ls) |
| syms = append(syms, s) |
| rsize += uint64(d.ldr.SymSize(s)) |
| } |
| |
| if d.linkctxt.HeadType == objabi.Haix { |
| addDwsectCUSize(".debug_ranges", unit.Lib.Pkg, rsize) |
| } |
| |
| return syms |
| } |
| |
| /* |
| * Emit .debug_frame |
| */ |
| const ( |
| dataAlignmentFactor = -4 |
| ) |
| |
| // appendPCDeltaCFA appends per-PC CFA deltas to b and returns the final slice. |
| func appendPCDeltaCFA(arch *sys.Arch, b []byte, deltapc, cfa int64) []byte { |
| b = append(b, dwarf.DW_CFA_def_cfa_offset_sf) |
| b = dwarf.AppendSleb128(b, cfa/dataAlignmentFactor) |
| |
| switch { |
| case deltapc < 0x40: |
| b = append(b, uint8(dwarf.DW_CFA_advance_loc+deltapc)) |
| case deltapc < 0x100: |
| b = append(b, dwarf.DW_CFA_advance_loc1) |
| b = append(b, uint8(deltapc)) |
| case deltapc < 0x10000: |
| b = append(b, dwarf.DW_CFA_advance_loc2, 0, 0) |
| arch.ByteOrder.PutUint16(b[len(b)-2:], uint16(deltapc)) |
| default: |
| b = append(b, dwarf.DW_CFA_advance_loc4, 0, 0, 0, 0) |
| arch.ByteOrder.PutUint32(b[len(b)-4:], uint32(deltapc)) |
| } |
| return b |
| } |
| |
| func (d *dwctxt) writeframes(fs loader.Sym) dwarfSecInfo { |
| fsd := dwSym(fs) |
| fsu := d.ldr.MakeSymbolUpdater(fs) |
| fsu.SetType(sym.SDWARFSECT) |
| isdw64 := isDwarf64(d.linkctxt) |
| haslr := haslinkregister(d.linkctxt) |
| |
| // Length field is 4 bytes on Dwarf32 and 12 bytes on Dwarf64 |
| lengthFieldSize := int64(4) |
| if isdw64 { |
| lengthFieldSize += 8 |
| } |
| |
| // Emit the CIE, Section 6.4.1 |
| cieReserve := uint32(16) |
| if haslr { |
| cieReserve = 32 |
| } |
| if isdw64 { |
| cieReserve += 4 // 4 bytes added for cid |
| } |
| d.createUnitLength(fsu, uint64(cieReserve)) // initial length, must be multiple of thearch.ptrsize |
| d.addDwarfAddrField(fsu, ^uint64(0)) // cid |
| fsu.AddUint8(3) // dwarf version (appendix F) |
| fsu.AddUint8(0) // augmentation "" |
| dwarf.Uleb128put(d, fsd, 1) // code_alignment_factor |
| dwarf.Sleb128put(d, fsd, dataAlignmentFactor) // all CFI offset calculations include multiplication with this factor |
| dwarf.Uleb128put(d, fsd, int64(thearch.Dwarfreglr)) // return_address_register |
| |
| fsu.AddUint8(dwarf.DW_CFA_def_cfa) // Set the current frame address.. |
| dwarf.Uleb128put(d, fsd, int64(thearch.Dwarfregsp)) // ...to use the value in the platform's SP register (defined in l.go)... |
| if haslr { |
| dwarf.Uleb128put(d, fsd, int64(0)) // ...plus a 0 offset. |
| |
| fsu.AddUint8(dwarf.DW_CFA_same_value) // The platform's link register is unchanged during the prologue. |
| dwarf.Uleb128put(d, fsd, int64(thearch.Dwarfreglr)) |
| |
| fsu.AddUint8(dwarf.DW_CFA_val_offset) // The previous value... |
| dwarf.Uleb128put(d, fsd, int64(thearch.Dwarfregsp)) // ...of the platform's SP register... |
| dwarf.Uleb128put(d, fsd, int64(0)) // ...is CFA+0. |
| } else { |
| dwarf.Uleb128put(d, fsd, int64(d.arch.PtrSize)) // ...plus the word size (because the call instruction implicitly adds one word to the frame). |
| |
| fsu.AddUint8(dwarf.DW_CFA_offset_extended) // The previous value... |
| dwarf.Uleb128put(d, fsd, int64(thearch.Dwarfreglr)) // ...of the return address... |
| dwarf.Uleb128put(d, fsd, int64(-d.arch.PtrSize)/dataAlignmentFactor) // ...is saved at [CFA - (PtrSize/4)]. |
| } |
| |
| pad := int64(cieReserve) + lengthFieldSize - int64(len(d.ldr.Data(fs))) |
| |
| if pad < 0 { |
| Exitf("dwarf: cieReserve too small by %d bytes.", -pad) |
| } |
| |
| internalExec := d.linkctxt.BuildMode == BuildModeExe && d.linkctxt.IsInternal() |
| addAddrPlus := loader.GenAddAddrPlusFunc(internalExec) |
| |
| fsu.AddBytes(zeros[:pad]) |
| |
| var deltaBuf []byte |
| pcsp := obj.NewPCIter(uint32(d.arch.MinLC)) |
| for _, s := range d.linkctxt.Textp { |
| fn := loader.Sym(s) |
| fi := d.ldr.FuncInfo(fn) |
| if !fi.Valid() { |
| continue |
| } |
| fpcsp := fi.Pcsp() |
| |
| // Emit a FDE, Section 6.4.1. |
| // First build the section contents into a byte buffer. |
| deltaBuf = deltaBuf[:0] |
| if haslr && d.ldr.AttrTopFrame(fn) { |
| // Mark the link register as having an undefined value. |
| // This stops call stack unwinders progressing any further. |
| // TODO: similar mark on non-LR architectures. |
| deltaBuf = append(deltaBuf, dwarf.DW_CFA_undefined) |
| deltaBuf = dwarf.AppendUleb128(deltaBuf, uint64(thearch.Dwarfreglr)) |
| } |
| |
| for pcsp.Init(d.linkctxt.loader.Data(fpcsp)); !pcsp.Done; pcsp.Next() { |
| nextpc := pcsp.NextPC |
| |
| // pciterinit goes up to the end of the function, |
| // but DWARF expects us to stop just before the end. |
| if int64(nextpc) == int64(len(d.ldr.Data(fn))) { |
| nextpc-- |
| if nextpc < pcsp.PC { |
| continue |
| } |
| } |
| |
| spdelta := int64(pcsp.Value) |
| if !haslr { |
| // Return address has been pushed onto stack. |
| spdelta += int64(d.arch.PtrSize) |
| } |
| |
| if haslr && !d.ldr.AttrTopFrame(fn) { |
| // TODO(bryanpkc): This is imprecise. In general, the instruction |
| // that stores the return address to the stack frame is not the |
| // same one that allocates the frame. |
| if pcsp.Value > 0 { |
| // The return address is preserved at (CFA-frame_size) |
| // after a stack frame has been allocated. |
| deltaBuf = append(deltaBuf, dwarf.DW_CFA_offset_extended_sf) |
| deltaBuf = dwarf.AppendUleb128(deltaBuf, uint64(thearch.Dwarfreglr)) |
| deltaBuf = dwarf.AppendSleb128(deltaBuf, -spdelta/dataAlignmentFactor) |
| } else { |
| // The return address is restored into the link register |
| // when a stack frame has been de-allocated. |
| deltaBuf = append(deltaBuf, dwarf.DW_CFA_same_value) |
| deltaBuf = dwarf.AppendUleb128(deltaBuf, uint64(thearch.Dwarfreglr)) |
| } |
| } |
| |
| deltaBuf = appendPCDeltaCFA(d.arch, deltaBuf, int64(nextpc)-int64(pcsp.PC), spdelta) |
| } |
| pad := int(Rnd(int64(len(deltaBuf)), int64(d.arch.PtrSize))) - len(deltaBuf) |
| deltaBuf = append(deltaBuf, zeros[:pad]...) |
| |
| // Emit the FDE header, Section 6.4.1. |
| // 4 bytes: length, must be multiple of thearch.ptrsize |
| // 4/8 bytes: Pointer to the CIE above, at offset 0 |
| // ptrsize: initial location |
| // ptrsize: address range |
| |
| fdeLength := uint64(4 + 2*d.arch.PtrSize + len(deltaBuf)) |
| if isdw64 { |
| fdeLength += 4 // 4 bytes added for CIE pointer |
| } |
| d.createUnitLength(fsu, fdeLength) |
| |
| if d.linkctxt.LinkMode == LinkExternal { |
| d.addDwarfAddrRef(fsu, fs) |
| } else { |
| d.addDwarfAddrField(fsu, 0) // CIE offset |
| } |
| addAddrPlus(fsu, d.arch, s, 0) |
| fsu.AddUintXX(d.arch, uint64(len(d.ldr.Data(fn))), d.arch.PtrSize) // address range |
| fsu.AddBytes(deltaBuf) |
| |
| if d.linkctxt.HeadType == objabi.Haix { |
| addDwsectCUSize(".debug_frame", d.ldr.SymPkg(fn), fdeLength+uint64(lengthFieldSize)) |
| } |
| } |
| |
| return dwarfSecInfo{syms: []loader.Sym{fs}} |
| } |
| |
| /* |
| * Walk DWarfDebugInfoEntries, and emit .debug_info |
| */ |
| |
| const ( |
| COMPUNITHEADERSIZE = 4 + 2 + 4 + 1 |
| ) |
| |
| // appendSyms appends the syms from 'src' into 'syms' and returns the |
| // result. This can go away once we do away with sym.LoaderSym |
| // entirely. |
| func appendSyms(syms []loader.Sym, src []sym.LoaderSym) []loader.Sym { |
| for _, s := range src { |
| syms = append(syms, loader.Sym(s)) |
| } |
| return syms |
| } |
| |
| func (d *dwctxt) writeUnitInfo(u *sym.CompilationUnit, abbrevsym loader.Sym, infoEpilog loader.Sym) []loader.Sym { |
| syms := []loader.Sym{} |
| if len(u.Textp) == 0 && u.DWInfo.Child == nil { |
| return syms |
| } |
| |
| compunit := u.DWInfo |
| s := d.dtolsym(compunit.Sym) |
| su := d.ldr.MakeSymbolUpdater(s) |
| |
| // Write .debug_info Compilation Unit Header (sec 7.5.1) |
| // Fields marked with (*) must be changed for 64-bit dwarf |
| // This must match COMPUNITHEADERSIZE above. |
| d.createUnitLength(su, 0) // unit_length (*), will be filled in later. |
| su.AddUint16(d.arch, 4) // dwarf version (appendix F) |
| |
| // debug_abbrev_offset (*) |
| d.addDwarfAddrRef(su, abbrevsym) |
| |
| su.AddUint8(uint8(d.arch.PtrSize)) // address_size |
| |
| ds := dwSym(s) |
| dwarf.Uleb128put(d, ds, int64(compunit.Abbrev)) |
| dwarf.PutAttrs(d, ds, compunit.Abbrev, compunit.Attr) |
| |
| // This is an under-estimate; more will be needed for type DIEs. |
| cu := make([]loader.Sym, 0, len(u.AbsFnDIEs)+len(u.FuncDIEs)) |
| cu = append(cu, s) |
| cu = appendSyms(cu, u.AbsFnDIEs) |
| cu = appendSyms(cu, u.FuncDIEs) |
| if u.Consts != 0 { |
| cu = append(cu, loader.Sym(u.Consts)) |
| } |
| var cusize int64 |
| for _, child := range cu { |
| cusize += int64(len(d.ldr.Data(child))) |
| } |
| |
| for die := compunit.Child; die != nil; die = die.Link { |
| l := len(cu) |
| lastSymSz := int64(len(d.ldr.Data(cu[l-1]))) |
| cu = d.putdie(cu, die) |
| if lastSymSz != int64(len(d.ldr.Data(cu[l-1]))) { |
| // putdie will sometimes append directly to the last symbol of the list |
| cusize = cusize - lastSymSz + int64(len(d.ldr.Data(cu[l-1]))) |
| } |
| for _, child := range cu[l:] { |
| cusize += int64(len(d.ldr.Data(child))) |
| } |
| } |
| |
| culu := d.ldr.MakeSymbolUpdater(infoEpilog) |
| culu.AddUint8(0) // closes compilation unit DIE |
| cu = append(cu, infoEpilog) |
| cusize++ |
| |
| // Save size for AIX symbol table. |
| if d.linkctxt.HeadType == objabi.Haix { |
| addDwsectCUSize(".debug_info", d.getPkgFromCUSym(s), uint64(cusize)) |
| } |
| if isDwarf64(d.linkctxt) { |
| cusize -= 12 // exclude the length field. |
| su.SetUint(d.arch, 4, uint64(cusize)) // 4 because of 0XFFFFFFFF |
| } else { |
| cusize -= 4 // exclude the length field. |
| su.SetUint32(d.arch, 0, uint32(cusize)) |
| } |
| return append(syms, cu...) |
| } |
| |
| func (d *dwctxt) writegdbscript() dwarfSecInfo { |
| // TODO (aix): make it available |
| if d.linkctxt.HeadType == objabi.Haix { |
| return dwarfSecInfo{} |
| } |
| if d.linkctxt.LinkMode == LinkExternal && d.linkctxt.HeadType == objabi.Hwindows && d.linkctxt.BuildMode == BuildModeCArchive { |
| // gcc on Windows places .debug_gdb_scripts in the wrong location, which |
| // causes the program not to run. See https://golang.org/issue/20183 |
| // Non c-archives can avoid this issue via a linker script |
| // (see fix near writeGDBLinkerScript). |
| // c-archive users would need to specify the linker script manually. |
| // For UX it's better not to deal with this. |
| return dwarfSecInfo{} |
| } |
| if gdbscript == "" { |
| return dwarfSecInfo{} |
| } |
| |
| gs := d.ldr.CreateSymForUpdate(".debug_gdb_scripts", 0) |
| gs.SetType(sym.SDWARFSECT) |
| |
| gs.AddUint8(1) // magic 1 byte? |
| gs.Addstring(gdbscript) |
| return dwarfSecInfo{syms: []loader.Sym{gs.Sym()}} |
| } |
| |
| // FIXME: might be worth looking replacing this map with a function |
| // that switches based on symbol instead. |
| |
| var prototypedies map[string]*dwarf.DWDie |
| |
| func dwarfEnabled(ctxt *Link) bool { |
| if *FlagW { // disable dwarf |
| return false |
| } |
| if *FlagS && ctxt.HeadType != objabi.Hdarwin { |
| return false |
| } |
| if ctxt.HeadType == objabi.Hplan9 { |
| return false |
| } |
| |
| if ctxt.LinkMode == LinkExternal { |
| switch { |
| case ctxt.IsELF: |
| case ctxt.HeadType == objabi.Hdarwin: |
| case ctxt.HeadType == objabi.Hwindows: |
| case ctxt.HeadType == objabi.Haix: |
| res, err := dwarf.IsDWARFEnabledOnAIXLd(ctxt.extld()) |
| if err != nil { |
| Exitf("%v", err) |
| } |
| return res |
| default: |
| return false |
| } |
| } |
| |
| return true |
| } |
| |
| // mkBuiltinType populates the dwctxt2 sym lookup maps for the |
| // newly created builtin type DIE 'typeDie'. |
| func (d *dwctxt) mkBuiltinType(ctxt *Link, abrv int, tname string) *dwarf.DWDie { |
| // create type DIE |
| die := d.newdie(&dwtypes, abrv, tname, 0) |
| |
| // Look up type symbol. |
| gotype := d.lookupOrDiag("type." + tname) |
| |
| // Map from die sym to type sym |
| ds := loader.Sym(die.Sym.(dwSym)) |
| d.rtmap[ds] = gotype |
| |
| // Map from type to def sym |
| d.tdmap[gotype] = ds |
| |
| return die |
| } |
| |
| // dwarfVisitFunction takes a function (text) symbol and processes the |
| // subprogram DIE for the function and picks up any other DIEs |
| // (absfns, types) that it references. |
| func (d *dwctxt) dwarfVisitFunction(fnSym loader.Sym, unit *sym.CompilationUnit) { |
| // The DWARF subprogram DIE symbol is listed as an aux sym |
| // of the text (fcn) symbol, so ask the loader to retrieve it, |
| // as well as the associated range symbol. |
| infosym, _, rangesym, _ := d.ldr.GetFuncDwarfAuxSyms(fnSym) |
| if infosym == 0 { |
| return |
| } |
| d.ldr.SetAttrNotInSymbolTable(infosym, true) |
| d.ldr.SetAttrReachable(infosym, true) |
| unit.FuncDIEs = append(unit.FuncDIEs, sym.LoaderSym(infosym)) |
| if rangesym != 0 { |
| d.ldr.SetAttrNotInSymbolTable(rangesym, true) |
| d.ldr.SetAttrReachable(rangesym, true) |
| unit.RangeSyms = append(unit.RangeSyms, sym.LoaderSym(rangesym)) |
| } |
| |
| // Walk the relocations of the subprogram DIE symbol to discover |
| // references to abstract function DIEs, Go type DIES, and |
| // (via R_USETYPE relocs) types that were originally assigned to |
| // locals/params but were optimized away. |
| drelocs := d.ldr.Relocs(infosym) |
| for ri := 0; ri < drelocs.Count(); ri++ { |
| r := drelocs.At(ri) |
| // Look for "use type" relocs. |
| if r.Type() == objabi.R_USETYPE { |
| d.defgotype(r.Sym()) |
| continue |
| } |
| if r.Type() != objabi.R_DWARFSECREF { |
| continue |
| } |
| |
| rsym := r.Sym() |
| rst := d.ldr.SymType(rsym) |
| |
| // Look for abstract function references. |
| if rst == sym.SDWARFABSFCN { |
| if !d.ldr.AttrOnList(rsym) { |
| // abstract function |
| d.ldr.SetAttrOnList(rsym, true) |
| unit.AbsFnDIEs = append(unit.AbsFnDIEs, sym.LoaderSym(rsym)) |
| d.importInfoSymbol(rsym) |
| } |
| continue |
| } |
| |
| // Look for type references. |
| if rst != sym.SDWARFTYPE && rst != sym.Sxxx { |
| continue |
| } |
| if _, ok := d.rtmap[rsym]; ok { |
| // type already generated |
| continue |
| } |
| |
| rsn := d.ldr.SymName(rsym) |
| tn := rsn[len(dwarf.InfoPrefix):] |
| ts := d.ldr.Lookup("type."+tn, 0) |
| d.defgotype(ts) |
| } |
| } |
| |
| // dwarfGenerateDebugInfo generated debug info entries for all types, |
| // variables and functions in the program. |
| // Along with dwarfGenerateDebugSyms they are the two main entry points into |
| // dwarf generation: dwarfGenerateDebugInfo does all the work that should be |
| // done before symbol names are mangled while dwarfGenerateDebugSyms does |
| // all the work that can only be done after addresses have been assigned to |
| // text symbols. |
| func dwarfGenerateDebugInfo(ctxt *Link) { |
| if !dwarfEnabled(ctxt) { |
| return |
| } |
| |
| d := newdwctxt(ctxt, true) |
| |
| if ctxt.HeadType == objabi.Haix { |
| // Initial map used to store package size for each DWARF section. |
| dwsectCUSize = make(map[string]uint64) |
| } |
| |
| // For ctxt.Diagnostic messages. |
| newattr(&dwtypes, dwarf.DW_AT_name, dwarf.DW_CLS_STRING, int64(len("dwtypes")), "dwtypes") |
| |
| // Unspecified type. There are no references to this in the symbol table. |
| d.newdie(&dwtypes, dwarf.DW_ABRV_NULLTYPE, "<unspecified>", 0) |
| |
| // Some types that must exist to define other ones (uintptr in particular |
| // is needed for array size) |
| d.mkBuiltinType(ctxt, dwarf.DW_ABRV_BARE_PTRTYPE, "unsafe.Pointer") |
| die := d.mkBuiltinType(ctxt, dwarf.DW_ABRV_BASETYPE, "uintptr") |
| newattr(die, dwarf.DW_AT_encoding, dwarf.DW_CLS_CONSTANT, dwarf.DW_ATE_unsigned, 0) |
| newattr(die, dwarf.DW_AT_byte_size, dwarf.DW_CLS_CONSTANT, int64(d.arch.PtrSize), 0) |
| newattr(die, dwarf.DW_AT_go_kind, dwarf.DW_CLS_CONSTANT, objabi.KindUintptr, 0) |
| newattr(die, dwarf.DW_AT_go_runtime_type, dwarf.DW_CLS_ADDRESS, 0, dwSym(d.lookupOrDiag("type.uintptr"))) |
| |
| d.uintptrInfoSym = d.mustFind("uintptr") |
| |
| // Prototypes needed for type synthesis. |
| prototypedies = map[string]*dwarf.DWDie{ |
| "type.runtime.stringStructDWARF": nil, |
| "type.runtime.slice": nil, |
| "type.runtime.hmap": nil, |
| "type.runtime.bmap": nil, |
| "type.runtime.sudog": nil, |
| "type.runtime.waitq": nil, |
| "type.runtime.hchan": nil, |
| } |
| |
| // Needed by the prettyprinter code for interface inspection. |
| for _, typ := range []string{ |
| "type.runtime._type", |
| "type.runtime.arraytype", |
| "type.runtime.chantype", |
| "type.runtime.functype", |
| "type.runtime.maptype", |
| "type.runtime.ptrtype", |
| "type.runtime.slicetype", |
| "type.runtime.structtype", |
| "type.runtime.interfacetype", |
| "type.runtime.itab", |
| "type.runtime.imethod"} { |
| d.defgotype(d.lookupOrDiag(typ)) |
| } |
| |
| // fake root DIE for compile unit DIEs |
| var dwroot dwarf.DWDie |
| flagVariants := make(map[string]bool) |
| |
| for _, lib := range ctxt.Library { |
| |
| consts := d.ldr.Lookup(dwarf.ConstInfoPrefix+lib.Pkg, 0) |
| for _, unit := range lib.Units { |
| // We drop the constants into the first CU. |
| if consts != 0 { |
| unit.Consts = sym.LoaderSym(consts) |
| d.importInfoSymbol(consts) |
| consts = 0 |
| } |
| ctxt.compUnits = append(ctxt.compUnits, unit) |
| |
| // We need at least one runtime unit. |
| if unit.Lib.Pkg == "runtime" { |
| ctxt.runtimeCU = unit |
| } |
| |
| cuabrv := dwarf.DW_ABRV_COMPUNIT |
| if len(unit.Textp) == 0 { |
| cuabrv = dwarf.DW_ABRV_COMPUNIT_TEXTLESS |
| } |
| unit.DWInfo = d.newdie(&dwroot, cuabrv, unit.Lib.Pkg, 0) |
| newattr(unit.DWInfo, dwarf.DW_AT_language, dwarf.DW_CLS_CONSTANT, int64(dwarf.DW_LANG_Go), 0) |
| // OS X linker requires compilation dir or absolute path in comp unit name to output debug info. |
| compDir := getCompilationDir() |
| // TODO: Make this be the actual compilation directory, not |
| // the linker directory. If we move CU construction into the |
| // compiler, this should happen naturally. |
| newattr(unit.DWInfo, dwarf.DW_AT_comp_dir, dwarf.DW_CLS_STRING, int64(len(compDir)), compDir) |
| |
| var peData []byte |
| if producerExtra := d.ldr.Lookup(dwarf.CUInfoPrefix+"producer."+unit.Lib.Pkg, 0); producerExtra != 0 { |
| peData = d.ldr.Data(producerExtra) |
| } |
| producer := "Go cmd/compile " + objabi.Version |
| if len(peData) > 0 { |
| // We put a semicolon before the flags to clearly |
| // separate them from the version, which can be long |
| // and have lots of weird things in it in development |
| // versions. We promise not to put a semicolon in the |
| // version, so it should be safe for readers to scan |
| // forward to the semicolon. |
| producer += "; " + string(peData) |
| flagVariants[string(peData)] = true |
| } else { |
| flagVariants[""] = true |
| } |
| |
| newattr(unit.DWInfo, dwarf.DW_AT_producer, dwarf.DW_CLS_STRING, int64(len(producer)), producer) |
| |
| var pkgname string |
| if pnSymIdx := d.ldr.Lookup(dwarf.CUInfoPrefix+"packagename."+unit.Lib.Pkg, 0); pnSymIdx != 0 { |
| pnsData := d.ldr.Data(pnSymIdx) |
| pkgname = string(pnsData) |
| } |
| newattr(unit.DWInfo, dwarf.DW_AT_go_package_name, dwarf.DW_CLS_STRING, int64(len(pkgname)), pkgname) |
| |
| // Scan all functions in this compilation unit, create |
| // DIEs for all referenced types, find all referenced |
| // abstract functions, visit range symbols. Note that |
| // Textp has been dead-code-eliminated already. |
| for _, s := range unit.Textp { |
| d.dwarfVisitFunction(loader.Sym(s), unit) |
| } |
| } |
| } |
| |
| // Fix for 31034: if the objects feeding into this link were compiled |
| // with different sets of flags, then don't issue an error if |
| // the -strictdups checks fail. |
| if checkStrictDups > 1 && len(flagVariants) > 1 { |
| checkStrictDups = 1 |
| } |
| |
| // Create DIEs for global variables and the types they use. |
| // FIXME: ideally this should be done in the compiler, since |
| // for globals there isn't any abiguity about which package |
| // a global belongs to. |
| for idx := loader.Sym(1); idx < loader.Sym(d.ldr.NDef()); idx++ { |
| if !d.ldr.AttrReachable(idx) || |
| d.ldr.AttrNotInSymbolTable(idx) || |
| d.ldr.SymVersion(idx) >= sym.SymVerStatic { |
| continue |
| } |
| t := d.ldr.SymType(idx) |
| switch t { |
| case sym.SRODATA, sym.SDATA, sym.SNOPTRDATA, sym.STYPE, sym.SBSS, sym.SNOPTRBSS, sym.STLSBSS: |
| // ok |
| default: |
| continue |
| } |
| // Skip things with no type |
| if d.ldr.SymGoType(idx) == 0 { |
| continue |
| } |
| // Skip file local symbols (this includes static tmps, stack |
| // object symbols, and local symbols in assembler src files). |
| if d.ldr.IsFileLocal(idx) { |
| continue |
| } |
| sn := d.ldr.SymName(idx) |
| if sn == "" { |
| // skip aux symbols |
| continue |
| } |
| |
| // Create DIE for global. |
| sv := d.ldr.SymValue(idx) |
| gt := d.ldr.SymGoType(idx) |
| d.dwarfDefineGlobal(ctxt, idx, sn, sv, gt) |
| } |
| |
| d.synthesizestringtypes(ctxt, dwtypes.Child) |
| d.synthesizeslicetypes(ctxt, dwtypes.Child) |
| d.synthesizemaptypes(ctxt, dwtypes.Child) |
| d.synthesizechantypes(ctxt, dwtypes.Child) |
| } |
| |
| // dwarfGenerateDebugSyms constructs debug_line, debug_frame, and |
| // debug_loc. It also writes out the debug_info section using symbols |
| // generated in dwarfGenerateDebugInfo. |
| func dwarfGenerateDebugSyms(ctxt *Link) { |
| if !dwarfEnabled(ctxt) { |
| return |
| } |
| d := &dwctxt{ |
| linkctxt: ctxt, |
| ldr: ctxt.loader, |
| arch: ctxt.Arch, |
| dwmu: new(sync.Mutex), |
| } |
| d.dwarfGenerateDebugSyms() |
| } |
| |
| // dwUnitSyms stores input and output symbols for DWARF generation |
| // for a given compilation unit. |
| type dwUnitSyms struct { |
| // Inputs for a given unit. |
| lineProlog loader.Sym |
| rangeProlog loader.Sym |
| infoEpilog loader.Sym |
| |
| // Outputs for a given unit. |
| linesyms []loader.Sym |
| infosyms []loader.Sym |
| locsyms []loader.Sym |
| rangessyms []loader.Sym |
| } |
| |
| // dwUnitPortion assembles the DWARF content for a given compilation |
| // unit: debug_info, debug_lines, debug_ranges, debug_loc (debug_frame |
| // is handled elsewere). Order is important; the calls to writelines |
| // and writepcranges below make updates to the compilation unit DIE, |
| // hence they have to happen before the call to writeUnitInfo. |
| func (d *dwctxt) dwUnitPortion(u *sym.CompilationUnit, abbrevsym loader.Sym, us *dwUnitSyms) { |
| if u.DWInfo.Abbrev != dwarf.DW_ABRV_COMPUNIT_TEXTLESS { |
| us.linesyms = d.writelines(u, us.lineProlog) |
| base := loader.Sym(u.Textp[0]) |
| us.rangessyms = d.writepcranges(u, base, u.PCs, us.rangeProlog) |
| us.locsyms = d.collectUnitLocs(u) |
| } |
| us.infosyms = d.writeUnitInfo(u, abbrevsym, us.infoEpilog) |
| } |
| |
| func (d *dwctxt) dwarfGenerateDebugSyms() { |
| abbrevSec := d.writeabbrev() |
| dwarfp = append(dwarfp, abbrevSec) |
| d.calcCompUnitRanges() |
| sort.Sort(compilationUnitByStartPC(d.linkctxt.compUnits)) |
| |
| // newdie adds DIEs to the *beginning* of the parent's DIE list. |
| // Now that we're done creating DIEs, reverse the trees so DIEs |
| // appear in the order they were created. |
| for _, u := range d.linkctxt.compUnits { |
| reversetree(&u.DWInfo.Child) |
| } |
| reversetree(&dwtypes.Child) |
| movetomodule(d.linkctxt, &dwtypes) |
| |
| mkSecSym := func(name string) loader.Sym { |
| s := d.ldr.CreateSymForUpdate(name, 0) |
| s.SetType(sym.SDWARFSECT) |
| s.SetReachable(true) |
| return s.Sym() |
| } |
| mkAnonSym := func(kind sym.SymKind) loader.Sym { |
| s := d.ldr.MakeSymbolUpdater(d.ldr.CreateExtSym("", 0)) |
| s.SetType(kind) |
| s.SetReachable(true) |
| return s.Sym() |
| } |
| |
| // Create the section symbols. |
| frameSym := mkSecSym(".debug_frame") |
| locSym := mkSecSym(".debug_loc") |
| lineSym := mkSecSym(".debug_line") |
| rangesSym := mkSecSym(".debug_ranges") |
| infoSym := mkSecSym(".debug_info") |
| |
| // Create the section objects |
| lineSec := dwarfSecInfo{syms: []loader.Sym{lineSym}} |
| locSec := dwarfSecInfo{syms: []loader.Sym{locSym}} |
| rangesSec := dwarfSecInfo{syms: []loader.Sym{rangesSym}} |
| frameSec := dwarfSecInfo{syms: []loader.Sym{frameSym}} |
| infoSec := dwarfSecInfo{syms: []loader.Sym{infoSym}} |
| |
| // Create any new symbols that will be needed during the |
| // parallel portion below. |
| ncu := len(d.linkctxt.compUnits) |
| unitSyms := make([]dwUnitSyms, ncu) |
| for i := 0; i < ncu; i++ { |
| us := &unitSyms[i] |
| us.lineProlog = mkAnonSym(sym.SDWARFLINES) |
| us.rangeProlog = mkAnonSym(sym.SDWARFRANGE) |
| us.infoEpilog = mkAnonSym(sym.SDWARFFCN) |
| } |
| |
| var wg sync.WaitGroup |
| sema := make(chan struct{}, runtime.GOMAXPROCS(0)) |
| |
| // Kick off generation of .debug_frame, since it doesn't have |
| // any entanglements and can be started right away. |
| wg.Add(1) |
| go func() { |
| sema <- struct{}{} |
| defer func() { |
| <-sema |
| wg.Done() |
| }() |
| frameSec = d.writeframes(frameSym) |
| }() |
| |
| // Create a goroutine per comp unit to handle the generation that |
| // unit's portion of .debug_line, .debug_loc, .debug_ranges, and |
| // .debug_info. |
| wg.Add(len(d.linkctxt.compUnits)) |
| for i := 0; i < ncu; i++ { |
| go func(u *sym.CompilationUnit, us *dwUnitSyms) { |
| sema <- struct{}{} |
| defer func() { |
| <-sema |
| wg.Done() |
| }() |
| d.dwUnitPortion(u, abbrevSec.secSym(), us) |
| }(d.linkctxt.compUnits[i], &unitSyms[i]) |
| } |
| wg.Wait() |
| |
| markReachable := func(syms []loader.Sym) []loader.Sym { |
| for _, s := range syms { |
| d.ldr.SetAttrNotInSymbolTable(s, true) |
| d.ldr.SetAttrReachable(s, true) |
| } |
| return syms |
| } |
| |
| // Stitch together the results. |
| for i := 0; i < ncu; i++ { |
| r := &unitSyms[i] |
| lineSec.syms = append(lineSec.syms, markReachable(r.linesyms)...) |
| infoSec.syms = append(infoSec.syms, markReachable(r.infosyms)...) |
| locSec.syms = append(locSec.syms, markReachable(r.locsyms)...) |
| rangesSec.syms = append(rangesSec.syms, markReachable(r.rangessyms)...) |
| } |
| dwarfp = append(dwarfp, lineSec) |
| dwarfp = append(dwarfp, frameSec) |
| gdbScriptSec := d.writegdbscript() |
| if gdbScriptSec.secSym() != 0 { |
| dwarfp = append(dwarfp, gdbScriptSec) |
| } |
| dwarfp = append(dwarfp, infoSec) |
| if len(locSec.syms) > 1 { |
| dwarfp = append(dwarfp, locSec) |
| } |
| dwarfp = append(dwarfp, rangesSec) |
| |
| // Check to make sure we haven't listed any symbols more than once |
| // in the info section. This used to be done by setting and |
| // checking the OnList attribute in "putdie", but that strategy |
| // was not friendly for concurrency. |
| seen := loader.MakeBitmap(d.ldr.NSym()) |
| for _, s := range infoSec.syms { |
| if seen.Has(s) { |
| log.Fatalf("symbol %s listed multiple times", d.ldr.SymName(s)) |
| } |
| seen.Set(s) |
| } |
| } |
| |
| func (d *dwctxt) collectUnitLocs(u *sym.CompilationUnit) []loader.Sym { |
| syms := []loader.Sym{} |
| for _, fn := range u.FuncDIEs { |
| relocs := d.ldr.Relocs(loader.Sym(fn)) |
| for i := 0; i < relocs.Count(); i++ { |
| reloc := relocs.At(i) |
| if reloc.Type() != objabi.R_DWARFSECREF { |
| continue |
| } |
| rsym := reloc.Sym() |
| if d.ldr.SymType(rsym) == sym.SDWARFLOC { |
| syms = append(syms, rsym) |
| // One location list entry per function, but many relocations to it. Don't duplicate. |
| break |
| } |
| } |
| } |
| return syms |
| } |
| |
| /* |
| * Elf. |
| */ |
| func dwarfaddshstrings(ctxt *Link, shstrtab *loader.SymbolBuilder) { |
| if *FlagW { // disable dwarf |
| return |
| } |
| |
| secs := []string{"abbrev", "frame", "info", "loc", "line", "gdb_scripts", "ranges"} |
| for _, sec := range secs { |
| shstrtab.Addstring(".debug_" + sec) |
| if ctxt.IsExternal() { |
| shstrtab.Addstring(elfRelType + ".debug_" + sec) |
| } else { |
| shstrtab.Addstring(".zdebug_" + sec) |
| } |
| } |
| } |
| |
| func dwarfaddelfsectionsyms(ctxt *Link) { |
| if *FlagW { // disable dwarf |
| return |
| } |
| if ctxt.LinkMode != LinkExternal { |
| return |
| } |
| |
| ldr := ctxt.loader |
| for _, si := range dwarfp { |
| s := si.secSym() |
| sect := ldr.SymSect(si.secSym()) |
| putelfsectionsym(ctxt, ctxt.Out, s, sect.Elfsect.(*ElfShdr).shnum) |
| } |
| } |
| |
| // dwarfcompress compresses the DWARF sections. Relocations are applied |
| // on the fly. After this, dwarfp will contain a different (new) set of |
| // symbols, and sections may have been replaced. |
| func dwarfcompress(ctxt *Link) { |
| // compressedSect is a helper type for parallelizing compression. |
| type compressedSect struct { |
| index int |
| compressed []byte |
| syms []loader.Sym |
| } |
| |
| supported := ctxt.IsELF || ctxt.IsWindows() || ctxt.IsDarwin() |
| if !ctxt.compressDWARF || !supported || ctxt.IsExternal() { |
| return |
| } |
| |
| var compressedCount int |
| resChannel := make(chan compressedSect) |
| for i := range dwarfp { |
| go func(resIndex int, syms []loader.Sym) { |
| resChannel <- compressedSect{resIndex, compressSyms(ctxt, syms), syms} |
| }(compressedCount, dwarfp[i].syms) |
| compressedCount++ |
| } |
| res := make([]compressedSect, compressedCount) |
| for ; compressedCount > 0; compressedCount-- { |
| r := <-resChannel |
| res[r.index] = r |
| } |
| |
| ldr := ctxt.loader |
| var newDwarfp []dwarfSecInfo |
| Segdwarf.Sections = Segdwarf.Sections[:0] |
| for _, z := range res { |
| s := z.syms[0] |
| if z.compressed == nil { |
| // Compression didn't help. |
| ds := dwarfSecInfo{syms: z.syms} |
| newDwarfp = append(newDwarfp, ds) |
| Segdwarf.Sections = append(Segdwarf.Sections, ldr.SymSect(s)) |
| } else { |
| compressedSegName := ".zdebug_" + ldr.SymSect(s).Name[len(".debug_"):] |
| sect := addsection(ctxt.loader, ctxt.Arch, &Segdwarf, compressedSegName, 04) |
| sect.Align = 1 |
| sect.Length = uint64(len(z.compressed)) |
| newSym := ldr.CreateSymForUpdate(compressedSegName, 0) |
| newSym.SetData(z.compressed) |
| newSym.SetSize(int64(len(z.compressed))) |
| ldr.SetSymSect(newSym.Sym(), sect) |
| ds := dwarfSecInfo{syms: []loader.Sym{newSym.Sym()}} |
| newDwarfp = append(newDwarfp, ds) |
| |
| // compressed symbols are no longer needed. |
| for _, s := range z.syms { |
| ldr.SetAttrReachable(s, false) |
| ldr.FreeSym(s) |
| } |
| } |
| } |
| dwarfp = newDwarfp |
| |
| // Re-compute the locations of the compressed DWARF symbols |
| // and sections, since the layout of these within the file is |
| // based on Section.Vaddr and Symbol.Value. |
| pos := Segdwarf.Vaddr |
| var prevSect *sym.Section |
| for _, si := range dwarfp { |
| for _, s := range si.syms { |
| ldr.SetSymValue(s, int64(pos)) |
| sect := ldr.SymSect(s) |
| if sect != prevSect { |
| sect.Vaddr = uint64(pos) |
| prevSect = sect |
| } |
| if ldr.SubSym(s) != 0 { |
| log.Fatalf("%s: unexpected sub-symbols", ldr.SymName(s)) |
| } |
| pos += uint64(ldr.SymSize(s)) |
| if ctxt.IsWindows() { |
| pos = uint64(Rnd(int64(pos), PEFILEALIGN)) |
| } |
| } |
| } |
| Segdwarf.Length = pos - Segdwarf.Vaddr |
| } |
| |
| type compilationUnitByStartPC []*sym.CompilationUnit |
| |
| func (v compilationUnitByStartPC) Len() int { return len(v) } |
| func (v compilationUnitByStartPC) Swap(i, j int) { v[i], v[j] = v[j], v[i] } |
| |
| func (v compilationUnitByStartPC) Less(i, j int) bool { |
| switch { |
| case len(v[i].Textp) == 0 && len(v[j].Textp) == 0: |
| return v[i].Lib.Pkg < v[j].Lib.Pkg |
| case len(v[i].Textp) != 0 && len(v[j].Textp) == 0: |
| return true |
| case len(v[i].Textp) == 0 && len(v[j].Textp) != 0: |
| return false |
| default: |
| return v[i].PCs[0].Start < v[j].PCs[0].Start |
| } |
| } |
| |
| // getPkgFromCUSym returns the package name for the compilation unit |
| // represented by s. |
| // The prefix dwarf.InfoPrefix+".pkg." needs to be removed in order to get |
| // the package name. |
| func (d *dwctxt) getPkgFromCUSym(s loader.Sym) string { |
| return strings.TrimPrefix(d.ldr.SymName(s), dwarf.InfoPrefix+".pkg.") |
| } |
| |
| // On AIX, the symbol table needs to know where are the compilation units parts |
| // for a specific package in each .dw section. |
| // dwsectCUSize map will save the size of a compilation unit for |
| // the corresponding .dw section. |
| // This size can later be retrieved with the index "sectionName.pkgName". |
| var dwsectCUSizeMu sync.Mutex |
| var dwsectCUSize map[string]uint64 |
| |
| // getDwsectCUSize retrieves the corresponding package size inside the current section. |
| func getDwsectCUSize(sname string, pkgname string) uint64 { |
| return dwsectCUSize[sname+"."+pkgname] |
| } |
| |
| func saveDwsectCUSize(sname string, pkgname string, size uint64) { |
| dwsectCUSizeMu.Lock() |
| defer dwsectCUSizeMu.Unlock() |
| dwsectCUSize[sname+"."+pkgname] = size |
| } |
| |
| func addDwsectCUSize(sname string, pkgname string, size uint64) { |
| dwsectCUSizeMu.Lock() |
| defer dwsectCUSizeMu.Unlock() |
| dwsectCUSize[sname+"."+pkgname] += size |
| } |