source: soft/giet_vm/memo/src/libelfpp/elfpp_object.cc @ 333

/*
    This file is part of Libelfpp.

    Libelfpp is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as
    published by the Free Software Foundation, either version 3 of the
    License, or (at your option) any later version.

    Libelfpp is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with Libelfpp.  If not, see
    <http://www.gnu.org/licenses/>.

   Copyright (c) Alexandre Becoulet <alexandre.becoulet@free.fr>
*/


#include <stdexcept>
#include <cstring>

#include <dpp/foreach>
#include <dpp/interval_set>

#include <elfpp/object>
#include <elfpp/access>
#include <elfpp/section>
#include <elfpp/segment>
#include <elfpp/symbol>
#include <elfpp/reloc>

namespace elfpp
{

  ei_class_e object::get_word_width(e_machine_e machine)
  {
    switch (machine)
      {
      case EM_386:
        return ELFCLASS32;

      case EM_X86_64:
        return ELFCLASS64;

      default:
        throw std::runtime_error("unable to guess machine word width");
      }
  }

  ei_data_e object::get_byte_order(e_machine_e machine)
  {
    switch (machine)
      {
      case EM_SPARC:
        return ELFDATA2MSB;

      case EM_X86_64:
      case EM_386:
        return ELFDATA2LSB;

      default:
        throw std::runtime_error("unable to guess machine byte order");
      }
  }

  object::object(e_machine_e machine,
                 ei_class_e word_width,
                 ei_data_e byte_order)
    : section_tab_(),
      os_abi_(ELFOSABI_SYSV),
      type_(ET_REL),
      machine_(machine),
      generate_symtab_(true),
      entry_(0),
      flags_(0)
  {
    switch (machine)
      {
      case EM_X86_64:
      case EM_386:
        rel_with_addend_ = false;
        break;

      default:
        rel_with_addend_ = true;
        break;
      }

    if (byte_order == ELFDATANONE)
      byte_order = get_byte_order(machine);

    if (word_width == ELFCLASSNONE)
      word_width = get_word_width(machine);

    switch (word_width)
    {
        case ELFCLASS32: {
          static elf32_access a;
          access_ = static_cast<elf_access*>(&a);
          break;
        }

        case ELFCLASS64: {
          static elf64_access a;
          access_ = static_cast<elf_access*>(&a);
          break;
        }

        default:
          throw std::runtime_error("bad elf class");
        }


  }

  object::object()
    : section_tab_(),
      os_abi_(ELFOSABI_SYSV),
      type_(ET_REL),
      machine_(EM_NONE),
      generate_symtab_(true),
      entry_(0),
      flags_(0)
  {}

    

  void object::copy_info(object& obj, size_t word_width)
  {

        if(word_width == 32)
                this->word_width_  = ELFCLASS32;
        else if(word_width == 64)
            this->word_width_  =  ELFCLASS64;
        else
            this->word_width_  = obj.word_width_ ;

    this->byteorder_  = obj.byteorder_ ;
    this->machine_  = obj.machine_ ;
    this->os_abi_   = obj.os_abi_ ;
    this->abi_ver_  = obj.abi_ver_ ;
    this->type_     = obj.type_ ;
    this->flags_    = obj.flags_ ;

    switch (this->word_width_)
    {
        case ELFCLASS32: {
          static elf32_access a;
          access_ = static_cast<elf_access*>(&a);
          break;
        }

        case ELFCLASS64: {
          static elf64_access a;
          access_ = static_cast<elf_access*>(&a);
          break;
        }

        default:
          throw std::runtime_error("bad elf class");
        }

  }

  object::object(const std::string &filename)
    : generate_symtab_(false)
  {
    FILE *file = fopen(filename.c_str(), "rb");

    if (!file)
      throw std::runtime_error("unable to open file");

    unsigned char       e_ident[EI_NIDENT];     /* Magic number and other info */

    if (fread(e_ident, EI_NIDENT, 1, file) != 1)
      throw std::runtime_error("unable to read file");

    try {

      if (std::memcmp(e_ident, ELFMAG, 4))
        throw std::runtime_error("bad elf file header");

      switch (e_ident[EI_CLASS])
        {
        case ELFCLASS32: {
          static elf32_access a;
          access_ = static_cast<elf_access*>(&a);
          break;
        }

        case ELFCLASS64: {
          static elf64_access a;
          access_ = static_cast<elf_access*>(&a);
          break;
        }

        default:
          throw std::runtime_error("bad elf class");
        }

      access_->read(*this, file);

    } catch (...) {
      fclose(file);
      throw;
    }

    fclose(file);
  }

  object::~object()
  {
    FOREACH2(s, section_tab_)
      delete &*s;

