Subversion Repositories openrisc

// Copyright 2009 The Go Authors.  All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

// Package elf implements access to ELF object files.

package elf

import (

        "bytes"

        "debug/dwarf"

        "encoding/binary"

        "errors"

        "fmt"

        "io"

        "os"

)

// TODO: error reporting detail

/*

 * Internal ELF representation

 */

// A FileHeader represents an ELF file header.

type FileHeader struct {

        Class      Class

        Data       Data

        Version    Version

        OSABI      OSABI

        ABIVersion uint8

        ByteOrder  binary.ByteOrder

        Type       Type

        Machine    Machine

}

// A File represents an open ELF file.

type File struct {

        FileHeader

        Sections  []*Section

        Progs     []*Prog

        closer    io.Closer

        gnuNeed   []verneed

        gnuVersym []byte

}

// A SectionHeader represents a single ELF section header.

type SectionHeader struct {

        Name      string

        Type      SectionType

        Flags     SectionFlag

        Addr      uint64

        Offset    uint64

        Size      uint64

        Link      uint32

        Info      uint32

        Addralign uint64

        Entsize   uint64

}

// A Section represents a single section in an ELF file.

type Section struct {

        SectionHeader

        // Embed ReaderAt for ReadAt method.

        // Do not embed SectionReader directly

        // to avoid having Read and Seek.

        // If a client wants Read and Seek it must use

        // Open() to avoid fighting over the seek offset

        // with other clients.

        io.ReaderAt

        sr *io.SectionReader

}

// Data reads and returns the contents of the ELF section.

func (s *Section) Data() ([]byte, error) {

        dat := make([]byte, s.sr.Size())

        n, err := s.sr.ReadAt(dat, 0)

        return dat[0:n], err

}

// stringTable reads and returns the string table given by the

// specified link value.

func (f *File) stringTable(link uint32) ([]byte, error) {

        if link <= 0 || link >= uint32(len(f.Sections)) {

                return nil, errors.New("section has invalid string table link")

        }

        return f.Sections[link].Data()

}

// Open returns a new ReadSeeker reading the ELF section.

func (s *Section) Open() io.ReadSeeker { return io.NewSectionReader(s.sr, 0, 1<<63-1) }

// A ProgHeader represents a single ELF program header.

type ProgHeader struct {

        Type   ProgType

        Flags  ProgFlag

        Off    uint64

        Vaddr  uint64

        Paddr  uint64

        Filesz uint64

        Memsz  uint64

        Align  uint64

}

// A Prog represents a single ELF program header in an ELF binary.

type Prog struct {

        ProgHeader

        // Embed ReaderAt for ReadAt method.

        // Do not embed SectionReader directly

        // to avoid having Read and Seek.

        // If a client wants Read and Seek it must use

        // Open() to avoid fighting over the seek offset

        // with other clients.

        io.ReaderAt

        sr *io.SectionReader

}

// Open returns a new ReadSeeker reading the ELF program body.

func (p *Prog) Open() io.ReadSeeker { return io.NewSectionReader(p.sr, 0, 1<<63-1) }

// A Symbol represents an entry in an ELF symbol table section.

type Symbol struct {

        Name        string

        Info, Other byte

        Section     SectionIndex

        Value, Size uint64

}

/*

 * ELF reader

 */

type FormatError struct {

        off int64

        msg string

        val interface{}

}

func (e *FormatError) Error() string {

        msg := e.msg

        if e.val != nil {

                msg += fmt.Sprintf(" '%v' ", e.val)

        }

        msg += fmt.Sprintf("in record at byte %#x", e.off)

        return msg

}

// Open opens the named file using os.Open and prepares it for use as an ELF binary.

func Open(name string) (*File, error) {

        f, err := os.Open(name)

        if err != nil {

                return nil, err

        }

        ff, err := NewFile(f)

        if err != nil {

                f.Close()

                return nil, err

        }

        ff.closer = f

        return ff, nil

}

