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.

Definition at line 61 of file decomp.hpp.

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.

Definition at line 34 of file decomp.cpp.

35 : 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.

Definition at line 37 of file decomp.cpp.

                          {
  // 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;
}

References lib().

Referenced by theo::theo_t::decompose().

◆ 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.

Definition at line 285 of file decomp.cpp.

                                    {
  return m_lib;
}

Referenced by decompose().

◆ 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.

Definition at line 289 of file decomp.cpp.

                                                {
  return m_objs;
}

◆ rtns()

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

gets all of the routine objects.

Returns: vector of routine objects.

Definition at line 281 of file decomp.cpp.

                                    {
  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.

Definition at line 297 of file decomp.cpp.

                                                                 {
  return m_scn_hash_tbl;
}

◆ syms()

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

gets the symbol table.

Returns: the symbol table.

Definition at line 293 of file decomp.cpp.

                                     {
  return m_syms;
}

Referenced by theo::recomp::recomp_t::allocate().

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

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

Public Member Functions