Source file src/debug/elf/file.go

Documentation: debug/elf

     1  // Copyright 2009 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 elf implements access to ELF object files.
     6  package elf
     7  
     8  import (
     9  	"bytes"
    10  	"compress/zlib"
    11  	"debug/dwarf"
    12  	"encoding/binary"
    13  	"errors"
    14  	"fmt"
    15  	"io"
    16  	"os"
    17  	"strings"
    18  )
    19  
    20  // seekStart, seekCurrent, seekEnd are copies of
    21  // io.SeekStart, io.SeekCurrent, and io.SeekEnd.
    22  // We can't use the ones from package io because
    23  // we want this code to build with Go 1.4 during
    24  // cmd/dist bootstrap.
    25  const (
    26  	seekStart   int = 0
    27  	seekCurrent int = 1
    28  	seekEnd     int = 2
    29  )
    30  
    31  // TODO: error reporting detail
    32  
    33  /*
    34   * Internal ELF representation
    35   */
    36  
    37  // A FileHeader represents an ELF file header.
    38  type FileHeader struct {
    39  	Class      Class
    40  	Data       Data
    41  	Version    Version
    42  	OSABI      OSABI
    43  	ABIVersion uint8
    44  	ByteOrder  binary.ByteOrder
    45  	Type       Type
    46  	Machine    Machine
    47  	Entry      uint64
    48  }
    49  
    50  // A File represents an open ELF file.
    51  type File struct {
    52  	FileHeader
    53  	Sections  []*Section
    54  	Progs     []*Prog
    55  	closer    io.Closer
    56  	gnuNeed   []verneed
    57  	gnuVersym []byte
    58  }
    59  
    60  // A SectionHeader represents a single ELF section header.
    61  type SectionHeader struct {
    62  	Name      string
    63  	Type      SectionType
    64  	Flags     SectionFlag
    65  	Addr      uint64
    66  	Offset    uint64
    67  	Size      uint64
    68  	Link      uint32
    69  	Info      uint32
    70  	Addralign uint64
    71  	Entsize   uint64
    72  
    73  	// FileSize is the size of this section in the file in bytes.
    74  	// If a section is compressed, FileSize is the size of the
    75  	// compressed data, while Size (above) is the size of the
    76  	// uncompressed data.
    77  	FileSize uint64
    78  }
    79  
    80  // A Section represents a single section in an ELF file.
    81  type Section struct {
    82  	SectionHeader
    83  
    84  	// Embed ReaderAt for ReadAt method.
    85  	// Do not embed SectionReader directly
    86  	// to avoid having Read and Seek.
    87  	// If a client wants Read and Seek it must use
    88  	// Open() to avoid fighting over the seek offset
    89  	// with other clients.
    90  	//
    91  	// ReaderAt may be nil if the section is not easily available
    92  	// in a random-access form. For example, a compressed section
    93  	// may have a nil ReaderAt.
    94  	io.ReaderAt
    95  	sr *io.SectionReader
    96  
    97  	compressionType   CompressionType
    98  	compressionOffset int64
    99  }
   100  
   101  // Data reads and returns the contents of the ELF section.
   102  // Even if the section is stored compressed in the ELF file,
   103  // Data returns uncompressed data.
   104  func (s *Section) Data() ([]byte, error) {
   105  	dat := make([]byte, s.Size)
   106  	n, err := io.ReadFull(s.Open(), dat)
   107  	return dat[0:n], err
   108  }
   109  
   110  // stringTable reads and returns the string table given by the
   111  // specified link value.
   112  func (f *File) stringTable(link uint32) ([]byte, error) {
   113  	if link <= 0 || link >= uint32(len(f.Sections)) {
   114  		return nil, errors.New("section has invalid string table link")
   115  	}
   116  	return f.Sections[link].Data()
   117  }
   118  
   119  // Open returns a new ReadSeeker reading the ELF section.
   120  // Even if the section is stored compressed in the ELF file,
   121  // the ReadSeeker reads uncompressed data.
   122  func (s *Section) Open() io.ReadSeeker {
   123  	if s.Flags&SHF_COMPRESSED == 0 {
   124  		return io.NewSectionReader(s.sr, 0, 1<<63-1)
   125  	}
   126  	if s.compressionType == COMPRESS_ZLIB {
   127  		return &readSeekerFromReader{
   128  			reset: func() (io.Reader, error) {
   129  				fr := io.NewSectionReader(s.sr, s.compressionOffset, int64(s.FileSize)-s.compressionOffset)
   130  				return zlib.NewReader(fr)
   131  			},
   132  			size: int64(s.Size),
   133  		}
   134  	}
   135  	err := &FormatError{int64(s.Offset), "unknown compression type", s.compressionType}
   136  	return errorReader{err}
   137  }
   138  
   139  // A ProgHeader represents a single ELF program header.
   140  type ProgHeader struct {
   141  	Type   ProgType
   142  	Flags  ProgFlag
   143  	Off    uint64
   144  	Vaddr  uint64
   145  	Paddr  uint64
   146  	Filesz uint64
   147  	Memsz  uint64
   148  	Align  uint64
   149  }
   150  
   151  // A Prog represents a single ELF program header in an ELF binary.
   152  type Prog struct {
   153  	ProgHeader
   154  
   155  	// Embed ReaderAt for ReadAt method.
   156  	// Do not embed SectionReader directly
   157  	// to avoid having Read and Seek.
   158  	// If a client wants Read and Seek it must use
   159  	// Open() to avoid fighting over the seek offset
   160  	// with other clients.
   161  	io.ReaderAt
   162  	sr *io.SectionReader
   163  }
   164  
   165  // Open returns a new ReadSeeker reading the ELF program body.
   166  func (p *Prog) Open() io.ReadSeeker { return io.NewSectionReader(p.sr, 0, 1<<63-1) }
   167  
   168  // A Symbol represents an entry in an ELF symbol table section.
   169  type Symbol struct {
   170  	Name        string
   171  	Info, Other byte
   172  	Section     SectionIndex
   173  	Value, Size uint64
   174  
   175  	// Version and Library are present only for the dynamic symbol
   176  	// table.
   177  	Version string
   178  	Library string
   179  }
   180  
   181  /*
   182   * ELF reader
   183   */
   184  
   185  type FormatError struct {
   186  	off int64
   187  	msg string
   188  	val interface{}
   189  }
   190  
   191  func (e *FormatError) Error() string {
   192  	msg := e.msg
   193  	if e.val != nil {
   194  		msg += fmt.Sprintf(" '%v' ", e.val)
   195  	}
   196  	msg += fmt.Sprintf("in record at byte %#x", e.off)
   197  	return msg
   198  }
   199  
   200  // Open opens the named file using os.Open and prepares it for use as an ELF binary.
   201  func Open(name string) (*File, error) {
   202  	f, err := os.Open(name)
   203  	if err != nil {
   204  		return nil, err
   205  	}
   206  	ff, err := NewFile(f)
   207  	if err != nil {
   208  		f.Close()
   209  		return nil, err
   210  	}
   211  	ff.closer = f
   212  	return ff, nil
   213  }
   214  
   215  // Close closes the File.
   216  // If the File was created using NewFile directly instead of Open,
   217  // Close has no effect.
   218  func (f *File) Close() error {
   219  	var err error
   220  	if f.closer != nil {
   221  		err = f.closer.Close()
   222  		f.closer = nil
   223  	}
   224  	return err
   225  }
   226  
   227  // SectionByType returns the first section in f with the
   228  // given type, or nil if there is no such section.
   229  func (f *File) SectionByType(typ SectionType) *Section {
   230  	for _, s := range f.Sections {
   231  		if s.Type == typ {
   232  			return s
   233  		}
   234  	}
   235  	return nil
   236  }
   237  
   238  // NewFile creates a new File for accessing an ELF binary in an underlying reader.
   239  // The ELF binary is expected to start at position 0 in the ReaderAt.
   240  func NewFile(r io.ReaderAt) (*File, error) {
   241  	sr := io.NewSectionReader(r, 0, 1<<63-1)
   242  	// Read and decode ELF identifier
   243  	var ident [16]uint8
   244  	if _, err := r.ReadAt(ident[0:], 0); err != nil {
   245  		return nil, err
   246  	}
   247  	if ident[0] != '\x7f' || ident[1] != 'E' || ident[2] != 'L' || ident[3] != 'F' {
   248  		return nil, &FormatError{0, "bad magic number", ident[0:4]}
   249  	}
   250  
   251  	f := new(File)
   252  	f.Class = Class(ident[EI_CLASS])
   253  	switch f.Class {
   254  	case ELFCLASS32:
   255  	case ELFCLASS64:
   256  		// ok
   257  	default:
   258  		return nil, &FormatError{0, "unknown ELF class", f.Class}
   259  	}
   260  
   261  	f.Data = Data(ident[EI_DATA])
   262  	switch f.Data {
   263  	case ELFDATA2LSB:
   264  		f.ByteOrder = binary.LittleEndian
   265  	case ELFDATA2MSB:
   266  		f.ByteOrder = binary.BigEndian
   267  	default:
   268  		return nil, &FormatError{0, "unknown ELF data encoding", f.Data}
   269  	}
   270  
   271  	f.Version = Version(ident[EI_VERSION])
   272  	if f.Version != EV_CURRENT {
   273  		return nil, &FormatError{0, "unknown ELF version", f.Version}
   274  	}
   275  
   276  	f.OSABI = OSABI(ident[EI_OSABI])
   277  	f.ABIVersion = ident[EI_ABIVERSION]
   278  
   279  	// Read ELF file header
   280  	var phoff int64
   281  	var phentsize, phnum int
   282  	var shoff int64
   283  	var shentsize, shnum, shstrndx int
   284  	switch f.Class {
   285  	case ELFCLASS32:
   286  		hdr := new(Header32)
   287  		sr.Seek(0, seekStart)
   288  		if err := binary.Read(sr, f.ByteOrder, hdr); err != nil {
   289  			return nil, err
   290  		}
   291  		f.Type = Type(hdr.Type)
   292  		f.Machine = Machine(hdr.Machine)
   293  		f.Entry = uint64(hdr.Entry)
   294  		if v := Version(hdr.Version); v != f.Version {
   295  			return nil, &FormatError{0, "mismatched ELF version", v}
   296  		}
   297  		phoff = int64(hdr.Phoff)
   298  		phentsize = int(hdr.Phentsize)
   299  		phnum = int(hdr.Phnum)
   300  		shoff = int64(hdr.Shoff)
   301  		shentsize = int(hdr.Shentsize)
   302  		shnum = int(hdr.Shnum)
   303  		shstrndx = int(hdr.Shstrndx)
   304  	case ELFCLASS64:
   305  		hdr := new(Header64)
   306  		sr.Seek(0, seekStart)
   307  		if err := binary.Read(sr, f.ByteOrder, hdr); err != nil {
   308  			return nil, err
   309  		}
   310  		f.Type = Type(hdr.Type)
   311  		f.Machine = Machine(hdr.Machine)
   312  		f.Entry = hdr.Entry
   313  		if v := Version(hdr.Version); v != f.Version {
   314  			return nil, &FormatError{0, "mismatched ELF version", v}
   315  		}
   316  		phoff = int64(hdr.Phoff)
   317  		phentsize = int(hdr.Phentsize)
   318  		phnum = int(hdr.Phnum)
   319  		shoff = int64(hdr.Shoff)
   320  		shentsize = int(hdr.Shentsize)
   321  		shnum = int(hdr.Shnum)
   322  		shstrndx = int(hdr.Shstrndx)
   323  	}
   324  
   325  	if shoff == 0 && shnum != 0 {
   326  		return nil, &FormatError{0, "invalid ELF shnum for shoff=0", shnum}
   327  	}
   328  
   329  	if shnum > 0 && shstrndx >= shnum {
   330  		return nil, &FormatError{0, "invalid ELF shstrndx", shstrndx}
   331  	}
   332  
   333  	// Read program headers
   334  	f.Progs = make([]*Prog, phnum)
   335  	for i := 0; i < phnum; i++ {
   336  		off := phoff + int64(i)*int64(phentsize)
   337  		sr.Seek(off, seekStart)
   338  		p := new(Prog)
   339  		switch f.Class {
   340  		case ELFCLASS32:
   341  			ph := new(Prog32)
   342  			if err := binary.Read(sr, f.ByteOrder, ph); err != nil {
   343  				return nil, err
   344  			}
   345  			p.ProgHeader = ProgHeader{
   346  				Type:   ProgType(ph.Type),
   347  				Flags:  ProgFlag(ph.Flags),
   348  				Off:    uint64(ph.Off),
   349  				Vaddr:  uint64(ph.Vaddr),
   350  				Paddr:  uint64(ph.Paddr),
   351  				Filesz: uint64(ph.Filesz),
   352  				Memsz:  uint64(ph.Memsz),
   353  				Align:  uint64(ph.Align),
   354  			}
   355  		case ELFCLASS64:
   356  			ph := new(Prog64)
   357  			if err := binary.Read(sr, f.ByteOrder, ph); err != nil {
   358  				return nil, err
   359  			}
   360  			p.ProgHeader = ProgHeader{
   361  				Type:   ProgType(ph.Type),
   362  				Flags:  ProgFlag(ph.Flags),
   363  				Off:    ph.Off,
   364  				Vaddr:  ph.Vaddr,
   365  				Paddr:  ph.Paddr,
   366  				Filesz: ph.Filesz,
   367  				Memsz:  ph.Memsz,
   368  				Align:  ph.Align,
   369  			}
   370  		}
   371  		p.sr = io.NewSectionReader(r, int64(p.Off), int64(p.Filesz))
   372  		p.ReaderAt = p.sr
   373  		f.Progs[i] = p
   374  	}
   375  
   376  	// Read section headers
   377  	f.Sections = make([]*Section, shnum)
   378  	names := make([]uint32, shnum)
   379  	for i := 0; i < shnum; i++ {
   380  		off := shoff + int64(i)*int64(shentsize)
   381  		sr.Seek(off, seekStart)
   382  		s := new(Section)
   383  		switch f.Class {
   384  		case ELFCLASS32:
   385  			sh := new(Section32)
   386  			if err := binary.Read(sr, f.ByteOrder, sh); err != nil {
   387  				return nil, err
   388  			}
   389  			names[i] = sh.Name
   390  			s.SectionHeader = SectionHeader{
   391  				Type:      SectionType(sh.Type),
   392  				Flags:     SectionFlag(sh.Flags),
   393  				Addr:      uint64(sh.Addr),
   394  				Offset:    uint64(sh.Off),
   395  				FileSize:  uint64(sh.Size),
   396  				Link:      sh.Link,
   397  				Info:      sh.Info,
   398  				Addralign: uint64(sh.Addralign),
   399  				Entsize:   uint64(sh.Entsize),
   400  			}
   401  		case ELFCLASS64:
   402  			sh := new(Section64)
   403  			if err := binary.Read(sr, f.ByteOrder, sh); err != nil {
   404  				return nil, err
   405  			}
   406  			names[i] = sh.Name
   407  			s.SectionHeader = SectionHeader{
   408  				Type:      SectionType(sh.Type),
   409  				Flags:     SectionFlag(sh.Flags),
   410  				Offset:    sh.Off,
   411  				FileSize:  sh.Size,
   412  				Addr:      sh.Addr,
   413  				Link:      sh.Link,
   414  				Info:      sh.Info,
   415  				Addralign: sh.Addralign,
   416  				Entsize:   sh.Entsize,
   417  			}
   418  		}
   419  		s.sr = io.NewSectionReader(r, int64(s.Offset), int64(s.FileSize))
   420  
   421  		if s.Flags&SHF_COMPRESSED == 0 {
   422  			s.ReaderAt = s.sr
   423  			s.Size = s.FileSize
   424  		} else {
   425  			// Read the compression header.
   426  			switch f.Class {
   427  			case ELFCLASS32:
   428  				ch := new(Chdr32)
   429  				if err := binary.Read(s.sr, f.ByteOrder, ch); err != nil {
   430  					return nil, err
   431  				}
   432  				s.compressionType = CompressionType(ch.Type)
   433  				s.Size = uint64(ch.Size)
   434  				s.Addralign = uint64(ch.Addralign)
   435  				s.compressionOffset = int64(binary.Size(ch))
   436  			case ELFCLASS64:
   437  				ch := new(Chdr64)
   438  				if err := binary.Read(s.sr, f.ByteOrder, ch); err != nil {
   439  					return nil, err
   440  				}
   441  				s.compressionType = CompressionType(ch.Type)
   442  				s.Size = ch.Size
   443  				s.Addralign = ch.Addralign
   444  				s.compressionOffset = int64(binary.Size(ch))
   445  			}
   446  		}
   447  
   448  		f.Sections[i] = s
   449  	}
   450  
   451  	if len(f.Sections) == 0 {
   452  		return f, nil
   453  	}
   454  
   455  	// Load section header string table.
   456  	shstrtab, err := f.Sections[shstrndx].Data()
   457  	if err != nil {
   458  		return nil, err
   459  	}
   460  	for i, s := range f.Sections {
   461  		var ok bool
   462  		s.Name, ok = getString(shstrtab, int(names[i]))
   463  		if !ok {
   464  			return nil, &FormatError{shoff + int64(i*shentsize), "bad section name index", names[i]}
   465  		}
   466  	}
   467  
   468  	return f, nil
   469  }
   470  
   471  // getSymbols returns a slice of Symbols from parsing the symbol table
   472  // with the given type, along with the associated string table.
   473  func (f *File) getSymbols(typ SectionType) ([]Symbol, []byte, error) {
   474  	switch f.Class {
   475  	case ELFCLASS64:
   476  		return f.getSymbols64(typ)
   477  
   478  	case ELFCLASS32:
   479  		return f.getSymbols32(typ)
   480  	}
   481  
   482  	return nil, nil, errors.New("not implemented")
   483  }
   484  
   485  // ErrNoSymbols is returned by File.Symbols and File.DynamicSymbols
   486  // if there is no such section in the File.
   487  var ErrNoSymbols = errors.New("no symbol section")
   488  
   489  func (f *File) getSymbols32(typ SectionType) ([]Symbol, []byte, error) {
   490  	symtabSection := f.SectionByType(typ)
   491  	if symtabSection == nil {
   492  		return nil, nil, ErrNoSymbols
   493  	}
   494  
   495  	data, err := symtabSection.Data()
   496  	if err != nil {
   497  		return nil, nil, errors.New("cannot load symbol section")
   498  	}
   499  	symtab := bytes.NewReader(data)
   500  	if symtab.Len()%Sym32Size != 0 {
   501  		return nil, nil, errors.New("length of symbol section is not a multiple of SymSize")
   502  	}
   503  
   504  	strdata, err := f.stringTable(symtabSection.Link)
   505  	if err != nil {
   506  		return nil, nil, errors.New("cannot load string table section")
   507  	}
   508  
   509  	// The first entry is all zeros.
   510  	var skip [Sym32Size]byte
   511  	symtab.Read(skip[:])
   512  
   513  	symbols := make([]Symbol, symtab.Len()/Sym32Size)
   514  
   515  	i := 0
   516  	var sym Sym32
   517  	for symtab.Len() > 0 {
   518  		binary.Read(symtab, f.ByteOrder, &sym)
   519  		str, _ := getString(strdata, int(sym.Name))
   520  		symbols[i].Name = str
   521  		symbols[i].Info = sym.Info
   522  		symbols[i].Other = sym.Other
   523  		symbols[i].Section = SectionIndex(sym.Shndx)
   524  		symbols[i].Value = uint64(sym.Value)
   525  		symbols[i].Size = uint64(sym.Size)
   526  		i++
   527  	}
   528  
   529  	return symbols, strdata, nil
   530  }
   531  
   532  func (f *File) getSymbols64(typ SectionType) ([]Symbol, []byte, error) {
   533  	symtabSection := f.SectionByType(typ)
   534  	if symtabSection == nil {
   535  		return nil, nil, ErrNoSymbols
   536  	}
   537  
   538  	data, err := symtabSection.Data()
   539  	if err != nil {
   540  		return nil, nil, errors.New("cannot load symbol section")
   541  	}
   542  	symtab := bytes.NewReader(data)
   543  	if symtab.Len()%Sym64Size != 0 {
   544  		return nil, nil, errors.New("length of symbol section is not a multiple of Sym64Size")
   545  	}
   546  
   547  	strdata, err := f.stringTable(symtabSection.Link)
   548  	if err != nil {
   549  		return nil, nil, errors.New("cannot load string table section")
   550  	}
   551  
   552  	// The first entry is all zeros.
   553  	var skip [Sym64Size]byte
   554  	symtab.Read(skip[:])
   555  
   556  	symbols := make([]Symbol, symtab.Len()/Sym64Size)
   557  
   558  	i := 0
   559  	var sym Sym64
   560  	for symtab.Len() > 0 {
   561  		binary.Read(symtab, f.ByteOrder, &sym)
   562  		str, _ := getString(strdata, int(sym.Name))
   563  		symbols[i].Name = str
   564  		symbols[i].Info = sym.Info
   565  		symbols[i].Other = sym.Other
   566  		symbols[i].Section = SectionIndex(sym.Shndx)
   567  		symbols[i].Value = sym.Value
   568  		symbols[i].Size = sym.Size
   569  		i++
   570  	}
   571  
   572  	return symbols, strdata, nil
   573  }
   574  
   575  // getString extracts a string from an ELF string table.
   576  func getString(section []byte, start int) (string, bool) {
   577  	if start < 0 || start >= len(section) {
   578  		return "", false
   579  	}
   580  
   581  	for end := start; end < len(section); end++ {
   582  		if section[end] == 0 {
   583  			return string(section[start:end]), true
   584  		}
   585  	}
   586  	return "", false
   587  }
   588  
   589  // Section returns a section with the given name, or nil if no such
   590  // section exists.
   591  func (f *File) Section(name string) *Section {
   592  	for _, s := range f.Sections {
   593  		if s.Name == name {
   594  			return s
   595  		}
   596  	}
   597  	return nil
   598  }
   599  
   600  // applyRelocations applies relocations to dst. rels is a relocations section
   601  // in REL or RELA format.
   602  func (f *File) applyRelocations(dst []byte, rels []byte) error {
   603  	switch {
   604  	case f.Class == ELFCLASS64 && f.Machine == EM_X86_64:
   605  		return f.applyRelocationsAMD64(dst, rels)
   606  	case f.Class == ELFCLASS32 && f.Machine == EM_386:
   607  		return f.applyRelocations386(dst, rels)
   608  	case f.Class == ELFCLASS32 && f.Machine == EM_ARM:
   609  		return f.applyRelocationsARM(dst, rels)
   610  	case f.Class == ELFCLASS64 && f.Machine == EM_AARCH64:
   611  		return f.applyRelocationsARM64(dst, rels)
   612  	case f.Class == ELFCLASS32 && f.Machine == EM_PPC:
   613  		return f.applyRelocationsPPC(dst, rels)
   614  	case f.Class == ELFCLASS64 && f.Machine == EM_PPC64:
   615  		return f.applyRelocationsPPC64(dst, rels)
   616  	case f.Class == ELFCLASS32 && f.Machine == EM_MIPS:
   617  		return f.applyRelocationsMIPS(dst, rels)
   618  	case f.Class == ELFCLASS64 && f.Machine == EM_MIPS:
   619  		return f.applyRelocationsMIPS64(dst, rels)
   620  	case f.Class == ELFCLASS64 && f.Machine == EM_RISCV:
   621  		return f.applyRelocationsRISCV64(dst, rels)
   622  	case f.Class == ELFCLASS64 && f.Machine == EM_S390:
   623  		return f.applyRelocationss390x(dst, rels)
   624  	case f.Class == ELFCLASS64 && f.Machine == EM_SPARCV9:
   625  		return f.applyRelocationsSPARC64(dst, rels)
   626  	default:
   627  		return errors.New("applyRelocations: not implemented")
   628  	}
   629  }
   630  
   631  // canApplyRelocation reports whether we should try to apply a
   632  // relocation to a DWARF data section, given a pointer to the symbol
   633  // targeted by the relocation.
   634  // Most relocations in DWARF data tend to be section-relative, but
   635  // some target non-section symbols (for example, low_PC attrs on
   636  // subprogram or compilation unit DIEs that target function symbols).
   637  func canApplyRelocation(sym *Symbol) bool {
   638  	return sym.Section != SHN_UNDEF && sym.Section < SHN_LORESERVE
   639  }
   640  
   641  func (f *File) applyRelocationsAMD64(dst []byte, rels []byte) error {
   642  	// 24 is the size of Rela64.
   643  	if len(rels)%24 != 0 {
   644  		return errors.New("length of relocation section is not a multiple of 24")
   645  	}
   646  
   647  	symbols, _, err := f.getSymbols(SHT_SYMTAB)
   648  	if err != nil {
   649  		return err
   650  	}
   651  
   652  	b := bytes.NewReader(rels)
   653  	var rela Rela64
   654  
   655  	for b.Len() > 0 {
   656  		binary.Read(b, f.ByteOrder, &rela)
   657  		symNo := rela.Info >> 32
   658  		t := R_X86_64(rela.Info & 0xffff)
   659  
   660  		if symNo == 0 || symNo > uint64(len(symbols)) {
   661  			continue
   662  		}
   663  		sym := &symbols[symNo-1]
   664  		if !canApplyRelocation(sym) {
   665  			continue
   666  		}
   667  
   668  		// There are relocations, so this must be a normal
   669  		// object file.  The code below handles only basic relocations
   670  		// of the form S + A (symbol plus addend).
   671  
   672  		switch t {
   673  		case R_X86_64_64:
   674  			if rela.Off+8 >= uint64(len(dst)) || rela.Addend < 0 {
   675  				continue
   676  			}
   677  			val64 := sym.Value + uint64(rela.Addend)
   678  			f.ByteOrder.PutUint64(dst[rela.Off:rela.Off+8], val64)
   679  		case R_X86_64_32:
   680  			if rela.Off+4 >= uint64(len(dst)) || rela.Addend < 0 {
   681  				continue
   682  			}
   683  			val32 := uint32(sym.Value) + uint32(rela.Addend)
   684  			f.ByteOrder.PutUint32(dst[rela.Off:rela.Off+4], val32)
   685  		}
   686  	}
   687  
   688  	return nil
   689  }
   690  
   691  func (f *File) applyRelocations386(dst []byte, rels []byte) error {
   692  	// 8 is the size of Rel32.
   693  	if len(rels)%8 != 0 {
   694  		return errors.New("length of relocation section is not a multiple of 8")
   695  	}
   696  
   697  	symbols, _, err := f.getSymbols(SHT_SYMTAB)
   698  	if err != nil {
   699  		return err
   700  	}
   701  
   702  	b := bytes.NewReader(rels)
   703  	var rel Rel32
   704  
   705  	for b.Len() > 0 {
   706  		binary.Read(b, f.ByteOrder, &rel)
   707  		symNo := rel.Info >> 8
   708  		t := R_386(rel.Info & 0xff)
   709  
   710  		if symNo == 0 || symNo > uint32(len(symbols)) {
   711  			continue
   712  		}
   713  		sym := &symbols[symNo-1]
   714  
   715  		if t == R_386_32 {
   716  			if rel.Off+4 >= uint32(len(dst)) {
   717  				continue
   718  			}
   719  			val := f.ByteOrder.Uint32(dst[rel.Off : rel.Off+4])
   720  			val += uint32(sym.Value)
   721  			f.ByteOrder.PutUint32(dst[rel.Off:rel.Off+4], val)
   722  		}
   723  	}
   724  
   725  	return nil
   726  }
   727  
   728  func (f *File) applyRelocationsARM(dst []byte, rels []byte) error {
   729  	// 8 is the size of Rel32.
   730  	if len(rels)%8 != 0 {
   731  		return errors.New("length of relocation section is not a multiple of 8")
   732  	}
   733  
   734  	symbols, _, err := f.getSymbols(SHT_SYMTAB)
   735  	if err != nil {
   736  		return err
   737  	}
   738  
   739  	b := bytes.NewReader(rels)
   740  	var rel Rel32
   741  
   742  	for b.Len() > 0 {
   743  		binary.Read(b, f.ByteOrder, &rel)
   744  		symNo := rel.Info >> 8
   745  		t := R_ARM(rel.Info & 0xff)
   746  
   747  		if symNo == 0 || symNo > uint32(len(symbols)) {
   748  			continue
   749  		}
   750  		sym := &symbols[symNo-1]
   751  
   752  		switch t {
   753  		case R_ARM_ABS32:
   754  			if rel.Off+4 >= uint32(len(dst)) {
   755  				continue
   756  			}
   757  			val := f.ByteOrder.Uint32(dst[rel.Off : rel.Off+4])
   758  			val += uint32(sym.Value)
   759  			f.ByteOrder.PutUint32(dst[rel.Off:rel.Off+4], val)
   760  		}
   761  	}
   762  
   763  	return nil
   764  }
   765  
   766  func (f *File) applyRelocationsARM64(dst []byte, rels []byte) error {
   767  	// 24 is the size of Rela64.
   768  	if len(rels)%24 != 0 {
   769  		return errors.New("length of relocation section is not a multiple of 24")
   770  	}
   771  
   772  	symbols, _, err := f.getSymbols(SHT_SYMTAB)
   773  	if err != nil {
   774  		return err
   775  	}
   776  
   777  	b := bytes.NewReader(rels)
   778  	var rela Rela64
   779  
   780  	for b.Len() > 0 {
   781  		binary.Read(b, f.ByteOrder, &rela)
   782  		symNo := rela.Info >> 32
   783  		t := R_AARCH64(rela.Info & 0xffff)
   784  
   785  		if symNo == 0 || symNo > uint64(len(symbols)) {
   786  			continue
   787  		}
   788  		sym := &symbols[symNo-1]
   789  		if !canApplyRelocation(sym) {
   790  			continue
   791  		}
   792  
   793  		// There are relocations, so this must be a normal
   794  		// object file.  The code below handles only basic relocations
   795  		// of the form S + A (symbol plus addend).
   796  
   797  		switch t {
   798  		case R_AARCH64_ABS64:
   799  			if rela.Off+8 >= uint64(len(dst)) || rela.Addend < 0 {
   800  				continue
   801  			}
   802  			val64 := sym.Value + uint64(rela.Addend)
   803  			f.ByteOrder.PutUint64(dst[rela.Off:rela.Off+8], val64)
   804  		case R_AARCH64_ABS32:
   805  			if rela.Off+4 >= uint64(len(dst)) || rela.Addend < 0 {
   806  				continue
   807  			}
   808  			val32 := uint32(sym.Value) + uint32(rela.Addend)
   809  			f.ByteOrder.PutUint32(dst[rela.Off:rela.Off+4], val32)
   810  		}
   811  	}
   812  
   813  	return nil
   814  }
   815  
   816  func (f *File) applyRelocationsPPC(dst []byte, rels []byte) error {
   817  	// 12 is the size of Rela32.
   818  	if len(rels)%12 != 0 {
   819  		return errors.New("length of relocation section is not a multiple of 12")
   820  	}
   821  
   822  	symbols, _, err := f.getSymbols(SHT_SYMTAB)
   823  	if err != nil {
   824  		return err
   825  	}
   826  
   827  	b := bytes.NewReader(rels)
   828  	var rela Rela32
   829  
   830  	for b.Len() > 0 {
   831  		binary.Read(b, f.ByteOrder, &rela)
   832  		symNo := rela.Info >> 8
   833  		t := R_PPC(rela.Info & 0xff)
   834  
   835  		if symNo == 0 || symNo > uint32(len(symbols)) {
   836  			continue
   837  		}
   838  		sym := &symbols[symNo-1]
   839  		if !canApplyRelocation(sym) {
   840  			continue
   841  		}
   842  
   843  		switch t {
   844  		case R_PPC_ADDR32:
   845  			if rela.Off+4 >= uint32(len(dst)) || rela.Addend < 0 {
   846  				continue
   847  			}
   848  			val32 := uint32(sym.Value) + uint32(rela.Addend)
   849  			f.ByteOrder.PutUint32(dst[rela.Off:rela.Off+4], val32)
   850  		}
   851  	}
   852  
   853  	return nil
   854  }
   855  
   856  func (f *File) applyRelocationsPPC64(dst []byte, rels []byte) error {
   857  	// 24 is the size of Rela64.
   858  	if len(rels)%24 != 0 {
   859  		return errors.New("length of relocation section is not a multiple of 24")
   860  	}
   861  
   862  	symbols, _, err := f.getSymbols(SHT_SYMTAB)
   863  	if err != nil {
   864  		return err
   865  	}
   866  
   867  	b := bytes.NewReader(rels)
   868  	var rela Rela64
   869  
   870  	for b.Len() > 0 {
   871  		binary.Read(b, f.ByteOrder, &rela)
   872  		symNo := rela.Info >> 32
   873  		t := R_PPC64(rela.Info & 0xffff)
   874  
   875  		if symNo == 0 || symNo > uint64(len(symbols)) {
   876  			continue
   877  		}
   878  		sym := &symbols[symNo-1]
   879  		if !canApplyRelocation(sym) {
   880  			continue
   881  		}
   882  
   883  		switch t {
   884  		case R_PPC64_ADDR64:
   885  			if rela.Off+8 >= uint64(len(dst)) || rela.Addend < 0 {
   886  				continue
   887  			}
   888  			val64 := sym.Value + uint64(rela.Addend)
   889  			f.ByteOrder.PutUint64(dst[rela.Off:rela.Off+8], val64)
   890  		case R_PPC64_ADDR32:
   891  			if rela.Off+4 >= uint64(len(dst)) || rela.Addend < 0 {
   892  				continue
   893  			}
   894  			val32 := uint32(sym.Value) + uint32(rela.Addend)
   895  			f.ByteOrder.PutUint32(dst[rela.Off:rela.Off+4], val32)
   896  		}
   897  	}
   898  
   899  	return nil
   900  }
   901  
   902  func (f *File) applyRelocationsMIPS(dst []byte, rels []byte) error {
   903  	// 8 is the size of Rel32.
   904  	if len(rels)%8 != 0 {
   905  		return errors.New("length of relocation section is not a multiple of 8")
   906  	}
   907  
   908  	symbols, _, err := f.getSymbols(SHT_SYMTAB)
   909  	if err != nil {
   910  		return err
   911  	}
   912  
   913  	b := bytes.NewReader(rels)
   914  	var rel Rel32
   915  
   916  	for b.Len() > 0 {
   917  		binary.Read(b, f.ByteOrder, &rel)
   918  		symNo := rel.Info >> 8
   919  		t := R_MIPS(rel.Info & 0xff)
   920  
   921  		if symNo == 0 || symNo > uint32(len(symbols)) {
   922  			continue
   923  		}
   924  		sym := &symbols[symNo-1]
   925  
   926  		switch t {
   927  		case R_MIPS_32:
   928  			if rel.Off+4 >= uint32(len(dst)) {
   929  				continue
   930  			}
   931  			val := f.ByteOrder.Uint32(dst[rel.Off : rel.Off+4])
   932  			val += uint32(sym.Value)
   933  			f.ByteOrder.PutUint32(dst[rel.Off:rel.Off+4], val)
   934  		}
   935  	}
   936  
   937  	return nil
   938  }
   939  
   940  func (f *File) applyRelocationsMIPS64(dst []byte, rels []byte) error {
   941  	// 24 is the size of Rela64.
   942  	if len(rels)%24 != 0 {
   943  		return errors.New("length of relocation section is not a multiple of 24")
   944  	}
   945  
   946  	symbols, _, err := f.getSymbols(SHT_SYMTAB)
   947  	if err != nil {
   948  		return err
   949  	}
   950  
   951  	b := bytes.NewReader(rels)
   952  	var rela Rela64
   953  
   954  	for b.Len() > 0 {
   955  		binary.Read(b, f.ByteOrder, &rela)
   956  		var symNo uint64
   957  		var t R_MIPS
   958  		if f.ByteOrder == binary.BigEndian {
   959  			symNo = rela.Info >> 32
   960  			t = R_MIPS(rela.Info & 0xff)
   961  		} else {
   962  			symNo = rela.Info & 0xffffffff
   963  			t = R_MIPS(rela.Info >> 56)
   964  		}
   965  
   966  		if symNo == 0 || symNo > uint64(len(symbols)) {
   967  			continue
   968  		}
   969  		sym := &symbols[symNo-1]
   970  		if !canApplyRelocation(sym) {
   971  			continue
   972  		}
   973  
   974  		switch t {
   975  		case R_MIPS_64:
   976  			if rela.Off+8 >= uint64(len(dst)) || rela.Addend < 0 {
   977  				continue
   978  			}
   979  			val64 := sym.Value + uint64(rela.Addend)
   980  			f.ByteOrder.PutUint64(dst[rela.Off:rela.Off+8], val64)
   981  		case R_MIPS_32:
   982  			if rela.Off+4 >= uint64(len(dst)) || rela.Addend < 0 {
   983  				continue
   984  			}
   985  			val32 := uint32(sym.Value) + uint32(rela.Addend)
   986  			f.ByteOrder.PutUint32(dst[rela.Off:rela.Off+4], val32)
   987  		}
   988  	}
   989  
   990  	return nil
   991  }
   992  
   993  func (f *File) applyRelocationsRISCV64(dst []byte, rels []byte) error {
   994  	// 24 is the size of Rela64.
   995  	if len(rels)%24 != 0 {
   996  		return errors.New("length of relocation section is not a multiple of 24")
   997  	}
   998  
   999  	symbols, _, err := f.getSymbols(SHT_SYMTAB)
  1000  	if err != nil {
  1001  		return err
  1002  	}
  1003  
  1004  	b := bytes.NewReader(rels)
  1005  	var rela Rela64
  1006  
  1007  	for b.Len() > 0 {
  1008  		binary.Read(b, f.ByteOrder, &rela)
  1009  		symNo := rela.Info >> 32
  1010  		t := R_RISCV(rela.Info & 0xffff)
  1011  
  1012  		if symNo == 0 || symNo > uint64(len(symbols)) {
  1013  			continue
  1014  		}
  1015  		sym := &symbols[symNo-1]
  1016  		if !canApplyRelocation(sym) {
  1017  			continue
  1018  		}
  1019  
  1020  		switch t {
  1021  		case R_RISCV_64:
  1022  			if rela.Off+8 >= uint64(len(dst)) || rela.Addend < 0 {
  1023  				continue
  1024  			}
  1025  			val64 := sym.Value + uint64(rela.Addend)
  1026  			f.ByteOrder.PutUint64(dst[rela.Off:rela.Off+8], val64)
  1027  		case R_RISCV_32:
  1028  			if rela.Off+4 >= uint64(len(dst)) || rela.Addend < 0 {
  1029  				continue
  1030  			}
  1031  			val32 := uint32(sym.Value) + uint32(rela.Addend)
  1032  			f.ByteOrder.PutUint32(dst[rela.Off:rela.Off+4], val32)
  1033  		}
  1034  	}
  1035  
  1036  	return nil
  1037  }
  1038  
  1039  func (f *File) applyRelocationss390x(dst []byte, rels []byte) error {
  1040  	// 24 is the size of Rela64.
  1041  	if len(rels)%24 != 0 {
  1042  		return errors.New("length of relocation section is not a multiple of 24")
  1043  	}
  1044  
  1045  	symbols, _, err := f.getSymbols(SHT_SYMTAB)
  1046  	if err != nil {
  1047  		return err
  1048  	}
  1049  
  1050  	b := bytes.NewReader(rels)
  1051  	var rela Rela64
  1052  
  1053  	for b.Len() > 0 {
  1054  		binary.Read(b, f.ByteOrder, &rela)
  1055  		symNo := rela.Info >> 32
  1056  		t := R_390(rela.Info & 0xffff)
  1057  
  1058  		if symNo == 0 || symNo > uint64(len(symbols)) {
  1059  			continue
  1060  		}
  1061  		sym := &symbols[symNo-1]
  1062  		if !canApplyRelocation(sym) {
  1063  			continue
  1064  		}
  1065  
  1066  		switch t {
  1067  		case R_390_64:
  1068  			if rela.Off+8 >= uint64(len(dst)) || rela.Addend < 0 {
  1069  				continue
  1070  			}
  1071  			val64 := sym.Value + uint64(rela.Addend)
  1072  			f.ByteOrder.PutUint64(dst[rela.Off:rela.Off+8], val64)
  1073  		case R_390_32:
  1074  			if rela.Off+4 >= uint64(len(dst)) || rela.Addend < 0 {
  1075  				continue
  1076  			}
  1077  			val32 := uint32(sym.Value) + uint32(rela.Addend)
  1078  			f.ByteOrder.PutUint32(dst[rela.Off:rela.Off+4], val32)
  1079  		}
  1080  	}
  1081  
  1082  	return nil
  1083  }
  1084  
  1085  func (f *File) applyRelocationsSPARC64(dst []byte, rels []byte) error {
  1086  	// 24 is the size of Rela64.
  1087  	if len(rels)%24 != 0 {
  1088  		return errors.New("length of relocation section is not a multiple of 24")
  1089  	}
  1090  
  1091  	symbols, _, err := f.getSymbols(SHT_SYMTAB)
  1092  	if err != nil {
  1093  		return err
  1094  	}
  1095  
  1096  	b := bytes.NewReader(rels)
  1097  	var rela Rela64
  1098  
  1099  	for b.Len() > 0 {
  1100  		binary.Read(b, f.ByteOrder, &rela)
  1101  		symNo := rela.Info >> 32
  1102  		t := R_SPARC(rela.Info & 0xff)
  1103  
  1104  		if symNo == 0 || symNo > uint64(len(symbols)) {
  1105  			continue
  1106  		}
  1107  		sym := &symbols[symNo-1]
  1108  		if !canApplyRelocation(sym) {
  1109  			continue
  1110  		}
  1111  
  1112  		switch t {
  1113  		case R_SPARC_64, R_SPARC_UA64:
  1114  			if rela.Off+8 >= uint64(len(dst)) || rela.Addend < 0 {
  1115  				continue
  1116  			}
  1117  			val64 := sym.Value + uint64(rela.Addend)
  1118  			f.ByteOrder.PutUint64(dst[rela.Off:rela.Off+8], val64)
  1119  		case R_SPARC_32, R_SPARC_UA32:
  1120  			if rela.Off+4 >= uint64(len(dst)) || rela.Addend < 0 {
  1121  				continue
  1122  			}
  1123  			val32 := uint32(sym.Value) + uint32(rela.Addend)
  1124  			f.ByteOrder.PutUint32(dst[rela.Off:rela.Off+4], val32)
  1125  		}
  1126  	}
  1127  
  1128  	return nil
  1129  }
  1130  
  1131  func (f *File) DWARF() (*dwarf.Data, error) {
  1132  	dwarfSuffix := func(s *Section) string {
  1133  		switch {
  1134  		case strings.HasPrefix(s.Name, ".debug_"):
  1135  			return s.Name[7:]
  1136  		case strings.HasPrefix(s.Name, ".zdebug_"):
  1137  			return s.Name[8:]
  1138  		default:
  1139  			return ""
  1140  		}
  1141  
  1142  	}
  1143  	// sectionData gets the data for s, checks its size, and
  1144  	// applies any applicable relations.
  1145  	sectionData := func(i int, s *Section) ([]byte, error) {
  1146  		b, err := s.Data()
  1147  		if err != nil && uint64(len(b)) < s.Size {
  1148  			return nil, err
  1149  		}
  1150  
  1151  		if len(b) >= 12 && string(b[:4]) == "ZLIB" {
  1152  			dlen := binary.BigEndian.Uint64(b[4:12])
  1153  			dbuf := make([]byte, dlen)
  1154  			r, err := zlib.NewReader(bytes.NewBuffer(b[12:]))
  1155  			if err != nil {
  1156  				return nil, err
  1157  			}
  1158  			if _, err := io.ReadFull(r, dbuf); err != nil {
  1159  				return nil, err
  1160  			}
  1161  			if err := r.Close(); err != nil {
  1162  				return nil, err
  1163  			}
  1164  			b = dbuf
  1165  		}
  1166  
  1167  		for _, r := range f.Sections {
  1168  			if r.Type != SHT_RELA && r.Type != SHT_REL {
  1169  				continue
  1170  			}
  1171  			if int(r.Info) != i {
  1172  				continue
  1173  			}
  1174  			rd, err := r.Data()
  1175  			if err != nil {
  1176  				return nil, err
  1177  			}
  1178  			err = f.applyRelocations(b, rd)
  1179  			if err != nil {
  1180  				return nil, err
  1181  			}
  1182  		}
  1183  		return b, nil
  1184  	}
  1185  
  1186  	// There are many DWARf sections, but these are the ones
  1187  	// the debug/dwarf package started with.
  1188  	var dat = map[string][]byte{"abbrev": nil, "info": nil, "str": nil, "line": nil, "ranges": nil}
  1189  	for i, s := range f.Sections {
  1190  		suffix := dwarfSuffix(s)
  1191  		if suffix == "" {
  1192  			continue
  1193  		}
  1194  		if _, ok := dat[suffix]; !ok {
  1195  			continue
  1196  		}
  1197  		b, err := sectionData(i, s)
  1198  		if err != nil {
  1199  			return nil, err
  1200  		}
  1201  		dat[suffix] = b
  1202  	}
  1203  
  1204  	d, err := dwarf.New(dat["abbrev"], nil, nil, dat["info"], dat["line"], nil, dat["ranges"], dat["str"])
  1205  	if err != nil {
  1206  		return nil, err
  1207  	}
  1208  
  1209  	// Look for DWARF4 .debug_types sections and DWARF5 sections.
  1210  	for i, s := range f.Sections {
  1211  		suffix := dwarfSuffix(s)
  1212  		if suffix == "" {
  1213  			continue
  1214  		}
  1215  		if _, ok := dat[suffix]; ok {
  1216  			// Already handled.
  1217  			continue
  1218  		}
  1219  
  1220  		b, err := sectionData(i, s)
  1221  		if err != nil {
  1222  			return nil, err
  1223  		}
  1224  
  1225  		if suffix == "types" {
  1226  			if err := d.AddTypes(fmt.Sprintf("types-%d", i), b); err != nil {
  1227  				return nil, err
  1228  			}
  1229  		} else {
  1230  			if err := d.AddSection(".debug_"+suffix, b); err != nil {
  1231  				return nil, err
  1232  			}
  1233  		}
  1234  	}
  1235  
  1236  	return d, nil
  1237  }
  1238  
  1239  // Symbols returns the symbol table for f. The symbols will be listed in the order
  1240  // they appear in f.
  1241  //
  1242  // For compatibility with Go 1.0, Symbols omits the null symbol at index 0.
  1243  // After retrieving the symbols as symtab, an externally supplied index x
  1244  // corresponds to symtab[x-1], not symtab[x].
  1245  func (f *File) Symbols() ([]Symbol, error) {
  1246  	sym, _, err := f.getSymbols(SHT_SYMTAB)
  1247  	return sym, err
  1248  }
  1249  
  1250  // DynamicSymbols returns the dynamic symbol table for f. The symbols
  1251  // will be listed in the order they appear in f.
  1252  //
  1253  // If f has a symbol version table, the returned Symbols will have
  1254  // initialized Version and Library fields.
  1255  //
  1256  // For compatibility with Symbols, DynamicSymbols omits the null symbol at index 0.
  1257  // After retrieving the symbols as symtab, an externally supplied index x
  1258  // corresponds to symtab[x-1], not symtab[x].
  1259  func (f *File) DynamicSymbols() ([]Symbol, error) {
  1260  	sym, str, err := f.getSymbols(SHT_DYNSYM)
  1261  	if err != nil {
  1262  		return nil, err
  1263  	}
  1264  	if f.gnuVersionInit(str) {
  1265  		for i := range sym {
  1266  			sym[i].Library, sym[i].Version = f.gnuVersion(i)
  1267  		}
  1268  	}
  1269  	return sym, nil
  1270  }
  1271  
  1272  type ImportedSymbol struct {
  1273  	Name    string
  1274  	Version string
  1275  	Library string
  1276  }
  1277  
  1278  // ImportedSymbols returns the names of all symbols
  1279  // referred to by the binary f that are expected to be
  1280  // satisfied by other libraries at dynamic load time.
  1281  // It does not return weak symbols.
  1282  func (f *File) ImportedSymbols() ([]ImportedSymbol, error) {
  1283  	sym, str, err := f.getSymbols(SHT_DYNSYM)
  1284  	if err != nil {
  1285  		return nil, err
  1286  	}
  1287  	f.gnuVersionInit(str)
  1288  	var all []ImportedSymbol
  1289  	for i, s := range sym {
  1290  		if ST_BIND(s.Info) == STB_GLOBAL && s.Section == SHN_UNDEF {
  1291  			all = append(all, ImportedSymbol{Name: s.Name})
  1292  			sym := &all[len(all)-1]
  1293  			sym.Library, sym.Version = f.gnuVersion(i)
  1294  		}
  1295  	}
  1296  	return all, nil
  1297  }
  1298  
  1299  type verneed struct {
  1300  	File string
  1301  	Name string
  1302  }
  1303  
  1304  // gnuVersionInit parses the GNU version tables
  1305  // for use by calls to gnuVersion.
  1306  func (f *File) gnuVersionInit(str []byte) bool {
  1307  	if f.gnuNeed != nil {
  1308  		// Already initialized
  1309  		return true
  1310  	}
  1311  
  1312  	// Accumulate verneed information.
  1313  	vn := f.SectionByType(SHT_GNU_VERNEED)
  1314  	if vn == nil {
  1315  		return false
  1316  	}
  1317  	d, _ := vn.Data()
  1318  
  1319  	var need []verneed
  1320  	i := 0
  1321  	for {
  1322  		if i+16 > len(d) {
  1323  			break
  1324  		}
  1325  		vers := f.ByteOrder.Uint16(d[i : i+2])
  1326  		if vers != 1 {
  1327  			break
  1328  		}
  1329  		cnt := f.ByteOrder.Uint16(d[i+2 : i+4])
  1330  		fileoff := f.ByteOrder.Uint32(d[i+4 : i+8])
  1331  		aux := f.ByteOrder.Uint32(d[i+8 : i+12])
  1332  		next := f.ByteOrder.Uint32(d[i+12 : i+16])
  1333  		file, _ := getString(str, int(fileoff))
  1334  
  1335  		var name string
  1336  		j := i + int(aux)
  1337  		for c := 0; c < int(cnt); c++ {
  1338  			if j+16 > len(d) {
  1339  				break
  1340  			}
  1341  			// hash := f.ByteOrder.Uint32(d[j:j+4])
  1342  			// flags := f.ByteOrder.Uint16(d[j+4:j+6])
  1343  			other := f.ByteOrder.Uint16(d[j+6 : j+8])
  1344  			nameoff := f.ByteOrder.Uint32(d[j+8 : j+12])
  1345  			next := f.ByteOrder.Uint32(d[j+12 : j+16])
  1346  			name, _ = getString(str, int(nameoff))
  1347  			ndx := int(other)
  1348  			if ndx >= len(need) {
  1349  				a := make([]verneed, 2*(ndx+1))
  1350  				copy(a, need)
  1351  				need = a
  1352  			}
  1353  
  1354  			need[ndx] = verneed{file, name}
  1355  			if next == 0 {
  1356  				break
  1357  			}
  1358  			j += int(next)
  1359  		}
  1360  
  1361  		if next == 0 {
  1362  			break
  1363  		}
  1364  		i += int(next)
  1365  	}
  1366  
  1367  	// Versym parallels symbol table, indexing into verneed.
  1368  	vs := f.SectionByType(SHT_GNU_VERSYM)
  1369  	if vs == nil {
  1370  		return false
  1371  	}
  1372  	d, _ = vs.Data()
  1373  
  1374  	f.gnuNeed = need
  1375  	f.gnuVersym = d
  1376  	return true
  1377  }
  1378  
  1379  // gnuVersion adds Library and Version information to sym,
  1380  // which came from offset i of the symbol table.
  1381  func (f *File) gnuVersion(i int) (library string, version string) {
  1382  	// Each entry is two bytes.
  1383  	i = (i + 1) * 2
  1384  	if i >= len(f.gnuVersym) {
  1385  		return
  1386  	}
  1387  	j := int(f.ByteOrder.Uint16(f.gnuVersym[i:]))
  1388  	if j < 2 || j >= len(f.gnuNeed) {
  1389  		return
  1390  	}
  1391  	n := &f.gnuNeed[j]
  1392  	return n.File, n.Name
  1393  }
  1394  
  1395  // ImportedLibraries returns the names of all libraries
  1396  // referred to by the binary f that are expected to be
  1397  // linked with the binary at dynamic link time.
  1398  func (f *File) ImportedLibraries() ([]string, error) {
  1399  	return f.DynString(DT_NEEDED)
  1400  }
  1401  
  1402  // DynString returns the strings listed for the given tag in the file's dynamic
  1403  // section.
  1404  //
  1405  // The tag must be one that takes string values: DT_NEEDED, DT_SONAME, DT_RPATH, or
  1406  // DT_RUNPATH.
  1407  func (f *File) DynString(tag DynTag) ([]string, error) {
  1408  	switch tag {
  1409  	case DT_NEEDED, DT_SONAME, DT_RPATH, DT_RUNPATH:
  1410  	default:
  1411  		return nil, fmt.Errorf("non-string-valued tag %v", tag)
  1412  	}
  1413  	ds := f.SectionByType(SHT_DYNAMIC)
  1414  	if ds == nil {
  1415  		// not dynamic, so no libraries
  1416  		return nil, nil
  1417  	}
  1418  	d, err := ds.Data()
  1419  	if err != nil {
  1420  		return nil, err
  1421  	}
  1422  	str, err := f.stringTable(ds.Link)
  1423  	if err != nil {
  1424  		return nil, err
  1425  	}
  1426  	var all []string
  1427  	for len(d) > 0 {
  1428  		var t DynTag
  1429  		var v uint64
  1430  		switch f.Class {
  1431  		case ELFCLASS32:
  1432  			t = DynTag(f.ByteOrder.Uint32(d[0:4]))
  1433  			v = uint64(f.ByteOrder.Uint32(d[4:8]))
  1434  			d = d[8:]
  1435  		case ELFCLASS64:
  1436  			t = DynTag(f.ByteOrder.Uint64(d[0:8]))
  1437  			v = f.ByteOrder.Uint64(d[8:16])
  1438  			d = d[16:]
  1439  		}
  1440  		if t == tag {
  1441  			s, ok := getString(str, int(v))
  1442  			if ok {
  1443  				all = append(all, s)
  1444  			}
  1445  		}
  1446  	}
  1447  	return all, nil
  1448  }
  1449  

View as plain text