Source file src/github.com/twitchyliquid64/golang-asm/obj/dwarf.go

Documentation: github.com/twitchyliquid64/golang-asm/obj

     1  // Copyright 2019 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Writes dwarf information to object files.
     6  
     7  package obj
     8  
     9  import (
    10  	"github.com/twitchyliquid64/golang-asm/dwarf"
    11  	"github.com/twitchyliquid64/golang-asm/objabi"
    12  	"github.com/twitchyliquid64/golang-asm/src"
    13  	"fmt"
    14  	"sort"
    15  	"sync"
    16  )
    17  
    18  // Generate a sequence of opcodes that is as short as possible.
    19  // See section 6.2.5
    20  const (
    21  	LINE_BASE   = -4
    22  	LINE_RANGE  = 10
    23  	PC_RANGE    = (255 - OPCODE_BASE) / LINE_RANGE
    24  	OPCODE_BASE = 11
    25  )
    26  
    27  // generateDebugLinesSymbol fills the debug lines symbol of a given function.
    28  //
    29  // It's worth noting that this function doesn't generate the full debug_lines
    30  // DWARF section, saving that for the linker. This function just generates the
    31  // state machine part of debug_lines. The full table is generated by the
    32  // linker.  Also, we use the file numbers from the full package (not just the
    33  // function in question) when generating the state machine. We do this so we
    34  // don't have to do a fixup on the indices when writing the full section.
    35  func (ctxt *Link) generateDebugLinesSymbol(s, lines *LSym) {
    36  	dctxt := dwCtxt{ctxt}
    37  
    38  	// Emit a LNE_set_address extended opcode, so as to establish the
    39  	// starting text address of this function.
    40  	dctxt.AddUint8(lines, 0)
    41  	dwarf.Uleb128put(dctxt, lines, 1+int64(ctxt.Arch.PtrSize))
    42  	dctxt.AddUint8(lines, dwarf.DW_LNE_set_address)
    43  	dctxt.AddAddress(lines, s, 0)
    44  
    45  	// Set up the debug_lines state machine to the default values
    46  	// we expect at the start of a new sequence.
    47  	stmt := true
    48  	line := int64(1)
    49  	pc := s.Func.Text.Pc
    50  	var lastpc int64 // last PC written to line table, not last PC in func
    51  	name := ""
    52  	prologue, wrotePrologue := false, false
    53  	// Walk the progs, generating the DWARF table.
    54  	for p := s.Func.Text; p != nil; p = p.Link {
    55  		prologue = prologue || (p.Pos.Xlogue() == src.PosPrologueEnd)
    56  		// If we're not at a real instruction, keep looping!
    57  		if p.Pos.Line() == 0 || (p.Link != nil && p.Link.Pc == p.Pc) {
    58  			continue
    59  		}
    60  		newStmt := p.Pos.IsStmt() != src.PosNotStmt
    61  		newName, newLine := linkgetlineFromPos(ctxt, p.Pos)
    62  
    63  		// Output debug info.
    64  		wrote := false
    65  		if name != newName {
    66  			newFile := ctxt.PosTable.FileIndex(newName) + 1 // 1 indexing for the table.
    67  			dctxt.AddUint8(lines, dwarf.DW_LNS_set_file)
    68  			dwarf.Uleb128put(dctxt, lines, int64(newFile))
    69  			name = newName
    70  			wrote = true
    71  		}
    72  		if prologue && !wrotePrologue {
    73  			dctxt.AddUint8(lines, uint8(dwarf.DW_LNS_set_prologue_end))
    74  			wrotePrologue = true
    75  			wrote = true
    76  		}
    77  		if stmt != newStmt {
    78  			dctxt.AddUint8(lines, uint8(dwarf.DW_LNS_negate_stmt))
    79  			stmt = newStmt
    80  			wrote = true
    81  		}
    82  
    83  		if line != int64(newLine) || wrote {
    84  			pcdelta := p.Pc - pc
    85  			lastpc = p.Pc
    86  			putpclcdelta(ctxt, dctxt, lines, uint64(pcdelta), int64(newLine)-line)
    87  			line, pc = int64(newLine), p.Pc
    88  		}
    89  	}
    90  
    91  	// Because these symbols will be concatenated together by the
    92  	// linker, we need to reset the state machine that controls the
    93  	// debug symbols. Do this using an end-of-sequence operator.
    94  	//
    95  	// Note: at one point in time, Delve did not support multiple end
    96  	// sequence ops within a compilation unit (bug for this:
    97  	// https://github.com/go-delve/delve/issues/1694), however the bug
    98  	// has since been fixed (Oct 2019).
    99  	//
   100  	// Issue 38192: the DWARF standard specifies that when you issue
   101  	// an end-sequence op, the PC value should be one past the last
   102  	// text address in the translation unit, so apply a delta to the
   103  	// text address before the end sequence op. If this isn't done,
   104  	// GDB will assign a line number of zero the last row in the line
   105  	// table, which we don't want.
   106  	lastlen := uint64(s.Size - (lastpc - s.Func.Text.Pc))
   107  	putpclcdelta(ctxt, dctxt, lines, lastlen, 0)
   108  	dctxt.AddUint8(lines, 0) // start extended opcode
   109  	dwarf.Uleb128put(dctxt, lines, 1)
   110  	dctxt.AddUint8(lines, dwarf.DW_LNE_end_sequence)
   111  }
   112  
   113  func putpclcdelta(linkctxt *Link, dctxt dwCtxt, s *LSym, deltaPC uint64, deltaLC int64) {
   114  	// Choose a special opcode that minimizes the number of bytes needed to
   115  	// encode the remaining PC delta and LC delta.
   116  	var opcode int64
   117  	if deltaLC < LINE_BASE {
   118  		if deltaPC >= PC_RANGE {
   119  			opcode = OPCODE_BASE + (LINE_RANGE * PC_RANGE)
   120  		} else {
   121  			opcode = OPCODE_BASE + (LINE_RANGE * int64(deltaPC))
   122  		}
   123  	} else if deltaLC < LINE_BASE+LINE_RANGE {
   124  		if deltaPC >= PC_RANGE {
   125  			opcode = OPCODE_BASE + (deltaLC - LINE_BASE) + (LINE_RANGE * PC_RANGE)
   126  			if opcode > 255 {
   127  				opcode -= LINE_RANGE
   128  			}
   129  		} else {
   130  			opcode = OPCODE_BASE + (deltaLC - LINE_BASE) + (LINE_RANGE * int64(deltaPC))
   131  		}
   132  	} else {
   133  		if deltaPC <= PC_RANGE {
   134  			opcode = OPCODE_BASE + (LINE_RANGE - 1) + (LINE_RANGE * int64(deltaPC))
   135  			if opcode > 255 {
   136  				opcode = 255
   137  			}
   138  		} else {
   139  			// Use opcode 249 (pc+=23, lc+=5) or 255 (pc+=24, lc+=1).
   140  			//
   141  			// Let x=deltaPC-PC_RANGE.  If we use opcode 255, x will be the remaining
   142  			// deltaPC that we need to encode separately before emitting 255.  If we
   143  			// use opcode 249, we will need to encode x+1.  If x+1 takes one more
   144  			// byte to encode than x, then we use opcode 255.
   145  			//
   146  			// In all other cases x and x+1 take the same number of bytes to encode,
   147  			// so we use opcode 249, which may save us a byte in encoding deltaLC,
   148  			// for similar reasons.
   149  			switch deltaPC - PC_RANGE {
   150  			// PC_RANGE is the largest deltaPC we can encode in one byte, using
   151  			// DW_LNS_const_add_pc.
   152  			//
   153  			// (1<<16)-1 is the largest deltaPC we can encode in three bytes, using
   154  			// DW_LNS_fixed_advance_pc.
   155  			//
   156  			// (1<<(7n))-1 is the largest deltaPC we can encode in n+1 bytes for
   157  			// n=1,3,4,5,..., using DW_LNS_advance_pc.
   158  			case PC_RANGE, (1 << 7) - 1, (1 << 16) - 1, (1 << 21) - 1, (1 << 28) - 1,
   159  				(1 << 35) - 1, (1 << 42) - 1, (1 << 49) - 1, (1 << 56) - 1, (1 << 63) - 1:
   160  				opcode = 255
   161  			default:
   162  				opcode = OPCODE_BASE + LINE_RANGE*PC_RANGE - 1 // 249
   163  			}
   164  		}
   165  	}
   166  	if opcode < OPCODE_BASE || opcode > 255 {
   167  		panic(fmt.Sprintf("produced invalid special opcode %d", opcode))
   168  	}
   169  
   170  	// Subtract from deltaPC and deltaLC the amounts that the opcode will add.
   171  	deltaPC -= uint64((opcode - OPCODE_BASE) / LINE_RANGE)
   172  	deltaLC -= (opcode-OPCODE_BASE)%LINE_RANGE + LINE_BASE
   173  
   174  	// Encode deltaPC.
   175  	if deltaPC != 0 {
   176  		if deltaPC <= PC_RANGE {
   177  			// Adjust the opcode so that we can use the 1-byte DW_LNS_const_add_pc
   178  			// instruction.
   179  			opcode -= LINE_RANGE * int64(PC_RANGE-deltaPC)
   180  			if opcode < OPCODE_BASE {
   181  				panic(fmt.Sprintf("produced invalid special opcode %d", opcode))
   182  			}
   183  			dctxt.AddUint8(s, dwarf.DW_LNS_const_add_pc)
   184  		} else if (1<<14) <= deltaPC && deltaPC < (1<<16) {
   185  			dctxt.AddUint8(s, dwarf.DW_LNS_fixed_advance_pc)
   186  			dctxt.AddUint16(s, uint16(deltaPC))
   187  		} else {
   188  			dctxt.AddUint8(s, dwarf.DW_LNS_advance_pc)
   189  			dwarf.Uleb128put(dctxt, s, int64(deltaPC))
   190  		}
   191  	}
   192  
   193  	// Encode deltaLC.
   194  	if deltaLC != 0 {
   195  		dctxt.AddUint8(s, dwarf.DW_LNS_advance_line)
   196  		dwarf.Sleb128put(dctxt, s, deltaLC)
   197  	}
   198  
   199  	// Output the special opcode.
   200  	dctxt.AddUint8(s, uint8(opcode))
   201  }
   202  
   203  // implement dwarf.Context
   204  type dwCtxt struct{ *Link }
   205  
   206  func (c dwCtxt) PtrSize() int {
   207  	return c.Arch.PtrSize
   208  }
   209  func (c dwCtxt) AddInt(s dwarf.Sym, size int, i int64) {
   210  	ls := s.(*LSym)
   211  	ls.WriteInt(c.Link, ls.Size, size, i)
   212  }
   213  func (c dwCtxt) AddUint16(s dwarf.Sym, i uint16) {
   214  	c.AddInt(s, 2, int64(i))
   215  }
   216  func (c dwCtxt) AddUint8(s dwarf.Sym, i uint8) {
   217  	b := []byte{byte(i)}
   218  	c.AddBytes(s, b)
   219  }
   220  func (c dwCtxt) AddBytes(s dwarf.Sym, b []byte) {
   221  	ls := s.(*LSym)
   222  	ls.WriteBytes(c.Link, ls.Size, b)
   223  }
   224  func (c dwCtxt) AddString(s dwarf.Sym, v string) {
   225  	ls := s.(*LSym)
   226  	ls.WriteString(c.Link, ls.Size, len(v), v)
   227  	ls.WriteInt(c.Link, ls.Size, 1, 0)
   228  }
   229  func (c dwCtxt) AddAddress(s dwarf.Sym, data interface{}, value int64) {
   230  	ls := s.(*LSym)
   231  	size := c.PtrSize()
   232  	if data != nil {
   233  		rsym := data.(*LSym)
   234  		ls.WriteAddr(c.Link, ls.Size, size, rsym, value)
   235  	} else {
   236  		ls.WriteInt(c.Link, ls.Size, size, value)
   237  	}
   238  }
   239  func (c dwCtxt) AddCURelativeAddress(s dwarf.Sym, data interface{}, value int64) {
   240  	ls := s.(*LSym)
   241  	rsym := data.(*LSym)
   242  	ls.WriteCURelativeAddr(c.Link, ls.Size, rsym, value)
   243  }
   244  func (c dwCtxt) AddSectionOffset(s dwarf.Sym, size int, t interface{}, ofs int64) {
   245  	panic("should be used only in the linker")
   246  }
   247  func (c dwCtxt) AddDWARFAddrSectionOffset(s dwarf.Sym, t interface{}, ofs int64) {
   248  	size := 4
   249  	if isDwarf64(c.Link) {
   250  		size = 8
   251  	}
   252  
   253  	ls := s.(*LSym)
   254  	rsym := t.(*LSym)
   255  	ls.WriteAddr(c.Link, ls.Size, size, rsym, ofs)
   256  	r := &ls.R[len(ls.R)-1]
   257  	r.Type = objabi.R_DWARFSECREF
   258  }
   259  
   260  func (c dwCtxt) AddFileRef(s dwarf.Sym, f interface{}) {
   261  	ls := s.(*LSym)
   262  	rsym := f.(*LSym)
   263  	fidx := c.Link.PosTable.FileIndex(rsym.Name)
   264  	// Note the +1 here -- the value we're writing is going to be an
   265  	// index into the DWARF line table file section, whose entries
   266  	// are numbered starting at 1, not 0.
   267  	ls.WriteInt(c.Link, ls.Size, 4, int64(fidx+1))
   268  }
   269  
   270  func (c dwCtxt) CurrentOffset(s dwarf.Sym) int64 {
   271  	ls := s.(*LSym)
   272  	return ls.Size
   273  }
   274  
   275  // Here "from" is a symbol corresponding to an inlined or concrete
   276  // function, "to" is the symbol for the corresponding abstract
   277  // function, and "dclIdx" is the index of the symbol of interest with
   278  // respect to the Dcl slice of the original pre-optimization version
   279  // of the inlined function.
   280  func (c dwCtxt) RecordDclReference(from dwarf.Sym, to dwarf.Sym, dclIdx int, inlIndex int) {
   281  	ls := from.(*LSym)
   282  	tls := to.(*LSym)
   283  	ridx := len(ls.R) - 1
   284  	c.Link.DwFixups.ReferenceChildDIE(ls, ridx, tls, dclIdx, inlIndex)
   285  }
   286  
   287  func (c dwCtxt) RecordChildDieOffsets(s dwarf.Sym, vars []*dwarf.Var, offsets []int32) {
   288  	ls := s.(*LSym)
   289  	c.Link.DwFixups.RegisterChildDIEOffsets(ls, vars, offsets)
   290  }
   291  
   292  func (c dwCtxt) Logf(format string, args ...interface{}) {
   293  	c.Link.Logf(format, args...)
   294  }
   295  
   296  func isDwarf64(ctxt *Link) bool {
   297  	return ctxt.Headtype == objabi.Haix
   298  }
   299  
   300  func (ctxt *Link) dwarfSym(s *LSym) (dwarfInfoSym, dwarfLocSym, dwarfRangesSym, dwarfAbsFnSym, dwarfDebugLines *LSym) {
   301  	if s.Type != objabi.STEXT {
   302  		ctxt.Diag("dwarfSym of non-TEXT %v", s)
   303  	}
   304  	if s.Func.dwarfInfoSym == nil {
   305  		s.Func.dwarfInfoSym = &LSym{
   306  			Type: objabi.SDWARFFCN,
   307  		}
   308  		if ctxt.Flag_locationlists {
   309  			s.Func.dwarfLocSym = &LSym{
   310  				Type: objabi.SDWARFLOC,
   311  			}
   312  		}
   313  		s.Func.dwarfRangesSym = &LSym{
   314  			Type: objabi.SDWARFRANGE,
   315  		}
   316  		s.Func.dwarfDebugLinesSym = &LSym{
   317  			Type: objabi.SDWARFLINES,
   318  		}
   319  		if s.WasInlined() {
   320  			s.Func.dwarfAbsFnSym = ctxt.DwFixups.AbsFuncDwarfSym(s)
   321  		}
   322  	}
   323  	return s.Func.dwarfInfoSym, s.Func.dwarfLocSym, s.Func.dwarfRangesSym, s.Func.dwarfAbsFnSym, s.Func.dwarfDebugLinesSym
   324  }
   325  
   326  func (s *LSym) Length(dwarfContext interface{}) int64 {
   327  	return s.Size
   328  }
   329  
   330  // fileSymbol returns a symbol corresponding to the source file of the
   331  // first instruction (prog) of the specified function. This will
   332  // presumably be the file in which the function is defined.
   333  func (ctxt *Link) fileSymbol(fn *LSym) *LSym {
   334  	p := fn.Func.Text
   335  	if p != nil {
   336  		f, _ := linkgetlineFromPos(ctxt, p.Pos)
   337  		fsym := ctxt.Lookup(f)
   338  		return fsym
   339  	}
   340  	return nil
   341  }
   342  
   343  // populateDWARF fills in the DWARF Debugging Information Entries for
   344  // TEXT symbol 's'. The various DWARF symbols must already have been
   345  // initialized in InitTextSym.
   346  func (ctxt *Link) populateDWARF(curfn interface{}, s *LSym, myimportpath string) {
   347  	info, loc, ranges, absfunc, lines := ctxt.dwarfSym(s)
   348  	if info.Size != 0 {
   349  		ctxt.Diag("makeFuncDebugEntry double process %v", s)
   350  	}
   351  	var scopes []dwarf.Scope
   352  	var inlcalls dwarf.InlCalls
   353  	if ctxt.DebugInfo != nil {
   354  		scopes, inlcalls = ctxt.DebugInfo(s, info, curfn)
   355  	}
   356  	var err error
   357  	dwctxt := dwCtxt{ctxt}
   358  	filesym := ctxt.fileSymbol(s)
   359  	fnstate := &dwarf.FnState{
   360  		Name:          s.Name,
   361  		Importpath:    myimportpath,
   362  		Info:          info,
   363  		Filesym:       filesym,
   364  		Loc:           loc,
   365  		Ranges:        ranges,
   366  		Absfn:         absfunc,
   367  		StartPC:       s,
   368  		Size:          s.Size,
   369  		External:      !s.Static(),
   370  		Scopes:        scopes,
   371  		InlCalls:      inlcalls,
   372  		UseBASEntries: ctxt.UseBASEntries,
   373  	}
   374  	if absfunc != nil {
   375  		err = dwarf.PutAbstractFunc(dwctxt, fnstate)
   376  		if err != nil {
   377  			ctxt.Diag("emitting DWARF for %s failed: %v", s.Name, err)
   378  		}
   379  		err = dwarf.PutConcreteFunc(dwctxt, fnstate)
   380  	} else {
   381  		err = dwarf.PutDefaultFunc(dwctxt, fnstate)
   382  	}
   383  	if err != nil {
   384  		ctxt.Diag("emitting DWARF for %s failed: %v", s.Name, err)
   385  	}
   386  	// Fill in the debug lines symbol.
   387  	ctxt.generateDebugLinesSymbol(s, lines)
   388  }
   389  
   390  // DwarfIntConst creates a link symbol for an integer constant with the
   391  // given name, type and value.
   392  func (ctxt *Link) DwarfIntConst(myimportpath, name, typename string, val int64) {
   393  	if myimportpath == "" {
   394  		return
   395  	}
   396  	s := ctxt.LookupInit(dwarf.ConstInfoPrefix+myimportpath, func(s *LSym) {
   397  		s.Type = objabi.SDWARFCONST
   398  		ctxt.Data = append(ctxt.Data, s)
   399  	})
   400  	dwarf.PutIntConst(dwCtxt{ctxt}, s, ctxt.Lookup(dwarf.InfoPrefix+typename), myimportpath+"."+name, val)
   401  }
   402  
   403  func (ctxt *Link) DwarfAbstractFunc(curfn interface{}, s *LSym, myimportpath string) {
   404  	absfn := ctxt.DwFixups.AbsFuncDwarfSym(s)
   405  	if absfn.Size != 0 {
   406  		ctxt.Diag("internal error: DwarfAbstractFunc double process %v", s)
   407  	}
   408  	if s.Func == nil {
   409  		s.Func = new(FuncInfo)
   410  	}
   411  	scopes, _ := ctxt.DebugInfo(s, absfn, curfn)
   412  	dwctxt := dwCtxt{ctxt}
   413  	filesym := ctxt.fileSymbol(s)
   414  	fnstate := dwarf.FnState{
   415  		Name:          s.Name,
   416  		Importpath:    myimportpath,
   417  		Info:          absfn,
   418  		Filesym:       filesym,
   419  		Absfn:         absfn,
   420  		External:      !s.Static(),
   421  		Scopes:        scopes,
   422  		UseBASEntries: ctxt.UseBASEntries,
   423  	}
   424  	if err := dwarf.PutAbstractFunc(dwctxt, &fnstate); err != nil {
   425  		ctxt.Diag("emitting DWARF for %s failed: %v", s.Name, err)
   426  	}
   427  }
   428  
   429  // This table is designed to aid in the creation of references between
   430  // DWARF subprogram DIEs.
   431  //
   432  // In most cases when one DWARF DIE has to refer to another DWARF DIE,
   433  // the target of the reference has an LSym, which makes it easy to use
   434  // the existing relocation mechanism. For DWARF inlined routine DIEs,
   435  // however, the subprogram DIE has to refer to a child
   436  // parameter/variable DIE of the abstract subprogram. This child DIE
   437  // doesn't have an LSym, and also of interest is the fact that when
   438  // DWARF generation is happening for inlined function F within caller
   439  // G, it's possible that DWARF generation hasn't happened yet for F,
   440  // so there is no way to know the offset of a child DIE within F's
   441  // abstract function. Making matters more complex, each inlined
   442  // instance of F may refer to a subset of the original F's variables
   443  // (depending on what happens with optimization, some vars may be
   444  // eliminated).
   445  //
   446  // The fixup table below helps overcome this hurdle. At the point
   447  // where a parameter/variable reference is made (via a call to
   448  // "ReferenceChildDIE"), a fixup record is generate that records
   449  // the relocation that is targeting that child variable. At a later
   450  // point when the abstract function DIE is emitted, there will be
   451  // a call to "RegisterChildDIEOffsets", at which point the offsets
   452  // needed to apply fixups are captured. Finally, once the parallel
   453  // portion of the compilation is done, fixups can actually be applied
   454  // during the "Finalize" method (this can't be done during the
   455  // parallel portion of the compile due to the possibility of data
   456  // races).
   457  //
   458  // This table is also used to record the "precursor" function node for
   459  // each function that is the target of an inline -- child DIE references
   460  // have to be made with respect to the original pre-optimization
   461  // version of the function (to allow for the fact that each inlined
   462  // body may be optimized differently).
   463  type DwarfFixupTable struct {
   464  	ctxt      *Link
   465  	mu        sync.Mutex
   466  	symtab    map[*LSym]int // maps abstract fn LSYM to index in svec
   467  	svec      []symFixups
   468  	precursor map[*LSym]fnState // maps fn Lsym to precursor Node, absfn sym
   469  }
   470  
   471  type symFixups struct {
   472  	fixups   []relFixup
   473  	doffsets []declOffset
   474  	inlIndex int32
   475  	defseen  bool
   476  }
   477  
   478  type declOffset struct {
   479  	// Index of variable within DCL list of pre-optimization function
   480  	dclIdx int32
   481  	// Offset of var's child DIE with respect to containing subprogram DIE
   482  	offset int32
   483  }
   484  
   485  type relFixup struct {
   486  	refsym *LSym
   487  	relidx int32
   488  	dclidx int32
   489  }
   490  
   491  type fnState struct {
   492  	// precursor function (really *gc.Node)
   493  	precursor interface{}
   494  	// abstract function symbol
   495  	absfn *LSym
   496  }
   497  
   498  func NewDwarfFixupTable(ctxt *Link) *DwarfFixupTable {
   499  	return &DwarfFixupTable{
   500  		ctxt:      ctxt,
   501  		symtab:    make(map[*LSym]int),
   502  		precursor: make(map[*LSym]fnState),
   503  	}
   504  }
   505  
   506  func (ft *DwarfFixupTable) GetPrecursorFunc(s *LSym) interface{} {
   507  	if fnstate, found := ft.precursor[s]; found {
   508  		return fnstate.precursor
   509  	}
   510  	return nil
   511  }
   512  
   513  func (ft *DwarfFixupTable) SetPrecursorFunc(s *LSym, fn interface{}) {
   514  	if _, found := ft.precursor[s]; found {
   515  		ft.ctxt.Diag("internal error: DwarfFixupTable.SetPrecursorFunc double call on %v", s)
   516  	}
   517  
   518  	// initialize abstract function symbol now. This is done here so
   519  	// as to avoid data races later on during the parallel portion of
   520  	// the back end.
   521  	absfn := ft.ctxt.LookupDerived(s, dwarf.InfoPrefix+s.Name+dwarf.AbstractFuncSuffix)
   522  	absfn.Set(AttrDuplicateOK, true)
   523  	absfn.Type = objabi.SDWARFABSFCN
   524  	ft.ctxt.Data = append(ft.ctxt.Data, absfn)
   525  
   526  	// In the case of "late" inlining (inlines that happen during
   527  	// wrapper generation as opposed to the main inlining phase) it's
   528  	// possible that we didn't cache the abstract function sym for the
   529  	// text symbol -- do so now if needed. See issue 38068.
   530  	if s.Func != nil && s.Func.dwarfAbsFnSym == nil {
   531  		s.Func.dwarfAbsFnSym = absfn
   532  	}
   533  
   534  	ft.precursor[s] = fnState{precursor: fn, absfn: absfn}
   535  }
   536  
   537  // Make a note of a child DIE reference: relocation 'ridx' within symbol 's'
   538  // is targeting child 'c' of DIE with symbol 'tgt'.
   539  func (ft *DwarfFixupTable) ReferenceChildDIE(s *LSym, ridx int, tgt *LSym, dclidx int, inlIndex int) {
   540  	// Protect against concurrent access if multiple backend workers
   541  	ft.mu.Lock()
   542  	defer ft.mu.Unlock()
   543  
   544  	// Create entry for symbol if not already present.
   545  	idx, found := ft.symtab[tgt]
   546  	if !found {
   547  		ft.svec = append(ft.svec, symFixups{inlIndex: int32(inlIndex)})
   548  		idx = len(ft.svec) - 1
   549  		ft.symtab[tgt] = idx
   550  	}
   551  
   552  	// Do we have child DIE offsets available? If so, then apply them,
   553  	// otherwise create a fixup record.
   554  	sf := &ft.svec[idx]
   555  	if len(sf.doffsets) > 0 {
   556  		found := false
   557  		for _, do := range sf.doffsets {
   558  			if do.dclIdx == int32(dclidx) {
   559  				off := do.offset
   560  				s.R[ridx].Add += int64(off)
   561  				found = true
   562  				break
   563  			}
   564  		}
   565  		if !found {
   566  			ft.ctxt.Diag("internal error: DwarfFixupTable.ReferenceChildDIE unable to locate child DIE offset for dclIdx=%d src=%v tgt=%v", dclidx, s, tgt)
   567  		}
   568  	} else {
   569  		sf.fixups = append(sf.fixups, relFixup{s, int32(ridx), int32(dclidx)})
   570  	}
   571  }
   572  
   573  // Called once DWARF generation is complete for a given abstract function,
   574  // whose children might have been referenced via a call above. Stores
   575  // the offsets for any child DIEs (vars, params) so that they can be
   576  // consumed later in on DwarfFixupTable.Finalize, which applies any
   577  // outstanding fixups.
   578  func (ft *DwarfFixupTable) RegisterChildDIEOffsets(s *LSym, vars []*dwarf.Var, coffsets []int32) {
   579  	// Length of these two slices should agree
   580  	if len(vars) != len(coffsets) {
   581  		ft.ctxt.Diag("internal error: RegisterChildDIEOffsets vars/offsets length mismatch")
   582  		return
   583  	}
   584  
   585  	// Generate the slice of declOffset's based in vars/coffsets
   586  	doffsets := make([]declOffset, len(coffsets))
   587  	for i := range coffsets {
   588  		doffsets[i].dclIdx = vars[i].ChildIndex
   589  		doffsets[i].offset = coffsets[i]
   590  	}
   591  
   592  	ft.mu.Lock()
   593  	defer ft.mu.Unlock()
   594  
   595  	// Store offsets for this symbol.
   596  	idx, found := ft.symtab[s]
   597  	if !found {
   598  		sf := symFixups{inlIndex: -1, defseen: true, doffsets: doffsets}
   599  		ft.svec = append(ft.svec, sf)
   600  		ft.symtab[s] = len(ft.svec) - 1
   601  	} else {
   602  		sf := &ft.svec[idx]
   603  		sf.doffsets = doffsets
   604  		sf.defseen = true
   605  	}
   606  }
   607  
   608  func (ft *DwarfFixupTable) processFixups(slot int, s *LSym) {
   609  	sf := &ft.svec[slot]
   610  	for _, f := range sf.fixups {
   611  		dfound := false
   612  		for _, doffset := range sf.doffsets {
   613  			if doffset.dclIdx == f.dclidx {
   614  				f.refsym.R[f.relidx].Add += int64(doffset.offset)
   615  				dfound = true
   616  				break
   617  			}
   618  		}
   619  		if !dfound {
   620  			ft.ctxt.Diag("internal error: DwarfFixupTable has orphaned fixup on %v targeting %v relidx=%d dclidx=%d", f.refsym, s, f.relidx, f.dclidx)
   621  		}
   622  	}
   623  }
   624  
   625  // return the LSym corresponding to the 'abstract subprogram' DWARF
   626  // info entry for a function.
   627  func (ft *DwarfFixupTable) AbsFuncDwarfSym(fnsym *LSym) *LSym {
   628  	// Protect against concurrent access if multiple backend workers
   629  	ft.mu.Lock()
   630  	defer ft.mu.Unlock()
   631  
   632  	if fnstate, found := ft.precursor[fnsym]; found {
   633  		return fnstate.absfn
   634  	}
   635  	ft.ctxt.Diag("internal error: AbsFuncDwarfSym requested for %v, not seen during inlining", fnsym)
   636  	return nil
   637  }
   638  
   639  // Called after all functions have been compiled; the main job of this
   640  // function is to identify cases where there are outstanding fixups.
   641  // This scenario crops up when we have references to variables of an
   642  // inlined routine, but that routine is defined in some other package.
   643  // This helper walks through and locate these fixups, then invokes a
   644  // helper to create an abstract subprogram DIE for each one.
   645  func (ft *DwarfFixupTable) Finalize(myimportpath string, trace bool) {
   646  	if trace {
   647  		ft.ctxt.Logf("DwarfFixupTable.Finalize invoked for %s\n", myimportpath)
   648  	}
   649  
   650  	// Collect up the keys from the precursor map, then sort the
   651  	// resulting list (don't want to rely on map ordering here).
   652  	fns := make([]*LSym, len(ft.precursor))
   653  	idx := 0
   654  	for fn := range ft.precursor {
   655  		fns[idx] = fn
   656  		idx++
   657  	}
   658  	sort.Sort(BySymName(fns))
   659  
   660  	// Should not be called during parallel portion of compilation.
   661  	if ft.ctxt.InParallel {
   662  		ft.ctxt.Diag("internal error: DwarfFixupTable.Finalize call during parallel backend")
   663  	}
   664  
   665  	// Generate any missing abstract functions.
   666  	for _, s := range fns {
   667  		absfn := ft.AbsFuncDwarfSym(s)
   668  		slot, found := ft.symtab[absfn]
   669  		if !found || !ft.svec[slot].defseen {
   670  			ft.ctxt.GenAbstractFunc(s)
   671  		}
   672  	}
   673  
   674  	// Apply fixups.
   675  	for _, s := range fns {
   676  		absfn := ft.AbsFuncDwarfSym(s)
   677  		slot, found := ft.symtab[absfn]
   678  		if !found {
   679  			ft.ctxt.Diag("internal error: DwarfFixupTable.Finalize orphan abstract function for %v", s)
   680  		} else {
   681  			ft.processFixups(slot, s)
   682  		}
   683  	}
   684  }
   685  
   686  type BySymName []*LSym
   687  
   688  func (s BySymName) Len() int           { return len(s) }
   689  func (s BySymName) Less(i, j int) bool { return s[i].Name < s[j].Name }
   690  func (s BySymName) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
   691  

View as plain text