RegisterSet.hxx

#pragma once
 
// C++
#include <iosfwd>
#include <variant>
 
// Linux
#include <sys/uio.h> // struct iov
 
// cosmos
#include <cosmos/error/RuntimeError.hxx>
#include <cosmos/error/UsageError.hxx>
#include <cosmos/io/iovector.hxx>
#include <cosmos/proc/ptrace.hxx>
#include <cosmos/types.hxx>
#include <cosmos/utils.hxx>
 
// clues
#include <clues/regs/traits.hxx>
#include <clues/sysnrs/fwd.hxx>
#include <clues/types.hxx>
 
namespace clues {


template <ABI abi>
class RegisterSet {
public: // types

        using ABIRegisterData = RegisterDataTraits<abi>::type;
        static constexpr auto ABI = abi;
        using register_t = ABIRegisterData::register_t;
 
public: // functions
 
        explicit RegisterSet(const cosmos::no_init_t &) {
        }
 
        RegisterSet() {
                m_regs.clear();
        }

        void fillIov(cosmos::InputMemoryRegion &iov) {
                // This makes sure the RegisterData wrapper is not bigger than
                // the expected amount of register data.
                static_assert(sizeof(m_regs) == sizeof(typename ABIRegisterData::register_t) * ABIRegisterData::NUM_REGS);
                iov.setBase(&m_regs);
                iov.setLength(sizeof(m_regs));
        }

        void iovFilled(const cosmos::InputMemoryRegion &iov) {
                if (iov.getLength() < sizeof(m_regs)) {
                        throw cosmos::RuntimeError{"received incomplete register set"};
                }
        }

        static constexpr cosmos::ptrace::RegisterType registerType() {
                return cosmos::ptrace::RegisterType::GENERAL_PURPOSE;
        }

        auto abiSyscallNr() const { return m_regs.syscallNr(); }

        SystemCallNr syscallNr() const {
                return to_generic(abiSyscallNr());
        }

        register_t syscallRes() const { return m_regs.syscallRes(); }


        register_t syscallParameter(const size_t number) const {
                auto pars = m_regs.syscallPars();
                if (number >= pars.size()) {
                        throw cosmos::UsageError{"invalid system call parameter nr."};
                }
 
                return pars[number];
        }

        auto& raw() const {
                return m_regs;
        }
 
protected: // data

        ABIRegisterData m_regs;
};

using AnyRegisterSet = std::variant<
        RegisterSet<ABI::I386>,
        RegisterSet<ABI::X86_64>,
        RegisterSet<ABI::X32>,
        RegisterSet<ABI::AARCH64>>;
 
} // end ns
 
template <clues::ABI abi>
CLUES_API std::ostream& operator<<(std::ostream &o, const clues::RegisterSet<abi> &rs);