| // Copyright 2017 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package gc |
| |
| import ( |
| "cmd/internal/dwarf" |
| "cmd/internal/obj" |
| "cmd/internal/src" |
| "strings" |
| ) |
| |
| // To identify variables by original source position. |
| type varPos struct { |
| DeclName string |
| DeclFile string |
| DeclLine uint |
| DeclCol uint |
| } |
| |
| // This is the main entry point for collection of raw material to |
| // drive generation of DWARF "inlined subroutine" DIEs. See proposal |
| // 22080 for more details and background info. |
| func assembleInlines(fnsym *obj.LSym, dwVars []*dwarf.Var) dwarf.InlCalls { |
| var inlcalls dwarf.InlCalls |
| |
| if Debug_gendwarfinl != 0 { |
| Ctxt.Logf("assembling DWARF inlined routine info for %v\n", fnsym.Name) |
| } |
| |
| // This maps inline index (from Ctxt.InlTree) to index in inlcalls.Calls |
| imap := make(map[int]int) |
| |
| // Walk progs to build up the InlCalls data structure |
| var prevpos src.XPos |
| for p := fnsym.Func().Text; p != nil; p = p.Link { |
| if p.Pos == prevpos { |
| continue |
| } |
| ii := posInlIndex(p.Pos) |
| if ii >= 0 { |
| insertInlCall(&inlcalls, ii, imap) |
| } |
| prevpos = p.Pos |
| } |
| |
| // This is used to partition DWARF vars by inline index. Vars not |
| // produced by the inliner will wind up in the vmap[0] entry. |
| vmap := make(map[int32][]*dwarf.Var) |
| |
| // Now walk the dwarf vars and partition them based on whether they |
| // were produced by the inliner (dwv.InlIndex > 0) or were original |
| // vars/params from the function (dwv.InlIndex == 0). |
| for _, dwv := range dwVars { |
| |
| vmap[dwv.InlIndex] = append(vmap[dwv.InlIndex], dwv) |
| |
| // Zero index => var was not produced by an inline |
| if dwv.InlIndex == 0 { |
| continue |
| } |
| |
| // Look up index in our map, then tack the var in question |
| // onto the vars list for the correct inlined call. |
| ii := int(dwv.InlIndex) - 1 |
| idx, ok := imap[ii] |
| if !ok { |
| // We can occasionally encounter a var produced by the |
| // inliner for which there is no remaining prog; add a new |
| // entry to the call list in this scenario. |
| idx = insertInlCall(&inlcalls, ii, imap) |
| } |
| inlcalls.Calls[idx].InlVars = |
| append(inlcalls.Calls[idx].InlVars, dwv) |
| } |
| |
| // Post process the map above to assign child indices to vars. |
| // |
| // A given variable is treated differently depending on whether it |
| // is part of the top-level function (ii == 0) or if it was |
| // produced as a result of an inline (ii != 0). |
| // |
| // If a variable was not produced by an inline and its containing |
| // function was not inlined, then we just assign an ordering of |
| // based on variable name. |
| // |
| // If a variable was not produced by an inline and its containing |
| // function was inlined, then we need to assign a child index |
| // based on the order of vars in the abstract function (in |
| // addition, those vars that don't appear in the abstract |
| // function, such as "~r1", are flagged as such). |
| // |
| // If a variable was produced by an inline, then we locate it in |
| // the pre-inlining decls for the target function and assign child |
| // index accordingly. |
| for ii, sl := range vmap { |
| var m map[varPos]int |
| if ii == 0 { |
| if !fnsym.WasInlined() { |
| for j, v := range sl { |
| v.ChildIndex = int32(j) |
| } |
| continue |
| } |
| m = makePreinlineDclMap(fnsym) |
| } else { |
| ifnlsym := Ctxt.InlTree.InlinedFunction(int(ii - 1)) |
| m = makePreinlineDclMap(ifnlsym) |
| } |
| |
| // Here we assign child indices to variables based on |
| // pre-inlined decls, and set the "IsInAbstract" flag |
| // appropriately. In addition: parameter and local variable |
| // names are given "middle dot" version numbers as part of the |
| // writing them out to export data (see issue 4326). If DWARF |
| // inlined routine generation is turned on, we want to undo |
| // this versioning, since DWARF variables in question will be |
| // parented by the inlined routine and not the top-level |
| // caller. |
| synthCount := len(m) |
| for _, v := range sl { |
| canonName := unversion(v.Name) |
| vp := varPos{ |
| DeclName: canonName, |
| DeclFile: v.DeclFile, |
| DeclLine: v.DeclLine, |
| DeclCol: v.DeclCol, |
| } |
| synthesized := strings.HasPrefix(v.Name, "~r") || canonName == "_" || strings.HasPrefix(v.Name, "~b") |
| if idx, found := m[vp]; found { |
| v.ChildIndex = int32(idx) |
| v.IsInAbstract = !synthesized |
| v.Name = canonName |
| } else { |
| // Variable can't be found in the pre-inline dcl list. |
| // In the top-level case (ii=0) this can happen |
| // because a composite variable was split into pieces, |
| // and we're looking at a piece. We can also see |
| // return temps (~r%d) that were created during |
| // lowering, or unnamed params ("_"). |
| v.ChildIndex = int32(synthCount) |
| synthCount++ |
| } |
| } |
| } |
| |
| // Make a second pass through the progs to compute PC ranges for |
| // the various inlined calls. |
| start := int64(-1) |
| curii := -1 |
| var prevp *obj.Prog |
| for p := fnsym.Func().Text; p != nil; prevp, p = p, p.Link { |
| if prevp != nil && p.Pos == prevp.Pos { |
| continue |
| } |
| ii := posInlIndex(p.Pos) |
| if ii == curii { |
| continue |
| } |
| // Close out the current range |
| if start != -1 { |
| addRange(inlcalls.Calls, start, p.Pc, curii, imap) |
| } |
| // Begin new range |
| start = p.Pc |
| curii = ii |
| } |
| if start != -1 { |
| addRange(inlcalls.Calls, start, fnsym.Size, curii, imap) |
| } |
| |
| // Debugging |
| if Debug_gendwarfinl != 0 { |
| dumpInlCalls(inlcalls) |
| dumpInlVars(dwVars) |
| } |
| |
| return inlcalls |
| } |
| |
| // Secondary hook for DWARF inlined subroutine generation. This is called |
| // late in the compilation when it is determined that we need an |
| // abstract function DIE for an inlined routine imported from a |
| // previously compiled package. |
| func genAbstractFunc(fn *obj.LSym) { |
| ifn := Ctxt.DwFixups.GetPrecursorFunc(fn) |
| if ifn == nil { |
| Ctxt.Diag("failed to locate precursor fn for %v", fn) |
| return |
| } |
| if Debug_gendwarfinl != 0 { |
| Ctxt.Logf("DwarfAbstractFunc(%v)\n", fn.Name) |
| } |
| Ctxt.DwarfAbstractFunc(ifn, fn, myimportpath) |
| } |
| |
| // Undo any versioning performed when a name was written |
| // out as part of export data. |
| func unversion(name string) string { |
| if i := strings.Index(name, "ยท"); i > 0 { |
| name = name[:i] |
| } |
| return name |
| } |
| |
| // Given a function that was inlined as part of the compilation, dig |
| // up the pre-inlining DCL list for the function and create a map that |
| // supports lookup of pre-inline dcl index, based on variable |
| // position/name. NB: the recipe for computing variable pos/file/line |
| // needs to be kept in sync with the similar code in gc.createSimpleVars |
| // and related functions. |
| func makePreinlineDclMap(fnsym *obj.LSym) map[varPos]int { |
| dcl := preInliningDcls(fnsym) |
| m := make(map[varPos]int) |
| for i, n := range dcl { |
| pos := Ctxt.InnermostPos(n.Pos) |
| vp := varPos{ |
| DeclName: unversion(n.Sym.Name), |
| DeclFile: pos.RelFilename(), |
| DeclLine: pos.RelLine(), |
| DeclCol: pos.Col(), |
| } |
| if _, found := m[vp]; found { |
| Fatalf("child dcl collision on symbol %s within %v\n", n.Sym.Name, fnsym.Name) |
| } |
| m[vp] = i |
| } |
| return m |
| } |
| |
| func insertInlCall(dwcalls *dwarf.InlCalls, inlIdx int, imap map[int]int) int { |
| callIdx, found := imap[inlIdx] |
| if found { |
| return callIdx |
| } |
| |
| // Haven't seen this inline yet. Visit parent of inline if there |
| // is one. We do this first so that parents appear before their |
| // children in the resulting table. |
| parCallIdx := -1 |
| parInlIdx := Ctxt.InlTree.Parent(inlIdx) |
| if parInlIdx >= 0 { |
| parCallIdx = insertInlCall(dwcalls, parInlIdx, imap) |
| } |
| |
| // Create new entry for this inline |
| inlinedFn := Ctxt.InlTree.InlinedFunction(inlIdx) |
| callXPos := Ctxt.InlTree.CallPos(inlIdx) |
| absFnSym := Ctxt.DwFixups.AbsFuncDwarfSym(inlinedFn) |
| pb := Ctxt.PosTable.Pos(callXPos).Base() |
| callFileSym := Ctxt.Lookup(pb.SymFilename()) |
| ic := dwarf.InlCall{ |
| InlIndex: inlIdx, |
| CallFile: callFileSym, |
| CallLine: uint32(callXPos.Line()), |
| AbsFunSym: absFnSym, |
| Root: parCallIdx == -1, |
| } |
| dwcalls.Calls = append(dwcalls.Calls, ic) |
| callIdx = len(dwcalls.Calls) - 1 |
| imap[inlIdx] = callIdx |
| |
| if parCallIdx != -1 { |
| // Add this inline to parent's child list |
| dwcalls.Calls[parCallIdx].Children = append(dwcalls.Calls[parCallIdx].Children, callIdx) |
| } |
| |
| return callIdx |
| } |
| |
| // Given a src.XPos, return its associated inlining index if it |
| // corresponds to something created as a result of an inline, or -1 if |
| // there is no inline info. Note that the index returned will refer to |
| // the deepest call in the inlined stack, e.g. if you have "A calls B |
| // calls C calls D" and all three callees are inlined (B, C, and D), |
| // the index for a node from the inlined body of D will refer to the |
| // call to D from C. Whew. |
| func posInlIndex(xpos src.XPos) int { |
| pos := Ctxt.PosTable.Pos(xpos) |
| if b := pos.Base(); b != nil { |
| ii := b.InliningIndex() |
| if ii >= 0 { |
| return ii |
| } |
| } |
| return -1 |
| } |
| |
| func addRange(calls []dwarf.InlCall, start, end int64, ii int, imap map[int]int) { |
| if start == -1 { |
| panic("bad range start") |
| } |
| if end == -1 { |
| panic("bad range end") |
| } |
| if ii == -1 { |
| return |
| } |
| if start == end { |
| return |
| } |
| // Append range to correct inlined call |
| callIdx, found := imap[ii] |
| if !found { |
| Fatalf("can't find inlIndex %d in imap for prog at %d\n", ii, start) |
| } |
| call := &calls[callIdx] |
| call.Ranges = append(call.Ranges, dwarf.Range{Start: start, End: end}) |
| } |
| |
| func dumpInlCall(inlcalls dwarf.InlCalls, idx, ilevel int) { |
| for i := 0; i < ilevel; i++ { |
| Ctxt.Logf(" ") |
| } |
| ic := inlcalls.Calls[idx] |
| callee := Ctxt.InlTree.InlinedFunction(ic.InlIndex) |
| Ctxt.Logf(" %d: II:%d (%s) V: (", idx, ic.InlIndex, callee.Name) |
| for _, f := range ic.InlVars { |
| Ctxt.Logf(" %v", f.Name) |
| } |
| Ctxt.Logf(" ) C: (") |
| for _, k := range ic.Children { |
| Ctxt.Logf(" %v", k) |
| } |
| Ctxt.Logf(" ) R:") |
| for _, r := range ic.Ranges { |
| Ctxt.Logf(" [%d,%d)", r.Start, r.End) |
| } |
| Ctxt.Logf("\n") |
| for _, k := range ic.Children { |
| dumpInlCall(inlcalls, k, ilevel+1) |
| } |
| |
| } |
| |
| func dumpInlCalls(inlcalls dwarf.InlCalls) { |
| for k, c := range inlcalls.Calls { |
| if c.Root { |
| dumpInlCall(inlcalls, k, 0) |
| } |
| } |
| } |
| |
| func dumpInlVars(dwvars []*dwarf.Var) { |
| for i, dwv := range dwvars { |
| typ := "local" |
| if dwv.Abbrev == dwarf.DW_ABRV_PARAM_LOCLIST || dwv.Abbrev == dwarf.DW_ABRV_PARAM { |
| typ = "param" |
| } |
| ia := 0 |
| if dwv.IsInAbstract { |
| ia = 1 |
| } |
| Ctxt.Logf("V%d: %s CI:%d II:%d IA:%d %s\n", i, dwv.Name, dwv.ChildIndex, dwv.InlIndex-1, ia, typ) |
| } |
| } |