| // 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"; | |
| "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; | |
| } | |
| // 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, os.Error) { | |
| dat := make([]byte, s.sr.Size()); | |
| n, err := s.sr.ReadAt(dat, 0); | |
| return dat[0:n], err; | |
| } | |
| // 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; | |
| 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 uint32; | |
| Info, Other byte; | |
| Section uint32; | |
| Value, Size uint64; | |
| } | |
| /* | |
| * ELF reader | |
| */ | |
| type FormatError struct { | |
| off int64; | |
| msg string; | |
| val interface{}; | |
| } | |
| func (e *FormatError) String() 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, os.Error) { | |
| f, err := os.Open(name, os.O_RDONLY, 0); | |
| 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() os.Error { | |
| var err os.Error; | |
| if f.closer != nil { | |
| err = f.closer.Close(); | |
| f.closer = nil; | |
| } | |
| return err; | |
| } | |
| // NewFile creates a new File for acecssing 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, os.Error) { | |
| sr := io.NewSectionReader(r, 0, 1<<63-1); | |
| // Read and decode ELF identifier | |
| var ident [16]uint8; | |
| if _, err := r.ReadAt(&ident, 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 shoff int64; | |
| var shentsize, shnum, shstrndx int; | |
| shstrndx = -1; | |
| switch f.Class { | |
| case ELFCLASS32: | |
| hdr := new(Header32); | |
| sr.Seek(0, 0); | |
| 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} | |
| } | |
| shoff = int64(hdr.Shoff); | |
| shentsize = int(hdr.Shentsize); | |
| shnum = int(hdr.Shnum); | |
| shstrndx = int(hdr.Shstrndx); | |
| case ELFCLASS64: | |
| hdr := new(Header64); | |
| sr.Seek(0, 0); | |
| 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} | |
| } | |
| 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 | |
| // TODO | |
| // 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, 0); | |
| 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. | |
| s := f.Sections[shstrndx]; | |
| shstrtab := make([]byte, s.Size); | |
| if _, err := r.ReadAt(shstrtab, int64(s.Offset)); 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; | |
| } | |
| func (f *File) getSymbols() ([]Symbol, os.Error) { | |
| switch f.Class { | |
| case ELFCLASS64: | |
| return f.getSymbols64() | |
| } | |
| return nil, os.ErrorString("not implemented"); | |
| } | |
| // GetSymbols returns a slice of Symbols from parsing the symbol table. | |
| func (f *File) getSymbols64() ([]Symbol, os.Error) { | |
| var symtabSection *Section; | |
| for _, section := range f.Sections { | |
| if section.Type == SHT_SYMTAB { | |
| symtabSection = section; | |
| break; | |
| } | |
| } | |
| if symtabSection == nil { | |
| return nil, os.ErrorString("no symbol section") | |
| } | |
| data, err := symtabSection.Data(); | |
| if err != nil { | |
| return nil, os.ErrorString("cannot load symbol section") | |
| } | |
| symtab := bytes.NewBuffer(data); | |
| if symtab.Len()%Sym64Size != 0 { | |
| return nil, os.ErrorString("length of symbol section is not a multiple of Sym64Size") | |
| } | |
| // The first entry is all zeros. | |
| var skip [Sym64Size]byte; | |
| symtab.Read(skip[0:len(skip)]); | |
| symbols := make([]Symbol, symtab.Len()/Sym64Size); | |
| i := 0; | |
| var sym Sym64; | |
| for symtab.Len() > 0 { | |
| binary.Read(symtab, f.ByteOrder, &sym); | |
| symbols[i].Name = sym.Name; | |
| symbols[i].Info = sym.Info; | |
| symbols[i].Other = sym.Other; | |
| symbols[i].Section = uint32(sym.Shndx); | |
| symbols[i].Value = sym.Value; | |
| symbols[i].Size = sym.Size; | |
| i++; | |
| } | |
| return symbols, 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) os.Error { | |
| if f.Class == ELFCLASS64 && f.Machine == EM_X86_64 { | |
| return f.applyRelocationsAMD64(dst, rels) | |
| } | |
| return os.ErrorString("not implemented"); | |
| } | |
| func (f *File) applyRelocationsAMD64(dst []byte, rels []byte) os.Error { | |
| if len(rels)%Sym64Size != 0 { | |
| return os.ErrorString("length of relocation section is not a multiple of Sym64Size") | |
| } | |
| symbols, err := f.getSymbols(); | |
| 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, os.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); | |
| } |