mirror of
https://github.com/mikage-emu/mikage-dev.git
synced 2025-01-08 14:30:59 +01:00
109 lines
2.9 KiB
C++
109 lines
2.9 KiB
C++
#pragma once
|
|
|
|
#include <cstdint>
|
|
#include <functional>
|
|
|
|
namespace HLE {
|
|
|
|
namespace OS {
|
|
|
|
// Type of a virtual address
|
|
// TODO: Make this a strong typedef
|
|
using VAddr = uint32_t;
|
|
|
|
// Type of a physical address
|
|
// TODO: Make this a strong typedef
|
|
using PAddr = uint32_t;
|
|
|
|
// TODO: Make this a strong typedef
|
|
using ProcessId = uint32_t;
|
|
|
|
// TODO: Make this a strong typedef
|
|
using ThreadId = uint32_t;
|
|
|
|
/**
|
|
* Type used to identify objects by a number internally
|
|
* This is needed so that the emulated CPU core can pass around object handles
|
|
* without actually storing objects in emulated memory.
|
|
*/
|
|
struct Handle {
|
|
uint32_t value;
|
|
|
|
bool operator < (const Handle& other) const {
|
|
return value < other.value;
|
|
}
|
|
|
|
bool operator == (const Handle& other) const {
|
|
return value == other.value;
|
|
}
|
|
|
|
bool operator != (const Handle& other) const {
|
|
return value != other.value;
|
|
}
|
|
};
|
|
|
|
const Handle HANDLE_INVALID = { 0 };
|
|
|
|
/**
|
|
* Extension to the Handle type that stores additional debug information about
|
|
* the handle. DebugHandle compares and hashes equal to the Handle it decays
|
|
* to, so when it's used as a key into associative containers, regular Handles
|
|
* are sufficient for lookup.
|
|
*/
|
|
struct DebugHandle : Handle {
|
|
enum Source {
|
|
Original, // The owning process created the underlying object
|
|
Duplicated, // The owning process duplicated an existing handle
|
|
FromIPC, // The owning process received the handle from another process via IPC
|
|
Raw, // Obtained from emulated application, hence no valid debug information is attached
|
|
};
|
|
|
|
struct DebugInfo {
|
|
uint64_t created_time_stamp = 0;
|
|
|
|
Source source = Raw;
|
|
|
|
/// Header of the IPC request due to which the handle was transmitted (only valid if source is FromIPC)
|
|
uint32_t ipc_command_header = 0;
|
|
|
|
// TODO: For Duplicated, store the original Handle value
|
|
} debug_info;
|
|
|
|
DebugHandle() = default;
|
|
|
|
DebugHandle(uint32_t value, DebugInfo debug_info) : Handle{value}, debug_info(debug_info) {}
|
|
|
|
/// Create a DebugHandle from a plain handle, omitting the initialization of any debug information
|
|
DebugHandle(const Handle& handle) : Handle(handle) {}
|
|
|
|
// bool operator == (const DebugHandle& other) const {
|
|
// return value == other.value;
|
|
// }
|
|
|
|
// bool operator == (const Handle& other) const {
|
|
// return value == other.value;
|
|
// }
|
|
|
|
// bool operator != (const Handle& other) const {
|
|
// return value != other.value;
|
|
// }
|
|
};
|
|
|
|
} // namespace OS
|
|
|
|
} // namespace HLE
|
|
|
|
namespace std {
|
|
template<>
|
|
struct hash<HLE::OS::Handle> {
|
|
auto operator()(const HLE::OS::Handle& handle) const {
|
|
return std::hash<decltype(handle.value)>{}(handle.value);
|
|
}
|
|
};
|
|
template<>
|
|
struct hash<HLE::OS::DebugHandle> {
|
|
auto operator()(const HLE::OS::DebugHandle& handle) const {
|
|
return std::hash<HLE::OS::Handle>{}(handle);
|
|
}
|
|
};
|
|
} // namespace std
|