// Close closes the File.

// If the File was created using NewFile directly instead of Open,

// Close has no effect.

func (f *File) Close() error {

        var err error

        if f.closer != nil {

                err = f.closer.Close()

                f.closer = nil

        }

        return err

}

// SectionByType returns the first section in f with the

// given type, or nil if there is no such section.

func (f *File) SectionByType(typ SectionType) *Section {

        for _, s := range f.Sections {

                if s.Type == typ {

                        return s

                }

        }

        return nil

}

// NewFile creates a new File for accessing an ELF binary in an underlying reader.

// The ELF binary is expected to start at position 0 in the ReaderAt.

func NewFile(r io.ReaderAt) (*File, error) {

        sr := io.NewSectionReader(r, 0, 1<<63-1)

        // Read and decode ELF identifier

        var ident [16]uint8

        if _, err := r.ReadAt(ident[0:], 0); err != nil {

                return nil, err

        }

        if ident[0] != '\x7f' || ident[1] != 'E' || ident[2] != 'L' || ident[3] != 'F' {

                return nil, &FormatError{0, "bad magic number", ident[0:4]}

        }

        f := new(File)

        f.Class = Class(ident[EI_CLASS])

        switch f.Class {

        case ELFCLASS32:

        case ELFCLASS64:

                // ok

        default:

                return nil, &FormatError{0, "unknown ELF class", f.Class}

        }

        f.Data = Data(ident[EI_DATA])

        switch f.Data {

        case ELFDATA2LSB:

                f.ByteOrder = binary.LittleEndian

        case ELFDATA2MSB:

                f.ByteOrder = binary.BigEndian

        default:

                return nil, &FormatError{0, "unknown ELF data encoding", f.Data}

        }

        f.Version = Version(ident[EI_VERSION])

        if f.Version != EV_CURRENT {

                return nil, &FormatError{0, "unknown ELF version", f.Version}

        }

        f.OSABI = OSABI(ident[EI_OSABI])

        f.ABIVersion = ident[EI_ABIVERSION]

        // Read ELF file header

        var phoff int64

        var phentsize, phnum int

        var shoff int64

        var shentsize, shnum, shstrndx int

        shstrndx = -1

        switch f.Class {

        case ELFCLASS32:

                hdr := new(Header32)

                sr.Seek(0, os.SEEK_SET)

                if err := binary.Read(sr, f.ByteOrder, hdr); err != nil {

                        return nil, err

                }

                f.Type = Type(hdr.Type)

                f.Machine = Machine(hdr.Machine)

                if v := Version(hdr.Version); v != f.Version {

                        return nil, &FormatError{0, "mismatched ELF version", v}

                }

                phoff = int64(hdr.Phoff)

                phentsize = int(hdr.Phentsize)

                phnum = int(hdr.Phnum)

                shoff = int64(hdr.Shoff)

                shentsize = int(hdr.Shentsize)

                shnum = int(hdr.Shnum)

                shstrndx = int(hdr.Shstrndx)

        case ELFCLASS64:

                hdr := new(Header64)

                sr.Seek(0, os.SEEK_SET)

                if err := binary.Read(sr, f.ByteOrder, hdr); err != nil {

                        return nil, err

                }

                f.Type = Type(hdr.Type)

                f.Machine = Machine(hdr.Machine)

                if v := Version(hdr.Version); v != f.Version {

                        return nil, &FormatError{0, "mismatched ELF version", v}

                }

                phoff = int64(hdr.Phoff)

                phentsize = int(hdr.Phentsize)

                phnum = int(hdr.Phnum)

                shoff = int64(hdr.Shoff)

                shentsize = int(hdr.Shentsize)

                shnum = int(hdr.Shnum)

                shstrndx = int(hdr.Shstrndx)

        }

        if shstrndx < 0 || shstrndx >= shnum {

                return nil, &FormatError{0, "invalid ELF shstrndx", shstrndx}

        }

        // Read program headers

        f.Progs = make([]*Prog, phnum)

        for i := 0; i < phnum; i++ {

                off := phoff + int64(i)*int64(phentsize)

                sr.Seek(off, os.SEEK_SET)

                p := new(Prog)

                switch f.Class {

                case ELFCLASS32:

                        ph := new(Prog32)

                        if err := binary.Read(sr, f.ByteOrder, ph); err != nil {

                                return nil, err

                        }

                        p.ProgHeader = ProgHeader{

                                Type:   ProgType(ph.Type),

                                Flags:  ProgFlag(ph.Flags),

                                Off:    uint64(ph.Off),

                                Vaddr:  uint64(ph.Vaddr),

                                Paddr:  uint64(ph.Paddr),

                                Filesz: uint64(ph.Filesz),

                                Memsz:  uint64(ph.Memsz),

                                Align:  uint64(ph.Align),

                        }

                case ELFCLASS64:

                        ph := new(Prog64)

                        if err := binary.Read(sr, f.ByteOrder, ph); err != nil {

                                return nil, err

                        }

                        p.ProgHeader = ProgHeader{

                                Type:   ProgType(ph.Type),

                                Flags:  ProgFlag(ph.Flags),

                                Off:    uint64(ph.Off),

                                Vaddr:  uint64(ph.Vaddr),

                                Paddr:  uint64(ph.Paddr),

                                Filesz: uint64(ph.Filesz),

                                Memsz:  uint64(ph.Memsz),

                                Align:  uint64(ph.Align),

                        }

                }

                p.sr = io.NewSectionReader(r, int64(p.Off), int64(p.Filesz))

                p.ReaderAt = p.sr

                f.Progs[i] = p

        }

        // Read section headers

        f.Sections = make([]*Section, shnum)

        names := make([]uint32, shnum)

        for i := 0; i < shnum; i++ {

                off := shoff + int64(i)*int64(shentsize)

                sr.Seek(off, os.SEEK_SET)

                s := new(Section)

                switch f.Class {

                case ELFCLASS32:

                        sh := new(Section32)

                        if err := binary.Read(sr, f.ByteOrder, sh); err != nil {

                                return nil, err

                        }

                        names[i] = sh.Name

                        s.SectionHeader = SectionHeader{

                                Type:      SectionType(sh.Type),

                                Flags:     SectionFlag(sh.Flags),

                                Addr:      uint64(sh.Addr),

                                Offset:    uint64(sh.Off),

                                Size:      uint64(sh.Size),

                                Link:      uint32(sh.Link),

                                Info:      uint32(sh.Info),

                                Addralign: uint64(sh.Addralign),

                                Entsize:   uint64(sh.Entsize),

                        }

                case ELFCLASS64:

                        sh := new(Section64)

                        if err := binary.Read(sr, f.ByteOrder, sh); err != nil {

                                return nil, err

                        }

                        names[i] = sh.Name

                        s.SectionHeader = SectionHeader{

                                Type:      SectionType(sh.Type),

                                Flags:     SectionFlag(sh.Flags),

                                Offset:    uint64(sh.Off),

                                Size:      uint64(sh.Size),

                                Addr:      uint64(sh.Addr),

                                Link:      uint32(sh.Link),

                                Info:      uint32(sh.Info),

                                Addralign: uint64(sh.Addralign),

                                Entsize:   uint64(sh.Entsize),

                        }

                }

                s.sr = io.NewSectionReader(r, int64(s.Offset), int64(s.Size))

                s.ReaderAt = s.sr

                f.Sections[i] = s

        }

        // Load section header string table.

        shstrtab, err := f.Sections[shstrndx].Data()

        if err != nil {

                return nil, err

        }

        for i, s := range f.Sections {

                var ok bool

                s.Name, ok = getString(shstrtab, int(names[i]))

                if !ok {

                        return nil, &FormatError{shoff + int64(i*shentsize), "bad section name index", names[i]}

                }

        }

        return f, nil

}

