Source file src/debug/elf/file.go

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

View as plain text