theo::decomp::decomp_t Class Reference

the main decomposition class which is responsible for breaking down lib file into coff files, and extracted used symbols from the coff files. More...

#include <decomp.hpp>

Public Member Functions
	decomp_t (std::vector< std::uint8_t > &lib, recomp::symbol_table_t *syms)
	the explicit constructor for decomp_t More...
std::vector< routine_t >	rtns ()
	gets all of the routine objects. More...
std::vector< std::uint8_t >	lib ()
	gets a vector of bytes consisting of the lib file. More...
std::vector< std::vector< std::uint8_t > >	objs ()
	gets all the obj files as a vector of a vector of bytes. More...
recomp::symbol_table_t *	syms ()
	gets the symbol table. More...
std::map< coff::section_header_t *, std::size_t > &	scn_hash_tbl ()
	gets the section hash table section header --> hash of the section header ptr. More...
std::optional< recomp::symbol_table_t * >	decompose (std::string &entry_sym)
	decomposes (extracts) the symbols used. this function determines all used symbols given the entry point. More...

Detailed Description

the main decomposition class which is responsible for breaking down lib file into coff files, and extracted used symbols from the coff files.

Constructor & Destructor Documentation

decomp_t()

theo::decomp::decomp_t::decomp_t ( std::vector< std::uint8_t > &  lib, recomp::symbol_table_t *  syms  )

explicit

the explicit constructor for decomp_t

Parameters

lib	vector of bytes containing the lib file.
syms	symbol table that gets populated and managed by this class.

    : m_lib(lib), m_syms(syms) {}

Member Function Documentation

decompose()

std::optional< recomp::symbol_table_t * > theo::decomp::decomp_t::decompose

(

std::string &

entry_sym

)

decomposes (extracts) the symbols used. this function determines all used symbols given the entry point.

Parameters

entry_sym

the entry point symbol name.

Returns

