Location.hpp

Go to the documentation of this file.

/* Copyright 2022 - 2026 R. Thomas
 *
 * 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_DWARF_LOCATION_H
#define LIEF_DWARF_LOCATION_H
 
#include <cstdint>
#include <memory>
#include <optional>
#include <ostream>
#include <string>
#include <utility>
#include <vector>
 
#include "LIEF/range.hpp"
#include "LIEF/visibility.h"
 
namespace LIEF::dwarf {

class LIEF_API Location {
  public:
  enum class Type : uint8_t {
    UNKNOWN = 0,
    REG,

    ADDRESS,

    FRAME_BASE,

    REGISTER_OFFSET,

    EXPRESSION,

    UNAVAILABLE,

    COMPOSITE,
  };
 
  explicit Location(Type ty) :
    type(ty) {}
 
  Location(const Location&) = default;
  Location& operator=(const Location&) = default;
 
  Location(Location&&) noexcept = default;
  Location& operator=(Location&&) noexcept = default;
 
  virtual ~Location();
 
  template<class T>
  const T* as() const LIEF_LIFETIMEBOUND {
    if (T::classof(this)) {
      return static_cast<const T*>(this);
    }
    return nullptr;
  }

  std::string to_string() const;
 
  friend std::ostream& operator<<(std::ostream& os, const Location& loc) {
    os << loc.to_string();
    return os;
  }
 
  Type type = Type::UNKNOWN;
};

class LIEF_API RegisterLoc : public Location {
  public:
  explicit RegisterLoc(uint64_t reg_id) :
    Location(Type::REG),
    id(reg_id) {}
 
  static bool classof(const Location* loc) {
    return loc->type == Type::REG;
  }
 
  ~RegisterLoc() override;

  uint64_t id = 0;
};

class LIEF_API AddressLoc : public Location {
  public:
  explicit AddressLoc(uint64_t value) :
    Location(Type::ADDRESS),
    address(value) {}
 
  static bool classof(const Location* loc) {
    return loc->type == Type::ADDRESS;
  }
 
  ~AddressLoc() override;

  uint64_t address = 0;
};

class LIEF_API FrameBaseLoc : public Location {
  public:
  explicit FrameBaseLoc(int64_t value) :
    Location(Type::FRAME_BASE),
    offset(value) {}
 
  static bool classof(const Location* loc) {
    return loc->type == Type::FRAME_BASE;
  }
 
  ~FrameBaseLoc() override;

  int64_t offset = 0;
};

class LIEF_API RegisterOffsetLoc : public Location {
  public:
  RegisterOffsetLoc(uint64_t reg_id, int64_t value) :
    Location(Type::REGISTER_OFFSET),
    id(reg_id),
    offset(value) {}
 
  static bool classof(const Location* loc) {
    return loc->type == Type::REGISTER_OFFSET;
  }
 
  ~RegisterOffsetLoc() override;

  uint64_t id = 0;

  int64_t offset = 0;
};

class LIEF_API ExpressionLoc : public Location {
  public:
  ExpressionLoc(std::vector<uint8_t> bytes, std::string text) :
    Location(Type::EXPRESSION),
    expression(std::move(bytes)),
    description(std::move(text)) {}
 
  static bool classof(const Location* loc) {
    return loc->type == Type::EXPRESSION;
  }
 
  ~ExpressionLoc() override;

  std::vector<uint8_t> expression;

  std::string description;
};

class LIEF_API UnavailableLoc : public Location {
  public:
  UnavailableLoc() :
    Location(Type::UNAVAILABLE) {}
 
  static bool classof(const Location* loc) {
    return loc->type == Type::UNAVAILABLE;
  }
 
  ~UnavailableLoc() override;
};

class LIEF_API CompositeLocation : public Location {
  public:
  struct LIEF_API Piece {
    enum class KIND : uint8_t {
      BYTE = 0, 
      BIT,      
    };

    KIND kind = KIND::BYTE;

    uint64_t bit_size = 0;

    uint64_t bit_offset = 0;

    std::optional<uint64_t> source_bit_offset;

    std::unique_ptr<Location> location;
  };
 
  CompositeLocation() :
    Location(Type::COMPOSITE) {}
 
  CompositeLocation(const CompositeLocation&) = delete;
  CompositeLocation& operator=(const CompositeLocation&) = delete;
 
  CompositeLocation(CompositeLocation&&) noexcept = default;
  CompositeLocation& operator=(CompositeLocation&&) noexcept = default;
 
  static bool classof(const Location* loc) {
    return loc->type == Type::COMPOSITE;
  }
 
  ~CompositeLocation() override;

  std::vector<Piece> pieces;
};

struct LIEF_API LocationEntry {
  std::optional<range_t> range;

  std::optional<uint64_t> section_index;

  std::unique_ptr<Location> location;

  std::string to_string() const;
 
  friend std::ostream& operator<<(std::ostream& os, const LocationEntry& entry) {
    os << entry.to_string();
    return os;
  }
};
 
}
 
#endif