CorePrStatus.hpp

Go to the documentation of this file.

/* Copyright 2017 - 2024 R. Thomas
 * Copyright 2017 - 2024 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_ELF_CORE_PRSTATUS_H
#define LIEF_ELF_CORE_PRSTATUS_H
 
#include <vector>
#include <ostream>
#include <utility>
 
#include "LIEF/visibility.h"
#include "LIEF/ELF/enums.hpp"
#include "LIEF/ELF/Note.hpp"
 
namespace LIEF {
namespace ELF {
 
class Parser;
class Builder;
class Binary;
 
class LIEF_API CorePrStatus : public Note {
  public:
  struct siginfo_t {
    int32_t signo = 0;
    int32_t code = 0;
    int32_t err = 0;
  };
 
  struct timeval_t {
    uint64_t sec = 0;
    uint64_t usec = 0;
  };
 
  struct pr_status_t {
    siginfo_t info;
 
    uint16_t cursig = 0;
    uint16_t reserved = 0;
 
    uint64_t sigpend = 0;
    uint64_t sighold = 0;
 
    int32_t  pid = 0;
    int32_t  ppid = 0;
    int32_t  pgrp = 0;
    int32_t  sid = 0;
 
    timeval_t utime;
    timeval_t stime;
    timeval_t cutime;
    timeval_t cstime;
  };
 
  struct Registers {
    enum class X86 {
      EBX = 0, ECX, EDX, ESI, EDI, EBP, EAX,
      DS, ES, FS, GS, ORIG_EAX, EIP, CS, EFLAGS, ESP, SS,
      _COUNT
    };
 
    enum class X86_64 {
      R15 = 0, R14, R13, R12, RBP, RBX, R11, R10,
      R9, R8, RAX, RCX, RDX, RSI, RDI, ORIG_RAX,
      RIP, CS, EFLAGS, RSP, SS,
      _COUNT
    };
 
    enum class ARM {
      R0 = 0, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15,
      CPSR,
      _COUNT
    };
 
    enum class AARCH64 {
      X0 = 0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15,
      X16, X17, X18, X19, X20, X21, X22, X23, X24, X25, X26, X27, X28, X29, X30,
      X31, PC, PSTATE,
      _COUNT
    };
  };
 
  public:
  CorePrStatus(ARCH arch, Header::CLASS cls, std::string name,
               uint32_t type, description_t description) :
    Note(std::move(name), TYPE::CORE_PRSTATUS, type, std::move(description), ""),
    arch_(arch), class_(cls)
  {}
 
  std::unique_ptr<Note> clone() const override {
    return std::unique_ptr<CorePrStatus>(new CorePrStatus(*this));
  }
 
  pr_status_t status() const;
  void status(const pr_status_t& status);
 
  ARCH architecture() const {
    return arch_;
  }
 
  result<uint64_t> pc() const;
 
  result<uint64_t> sp() const;
 
  result<uint64_t> return_value() const;
 
  result<uint64_t> get(Registers::X86 reg) const;
  result<uint64_t> get(Registers::X86_64 reg) const;
  result<uint64_t> get(Registers::ARM reg) const;
  result<uint64_t> get(Registers::AARCH64 reg) const;
 
  ok_error_t set(Registers::X86 reg, uint64_t value);
  ok_error_t set(Registers::X86_64 reg, uint64_t value);
  ok_error_t set(Registers::ARM reg, uint64_t value);
  ok_error_t set(Registers::AARCH64 reg, uint64_t value);
 
  std::vector<uint64_t> register_values() const;
 
  result<uint64_t> operator[](Registers::X86 reg) const {
    return get(reg);
  }
 
  result<uint64_t> operator[](Registers::X86_64 reg) const {
    return get(reg);
  }
 
  result<uint64_t> operator[](Registers::ARM reg) const {
    return get(reg);
  }
 
  result<uint64_t> operator[](Registers::AARCH64 reg) const {
    return get(reg);
  }
 
  void dump(std::ostream& os) const override;
  void accept(Visitor& visitor) const override;
 
  static bool classof(const Note* note) {
    return note->type() == Note::TYPE::CORE_PRSTATUS;
  }
 
  ~CorePrStatus() override = default;
 
  LIEF_API friend
  std::ostream& operator<<(std::ostream& os, const CorePrStatus& note) {
    note.dump(os);
    return os;
  }
 
  private:
  ARCH arch_ = ARCH::NONE;
  Header::CLASS class_ = Header::CLASS::NONE;
};
 
LIEF_API const char* to_string(CorePrStatus::Registers::X86 e);
LIEF_API const char* to_string(CorePrStatus::Registers::X86_64 e);
LIEF_API const char* to_string(CorePrStatus::Registers::ARM e);
LIEF_API const char* to_string(CorePrStatus::Registers::AARCH64 e);
 
} // namepsace ELF
} // namespace LIEF
 
#endif