// getSymbols returns a slice of Symbols from parsing the symbol table

// with the given type, along with the associated string table.

func (f *File) getSymbols(typ SectionType) ([]Symbol, []byte, error) {

        switch f.Class {

        case ELFCLASS64:

                return f.getSymbols64(typ)

        case ELFCLASS32:

                return f.getSymbols32(typ)

        }

        return nil, nil, errors.New("not implemented")

}

func (f *File) getSymbols32(typ SectionType) ([]Symbol, []byte, error) {

        symtabSection := f.SectionByType(typ)

        if symtabSection == nil {

                return nil, nil, errors.New("no symbol section")

        }

        data, err := symtabSection.Data()

        if err != nil {

                return nil, nil, errors.New("cannot load symbol section")

        }

        symtab := bytes.NewBuffer(data)

        if symtab.Len()%Sym32Size != 0 {

                return nil, nil, errors.New("length of symbol section is not a multiple of SymSize")

        }

        strdata, err := f.stringTable(symtabSection.Link)

        if err != nil {

                return nil, nil, errors.New("cannot load string table section")

        }

        // The first entry is all zeros.

        var skip [Sym32Size]byte

        symtab.Read(skip[0:])

        symbols := make([]Symbol, symtab.Len()/Sym32Size)

        i := 0

        var sym Sym32

        for symtab.Len() > 0 {

                binary.Read(symtab, f.ByteOrder, &sym)

                str, _ := getString(strdata, int(sym.Name))

                symbols[i].Name = str

                symbols[i].Info = sym.Info

                symbols[i].Other = sym.Other

                symbols[i].Section = SectionIndex(sym.Shndx)

                symbols[i].Value = uint64(sym.Value)

                symbols[i].Size = uint64(sym.Size)

                i++

        }

        return symbols, strdata, nil

}

