symbol.hpp

Go to the documentation of this file.

// Copyright (c) 2022, _xeroxz
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
//    this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its
//    contributors may be used to endorse or promote products derived from
//    this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
 
#pragma once
#include <coff/image.hpp>
#include <cstdint>
#include <recomp/reloc.hpp>
#include <string>
#include <vector>
 
namespace theo::decomp {
enum sym_type_t { function, instruction, data, section };
 
class symbol_t {
 public:
  explicit symbol_t(coff::image_t* img,
                    std::string name,
                    std::uintptr_t offset,
                    std::vector<std::uint8_t> data,
                    coff::section_header_t* scn = {},
                    coff::symbol_t* sym = {},
                    std::vector<recomp::reloc_t> relocs = {},
                    sym_type_t dcmp_type = {});
 
  std::string name() const;
 
  std::uintptr_t offset() const;
 
  std::uintptr_t allocated_at() const;
 
  std::uint32_t size() const;
 
  coff::section_header_t* scn() const;
 
  coff::image_t* img() const;
 
  std::vector<std::uint8_t>& data();
 
  coff::symbol_t* sym() const;
 
  sym_type_t type() const;
 
  std::vector<recomp::reloc_t>& relocs();
 
  void allocated_at(std::uintptr_t allocated_at);
 
  std::size_t hash();
 
  static std::size_t hash(const std::string& sym);
 
  static std::string name(const coff::image_t* img, coff::symbol_t* sym);
 
 private:
  std::string m_name;
  std::uintptr_t m_offset, m_allocated_at;
  std::vector<std::uint8_t> m_data;
  coff::section_header_t* m_scn;
  std::vector<recomp::reloc_t> m_relocs;
  sym_type_t m_sym_type;
  coff::symbol_t* m_sym;
  coff::image_t* m_img;
};
}  // namespace theo::decomp