returns an optional pointer to the symbol table. no value in the optional object on failure.

                          {
  // extract obj files from the archive file...
  //
  ar::view<false> lib(m_lib.data(), m_lib.size());
  std::for_each(
      lib.begin(), lib.end(),
      [&](std::pair<std::string_view, ar::entry_t&> itr) {
        // if the entry isnt the symbol table or the string table
        // then we know its an obj file...
        //
        if (!itr.second.is_symbol_table() && !itr.second.is_string_table()) {
          spdlog::info("extracted obj from archive: {}", itr.first);
          std::vector<std::uint8_t> data(itr.second.begin(), itr.second.end());
          m_objs.push_back(data);
        }
      });
 
  std::for_each(
      m_objs.begin(), m_objs.end(), [&](std::vector<std::uint8_t>& img_data) {
        auto img = reinterpret_cast<coff::image_t*>(img_data.data());
        for (auto idx = 0u; idx < img->file_header.num_symbols; ++idx) {
          auto sym = img->get_symbol(idx);
          if (sym->section_index - 1 > img->file_header.num_sections)
            continue;
 
          auto sym_name = symbol_t::name(img, sym);
          if (sym_name.length()) {
            auto sym_hash = symbol_t::hash(sym_name.data());
            auto sym_size =
                sym->has_section()
                    ? next_sym(img, img->get_section(sym->section_index - 1),
                               sym)
                    : 0u;
 
            m_lookup_tbl[sym_hash].emplace_back(img, sym, sym_size);
          }
        }
      });
 
  // extract used symbols from objs and create a nice little set of them so that
  // we can easily decompose them... no need deal with every single symbol...
  spdlog::info("extracted {} symbols being used...",
               ext_used_syms(entry_sym.data()));
 
  // generate symbols, populate section hash table, for each object file
  // extracted from the archive file...
  //
  std::for_each(m_used_syms.begin(), m_used_syms.end(), [&](sym_data_t data) {
    auto [img, sym, size] = data;
 
    // populate section hash table with sections for the img of this
    // symbol... only populate the hash table if its not been populated for
    // this obj before...
    //
    if (m_processed_objs.emplace(img).second) {
      for (auto idx = 0u; idx < img->file_header.num_sections; ++idx) {
        auto scn = img->get_section(idx);
        auto scn_sym_name =
            std::string(scn->name.to_string(img->get_strings()))
                .append("#")
                .append(std::to_string(idx))
                .append("!")
                .append(std::to_string(img->file_header.timedate_stamp));
 
        // hash the name of the section + the index + the timestamp of the
        // obj file it is in...
        //
        m_scn_hash_tbl.insert({scn, decomp::symbol_t::hash(scn_sym_name)});
      }
    }
 
    // if the symbol is a function then we are going to decompose it...
    // data symbols are handled after this...
    //
    if (sym->has_section()) {
      if (sym->derived_type == coff::derived_type_id::function) {
        auto scn = img->get_section(sym->section_index - 1);
        auto dcmp_type =
            scn->name.to_string(img->get_strings()) == INSTR_SPLIT_SECTION_NAME
                ? decomp::sym_type_t::instruction
                : decomp::sym_type_t::function;
 
        auto fn_size = next_sym(img, scn, sym);
        auto fn_bgn = scn->ptr_raw_data + reinterpret_cast<std::uint8_t*>(img) +
                      sym->value;
 
        std::vector<std::uint8_t> fn(fn_bgn, fn_bgn + fn_size);
        decomp::routine_t rtn(sym, img, scn, fn, dcmp_type);
 
        auto syms = rtn.decompose();
        m_syms->put_symbols(syms);
      } else if (sym->storage_class == coff::storage_class_id::public_symbol ||
                 sym->storage_class == coff::storage_class_id::private_symbol) {
        auto scn = img->get_section(sym->section_index - 1);
        auto scn_sym = m_syms->sym_from_hash(m_scn_hash_tbl[scn]);
 
        // if the section doesnt have a symbol then make one and put it into
        // the symbol table...
        //
        if (!scn_sym.has_value()) {
          auto scn_sym_name =
              std::string(scn->name.to_string(img->get_strings()))
                  .append("#")
                  .append(std::to_string(sym->section_index - 1))
                  .append("!")
                  .append(std::to_string(img->file_header.timedate_stamp));
 
          std::vector<std::uint8_t> scn_data(scn->size_raw_data);
          if (scn->characteristics.cnt_uninit_data) {
            scn_data.insert(scn_data.begin(), scn->size_raw_data, 0);
          } else {
            scn_data.insert(
                scn_data.begin(),
                reinterpret_cast<std::uint8_t*>(img) + scn->ptr_raw_data,
                reinterpret_cast<std::uint8_t*>(img) + scn->ptr_raw_data +
                    scn->size_raw_data);
          }
 
          std::vector<recomp::reloc_t> relocs;
          auto scn_relocs = reinterpret_cast<coff::reloc_t*>(
              scn->ptr_relocs + reinterpret_cast<std::uint8_t*>(img));
 
          for (auto idx = 0u; idx < scn->num_relocs; ++idx) {
            auto scn_reloc = &scn_relocs[idx];
            auto sym_reloc = img->get_symbol(scn_relocs[idx].symbol_index);
            auto sym_name = symbol_t::name(img, sym_reloc);
            auto sym_hash = decomp::symbol_t::hash(sym_name.data());
            relocs.push_back(
                recomp::reloc_t(scn_reloc->virtual_address - sym->value,
                                sym_hash, sym_name.data()));
          }
 
          decomp::symbol_t new_scn_sym(img, scn_sym_name, 0, scn_data, scn, {},
                                       relocs, sym_type_t::section);
 
          m_syms->put_symbol(new_scn_sym);
        }
 
        // create a symbol for the data...
        //
        decomp::symbol_t new_sym(img, symbol_t::name(img, sym).data(),
                                 sym->value, {}, scn, sym, {},
                                 sym_type_t::data);
 
        m_syms->put_symbol(new_sym);
      }
    } else if (sym->storage_class ==
               coff::storage_class_id::
                   external_definition) {  // else if the symbol has no
                                           // section... these symbols
                                           // require the linker to allocate
                                           // space for them...
 
      std::vector<std::uint8_t> data(sym->value, 0);
      decomp::symbol_t bss_sym(img, symbol_t::name(img, sym).data(), {}, data,
                               {}, sym, {}, sym_type_t::data);
 
      m_syms->put_symbol(bss_sym);
    }
  });
 
  // return the extract symbols to the caller...
  //
  return m_syms;
}

lib()

std::vector< std::uint8_t > theo::decomp::decomp_t::lib

(

)

gets a vector of bytes consisting of the lib file.

Returns

a vector of bytes consisting of the lib file.

                                    {
  return m_lib;
}

objs()

std::vector< std::vector< std::uint8_t > > theo::decomp::decomp_t::objs

(

)

gets all the obj files as a vector of a vector of bytes.

Returns

all the obj files as a vector of a vector of bytes.

                                                {
  return m_objs;
}

rtns()

std::vector< routine_t > theo::decomp::decomp_t::rtns

(

)

gets all of the routine objects.

Returns

vector of routine objects.

                                    {
  return m_rtns;
}

scn_hash_tbl()

std::map< coff::section_header_t *, std::size_t > & theo::decomp::decomp_t::scn_hash_tbl

(

)

gets the section hash table section header --> hash of the section header ptr.

Returns

the section hash table section header --> hash of the section header ptr.

                                                                 {
  return m_scn_hash_tbl;
}

syms()

recomp::symbol_table_t * theo::decomp::decomp_t::syms

(

)

gets the symbol table.

Returns

the symbol table.

                                     {
  return m_syms;
}

---

The documentation for this class was generated from the following files:

• include/decomp/decomp.hpp
• src/decomp/decomp.cpp