func (f *File) getSymbols64(typ SectionType) ([]Symbol, []byte, error) {

        symtabSection := f.SectionByType(typ)

        if symtabSection == nil {

                return nil, nil, errors.New("no symbol section")

        }

        data, err := symtabSection.Data()

        if err != nil {

                return nil, nil, errors.New("cannot load symbol section")

        }

        symtab := bytes.NewBuffer(data)

        if symtab.Len()%Sym64Size != 0 {

                return nil, nil, errors.New("length of symbol section is not a multiple of Sym64Size")

        }

        strdata, err := f.stringTable(symtabSection.Link)

        if err != nil {

                return nil, nil, errors.New("cannot load string table section")

        }

        // The first entry is all zeros.

        var skip [Sym64Size]byte

        symtab.Read(skip[0:])

        symbols := make([]Symbol, symtab.Len()/Sym64Size)

        i := 0

        var sym Sym64

        for symtab.Len() > 0 {

                binary.Read(symtab, f.ByteOrder, &sym)

                str, _ := getString(strdata, int(sym.Name))

                symbols[i].Name = str

                symbols[i].Info = sym.Info

                symbols[i].Other = sym.Other

                symbols[i].Section = SectionIndex(sym.Shndx)

                symbols[i].Value = sym.Value

                symbols[i].Size = sym.Size

                i++

        }

        return symbols, strdata, nil

}

// getString extracts a string from an ELF string table.

func getString(section []byte, start int) (string, bool) {

        if start < 0 || start >= len(section) {

                return "", false

        }

        for end := start; end < len(section); end++ {

                if section[end] == 0 {

                        return string(section[start:end]), true

                }

        }

        return "", false

}

// Section returns a section with the given name, or nil if no such

// section exists.

func (f *File) Section(name string) *Section {

        for _, s := range f.Sections {

                if s.Name == name {

                        return s

                }

        }

        return nil

}

