COFF/Symbol.hpp

Go to the documentation of this file.

/* Copyright 2017 - 2026 R. Thomas
 * Copyright 2017 - 2026 Quarkslab
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef LIEF_COFF_SYMBOL_H
#define LIEF_COFF_SYMBOL_H
 
#include "LIEF/Abstract/Symbol.hpp"
#include "LIEF/visibility.h"
#include "LIEF/iterators.hpp"
 
#include <memory>
#include <vector>
 
namespace LIEF {
class BinaryStream;
namespace COFF {
class Parser;
class AuxiliarySymbol;
class String;
class Section;

class LIEF_API Symbol : public LIEF::Symbol {
  public:
  friend class Parser;
 
  using auxiliary_symbols_t = std::vector<std::unique_ptr<AuxiliarySymbol>>;
  using it_auxiliary_symbols_t =
      ref_iterator<auxiliary_symbols_t&, AuxiliarySymbol*>;
  using it_const_auxiliary_symbols_t =
      const_ref_iterator<const auxiliary_symbols_t&, AuxiliarySymbol*>;
 
  struct parsing_context_t {
    std::function<String*(uint32_t)> find_string;
    bool is_bigobj;
  };
  static std::unique_ptr<Symbol> parse(parsing_context_t& ctx,
                                       BinaryStream& stream, size_t* idx);
 
  Symbol();
  Symbol(const Symbol&);
  Symbol& operator=(const Symbol&);
 
  Symbol(Symbol&&);
  Symbol& operator=(Symbol&&);

  static constexpr auto SYM_SEC_IDX_DEBUG = -2;

  static constexpr auto SYM_SEC_IDX_ABS = -1;

  static constexpr auto SYM_SEC_IDX_UNDEF = 0;
 
  static constexpr auto SYM_COMPLEX_TYPE_SHIFT = 4;

  enum class STORAGE_CLASS : int32_t {
    INVALID = 0xFF,
 
    END_OF_FUNCTION = -1,  
    NONE = 0,              
    AUTOMATIC = 1,         
    EXTERNAL = 2,          
    STATIC = 3,            
    REGISTER = 4,          
    EXTERNAL_DEF = 5,      
    LABEL = 6,             
    UNDEFINED_LABEL = 7,   
    MEMBER_OF_STRUCT = 8,  
    ARGUMENT = 9,          
    STRUCT_TAG = 10,       
    MEMBER_OF_UNION = 11,  
    UNION_TAG = 12,        
    TYPE_DEFINITION = 13,  
    UNDEFINED_STATIC = 14, 
    ENUM_TAG = 15,         
    MEMBER_OF_ENUM = 16,   
    REGISTER_PARAM = 17,   
    BIT_FIELD = 18,        
    BLOCK = 100,
    FUNCTION = 101,
    END_OF_STRUCT = 102, 
    FILE = 103,          
    SECTION = 104,
    WEAK_EXTERNAL = 105, 
    CLR_TOKEN = 107,
  };
 
  enum class BASE_TYPE : uint32_t {
    TY_NULL = 0,   
    TY_VOID = 1,   
    TY_CHAR = 2,   
    TY_SHORT = 3,  
    TY_INT = 4,    
    TY_LONG = 5,   
    TY_FLOAT = 6,  
    TY_DOUBLE = 7, 
    TY_STRUCT = 8, 
    TY_UNION = 9,  
    TY_ENUM = 10,  
    TY_MOE = 11,   
    TY_BYTE = 12,  
    TY_WORD = 13,  
    TY_UINT = 14,  
    TY_DWORD = 15, 
  };
 
  enum class COMPLEX_TYPE : uint32_t {
    TY_NULL = 0,     
    TY_POINTER = 1,  
    TY_FUNCTION = 2, 
    TY_ARRAY = 3,    
  };

  static constexpr bool is_reversed_sec_idx(int16_t idx) {
    return idx <= 0;
  }

  uint16_t type() const {
    return type_;
  }

  STORAGE_CLASS storage_class() const {
    return (STORAGE_CLASS)storage_class_;
  }

  BASE_TYPE base_type() const {
    return (BASE_TYPE)(type_ & 0x0F);
  }

  COMPLEX_TYPE complex_type() const {
    return (COMPLEX_TYPE)((type_ & 0xF0) >> SYM_COMPLEX_TYPE_SHIFT);
  }

  int16_t section_idx() const {
    return section_idx_;
  }

  Section* section() {
    return section_;
  }
 
  const Section* section() const {
    return section_;
  }
 
  bool is_external() const {
    return storage_class() == STORAGE_CLASS::EXTERNAL;
  }
 
  bool is_weak_external() const {
    return storage_class() == STORAGE_CLASS::WEAK_EXTERNAL;
  }
 
  bool is_absolute() const {
    return section_idx() == SYM_SEC_IDX_ABS;
  }
 
  bool is_undefined() const {
    return is_external() && section_idx() == SYM_SEC_IDX_UNDEF && value() == 0;
  }
 
  bool is_function_line_info() const {
    return storage_class() == STORAGE_CLASS::FUNCTION;
  }
 
  bool is_function() const {
    return complex_type() == COMPLEX_TYPE::TY_FUNCTION;
  }
 
  bool is_file_record() const {
    return storage_class() == STORAGE_CLASS::FILE;
  }

  it_auxiliary_symbols_t auxiliary_symbols() {
    return auxiliary_symbols_;
  }
 
  it_const_auxiliary_symbols_t auxiliary_symbols() const {
    return auxiliary_symbols_;
  }

  const std::string& name() const override;
 
  std::string& name() override;

  const String* coff_name() const {
    return coff_name_;
  }
 
  String* coff_name() {
    return coff_name_;
  }

  std::string demangled_name() const;
 
  Symbol& type(uint16_t ty) {
    type_ = ty;
    return *this;
  }
 
  Symbol& storage_class(uint8_t value) {
    storage_class_ = value;
    return *this;
  }
 
  Symbol& section_idx(int16_t idx) {
    section_idx_ = idx;
    return *this;
  }

  AuxiliarySymbol& add_aux(std::unique_ptr<AuxiliarySymbol> sym);
 
  std::string to_string() const;
 
  LIEF_API friend std::ostream& operator<<(std::ostream& os, const Symbol& entry) {
    os << entry.to_string();
    return os;
  }
 
  ~Symbol() override;
 
  private:
  template<class T>
  static std::unique_ptr<Symbol> parse_impl(parsing_context_t& ctx,
                                            BinaryStream& stream, size_t* idx);
  String* coff_name_ = nullptr;
  uint16_t type_ = 0;
  uint8_t storage_class_ = 0;
  int16_t section_idx_ = 0;
  auxiliary_symbols_t auxiliary_symbols_;
  Section* section_ = nullptr;
};
 
LIEF_API const char* to_string(Symbol::STORAGE_CLASS e);
LIEF_API const char* to_string(Symbol::BASE_TYPE e);
LIEF_API const char* to_string(Symbol::COMPLEX_TYPE e);
 
}
}
#endif