Source file src/debug/dwarf/line.go

Documentation: debug/dwarf

     1  // Copyright 2015 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  package dwarf
     6  
     7  import (
     8  	"errors"
     9  	"fmt"
    10  	"io"
    11  	"path"
    12  	"strings"
    13  )
    14  
    15  // A LineReader reads a sequence of LineEntry structures from a DWARF
    16  // "line" section for a single compilation unit. LineEntries occur in
    17  // order of increasing PC and each LineEntry gives metadata for the
    18  // instructions from that LineEntry's PC to just before the next
    19  // LineEntry's PC. The last entry will have its EndSequence field set.
    20  type LineReader struct {
    21  	buf buf
    22  
    23  	// Original .debug_line section data. Used by Seek.
    24  	section []byte
    25  
    26  	str     []byte // .debug_str
    27  	lineStr []byte // .debug_line_str
    28  
    29  	// Header information
    30  	version              uint16
    31  	addrsize             int
    32  	segmentSelectorSize  int
    33  	minInstructionLength int
    34  	maxOpsPerInstruction int
    35  	defaultIsStmt        bool
    36  	lineBase             int
    37  	lineRange            int
    38  	opcodeBase           int
    39  	opcodeLengths        []int
    40  	directories          []string
    41  	fileEntries          []*LineFile
    42  
    43  	programOffset Offset // section offset of line number program
    44  	endOffset     Offset // section offset of byte following program
    45  
    46  	initialFileEntries int // initial length of fileEntries
    47  
    48  	// Current line number program state machine registers
    49  	state     LineEntry // public state
    50  	fileIndex int       // private state
    51  }
    52  
    53  // A LineEntry is a row in a DWARF line table.
    54  type LineEntry struct {
    55  	// Address is the program-counter value of a machine
    56  	// instruction generated by the compiler. This LineEntry
    57  	// applies to each instruction from Address to just before the
    58  	// Address of the next LineEntry.
    59  	Address uint64
    60  
    61  	// OpIndex is the index of an operation within a VLIW
    62  	// instruction. The index of the first operation is 0. For
    63  	// non-VLIW architectures, it will always be 0. Address and
    64  	// OpIndex together form an operation pointer that can
    65  	// reference any individual operation within the instruction
    66  	// stream.
    67  	OpIndex int
    68  
    69  	// File is the source file corresponding to these
    70  	// instructions.
    71  	File *LineFile
    72  
    73  	// Line is the source code line number corresponding to these
    74  	// instructions. Lines are numbered beginning at 1. It may be
    75  	// 0 if these instructions cannot be attributed to any source
    76  	// line.
    77  	Line int
    78  
    79  	// Column is the column number within the source line of these
    80  	// instructions. Columns are numbered beginning at 1. It may
    81  	// be 0 to indicate the "left edge" of the line.
    82  	Column int
    83  
    84  	// IsStmt indicates that Address is a recommended breakpoint
    85  	// location, such as the beginning of a line, statement, or a
    86  	// distinct subpart of a statement.
    87  	IsStmt bool
    88  
    89  	// BasicBlock indicates that Address is the beginning of a
    90  	// basic block.
    91  	BasicBlock bool
    92  
    93  	// PrologueEnd indicates that Address is one (of possibly
    94  	// many) PCs where execution should be suspended for a
    95  	// breakpoint on entry to the containing function.
    96  	//
    97  	// Added in DWARF 3.
    98  	PrologueEnd bool
    99  
   100  	// EpilogueBegin indicates that Address is one (of possibly
   101  	// many) PCs where execution should be suspended for a
   102  	// breakpoint on exit from this function.
   103  	//
   104  	// Added in DWARF 3.
   105  	EpilogueBegin bool
   106  
   107  	// ISA is the instruction set architecture for these
   108  	// instructions. Possible ISA values should be defined by the
   109  	// applicable ABI specification.
   110  	//
   111  	// Added in DWARF 3.
   112  	ISA int
   113  
   114  	// Discriminator is an arbitrary integer indicating the block
   115  	// to which these instructions belong. It serves to
   116  	// distinguish among multiple blocks that may all have with
   117  	// the same source file, line, and column. Where only one
   118  	// block exists for a given source position, it should be 0.
   119  	//
   120  	// Added in DWARF 3.
   121  	Discriminator int
   122  
   123  	// EndSequence indicates that Address is the first byte after
   124  	// the end of a sequence of target machine instructions. If it
   125  	// is set, only this and the Address field are meaningful. A
   126  	// line number table may contain information for multiple
   127  	// potentially disjoint instruction sequences. The last entry
   128  	// in a line table should always have EndSequence set.
   129  	EndSequence bool
   130  }
   131  
   132  // A LineFile is a source file referenced by a DWARF line table entry.
   133  type LineFile struct {
   134  	Name   string
   135  	Mtime  uint64 // Implementation defined modification time, or 0 if unknown
   136  	Length int    // File length, or 0 if unknown
   137  }
   138  
   139  // LineReader returns a new reader for the line table of compilation
   140  // unit cu, which must be an Entry with tag TagCompileUnit.
   141  //
   142  // If this compilation unit has no line table, it returns nil, nil.
   143  func (d *Data) LineReader(cu *Entry) (*LineReader, error) {
   144  	if d.line == nil {
   145  		// No line tables available.
   146  		return nil, nil
   147  	}
   148  
   149  	// Get line table information from cu.
   150  	off, ok := cu.Val(AttrStmtList).(int64)
   151  	if !ok {
   152  		// cu has no line table.
   153  		return nil, nil
   154  	}
   155  	if off > int64(len(d.line)) {
   156  		return nil, errors.New("AttrStmtList value out of range")
   157  	}
   158  	// AttrCompDir is optional if all file names are absolute. Use
   159  	// the empty string if it's not present.
   160  	compDir, _ := cu.Val(AttrCompDir).(string)
   161  
   162  	// Create the LineReader.
   163  	u := &d.unit[d.offsetToUnit(cu.Offset)]
   164  	buf := makeBuf(d, u, "line", Offset(off), d.line[off:])
   165  	// The compilation directory is implicitly directories[0].
   166  	r := LineReader{
   167  		buf:     buf,
   168  		section: d.line,
   169  		str:     d.str,
   170  		lineStr: d.lineStr,
   171  	}
   172  
   173  	// Read the header.
   174  	if err := r.readHeader(compDir); err != nil {
   175  		return nil, err
   176  	}
   177  
   178  	// Initialize line reader state.
   179  	r.Reset()
   180  
   181  	return &r, nil
   182  }
   183  
   184  // readHeader reads the line number program header from r.buf and sets
   185  // all of the header fields in r.
   186  func (r *LineReader) readHeader(compDir string) error {
   187  	buf := &r.buf
   188  
   189  	// Read basic header fields [DWARF2 6.2.4].
   190  	hdrOffset := buf.off
   191  	unitLength, dwarf64 := buf.unitLength()
   192  	r.endOffset = buf.off + unitLength
   193  	if r.endOffset > buf.off+Offset(len(buf.data)) {
   194  		return DecodeError{"line", hdrOffset, fmt.Sprintf("line table end %d exceeds section size %d", r.endOffset, buf.off+Offset(len(buf.data)))}
   195  	}
   196  	r.version = buf.uint16()
   197  	if buf.err == nil && (r.version < 2 || r.version > 5) {
   198  		// DWARF goes to all this effort to make new opcodes
   199  		// backward-compatible, and then adds fields right in
   200  		// the middle of the header in new versions, so we're
   201  		// picky about only supporting known line table
   202  		// versions.
   203  		return DecodeError{"line", hdrOffset, fmt.Sprintf("unknown line table version %d", r.version)}
   204  	}
   205  	if r.version >= 5 {
   206  		r.addrsize = int(buf.uint8())
   207  		r.segmentSelectorSize = int(buf.uint8())
   208  	} else {
   209  		r.addrsize = buf.format.addrsize()
   210  		r.segmentSelectorSize = 0
   211  	}
   212  	var headerLength Offset
   213  	if dwarf64 {
   214  		headerLength = Offset(buf.uint64())
   215  	} else {
   216  		headerLength = Offset(buf.uint32())
   217  	}
   218  	r.programOffset = buf.off + headerLength
   219  	r.minInstructionLength = int(buf.uint8())
   220  	if r.version >= 4 {
   221  		// [DWARF4 6.2.4]
   222  		r.maxOpsPerInstruction = int(buf.uint8())
   223  	} else {
   224  		r.maxOpsPerInstruction = 1
   225  	}
   226  	r.defaultIsStmt = buf.uint8() != 0
   227  	r.lineBase = int(int8(buf.uint8()))
   228  	r.lineRange = int(buf.uint8())
   229  
   230  	// Validate header.
   231  	if buf.err != nil {
   232  		return buf.err
   233  	}
   234  	if r.maxOpsPerInstruction == 0 {
   235  		return DecodeError{"line", hdrOffset, "invalid maximum operations per instruction: 0"}
   236  	}
   237  	if r.lineRange == 0 {
   238  		return DecodeError{"line", hdrOffset, "invalid line range: 0"}
   239  	}
   240  
   241  	// Read standard opcode length table. This table starts with opcode 1.
   242  	r.opcodeBase = int(buf.uint8())
   243  	r.opcodeLengths = make([]int, r.opcodeBase)
   244  	for i := 1; i < r.opcodeBase; i++ {
   245  		r.opcodeLengths[i] = int(buf.uint8())
   246  	}
   247  
   248  	// Validate opcode lengths.
   249  	if buf.err != nil {
   250  		return buf.err
   251  	}
   252  	for i, length := range r.opcodeLengths {
   253  		if known, ok := knownOpcodeLengths[i]; ok && known != length {
   254  			return DecodeError{"line", hdrOffset, fmt.Sprintf("opcode %d expected to have length %d, but has length %d", i, known, length)}
   255  		}
   256  	}
   257  
   258  	if r.version < 5 {
   259  		// Read include directories table.
   260  		r.directories = []string{compDir}
   261  		for {
   262  			directory := buf.string()
   263  			if buf.err != nil {
   264  				return buf.err
   265  			}
   266  			if len(directory) == 0 {
   267  				break
   268  			}
   269  			if !pathIsAbs(directory) {
   270  				// Relative paths are implicitly relative to
   271  				// the compilation directory.
   272  				directory = pathJoin(compDir, directory)
   273  			}
   274  			r.directories = append(r.directories, directory)
   275  		}
   276  
   277  		// Read file name list. File numbering starts with 1,
   278  		// so leave the first entry nil.
   279  		r.fileEntries = make([]*LineFile, 1)
   280  		for {
   281  			if done, err := r.readFileEntry(); err != nil {
   282  				return err
   283  			} else if done {
   284  				break
   285  			}
   286  		}
   287  	} else {
   288  		dirFormat := r.readLNCTFormat()
   289  		c := buf.uint()
   290  		r.directories = make([]string, c)
   291  		for i := range r.directories {
   292  			dir, _, _, err := r.readLNCT(dirFormat, dwarf64)
   293  			if err != nil {
   294  				return err
   295  			}
   296  			r.directories[i] = dir
   297  		}
   298  		fileFormat := r.readLNCTFormat()
   299  		c = buf.uint()
   300  		r.fileEntries = make([]*LineFile, c)
   301  		for i := range r.fileEntries {
   302  			name, mtime, size, err := r.readLNCT(fileFormat, dwarf64)
   303  			if err != nil {
   304  				return err
   305  			}
   306  			r.fileEntries[i] = &LineFile{name, mtime, int(size)}
   307  		}
   308  	}
   309  
   310  	r.initialFileEntries = len(r.fileEntries)
   311  
   312  	return buf.err
   313  }
   314  
   315  // lnctForm is a pair of an LNCT code and a form. This represents an
   316  // entry in the directory name or file name description in the DWARF 5
   317  // line number program header.
   318  type lnctForm struct {
   319  	lnct int
   320  	form format
   321  }
   322  
   323  // readLNCTFormat reads an LNCT format description.
   324  func (r *LineReader) readLNCTFormat() []lnctForm {
   325  	c := r.buf.uint8()
   326  	ret := make([]lnctForm, c)
   327  	for i := range ret {
   328  		ret[i].lnct = int(r.buf.uint())
   329  		ret[i].form = format(r.buf.uint())
   330  	}
   331  	return ret
   332  }
   333  
   334  // readLNCT reads a sequence of LNCT entries and returns path information.
   335  func (r *LineReader) readLNCT(s []lnctForm, dwarf64 bool) (path string, mtime uint64, size uint64, err error) {
   336  	var dir string
   337  	for _, lf := range s {
   338  		var str string
   339  		var val uint64
   340  		switch lf.form {
   341  		case formString:
   342  			str = r.buf.string()
   343  		case formStrp, formLineStrp:
   344  			var off uint64
   345  			if dwarf64 {
   346  				off = r.buf.uint64()
   347  			} else {
   348  				off = uint64(r.buf.uint32())
   349  			}
   350  			if uint64(int(off)) != off {
   351  				return "", 0, 0, DecodeError{"line", r.buf.off, "strp/line_strp offset out of range"}
   352  			}
   353  			var b1 buf
   354  			if lf.form == formStrp {
   355  				b1 = makeBuf(r.buf.dwarf, r.buf.format, "str", 0, r.str)
   356  			} else {
   357  				b1 = makeBuf(r.buf.dwarf, r.buf.format, "line_str", 0, r.lineStr)
   358  			}
   359  			b1.skip(int(off))
   360  			str = b1.string()
   361  			if b1.err != nil {
   362  				return "", 0, 0, DecodeError{"line", r.buf.off, b1.err.Error()}
   363  			}
   364  		case formStrpSup:
   365  			// Supplemental sections not yet supported.
   366  			if dwarf64 {
   367  				r.buf.uint64()
   368  			} else {
   369  				r.buf.uint32()
   370  			}
   371  		case formStrx:
   372  			// .debug_line.dwo sections not yet supported.
   373  			r.buf.uint()
   374  		case formStrx1:
   375  			r.buf.uint8()
   376  		case formStrx2:
   377  			r.buf.uint16()
   378  		case formStrx3:
   379  			r.buf.uint24()
   380  		case formStrx4:
   381  			r.buf.uint32()
   382  		case formData1:
   383  			val = uint64(r.buf.uint8())
   384  		case formData2:
   385  			val = uint64(r.buf.uint16())
   386  		case formData4:
   387  			val = uint64(r.buf.uint32())
   388  		case formData8:
   389  			val = r.buf.uint64()
   390  		case formData16:
   391  			r.buf.bytes(16)
   392  		case formDwarfBlock:
   393  			r.buf.bytes(int(r.buf.uint()))
   394  		case formUdata:
   395  			val = r.buf.uint()
   396  		}
   397  
   398  		switch lf.lnct {
   399  		case lnctPath:
   400  			path = str
   401  		case lnctDirectoryIndex:
   402  			if val >= uint64(len(r.directories)) {
   403  				return "", 0, 0, DecodeError{"line", r.buf.off, "directory index out of range"}
   404  			}
   405  			dir = r.directories[val]
   406  		case lnctTimestamp:
   407  			mtime = val
   408  		case lnctSize:
   409  			size = val
   410  		case lnctMD5:
   411  			// Ignored.
   412  		}
   413  	}
   414  
   415  	if dir != "" && path != "" {
   416  		path = pathJoin(dir, path)
   417  	}
   418  
   419  	return path, mtime, size, nil
   420  }
   421  
   422  // readFileEntry reads a file entry from either the header or a
   423  // DW_LNE_define_file extended opcode and adds it to r.fileEntries. A
   424  // true return value indicates that there are no more entries to read.
   425  func (r *LineReader) readFileEntry() (bool, error) {
   426  	name := r.buf.string()
   427  	if r.buf.err != nil {
   428  		return false, r.buf.err
   429  	}
   430  	if len(name) == 0 {
   431  		return true, nil
   432  	}
   433  	off := r.buf.off
   434  	dirIndex := int(r.buf.uint())
   435  	if !pathIsAbs(name) {
   436  		if dirIndex >= len(r.directories) {
   437  			return false, DecodeError{"line", off, "directory index too large"}
   438  		}
   439  		name = pathJoin(r.directories[dirIndex], name)
   440  	}
   441  	mtime := r.buf.uint()
   442  	length := int(r.buf.uint())
   443  
   444  	// If this is a dynamically added path and the cursor was
   445  	// backed up, we may have already added this entry. Avoid
   446  	// updating existing line table entries in this case. This
   447  	// avoids an allocation and potential racy access to the slice
   448  	// backing store if the user called Files.
   449  	if len(r.fileEntries) < cap(r.fileEntries) {
   450  		fe := r.fileEntries[:len(r.fileEntries)+1]
   451  		if fe[len(fe)-1] != nil {
   452  			// We already processed this addition.
   453  			r.fileEntries = fe
   454  			return false, nil
   455  		}
   456  	}
   457  	r.fileEntries = append(r.fileEntries, &LineFile{name, mtime, length})
   458  	return false, nil
   459  }
   460  
   461  // updateFile updates r.state.File after r.fileIndex has
   462  // changed or r.fileEntries has changed.
   463  func (r *LineReader) updateFile() {
   464  	if r.fileIndex < len(r.fileEntries) {
   465  		r.state.File = r.fileEntries[r.fileIndex]
   466  	} else {
   467  		r.state.File = nil
   468  	}
   469  }
   470  
   471  // Next sets *entry to the next row in this line table and moves to
   472  // the next row. If there are no more entries and the line table is
   473  // properly terminated, it returns io.EOF.
   474  //
   475  // Rows are always in order of increasing entry.Address, but
   476  // entry.Line may go forward or backward.
   477  func (r *LineReader) Next(entry *LineEntry) error {
   478  	if r.buf.err != nil {
   479  		return r.buf.err
   480  	}
   481  
   482  	// Execute opcodes until we reach an opcode that emits a line
   483  	// table entry.
   484  	for {
   485  		if len(r.buf.data) == 0 {
   486  			return io.EOF
   487  		}
   488  		emit := r.step(entry)
   489  		if r.buf.err != nil {
   490  			return r.buf.err
   491  		}
   492  		if emit {
   493  			return nil
   494  		}
   495  	}
   496  }
   497  
   498  // knownOpcodeLengths gives the opcode lengths (in varint arguments)
   499  // of known standard opcodes.
   500  var knownOpcodeLengths = map[int]int{
   501  	lnsCopy:             0,
   502  	lnsAdvancePC:        1,
   503  	lnsAdvanceLine:      1,
   504  	lnsSetFile:          1,
   505  	lnsNegateStmt:       0,
   506  	lnsSetBasicBlock:    0,
   507  	lnsConstAddPC:       0,
   508  	lnsSetPrologueEnd:   0,
   509  	lnsSetEpilogueBegin: 0,
   510  	lnsSetISA:           1,
   511  	// lnsFixedAdvancePC takes a uint8 rather than a varint; it's
   512  	// unclear what length the header is supposed to claim, so
   513  	// ignore it.
   514  }
   515  
   516  // step processes the next opcode and updates r.state. If the opcode
   517  // emits a row in the line table, this updates *entry and returns
   518  // true.
   519  func (r *LineReader) step(entry *LineEntry) bool {
   520  	opcode := int(r.buf.uint8())
   521  
   522  	if opcode >= r.opcodeBase {
   523  		// Special opcode [DWARF2 6.2.5.1, DWARF4 6.2.5.1]
   524  		adjustedOpcode := opcode - r.opcodeBase
   525  		r.advancePC(adjustedOpcode / r.lineRange)
   526  		lineDelta := r.lineBase + adjustedOpcode%r.lineRange
   527  		r.state.Line += lineDelta
   528  		goto emit
   529  	}
   530  
   531  	switch opcode {
   532  	case 0:
   533  		// Extended opcode [DWARF2 6.2.5.3]
   534  		length := Offset(r.buf.uint())
   535  		startOff := r.buf.off
   536  		opcode := r.buf.uint8()
   537  
   538  		switch opcode {
   539  		case lneEndSequence:
   540  			r.state.EndSequence = true
   541  			*entry = r.state
   542  			r.resetState()
   543  
   544  		case lneSetAddress:
   545  			switch r.addrsize {
   546  			case 1:
   547  				r.state.Address = uint64(r.buf.uint8())
   548  			case 2:
   549  				r.state.Address = uint64(r.buf.uint16())
   550  			case 4:
   551  				r.state.Address = uint64(r.buf.uint32())
   552  			case 8:
   553  				r.state.Address = r.buf.uint64()
   554  			default:
   555  				r.buf.error("unknown address size")
   556  			}
   557  
   558  		case lneDefineFile:
   559  			if done, err := r.readFileEntry(); err != nil {
   560  				r.buf.err = err
   561  				return false
   562  			} else if done {
   563  				r.buf.err = DecodeError{"line", startOff, "malformed DW_LNE_define_file operation"}
   564  				return false
   565  			}
   566  			r.updateFile()
   567  
   568  		case lneSetDiscriminator:
   569  			// [DWARF4 6.2.5.3]
   570  			r.state.Discriminator = int(r.buf.uint())
   571  		}
   572  
   573  		r.buf.skip(int(startOff + length - r.buf.off))
   574  
   575  		if opcode == lneEndSequence {
   576  			return true
   577  		}
   578  
   579  	// Standard opcodes [DWARF2 6.2.5.2]
   580  	case lnsCopy:
   581  		goto emit
   582  
   583  	case lnsAdvancePC:
   584  		r.advancePC(int(r.buf.uint()))
   585  
   586  	case lnsAdvanceLine:
   587  		r.state.Line += int(r.buf.int())
   588  
   589  	case lnsSetFile:
   590  		r.fileIndex = int(r.buf.uint())
   591  		r.updateFile()
   592  
   593  	case lnsSetColumn:
   594  		r.state.Column = int(r.buf.uint())
   595  
   596  	case lnsNegateStmt:
   597  		r.state.IsStmt = !r.state.IsStmt
   598  
   599  	case lnsSetBasicBlock:
   600  		r.state.BasicBlock = true
   601  
   602  	case lnsConstAddPC:
   603  		r.advancePC((255 - r.opcodeBase) / r.lineRange)
   604  
   605  	case lnsFixedAdvancePC:
   606  		r.state.Address += uint64(r.buf.uint16())
   607  
   608  	// DWARF3 standard opcodes [DWARF3 6.2.5.2]
   609  	case lnsSetPrologueEnd:
   610  		r.state.PrologueEnd = true
   611  
   612  	case lnsSetEpilogueBegin:
   613  		r.state.EpilogueBegin = true
   614  
   615  	case lnsSetISA:
   616  		r.state.ISA = int(r.buf.uint())
   617  
   618  	default:
   619  		// Unhandled standard opcode. Skip the number of
   620  		// arguments that the prologue says this opcode has.
   621  		for i := 0; i < r.opcodeLengths[opcode]; i++ {
   622  			r.buf.uint()
   623  		}
   624  	}
   625  	return false
   626  
   627  emit:
   628  	*entry = r.state
   629  	r.state.BasicBlock = false
   630  	r.state.PrologueEnd = false
   631  	r.state.EpilogueBegin = false
   632  	r.state.Discriminator = 0
   633  	return true
   634  }
   635  
   636  // advancePC advances "operation pointer" (the combination of Address
   637  // and OpIndex) in r.state by opAdvance steps.
   638  func (r *LineReader) advancePC(opAdvance int) {
   639  	opIndex := r.state.OpIndex + opAdvance
   640  	r.state.Address += uint64(r.minInstructionLength * (opIndex / r.maxOpsPerInstruction))
   641  	r.state.OpIndex = opIndex % r.maxOpsPerInstruction
   642  }
   643  
   644  // A LineReaderPos represents a position in a line table.
   645  type LineReaderPos struct {
   646  	// off is the current offset in the DWARF line section.
   647  	off Offset
   648  	// numFileEntries is the length of fileEntries.
   649  	numFileEntries int
   650  	// state and fileIndex are the statement machine state at
   651  	// offset off.
   652  	state     LineEntry
   653  	fileIndex int
   654  }
   655  
   656  // Tell returns the current position in the line table.
   657  func (r *LineReader) Tell() LineReaderPos {
   658  	return LineReaderPos{r.buf.off, len(r.fileEntries), r.state, r.fileIndex}
   659  }
   660  
   661  // Seek restores the line table reader to a position returned by Tell.
   662  //
   663  // The argument pos must have been returned by a call to Tell on this
   664  // line table.
   665  func (r *LineReader) Seek(pos LineReaderPos) {
   666  	r.buf.off = pos.off
   667  	r.buf.data = r.section[r.buf.off:r.endOffset]
   668  	r.fileEntries = r.fileEntries[:pos.numFileEntries]
   669  	r.state = pos.state
   670  	r.fileIndex = pos.fileIndex
   671  }
   672  
   673  // Reset repositions the line table reader at the beginning of the
   674  // line table.
   675  func (r *LineReader) Reset() {
   676  	// Reset buffer to the line number program offset.
   677  	r.buf.off = r.programOffset
   678  	r.buf.data = r.section[r.buf.off:r.endOffset]
   679  
   680  	// Reset file entries list.
   681  	r.fileEntries = r.fileEntries[:r.initialFileEntries]
   682  
   683  	// Reset line number program state.
   684  	r.resetState()
   685  }
   686  
   687  // resetState resets r.state to its default values
   688  func (r *LineReader) resetState() {
   689  	// Reset the state machine registers to the defaults given in
   690  	// [DWARF4 6.2.2].
   691  	r.state = LineEntry{
   692  		Address:       0,
   693  		OpIndex:       0,
   694  		File:          nil,
   695  		Line:          1,
   696  		Column:        0,
   697  		IsStmt:        r.defaultIsStmt,
   698  		BasicBlock:    false,
   699  		PrologueEnd:   false,
   700  		EpilogueBegin: false,
   701  		ISA:           0,
   702  		Discriminator: 0,
   703  	}
   704  	r.fileIndex = 1
   705  	r.updateFile()
   706  }
   707  
   708  // Files returns the file name table of this compilation unit as of
   709  // the current position in the line table. The file name table may be
   710  // referenced from attributes in this compilation unit such as
   711  // AttrDeclFile.
   712  //
   713  // Entry 0 is always nil, since file index 0 represents "no file".
   714  //
   715  // The file name table of a compilation unit is not fixed. Files
   716  // returns the file table as of the current position in the line
   717  // table. This may contain more entries than the file table at an
   718  // earlier position in the line table, though existing entries never
   719  // change.
   720  func (r *LineReader) Files() []*LineFile {
   721  	return r.fileEntries
   722  }
   723  
   724  // ErrUnknownPC is the error returned by LineReader.ScanPC when the
   725  // seek PC is not covered by any entry in the line table.
   726  var ErrUnknownPC = errors.New("ErrUnknownPC")
   727  
   728  // SeekPC sets *entry to the LineEntry that includes pc and positions
   729  // the reader on the next entry in the line table. If necessary, this
   730  // will seek backwards to find pc.
   731  //
   732  // If pc is not covered by any entry in this line table, SeekPC
   733  // returns ErrUnknownPC. In this case, *entry and the final seek
   734  // position are unspecified.
   735  //
   736  // Note that DWARF line tables only permit sequential, forward scans.
   737  // Hence, in the worst case, this takes time linear in the size of the
   738  // line table. If the caller wishes to do repeated fast PC lookups, it
   739  // should build an appropriate index of the line table.
   740  func (r *LineReader) SeekPC(pc uint64, entry *LineEntry) error {
   741  	if err := r.Next(entry); err != nil {
   742  		return err
   743  	}
   744  	if entry.Address > pc {
   745  		// We're too far. Start at the beginning of the table.
   746  		r.Reset()
   747  		if err := r.Next(entry); err != nil {
   748  			return err
   749  		}
   750  		if entry.Address > pc {
   751  			// The whole table starts after pc.
   752  			r.Reset()
   753  			return ErrUnknownPC
   754  		}
   755  	}
   756  
   757  	// Scan until we pass pc, then back up one.
   758  	for {
   759  		var next LineEntry
   760  		pos := r.Tell()
   761  		if err := r.Next(&next); err != nil {
   762  			if err == io.EOF {
   763  				return ErrUnknownPC
   764  			}
   765  			return err
   766  		}
   767  		if next.Address > pc {
   768  			if entry.EndSequence {
   769  				// pc is in a hole in the table.
   770  				return ErrUnknownPC
   771  			}
   772  			// entry is the desired entry. Back up the
   773  			// cursor to "next" and return success.
   774  			r.Seek(pos)
   775  			return nil
   776  		}
   777  		*entry = next
   778  	}
   779  }
   780  
   781  // pathIsAbs reports whether path is an absolute path (or "full path
   782  // name" in DWARF parlance). This is in "whatever form makes sense for
   783  // the host system", so this accepts both UNIX-style and DOS-style
   784  // absolute paths. We avoid the filepath package because we want this
   785  // to behave the same regardless of our host system and because we
   786  // don't know what system the paths came from.
   787  func pathIsAbs(path string) bool {
   788  	_, path = splitDrive(path)
   789  	return len(path) > 0 && (path[0] == '/' || path[0] == '\\')
   790  }
   791  
   792  // pathJoin joins dirname and filename. filename must be relative.
   793  // DWARF paths can be UNIX-style or DOS-style, so this handles both.
   794  func pathJoin(dirname, filename string) string {
   795  	if len(dirname) == 0 {
   796  		return filename
   797  	}
   798  	// dirname should be absolute, which means we can determine
   799  	// whether it's a DOS path reasonably reliably by looking for
   800  	// a drive letter or UNC path.
   801  	drive, dirname := splitDrive(dirname)
   802  	if drive == "" {
   803  		// UNIX-style path.
   804  		return path.Join(dirname, filename)
   805  	}
   806  	// DOS-style path.
   807  	drive2, filename := splitDrive(filename)
   808  	if drive2 != "" {
   809  		if !strings.EqualFold(drive, drive2) {
   810  			// Different drives. There's not much we can
   811  			// do here, so just ignore the directory.
   812  			return drive2 + filename
   813  		}
   814  		// Drives are the same. Ignore drive on filename.
   815  	}
   816  	if !(strings.HasSuffix(dirname, "/") || strings.HasSuffix(dirname, `\`)) && dirname != "" {
   817  		dirname += `\`
   818  	}
   819  	return drive + dirname + filename
   820  }
   821  
   822  // splitDrive splits the DOS drive letter or UNC share point from
   823  // path, if any. path == drive + rest
   824  func splitDrive(path string) (drive, rest string) {
   825  	if len(path) >= 2 && path[1] == ':' {
   826  		if c := path[0]; 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' {
   827  			return path[:2], path[2:]
   828  		}
   829  	}
   830  	if len(path) > 3 && (path[0] == '\\' || path[0] == '/') && (path[1] == '\\' || path[1] == '/') {
   831  		// Normalize the path so we can search for just \ below.
   832  		npath := strings.Replace(path, "/", `\`, -1)
   833  		// Get the host part, which must be non-empty.
   834  		slash1 := strings.IndexByte(npath[2:], '\\') + 2
   835  		if slash1 > 2 {
   836  			// Get the mount-point part, which must be non-empty.
   837  			slash2 := strings.IndexByte(npath[slash1+1:], '\\') + slash1 + 1
   838  			if slash2 > slash1 {
   839  				return path[:slash2], path[slash2:]
   840  			}
   841  		}
   842  	}
   843  	return "", path
   844  }
   845  

View as plain text