// applyRelocations applies relocations to dst. rels is a relocations section

// in RELA format.

func (f *File) applyRelocations(dst []byte, rels []byte) error {

        if f.Class == ELFCLASS64 && f.Machine == EM_X86_64 {

                return f.applyRelocationsAMD64(dst, rels)

        }

        return errors.New("not implemented")

}

func (f *File) applyRelocationsAMD64(dst []byte, rels []byte) error {

        if len(rels)%Sym64Size != 0 {

                return errors.New("length of relocation section is not a multiple of Sym64Size")

        }

        symbols, _, err := f.getSymbols(SHT_SYMTAB)

        if err != nil {

                return err

        }

        b := bytes.NewBuffer(rels)

        var rela Rela64

        for b.Len() > 0 {

                binary.Read(b, f.ByteOrder, &rela)

                symNo := rela.Info >> 32

                t := R_X86_64(rela.Info & 0xffff)

                if symNo >= uint64(len(symbols)) {

                        continue

                }

                sym := &symbols[symNo]

                if SymType(sym.Info&0xf) != STT_SECTION {

                        // We don't handle non-section relocations for now.

                        continue

                }

                switch t {

                case R_X86_64_64:

                        if rela.Off+8 >= uint64(len(dst)) || rela.Addend < 0 {

                                continue

                        }

                        f.ByteOrder.PutUint64(dst[rela.Off:rela.Off+8], uint64(rela.Addend))

                case R_X86_64_32:

                        if rela.Off+4 >= uint64(len(dst)) || rela.Addend < 0 {

                                continue

                        }

                        f.ByteOrder.PutUint32(dst[rela.Off:rela.Off+4], uint32(rela.Addend))

                }

        }

        return nil

}

func (f *File) DWARF() (*dwarf.Data, error) {

        // There are many other DWARF sections, but these

        // are the required ones, and the debug/dwarf package

        // does not use the others, so don't bother loading them.

        var names = [...]string{"abbrev", "info", "str"}

        var dat [len(names)][]byte

        for i, name := range names {

                name = ".debug_" + name

                s := f.Section(name)

                if s == nil {

                        continue

                }

                b, err := s.Data()

                if err != nil && uint64(len(b)) < s.Size {

                        return nil, err

                }

                dat[i] = b

        }

        // If there's a relocation table for .debug_info, we have to process it

        // now otherwise the data in .debug_info is invalid for x86-64 objects.

        rela := f.Section(".rela.debug_info")

        if rela != nil && rela.Type == SHT_RELA && f.Machine == EM_X86_64 {

                data, err := rela.Data()

                if err != nil {

                        return nil, err

                }

                err = f.applyRelocations(dat[1], data)

                if err != nil {

                        return nil, err

                }

        }

        abbrev, info, str := dat[0], dat[1], dat[2]

        return dwarf.New(abbrev, nil, nil, info, nil, nil, nil, str)

}

// Symbols returns the symbol table for f.

func (f *File) Symbols() ([]Symbol, error) {

        sym, _, err := f.getSymbols(SHT_SYMTAB)

        return sym, err

}

type ImportedSymbol struct {

        Name    string

        Version string

        Library string

}

// ImportedSymbols returns the names of all symbols

// referred to by the binary f that are expected to be

// satisfied by other libraries at dynamic load time.

// It does not return weak symbols.

func (f *File) ImportedSymbols() ([]ImportedSymbol, error) {

        sym, str, err := f.getSymbols(SHT_DYNSYM)

        if err != nil {

                return nil, err

        }

        f.gnuVersionInit(str)

        var all []ImportedSymbol

        for i, s := range sym {

                if ST_BIND(s.Info) == STB_GLOBAL && s.Section == SHN_UNDEF {

                        all = append(all, ImportedSymbol{Name: s.Name})

                        f.gnuVersion(i, &all[len(all)-1])

                }

        }

        return all, nil

}