    FOREACH(s, sym_tab_)
      delete s->second;
  }

    e_machine_e object::get_machine()
    {
        return machine_;
    }
    ei_class_e object::get_word_width()
    {
        return  word_width_;
    }
    ei_data_e object::get_byteorder()
    {
        return byteorder_;
    }

  section & object::get_section(const std::string &name)
  {
    FOREACH(s, section_tab_)
      if (s->get_name() == name)
        return *s;

    throw std::runtime_error("no such section");
  }

  void object::parse_symbol_table()
  {
    access_->load_symtab(*this);
    access_->load_reltab(*this);
  }

  void object::set_relative_relocs(symbol *sym)
  {
    // find mangled symbol for each relocation and set offset relative
    // to symbol value.
    FOREACH2(k, sym->get_reloc_table())
      {
        if (k->get_mangled_symbol())
          continue;

        if (sym->get_type() == STT_SECTION)
          {
            section *sS = sym->get_section();
            int64_t addend = k->get_addend();
            try {
              symbol &ss = sS->get_symbol(addend);
              k->set_symbol(&ss);
              k->set_addend(addend - ss.get_value());
            } catch (std::runtime_error &e) {
#if 0
              std::cerr << e.what() << " at " << sS->get_name() << ":" << std::hex << addend
                        << " while resolving section symbol addend at "
                        << k->get_section()->get_name() << ":" << k->get_offset() << " type " << k->get_type() << std::endl;
#endif
            }
          }

        try {
          symbol &msym = k->get_section()->get_symbol(k->get_offset());
          // std::cerr << *i->second << " " << msym << std::endl;
          k->set_mangled_symbol(&msym);
          k->set_offset(k->get_offset() - msym.get_value());

        } catch (std::runtime_error &e) {
#if 0
          if (strncmp(k->get_section()->get_name().c_str(), ".debug", 6))
            std::cerr << e.what() << " at " << k->get_section()->get_name() << ":" << std::hex << k->get_offset() << std::endl;
#endif
        }

      }
  }

  void object::create_orphan_symbols()
  {
    FOREACH(s, get_section_table())
      {
        if (!(s->get_flags() & SHF_ALLOC))
          continue;

        typedef dpp::interval_set<uint32_t> is_t;
        is_t is;

        is |= is_t::interval_type(s->get_size(), (uint32_t)-1);

        FOREACH(i, s->get_symbol_table())
          {
            uint32_t val = i->second->get_value();
            size_t size = i->second->get_size();

            if (size)
              is |= is_t::interval_type(val, val + size);
          }

        is = ~is;

        // create symbols for all orphan section areas in this object
        FOREACH(i, is)
          {
            static int nosym_id = 0;
            char name[32];
            sprintf(name, "nosym_%i", nosym_id++);
            symbol *sym = new symbol(name);

            sym->set_value(i->low_bound());
            sym->set_size(i->high_bound() - i->low_bound());
            sym->set_section(*s);
            s->add_symbol(*sym);
          }
      }
  }

  void object::load_symbol_data()
  {
    FOREACH(s, get_section_table())
      {
        if (s->get_type() == SHT_NOBITS)
          continue;

        FOREACH(i, s->get_symbol_table())
          {
            symbol *j = i->second;

            // copy section data in each symbol content buffer
            size_t size = j->get_size();

            if (size != 0 && j->get_value() + size <= s->get_size())
              j->set_content(s->get_content() + j->get_value());
          }
      }
  }

  void object::set_relative_relocs()
  {
    FOREACH(s, get_section_table())
      {
        FOREACH(i, s->get_symbol_table())
          set_relative_relocs(i->second);
      }

    FOREACH(i, get_symbol_table())
      set_relative_relocs(i->second);
  }

  void object::write(const std::string &filename)
  {
    FILE *file = fopen(filename.c_str(), "wb");

    if (!file)
      throw std::runtime_error("unable to open file");

    try {
      access_->write(*this, file);
    } catch (...) {
      fclose(file);
      throw;
    }

    fclose(file);
  }

  void object::add_section(section &sec)
  {
    section_tab_.push_back(sec);
  }

  void object::add_segment(segment &seg)
  {
    segment_tab_.push_back(seg);
  }

  void object::remove_section(section &sec)
  {
    sec.remove();
  }

  void object::add_symbol(symbol &sym)
  {
#if 0
    if (sym.get_section())
      sym.get_section()->add_symbol(sym);
    else
#endif
      sym_tab_.insert(sym_tab_map_t::value_type(sym.get_name(), &sym));
  }

  void object::remove_symbol(symbol &sym)
  {
    sym_tab_.erase(sym.get_name());
  }

}