type verneed struct {

        File string

        Name string

}

// gnuVersionInit parses the GNU version tables

// for use by calls to gnuVersion.

func (f *File) gnuVersionInit(str []byte) {

        // Accumulate verneed information.

        vn := f.SectionByType(SHT_GNU_VERNEED)

        if vn == nil {

                return

        }

        d, _ := vn.Data()

        var need []verneed

        i := 0

        for {

                if i+16 > len(d) {

                        break

                }

                vers := f.ByteOrder.Uint16(d[i : i+2])

                if vers != 1 {

                        break

                }

                cnt := f.ByteOrder.Uint16(d[i+2 : i+4])

                fileoff := f.ByteOrder.Uint32(d[i+4 : i+8])

                aux := f.ByteOrder.Uint32(d[i+8 : i+12])

                next := f.ByteOrder.Uint32(d[i+12 : i+16])

                file, _ := getString(str, int(fileoff))

                var name string

                j := i + int(aux)

                for c := 0; c < int(cnt); c++ {

                        if j+16 > len(d) {

                                break

                        }

                        // hash := f.ByteOrder.Uint32(d[j:j+4])

                        // flags := f.ByteOrder.Uint16(d[j+4:j+6])

                        other := f.ByteOrder.Uint16(d[j+6 : j+8])

                        nameoff := f.ByteOrder.Uint32(d[j+8 : j+12])

                        next := f.ByteOrder.Uint32(d[j+12 : j+16])

                        name, _ = getString(str, int(nameoff))

                        ndx := int(other)

                        if ndx >= len(need) {

                                a := make([]verneed, 2*(ndx+1))

                                copy(a, need)

                                need = a

                        }

                        need[ndx] = verneed{file, name}

                        if next == 0 {

                                break

                        }

                        j += int(next)

                }

                if next == 0 {

                        break

                }

                i += int(next)

        }

        // Versym parallels symbol table, indexing into verneed.

        vs := f.SectionByType(SHT_GNU_VERSYM)

        if vs == nil {

                return

        }

        d, _ = vs.Data()

        f.gnuNeed = need

        f.gnuVersym = d

}

// gnuVersion adds Library and Version information to sym,

// which came from offset i of the symbol table.

func (f *File) gnuVersion(i int, sym *ImportedSymbol) {

        // Each entry is two bytes; skip undef entry at beginning.

        i = (i + 1) * 2

        if i >= len(f.gnuVersym) {

                return

        }

        j := int(f.ByteOrder.Uint16(f.gnuVersym[i:]))

        if j < 2 || j >= len(f.gnuNeed) {

                return

        }

        n := &f.gnuNeed[j]

        sym.Library = n.File

        sym.Version = n.Name

}

// ImportedLibraries returns the names of all libraries

// referred to by the binary f that are expected to be

// linked with the binary at dynamic link time.

func (f *File) ImportedLibraries() ([]string, error) {

        ds := f.SectionByType(SHT_DYNAMIC)

        if ds == nil {

                // not dynamic, so no libraries

                return nil, nil

        }

        d, err := ds.Data()

        if err != nil {

                return nil, err

        }

        str, err := f.stringTable(ds.Link)

        if err != nil {

                return nil, err

        }

        var all []string

        for len(d) > 0 {

                var tag DynTag

                var value uint64

                switch f.Class {

                case ELFCLASS32:

                        tag = DynTag(f.ByteOrder.Uint32(d[0:4]))

                        value = uint64(f.ByteOrder.Uint32(d[4:8]))

                        d = d[8:]

                case ELFCLASS64:

                        tag = DynTag(f.ByteOrder.Uint64(d[0:8]))

                        value = f.ByteOrder.Uint64(d[8:16])

                        d = d[16:]

                }

                if tag == DT_NEEDED {

                        s, ok := getString(str, int(value))

                        if ok {

                                all = append(all, s)

                        }

                }

        }

        return all, nil

}