gaming/rpcs3
gaming/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3 synced 2024-07-21 10:06:10 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Add usz alias for std::size_t

Browse source
This commit is contained in:
Nekotekina 2020-12-18 10:39:54 +03:00
parent 360c4d1554
commit fb29933d3d
173 changed files with 718 additions and 717 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Utilities/CPUStats.h
View file

@ -176,7 +176,7 @@ public:
};
u_int miblen = std::size(mib);
struct kinfo_proc info;
size_t size = sizeof(info);
usz size = sizeof(info);
if (sysctl(mib, miblen, &info, &size, NULL, 0))
{
return 0;
@ -194,7 +194,7 @@ public:
u_int miblen = std::size(mib);
// get number of structs
size_t size;
usz size;
if (sysctl(mib, miblen, NULL, &size, NULL, 0))
{
return 0;

20
Utilities/File.cpp
View file

@ -20,7 +20,7 @@ using namespace std::literals::string_literals;
static std::unique_ptr<wchar_t[]> to_wchar(const std::string& source)
{
// String size + null terminator
const std::size_t buf_size = source.size() + 1;
const usz buf_size = source.size() + 1;
// Safe size
const int size = narrow<int>(buf_size);
@ -51,7 +51,7 @@ static std::unique_ptr<wchar_t[]> to_wchar(const std::string& source)
static void to_utf8(std::string& out, const wchar_t* source)
{
// String size
const std::size_t length = std::wcslen(source);
const usz length = std::wcslen(source);
// Safe buffer size for max possible output length (including null terminator)
const int buf_size = narrow<int>(length * 3 + 1);
@ -181,7 +181,7 @@ static std::string path_append(std::string_view path, std::string_view more)
{
std::string result;
if (const size_t src_slash_pos = path.find_last_not_of('/'); src_slash_pos != path.npos)
if (const usz src_slash_pos = path.find_last_not_of('/'); src_slash_pos != path.npos)
{
path.remove_suffix(path.length() - src_slash_pos - 1);
result = path;
@ -189,7 +189,7 @@ static std::string path_append(std::string_view path, std::string_view more)
result.push_back('/');
if (const size_t dst_slash_pos = more.find_first_not_of('/'); dst_slash_pos != more.npos)
if (const usz dst_slash_pos = more.find_first_not_of('/'); dst_slash_pos != more.npos)
{
more.remove_prefix(dst_slash_pos);
result.append(more);
@ -505,7 +505,7 @@ bool fs::statfs(const std::string& path, fs::device_stat& info)
// Keep cutting path from right until it's short enough
while (str.size() > 256)
{
if (std::size_t x = str.find_last_of('\\') + 1)
if (usz x = str.find_last_of('\\') + 1)
str.resize(x - 1);
else
break;
@ -1240,7 +1240,7 @@ fs::file::file(const std::string& path, bs_t<open_mode> mode)
#endif
}
fs::file::file(const void* ptr, std::size_t size)
fs::file::file(const void* ptr, usz size)
{
class memory_stream : public file_base
{
@ -1355,7 +1355,7 @@ bool fs::dir::open(const std::string& path)
class windows_dir final : public dir_base
{
std::vector<dir_entry> m_entries;
std::size_t m_pos = 0;
usz m_pos = 0;
void add_entry(const WIN32_FIND_DATAW& found)
{
@ -1605,13 +1605,13 @@ std::string fs::escape_path(std::string_view path)
{
std::string real; real.resize(path.size());
auto get_char = [&](std::size_t& from, std::size_t& to, std::size_t count)
auto get_char = [&](usz& from, usz& to, usz count)
{
std::memcpy(&real[to], &path[from], count);
from += count, to += count;
};
std::size_t i = 0, j = -1, pos_nondelim = 0, after_delim = 0;
usz i = 0, j = -1, pos_nondelim = 0, after_delim = 0;
if (i < path.size())
{
@ -1648,7 +1648,7 @@ std::string fs::escape_path(std::string_view path)
case '.':
{
bool remove_element = true;
std::size_t k = 1;
usz k = 1;
for (; k + i != path.size(); k++)
{

8
Utilities/File.h
View file

@ -73,7 +73,7 @@ namespace fs
struct iovec_clone
{
const void* iov_base;
std::size_t iov_len;
usz iov_len;
};
// File handle base
@ -200,7 +200,7 @@ namespace fs
explicit file(const std::string& path, bs_t<open_mode> mode = ::fs::read);
// Open memory for read
explicit file(const void* ptr, std::size_t size);
explicit file(const void* ptr, usz size);
// Open file with specified args (forward to constructor)
template <typename... Args>
@ -370,7 +370,7 @@ namespace fs
// Read std::basic_string
template <typename T>
std::enable_if_t<std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>, bool> read(std::basic_string<T>& str, std::size_t size,
std::enable_if_t<std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>, bool> read(std::basic_string<T>& str, usz size,
const char* file = __builtin_FILE(),
const char* func = __builtin_FUNCTION(),
u32 line = __builtin_LINE(),
@ -405,7 +405,7 @@ namespace fs
// Read POD std::vector
template <typename T>
std::enable_if_t<std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>, bool> read(std::vector<T>& vec, std::size_t size,
std::enable_if_t<std::is_trivially_copyable_v<T> && !std::is_pointer_v<T>, bool> read(std::vector<T>& vec, usz size,
const char* file = __builtin_FILE(),
const char* func = __builtin_FUNCTION(),
u32 line = __builtin_LINE(),

16
Utilities/JIT.cpp
View file

@ -36,7 +36,7 @@ static atomic_t<u64> s_code_pos{0}, s_data_pos{0};
static std::vector<u8> s_code_init, s_data_init;
template <atomic_t<u64>& Ctr, uint Off, utils::protection Prot>
static u8* add_jit_memory(std::size_t size, uint align)
static u8* add_jit_memory(usz size, uint align)
{
// Select subrange
u8* pointer = get_jit_memory() + Off;
@ -112,7 +112,7 @@ jit_runtime::~jit_runtime()
asmjit::Error jit_runtime::_add(void** dst, asmjit::CodeHolder* code) noexcept
{
std::size_t codeSize = code->getCodeSize();
usz codeSize = code->getCodeSize();
if (!codeSize) [[unlikely]]
{
*dst = nullptr;
@ -126,7 +126,7 @@ asmjit::Error jit_runtime::_add(void** dst, asmjit::CodeHolder* code) noexcept
return asmjit::kErrorNoVirtualMemory;
}
std::size_t relocSize = code->relocate(p);
usz relocSize = code->relocate(p);
if (!relocSize) [[unlikely]]
{
*dst = nullptr;
@ -144,7 +144,7 @@ asmjit::Error jit_runtime::_release(void* ptr) noexcept
return asmjit::kErrorOk;
}
u8* jit_runtime::alloc(std::size_t size, uint align, bool exec) noexcept
u8* jit_runtime::alloc(usz size, uint align, bool exec) noexcept
{
if (exec)
{
@ -216,7 +216,7 @@ asmjit::Runtime& asmjit::get_global_runtime()
asmjit::Error _add(void** dst, asmjit::CodeHolder* code) noexcept override
{
std::size_t codeSize = code->getCodeSize();
usz codeSize = code->getCodeSize();
if (!codeSize) [[unlikely]]
{
*dst = nullptr;
@ -230,7 +230,7 @@ asmjit::Runtime& asmjit::get_global_runtime()
return asmjit::kErrorNoVirtualMemory;
}
std::size_t relocSize = code->relocate(p);
usz relocSize = code->relocate(p);
if (!relocSize) [[unlikely]]
{
*dst = nullptr;
@ -389,7 +389,7 @@ struct MemoryManager1 : llvm::RTDyldMemoryManager
return false;
}
void registerEHFrames(u8* addr, u64 load_addr, std::size_t size) override
void registerEHFrames(u8* addr, u64 load_addr, usz size) override
{
}
@ -422,7 +422,7 @@ struct MemoryManager2 : llvm::RTDyldMemoryManager
return false;
}
void registerEHFrames(u8* addr, u64 load_addr, std::size_t size) override
void registerEHFrames(u8* addr, u64 load_addr, usz size) override
{
}

2
Utilities/JIT.h
View file

@ -41,7 +41,7 @@ struct jit_runtime final : asmjit::HostRuntime
asmjit::Error _release(void* p) noexcept override;
// Allocate memory
static u8* alloc(std::size_t size, uint align, bool exec = true) noexcept;
static u8* alloc(usz size, uint align, bool exec = true) noexcept;
// Should be called at least once after global initialization
static void initialize();

42
Utilities/StrFmt.cpp
View file

@ -79,14 +79,14 @@ void fmt_class_string<fmt::base57>::format(std::string& out, u64 arg)
static constexpr u8 s_tail[8] = {0, 2, 3, 5, 6, 7, 9, 10};
// Get full output size
const std::size_t out_size = _arg.size / 8 * 11 + s_tail[_arg.size % 8];
const usz out_size = _arg.size / 8 * 11 + s_tail[_arg.size % 8];
out.resize(out.size() + out_size);
const auto ptr = &out.front() + (out.size() - out_size);
// Each 8 bytes of input data produce 11 bytes of base57 output
for (std::size_t i = 0, p = 0; i < _arg.size; i += 8, p += 11)
for (usz i = 0, p = 0; i < _arg.size; i += 8, p += 11)
{
// Load up to 8 bytes
be_t<u64> be_value;
@ -321,7 +321,7 @@ struct fmt::cfmt_src
const fmt_type_info* sup;
const u64* args;
bool test(std::size_t index) const
bool test(usz index) const
{
if (!sup[index].fmt_string)
{
@ -332,26 +332,26 @@ struct fmt::cfmt_src
}
template <typename T>
T get(std::size_t index) const
T get(usz index) const
{
return *reinterpret_cast<const T*>(reinterpret_cast<const u8*>(args + index));
}
void skip(std::size_t extra)
void skip(usz extra)
{
sup += extra + 1;
args += extra + 1;
}
std::size_t fmt_string(std::string& out, std::size_t extra) const
usz fmt_string(std::string& out, usz extra) const
{
const std::size_t start = out.size();
const usz start = out.size();
sup[extra].fmt_string(out, args[extra]);
return out.size() - start;
}
// Returns type size (0 if unknown, pointer, unsigned, assumed max)
std::size_t type(std::size_t extra) const
usz type(usz extra) const
{
// Hack: use known function pointers to determine type
#define TYPE(type) \
@ -369,14 +369,14 @@ struct fmt::cfmt_src
return 0;
}
static constexpr std::size_t size_char = 1;
static constexpr std::size_t size_short = 2;
static constexpr std::size_t size_int = 0;
static constexpr std::size_t size_long = sizeof(ulong);
static constexpr std::size_t size_llong = sizeof(ullong);
static constexpr std::size_t size_size = sizeof(std::size_t);
static constexpr std::size_t size_max = sizeof(std::uintmax_t);
static constexpr std::size_t size_diff = sizeof(std::ptrdiff_t);
static constexpr usz size_char = 1;
static constexpr usz size_short = 2;
static constexpr usz size_int = 0;
static constexpr usz size_long = sizeof(ulong);
static constexpr usz size_llong = sizeof(ullong);
static constexpr usz size_size = sizeof(usz);
static constexpr usz size_max = sizeof(std::uintmax_t);
static constexpr usz size_diff = sizeof(std::ptrdiff_t);
};
void fmt::raw_append(std::string& out, const char* fmt, const fmt_type_info* sup, const u64* args) noexcept
@ -412,9 +412,9 @@ std::vector<std::string> fmt::split(const std::string& source, std::initializer_
{
std::vector<std::string> result;
size_t cursor_begin = 0;
usz cursor_begin = 0;
for (size_t cursor_end = 0; cursor_end < source.length(); ++cursor_end)
for (usz cursor_end = 0; cursor_end < source.length(); ++cursor_end)
{
for (auto& separator : separators)
{
@ -441,7 +441,7 @@ std::vector<std::string> fmt::split(const std::string& source, std::initializer_
std::string fmt::trim(const std::string& source, const std::string& values)
{
std::size_t begin = source.find_first_not_of(values);
usz begin = source.find_first_not_of(values);
if (begin == source.npos)
return {};
@ -467,7 +467,7 @@ std::string fmt::to_lower(const std::string& string)
bool fmt::match(const std::string& source, const std::string& mask)
{
std::size_t source_position = 0, mask_position = 0;
usz source_position = 0, mask_position = 0;
for (; source_position < source.size() && mask_position < mask.size(); ++mask_position, ++source_position)
{
@ -476,7 +476,7 @@ bool fmt::match(const std::string& source, const std::string& mask)
case '?': break;
case '*':
for (std::size_t test_source_position = source_position; test_source_position < source.size(); ++test_source_position)
for (usz test_source_position = source_position; test_source_position < source.size(); ++test_source_position)
{
if (match(source.substr(test_source_position), mask.substr(mask_position + 1)))
{

18
Utilities/StrFmt.h
View file

@ -6,7 +6,7 @@
namespace fmt
{
template <typename CharT, std::size_t N, typename... Args>
template <typename CharT, usz N, typename... Args>
static std::string format(const CharT(&)[N], const Args&...);
}
@ -97,7 +97,7 @@ struct fmt_unveil<T*, void>
}
};
template <typename T, std::size_t N>
template <typename T, usz N>
struct fmt_unveil<T[N], void>
{
using type = std::add_const_t<T>*;
@ -119,7 +119,7 @@ struct fmt_unveil<b8, void>
}
};
template <typename T, bool Se, std::size_t Align>
template <typename T, bool Se, usz Align>
struct fmt_unveil<se_t<T, Se, Align>, void>
{
using type = typename fmt_unveil<T>::type;
@ -251,7 +251,7 @@ namespace fmt
struct base57
{
const uchar* data;
std::size_t size;
usz size;
template <typename T>
base57(const T& arg)
@ -260,7 +260,7 @@ namespace fmt
{
}
base57(const uchar* data, std::size_t size)
base57(const uchar* data, usz size)
: data(data)
, size(size)
{
@ -283,7 +283,7 @@ namespace fmt
void raw_append(std::string& out, const char*, const fmt_type_info*, const u64*) noexcept;
// Formatting function
template <typename CharT, std::size_t N, typename... Args>
template <typename CharT, usz N, typename... Args>
SAFE_BUFFERS FORCE_INLINE void append(std::string& out, const CharT(&fmt)[N], const Args&... args)
{
static constexpr fmt_type_info type_list[sizeof...(Args) + 1]{fmt_type_info::make<fmt_unveil_t<Args>>()...};
@ -291,7 +291,7 @@ namespace fmt
}
// Formatting function
template <typename CharT, std::size_t N, typename... Args>
template <typename CharT, usz N, typename... Args>
SAFE_BUFFERS FORCE_INLINE std::string format(const CharT(&fmt)[N], const Args&... args)
{
std::string result;
@ -303,7 +303,7 @@ namespace fmt
[[noreturn]] void raw_throw_exception(const src_loc&, const char*, const fmt_type_info*, const u64*);
// Throw exception with formatting
template <typename CharT, std::size_t N, typename... Args>
template <typename CharT, usz N, typename... Args>
struct throw_exception
{
[[noreturn]] SAFE_BUFFERS FORCE_INLINE throw_exception(const CharT(&fmt)[N], const Args&... args,
@ -317,6 +317,6 @@ namespace fmt
}
};
template <typename CharT, std::size_t N, typename... Args>
template <typename CharT, usz N, typename... Args>
throw_exception(const CharT(&)[N], const Args&...) -> throw_exception<CharT, N, Args...>;
}

18
Utilities/StrUtil.h
View file

@ -17,7 +17,7 @@ std::string utf8_path_to_ansi_path(const std::string& src);
template <typename D, typename T>
inline void strcpy_trunc(D& dst, const T& src)
{
const std::size_t count = std::size(src) >= std::size(dst) ? std::size(dst) - 1 : std::size(src);
const usz count = std::size(src) >= std::size(dst) ? std::size(dst) - 1 : std::size(src);
std::memcpy(std::data(dst), std::data(src), count);
std::memset(std::data(dst) + count, 0, std::size(dst) - count);
}
@ -27,14 +27,14 @@ namespace fmt
std::string replace_first(const std::string& src, const std::string& from, const std::string& to);
std::string replace_all(const std::string& src, const std::string& from, const std::string& to);
template <size_t list_size>
template <usz list_size>
std::string replace_all(std::string src, const std::pair<std::string, std::string> (&list)[list_size])
{
for (size_t pos = 0; pos < src.length(); ++pos)
for (usz pos = 0; pos < src.length(); ++pos)
{
for (size_t i = 0; i < list_size; ++i)
for (usz i = 0; i < list_size; ++i)
{
const size_t comp_length = list[i].first.length();
const usz comp_length = list[i].first.length();
if (src.length() - pos < comp_length)
continue;
@ -51,14 +51,14 @@ namespace fmt
return src;
}
template <size_t list_size>
template <usz list_size>
std::string replace_all(std::string src, const std::pair<std::string, std::function<std::string()>> (&list)[list_size])
{
for (size_t pos = 0; pos < src.length(); ++pos)
for (usz pos = 0; pos < src.length(); ++pos)
{
for (size_t i = 0; i < list_size; ++i)
for (usz i = 0; i < list_size; ++i)
{
const size_t comp_length = list[i].first.length();
const usz comp_length = list[i].first.length();
if (src.length() - pos < comp_length)
continue;

32
Utilities/Thread.cpp
View file

@ -118,7 +118,7 @@ bool IsDebuggerPresent()
};
u_int miblen = std::size(mib);
struct kinfo_proc info;
size_t size = sizeof(info);
usz size = sizeof(info);
if (sysctl(mib, miblen, &info, &size, NULL, 0))
{
@ -259,7 +259,7 @@ enum x64_op_t : u32
X64OP_SBB, // lock sbb [mem], ...
};
void decode_x64_reg_op(const u8* code, x64_op_t& out_op, x64_reg_t& out_reg, size_t& out_size, size_t& out_length)
void decode_x64_reg_op(const u8* code, x64_op_t& out_op, x64_reg_t& out_reg, usz& out_size, usz& out_length)
{
// simple analysis of x64 code allows to reinterpret MOV or other instructions in any desired way
out_length = 0;
@ -385,12 +385,12 @@ void decode_x64_reg_op(const u8* code, x64_op_t& out_op, x64_reg_t& out_reg, siz
return x64_reg_t{((*code & 0x38) >> 3) + X64R_AL};
};
auto get_op_size = [](const u8 rex, const bool oso) -> size_t
auto get_op_size = [](const u8 rex, const bool oso) -> usz
{
return rex & 8 ? 8 : (oso ? 2 : 4);
};
auto get_modRM_size = [](const u8* code) -> size_t
auto get_modRM_size = [](const u8* code) -> usz
{
switch (*code >> 6) // check Mod
{
@ -976,7 +976,7 @@ static const int reg_table[] =
#define RDI(c) (*X64REG((c), 7))
#define RIP(c) (*X64REG((c), 16))
bool get_x64_reg_value(x64_context* context, x64_reg_t reg, size_t d_size, size_t i_size, u64& out_value)
bool get_x64_reg_value(x64_context* context, x64_reg_t reg, usz d_size, usz i_size, u64& out_value)
{
// get x64 reg value (for store operations)
if (reg - X64R_RAX < 16)
@ -1067,7 +1067,7 @@ bool get_x64_reg_value(x64_context* context, x64_reg_t reg, size_t d_size, size_
return false;
}
bool put_x64_reg_value(x64_context* context, x64_reg_t reg, size_t d_size, u64 value)
bool put_x64_reg_value(x64_context* context, x64_reg_t reg, usz d_size, u64 value)
{
// save x64 reg value (for load operations)
if (reg - X64R_RAX < 16)
@ -1086,7 +1086,7 @@ bool put_x64_reg_value(x64_context* context, x64_reg_t reg, size_t d_size, u64 v
return false;
}
bool set_x64_cmp_flags(x64_context* context, size_t d_size, u64 x, u64 y, bool carry = true)
bool set_x64_cmp_flags(x64_context* context, usz d_size, u64 x, u64 y, bool carry = true)
{
switch (d_size)
{
@ -1162,7 +1162,7 @@ bool set_x64_cmp_flags(x64_context* context, size_t d_size, u64 x, u64 y, bool c
return true;
}
size_t get_x64_access_size(x64_context* context, x64_op_t op, x64_reg_t reg, size_t d_size, size_t i_size)
usz get_x64_access_size(x64_context* context, x64_op_t op, x64_reg_t reg, usz d_size, usz i_size)
{
if (op == X64OP_MOVS || op == X64OP_STOS)
{
@ -1227,8 +1227,8 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context) no
x64_op_t op;
x64_reg_t reg;
size_t d_size;
size_t i_size;
usz d_size;
usz i_size;
// decode single x64 instruction that causes memory access
decode_x64_reg_op(code, op, reg, d_size, i_size);
@ -1249,7 +1249,7 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context) no
}
// get length of data being accessed
size_t a_size = get_x64_access_size(context, op, reg, d_size, i_size);
usz a_size = get_x64_access_size(context, op, reg, d_size, i_size);
if (0x1'0000'0000ull - addr < a_size)
{
@ -1954,14 +1954,14 @@ void thread_base::set_name(std::string name)
#endif
#if defined(__APPLE__)
name.resize(std::min<std::size_t>(15, name.size()));
name.resize(std::min<usz>(15, name.size()));
pthread_setname_np(name.c_str());
#elif defined(__DragonFly__) || defined(__FreeBSD__) || defined(__OpenBSD__)
pthread_set_name_np(pthread_self(), name.c_str());
#elif defined(__NetBSD__)
pthread_setname_np(pthread_self(), "%s", name.data());
#elif !defined(_WIN32)
name.resize(std::min<std::size_t>(15, name.size()));
name.resize(std::min<usz>(15, name.size()));
pthread_setname_np(pthread_self(), name.c_str());
#endif
}
@ -2791,17 +2791,17 @@ u64 thread_ctrl::get_thread_affinity_mask()
#endif
}
std::pair<void*, std::size_t> thread_ctrl::get_thread_stack()
std::pair<void*, usz> thread_ctrl::get_thread_stack()
{
#ifdef _WIN32
ULONG_PTR _min = 0;
ULONG_PTR _max = 0;
GetCurrentThreadStackLimits(&_min, &_max);
const std::size_t ssize = _max - _min;
const usz ssize = _max - _min;
const auto saddr = reinterpret_cast<void*>(_min);
#else
void* saddr = 0;
std::size_t ssize = 0;
usz ssize = 0;
pthread_attr_t attr;
#ifdef __linux__
pthread_getattr_np(pthread_self(), &attr);

2
Utilities/Thread.h
View file

@ -262,7 +262,7 @@ public:
static u64 get_thread_affinity_mask();
// Get current thread stack addr and size
static std::pair<void*, std::size_t> get_thread_stack();
static std::pair<void*, usz> get_thread_stack();
private:
// Miscellaneous

16
Utilities/address_range.h
View file

@ -282,7 +282,7 @@ namespace utils
public:
// Wrapped functions
inline void reserve(size_t nr) { data.reserve(nr); }
inline void reserve(usz nr) { data.reserve(nr); }
inline void clear() { data.clear(); }
inline size_type size() const { return data.size(); }
inline bool empty() const { return data.empty(); }
@ -456,9 +456,9 @@ namespace utils
// Will fail if ranges within the vector overlap our touch each-other
bool check_consistency() const
{
size_t _size = data.size();
usz _size = data.size();
for (size_t i = 0; i < _size; ++i)
for (usz i = 0; i < _size; ++i)
{
const auto &r1 = data[i];
if (!r1.valid())
@ -466,7 +466,7 @@ namespace utils
continue;
}
for (size_t j = i + 1; j < _size; ++j)
for (usz j = i + 1; j < _size; ++j)
{
const auto &r2 = data[j];
if (!r2.valid())
@ -582,15 +582,15 @@ namespace utils
namespace std
{
static_assert(sizeof(size_t) >= 2 * sizeof(u32), "size_t must be at least twice the size of u32");
static_assert(sizeof(usz) >= 2 * sizeof(u32), "usz must be at least twice the size of u32");
template <>
struct hash<utils::address_range>
{
std::size_t operator()(const utils::address_range& k) const
usz operator()(const utils::address_range& k) const
{
// we can guarantee a unique hash since our type is 64 bits and size_t as well
return (size_t{ k.start } << 32) | size_t{ k.end };
// we can guarantee a unique hash since our type is 64 bits and usz as well
return (usz{ k.start } << 32) | usz{ k.end };
}
};
}

18
Utilities/bin_patch.cpp
View file

@ -577,20 +577,20 @@ void patch_engine::append_title_patches(const std::string& title_id)
load(m_map, get_patches_path() + title_id + "_patch.yml");
}
std::size_t patch_engine::apply(const std::string& name, u8* dst)
usz patch_engine::apply(const std::string& name, u8* dst)
{
return apply_patch<false>(name, dst, 0, 0);
}
std::size_t patch_engine::apply_with_ls_check(const std::string& name, u8* dst, u32 filesz, u32 ls_addr)
usz patch_engine::apply_with_ls_check(const std::string& name, u8* dst, u32 filesz, u32 ls_addr)
{
return apply_patch<true>(name, dst, filesz, ls_addr);
}
template <bool check_local_storage>
static std::size_t apply_modification(const patch_engine::patch_info& patch, u8* dst, u32 filesz, u32 ls_addr)
static usz apply_modification(const patch_engine::patch_info& patch, u8* dst, u32 filesz, u32 ls_addr)
{
size_t applied = 0;
usz applied = 0;
for (const auto& p : patch.data_list)
{
@ -681,14 +681,14 @@ static std::size_t apply_modification(const patch_engine::patch_info& patch, u8*
}
template <bool check_local_storage>
std::size_t patch_engine::apply_patch(const std::string& name, u8* dst, u32 filesz, u32 ls_addr)
usz patch_engine::apply_patch(const std::string& name, u8* dst, u32 filesz, u32 ls_addr)
{
if (m_map.find(name) == m_map.cend())
{
return 0;
}
size_t applied_total = 0;
usz applied_total = 0;
const auto& container = m_map.at(name);
const auto serial = Emu.GetTitleID();
const auto app_version = Emu.GetAppVersion();
@ -799,7 +799,7 @@ std::size_t patch_engine::apply_patch(const std::string& name, u8* dst, u32 file
m_applied_groups.insert(patch.patch_group);
}
const size_t applied = apply_modification<check_local_storage>(patch, dst, filesz, ls_addr);
const usz applied = apply_modification<check_local_storage>(patch, dst, filesz, ls_addr);
applied_total += applied;
if (patch.is_legacy)
@ -906,7 +906,7 @@ void patch_engine::save_config(const patch_map& patches_map, bool enable_legacy_
file.write(out.c_str(), out.size());
}
static void append_patches(patch_engine::patch_map& existing_patches, const patch_engine::patch_map& new_patches, size_t& count, size_t& total, std::stringstream* log_messages)
static void append_patches(patch_engine::patch_map& existing_patches, const patch_engine::patch_map& new_patches, usz& count, usz& total, std::stringstream* log_messages)
{
for (const auto& [hash, new_container] : new_patches)
{
@ -1058,7 +1058,7 @@ bool patch_engine::save_patches(const patch_map& patches, const std::string& pat
return true;
}
bool patch_engine::import_patches(const patch_engine::patch_map& patches, const std::string& path, size_t& count, size_t& total, std::stringstream* log_messages)
bool patch_engine::import_patches(const patch_engine::patch_map& patches, const std::string& path, usz& count, usz& total, std::stringstream* log_messages)
{
patch_engine::patch_map existing_patches;

8
Utilities/bin_patch.h
View file

@ -117,7 +117,7 @@ public:
static bool save_patches(const patch_map& patches, const std::string& path, std::stringstream* log_messages = nullptr);
// Create or append patches to a file
static bool import_patches(const patch_map& patches, const std::string& path, size_t& count, size_t& total, std::stringstream* log_messages = nullptr);
static bool import_patches(const patch_map& patches, const std::string& path, usz& count, usz& total, std::stringstream* log_messages = nullptr);
// Remove a patch from a file
static bool remove_patch(const patch_info& info);
@ -132,15 +132,15 @@ public:
void append_title_patches(const std::string& title_id);
// Apply patch (returns the number of entries applied)
std::size_t apply(const std::string& name, u8* dst);
usz apply(const std::string& name, u8* dst);
// Apply patch with a check that the address exists in SPU local storage
std::size_t apply_with_ls_check(const std::string& name, u8* dst, u32 filesz, u32 ls_addr);
usz apply_with_ls_check(const std::string& name, u8* dst, u32 filesz, u32 ls_addr);
private:
// Internal: Apply patch (returns the number of entries applied)
template <bool check_local_storage>
std::size_t apply_patch(const std::string& name, u8* dst, u32 filesz, u32 ls_addr);
usz apply_patch(const std::string& name, u8* dst, u32 filesz, u32 ls_addr);
// Database
patch_map m_map;

4
Utilities/bit_set.h
View file

@ -48,8 +48,8 @@ private:
}
public:
static constexpr std::size_t bitmax = sizeof(T) * 8;
static constexpr std::size_t bitsize = static_cast<under>(T::__bitset_enum_max);
static constexpr usz bitmax = sizeof(T) * 8;
static constexpr usz bitsize = static_cast<under>(T::__bitset_enum_max);
static_assert(std::is_enum<T>::value, "bs_t<> error: invalid type (must be enum)");
static_assert(bitsize <= bitmax, "bs_t<> error: invalid __bitset_enum_max");

42
Utilities/cfmt.h
View file

@ -6,7 +6,7 @@
#include <vector>
#include <algorithm>
static const std::size_t size_dropped = -1;
static const usz size_dropped = -1;
/*
C-style format parser. Appends formatted string to `out`, returns number of characters written.
@ -15,13 +15,13 @@ C-style format parser. Appends formatted string to `out`, returns number of char
`src`: rvalue reference to argument provider.
*/
template<typename Dst, typename Char, typename Src>
std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
usz cfmt_append(Dst& out, const Char* fmt, Src&& src)
{
const std::size_t start_pos = out.size();
const usz start_pos = out.size();
struct cfmt_context
{
std::size_t size; // Size of current format sequence
usz size; // Size of current format sequence
u8 args; // Number of extra args used
u8 type; // Integral type bytesize
@ -80,7 +80,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
const auto write_decimal = [&](u64 value, s64 min_size)
{
const std::size_t start = out.size();
const usz start = out.size();
do
{
@ -90,7 +90,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
while (0 < --min_size || value);
// Revert written characters
for (std::size_t i = start, j = out.size() - 1; i < j; i++, j--)
for (usz i = start, j = out.size() - 1; i < j; i++, j--)
{
std::swap(out[i], out[j]);
}
@ -285,7 +285,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
break;
}
const std::size_t start = out.size();
const usz start = out.size();
out.push_back(src.template get<Char>(ctx.args));
if (1 < ctx.width)
@ -307,8 +307,8 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
break;
}
const std::size_t start = out.size();
const std::size_t size1 = src.fmt_string(out, ctx.args);
const usz start = out.size();
const usz size1 = src.fmt_string(out, ctx.args);
if (ctx.dot && size1 > ctx.prec)
{
@ -316,7 +316,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
out.resize(start + ctx.prec);
}
const std::size_t size2 = out.size() - start;
const usz size2 = out.size() - start;
if (size2 < ctx.width)
{
@ -352,7 +352,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
const u64 val = src.template get<u64>(ctx.args);
const bool negative = ctx.type && static_cast<s64>(val) < 0;
const std::size_t start = out.size();
const usz start = out.size();
if (!ctx.dot || ctx.prec)
{
@ -372,7 +372,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
write_decimal(negative ? 0 - val : val, ctx.prec);
}
const std::size_t size2 = out.size() - start;
const usz size2 = out.size() - start;
if (size2 < ctx.width)
{
@ -419,7 +419,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
// Trunc sign-extended signed types
const u64 val = src.template get<u64>(ctx.args) & mask;
const std::size_t start = out.size();
const usz start = out.size();
if (ctx.alter)
{
@ -435,7 +435,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
write_octal(val, ctx.prec);
}
const std::size_t size2 = out.size() - start;
const usz size2 = out.size() - start;
if (size2 < ctx.width)
{
@ -476,7 +476,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
// Trunc sign-extended signed types
const u64 val = src.template get<u64>(ctx.args) & mask;
const std::size_t start = out.size();
const usz start = out.size();
if (ctx.alter)
{
@ -493,7 +493,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
write_hex(val, ch == 'X', ctx.prec);
}
const std::size_t size2 = out.size() - start;
const usz size2 = out.size() - start;
if (size2 < ctx.width)
{
@ -540,14 +540,14 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
// Trunc sign-extended signed types
const u64 val = src.template get<u64>(ctx.args) & mask;
const std::size_t start = out.size();
const usz start = out.size();
if (!ctx.dot || ctx.prec)
{
write_decimal(val, ctx.prec);
}
const std::size_t size2 = out.size() - start;
const usz size2 = out.size() - start;
if (size2 < ctx.width)
{
@ -570,11 +570,11 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
const u64 val = src.template get<u64>(ctx.args);
const std::size_t start = out.size();
const usz start = out.size();
write_hex(val, false, sizeof(void*) * 2);
const std::size_t size2 = out.size() - start;
const usz size2 = out.size() - start;
if (size2 < ctx.width)
{
@ -610,7 +610,7 @@ std::size_t cfmt_append(Dst& out, const Char* fmt, Src&& src)
const u64 arg1 = ctx.args >= 1 ? src.template get<u64>(1) : 0;
const u64 arg2 = ctx.args >= 2 ? src.template get<u64>(2) : 0;
if (const std::size_t _size = std::snprintf(0, 0, _fmt.c_str(), arg0, arg1, arg2))
if (const usz _size = std::snprintf(0, 0, _fmt.c_str(), arg0, arg1, arg2))
{
out.resize(out.size() + _size);
std::snprintf(&out.front() + out.size() - _size, _size + 1, _fmt.c_str(), arg0, arg1, arg2);

12
Utilities/hash.h
View file

@ -5,19 +5,19 @@
namespace rpcs3
{
template<typename T>
static size_t hash_base(T value)
static usz hash_base(T value)
{
return static_cast<size_t>(value);
return static_cast<usz>(value);
}
template<typename T, typename U>
static size_t hash_struct_base(const T& value)
static usz hash_struct_base(const T& value)
{
// FNV 64-bit
size_t result = 14695981039346656037ull;
usz result = 14695981039346656037ull;
const U *bits = reinterpret_cast<const U*>(&value);
for (size_t n = 0; n < (sizeof(T) / sizeof(U)); ++n)
for (usz n = 0; n < (sizeof(T) / sizeof(U)); ++n)
{
result ^= bits[n];
result *= 1099511628211ull;
@ -27,7 +27,7 @@ namespace rpcs3
}
template<typename T>
static size_t hash_struct(const T& value)
static usz hash_struct(const T& value)
{
static constexpr auto block_sz = sizeof(T);

10
Utilities/lockless.h
View file

@ -8,7 +8,7 @@
//!
//! T is the type of elements. Currently, default constructor of T shall be constexpr.
//! N is initial element count, available without any memory allocation and only stored contiguously.
template <typename T, std::size_t N>
template <typename T, usz N>
class lf_array
{
// Data (default-initialized)
@ -28,7 +28,7 @@ public:
}
}
T& operator [](std::size_t index)
T& operator [](usz index)
{
if (index < N) [[likely]]
{
@ -51,7 +51,7 @@ public:
//! Simple lock-free FIFO queue base. Based on lf_array<T, N> itself. Currently uses 32-bit counters.
//! There is no "push_end" or "pop_begin" provided, the queue element must signal its state on its own.
template<typename T, std::size_t N>
template<typename T, usz N>
class lf_fifo : public lf_array<T, N>
{
// LSB 32-bit: push, MSB 32-bit: pop
@ -354,9 +354,9 @@ public:
// Apply func(data) to each element, return the total length
template <typename F>
std::size_t apply(F func)
usz apply(F func)
{
std::size_t count = 0;
usz count = 0;
for (auto slice = pop_all(); slice; slice.pop_front())
{

8
Utilities/sysinfo.cpp
View file

@ -217,13 +217,13 @@ std::string utils::get_firmware_version()
std::string version = version_file.to_string();
// Extract version
const size_t start = version.find_first_of(':') + 1;
const size_t end = version.find_first_of(':', start);
const usz start = version.find_first_of(':') + 1;
const usz end = version.find_first_of(':', start);
version = version.substr(start, end - start);
// Trim version
const size_t trim_start = version.find_first_not_of('0');
const size_t trim_end = version.find_last_not_of('0');
const usz trim_start = version.find_first_not_of('0');
const usz trim_end = version.find_last_not_of('0');
version = version.substr(trim_start, trim_end);
return version;

38
Utilities/typemap.h
View file

@ -152,7 +152,7 @@ namespace utils
template <typename T>
class refctr final
{
atomic_t<std::size_t> m_ref{1};
atomic_t<usz> m_ref{1};
public:
T object;
@ -168,7 +168,7 @@ namespace utils
m_ref++;
}
std::size_t remove_ref() noexcept
usz remove_ref() noexcept
{
return --m_ref;
}
@ -464,8 +464,8 @@ namespace utils
uint get_id() const
{
// It's not often needed so figure it out instead of storing it
const std::size_t diff = reinterpret_cast<uchar*>(m_block) - m_head->m_ptr;
const std::size_t quot = diff / m_head->m_ssize;
const usz diff = reinterpret_cast<uchar*>(m_block) - m_head->m_ptr;
const usz quot = diff / m_head->m_ssize;
if (diff % m_head->m_ssize || quot > typeinfo_count<T>::max_count)
{
@ -498,7 +498,7 @@ namespace utils
void* m_memory = nullptr;
// Virtual memory size
std::size_t m_total = 0;
usz m_total = 0;
template <typename T>
typemap_head* get_head() const
@ -555,7 +555,7 @@ namespace utils
// Delete objects (there shall be no threads accessing them)
const uint lim = m_map[i].m_count != 1 ? +m_map[i].m_limit : 1;
for (std::size_t j = 0; j < lim; j++)
for (usz j = 0; j < lim; j++)
{
const auto block = reinterpret_cast<typemap_block*>(m_map[i].m_ptr + j * m_map[i].m_ssize);
@ -585,7 +585,7 @@ namespace utils
{
const uint align = type->align;
const uint ssize = ::align<uint>(sizeof(typemap_block), align) + ::align(type->size, align);
const auto total = std::size_t{ssize} * type->count;
const auto total = usz{ssize} * type->count;
const auto start = uptr{::align(m_total, align)};
if (total)
@ -624,7 +624,7 @@ namespace utils
}
// Return allocated virtual memory block size (not aligned)
std::size_t get_memory_size() const
usz get_memory_size() const
{
return m_total;
}
@ -664,7 +664,7 @@ namespace utils
// Find empty location and lock it, starting from hint index
for (uint lim = head->m_limit, i = (lim > last ? 0 : lim);; i = (i == last ? 0 : i + 1))
{
block = reinterpret_cast<typemap_block*>(head->m_ptr + std::size_t{i} * head->m_ssize);
block = reinterpret_cast<typemap_block*>(head->m_ptr + usz{i} * head->m_ssize);
if (block->m_type == 0 && block->m_mutex.try_lock())
{
@ -703,7 +703,7 @@ namespace utils
else if constexpr (std::is_invocable_r_v<bool, const Arg&, const Type&>)
{
// Access with a lookup function
for (std::size_t j = 0; j < (typeinfo_count<Type>::max_count != 1 ? +head->m_limit : 1); j++)
for (usz j = 0; j < (typeinfo_count<Type>::max_count != 1 ? +head->m_limit : 1); j++)
{
block = reinterpret_cast<typemap_block*>(head->m_ptr + j * head->m_ssize);
@ -731,7 +731,7 @@ namespace utils
const uint unbiased = static_cast<uint>(std::forward<Arg>(id)) - bias;
const uint unscaled = unbiased / step;
block = reinterpret_cast<typemap_block*>(head->m_ptr + std::size_t{head->m_ssize} * unscaled);
block = reinterpret_cast<typemap_block*>(head->m_ptr + usz{head->m_ssize} * unscaled);
// Check id range and type
if (unscaled >= typeinfo_count<Type>::max_count || unbiased % step) [[unlikely]]
@ -866,7 +866,7 @@ namespace utils
}
}
template <std::size_t I, typename Type, typename... Types, bool Lock, bool... Locks, std::size_t N>
template <usz I, typename Type, typename... Types, bool Lock, bool... Locks, usz N>
bool try_lock(const std::array<typeptr_base, N>& array, uint locked, std::integer_sequence<bool, Lock, Locks...>) const
{
// Try to lock mutex if not locked from the previous step
@ -905,8 +905,8 @@ namespace utils
return false;
}
template <typename... Types, std::size_t N, std::size_t... I, bool... Locks>
uint lock_array(const std::array<typeptr_base, N>& array, std::integer_sequence<std::size_t, I...>, std::integer_sequence<bool, Locks...>) const
template <typename... Types, usz N, usz... I, bool... Locks>
uint lock_array(const std::array<typeptr_base, N>& array, std::integer_sequence<usz, I...>, std::integer_sequence<bool, Locks...>) const
{
// Verify all mutexes are free or wait for one of them and return its index
uint locked = 0;
@ -914,15 +914,15 @@ namespace utils
return locked;
}
template <typename... Types, std::size_t N, std::size_t... I, typename... Args>
void check_array(std::array<typeptr_base, N>& array, std::integer_sequence<std::size_t, I...>, Args&&... ids) const
template <typename... Types, usz N, usz... I, typename... Args>
void check_array(std::array<typeptr_base, N>& array, std::integer_sequence<usz, I...>, Args&&... ids) const
{
// Check types and unlock on mismatch
(check_ptr<Types, Args>(array[I].m_block, std::forward<Args>(ids)), ...);
}
template <typename... Types, std::size_t N, std::size_t... I>
std::tuple<typeptr<Types>...> array_to_tuple(const std::array<typeptr_base, N>& array, std::integer_sequence<std::size_t, I...>) const
template <typename... Types, usz N, usz... I>
std::tuple<typeptr<Types>...> array_to_tuple(const std::array<typeptr_base, N>& array, std::integer_sequence<usz, I...>) const
{
return {array[I]...};
}
@ -1000,7 +1000,7 @@ namespace utils
const ullong ix = head->m_create_count;
for (std::size_t j = 0; j < (typeinfo_count<decode_t<Type>>::max_count != 1 ? +head->m_limit : 1); j++)
for (usz j = 0; j < (typeinfo_count<decode_t<Type>>::max_count != 1 ? +head->m_limit : 1); j++)
{
const auto block = reinterpret_cast<typemap_block*>(head->m_ptr + j * head->m_ssize);

2
Utilities/version.cpp
View file

@ -67,7 +67,7 @@ namespace utils
int vnum2 = 0;
// Loop until both strings are processed
for (size_t i = 0, j = 0; (i < v1.length() || j < v2.length());)
for (usz i = 0, j = 0; (i < v1.length() || j < v2.length());)
{
// Storing numeric part of version 1 in vnum1
while (i < v1.length() && v1[i] != '.')

4
rpcs3/Crypto/unedat.cpp
View file

@ -578,7 +578,7 @@ int validate_npd_hashes(const char* file_name, const u8* klicensee, NPD_HEADER *
int dev_hash_result = 0;
const s32 file_name_length = ::narrow<s32>(std::strlen(file_name));
const std::size_t buf_len = 0x30 + file_name_length;
const usz buf_len = 0x30 + file_name_length;
std::unique_ptr<u8[]> buf(new u8[buf_len]);
std::unique_ptr<u8[]> buf_lower(new u8[buf_len]);
@ -591,7 +591,7 @@ int validate_npd_hashes(const char* file_name, const u8* klicensee, NPD_HEADER *
std::memcpy(buf_lower.get(), buf.get(), buf_len);
std::memcpy(buf_upper.get(), buf.get(), buf_len);
for (std::size_t i = std::basic_string_view<u8>(buf.get() + 0x30, file_name_length).find_last_of('.'); i < buf_len; i++)
for (usz i = std::basic_string_view<u8>(buf.get() + 0x30, file_name_length).find_last_of('.'); i < buf_len; i++)
{
const u8 c = static_cast<u8>(buf[i]);
buf_upper[i] = std::toupper(c);

4
rpcs3/Crypto/unpkg.cpp
View file

@ -697,7 +697,7 @@ bool package_reader::extract_data(atomic_t<double>& sync)
return false;
}
size_t num_failures = 0;
usz num_failures = 0;
std::vector<PKGEntry> entries(header.file_count);
@ -857,7 +857,7 @@ void package_reader::archive_seek(const s64 new_offset, const fs::seek_mode damo
cur_offset += new_offset;
u64 _offset = 0;
for (size_t i = 0; i < filelist.size(); i++)
for (usz i = 0; i < filelist.size(); i++)
{
if (cur_offset < (_offset + filelist[i].size()))
{

10
rpcs3/Crypto/unpkg.h
View file

@ -117,16 +117,16 @@ struct PKGEntry
struct PKGMetaData
{
private:
static std::string to_hex_string(u8 buf[], size_t size)
static std::string to_hex_string(u8 buf[], usz size)
{
std::stringstream sstream;
for (size_t i = 0; i < size; i++)
for (usz i = 0; i < size; i++)
{
sstream << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(buf[i]);
}
return sstream.str();
}
static std::string to_hex_string(u8 buf[], size_t size, size_t dotpos)
static std::string to_hex_string(u8 buf[], usz size, usz dotpos)
{
std::string result = to_hex_string(buf, size);
if (result.size() > dotpos)
@ -312,14 +312,14 @@ private:
u64 archive_read(void* data_ptr, const u64 num_bytes);
u64 decrypt(u64 offset, u64 size, const uchar* key);
const std::size_t BUF_SIZE = 8192 * 1024; // 8 MB
const usz BUF_SIZE = 8192 * 1024; // 8 MB
bool m_is_valid = false;
std::string m_path;
std::string install_dir;
std::vector<fs::file> filelist;
size_t cur_file = 0;
usz cur_file = 0;
u64 cur_offset = 0;
u64 cur_file_offset = 0;
std::unique_ptr<u128[]> buf;

10
rpcs3/Crypto/unself.cpp
View file

@ -715,7 +715,7 @@ bool SCEDecrypter::LoadMetadata(const u8 erk[32], const u8 riv[16])
}
// Perform AES-CTR encryption on the metadata headers.
size_t ctr_nc_off = 0;
usz ctr_nc_off = 0;
u8 ctr_stream_block[0x10];
aes_setkey_enc(&aes, meta_info.key, 128);
aes_crypt_ctr(&aes, metadata_headers_size, &ctr_nc_off, meta_info.iv, ctr_stream_block, metadata_headers.get(), metadata_headers.get());
@ -758,7 +758,7 @@ bool SCEDecrypter::DecryptData()
// Parse the metadata section headers to find the offsets of encrypted data.
for (unsigned int i = 0; i < meta_hdr.section_count; i++)
{
size_t ctr_nc_off = 0;
usz ctr_nc_off = 0;
u8 ctr_stream_block[0x10];
u8 data_key[0x10];
u8 data_iv[0x10];
@ -824,7 +824,7 @@ std::vector<fs::file> SCEDecrypter::MakeFile()
// Decompress if necessary.
if (meta_shdr[i].compressed == 2)
{
const size_t BUFSIZE = 32 * 1024;
const usz BUFSIZE = 32 * 1024;
u8 tempbuf[BUFSIZE];
z_stream strm;
strm.zalloc = Z_NULL;
@ -1210,7 +1210,7 @@ bool SELFDecrypter::LoadMetadata(u8* klic_key)
}
// Perform AES-CTR encryption on the metadata headers.
size_t ctr_nc_off = 0;
usz ctr_nc_off = 0;
u8 ctr_stream_block[0x10];
aes_setkey_enc(&aes, meta_info.key, 128);
aes_crypt_ctr(&aes, metadata_headers_size, &ctr_nc_off, meta_info.iv, ctr_stream_block, metadata_headers.get(), metadata_headers.get());
@ -1257,7 +1257,7 @@ bool SELFDecrypter::DecryptData()
// Parse the metadata section headers to find the offsets of encrypted data.
for (unsigned int i = 0; i < meta_hdr.section_count; i++)
{
size_t ctr_nc_off = 0;
usz ctr_nc_off = 0;
u8 ctr_stream_block[0x10];
u8 data_key[0x10];
u8 data_iv[0x10];

2
rpcs3/Emu/CPU/CPUDisAsm.h
View file

@ -96,7 +96,7 @@ protected:
{
if (m_mode != CPUDisAsm_NormalMode)
{
op.resize(std::max<std::size_t>(op.length(), 10), ' ');
op.resize(std::max<usz>(op.length(), 10), ' ');
}
return op;

4
rpcs3/Emu/CPU/CPUTranslator.h
View file

@ -2917,9 +2917,9 @@ public:
template <>
struct fmt_unveil<llvm::TypeSize, void>
{
using type = std::size_t;
using type = usz;
static inline std::size_t get(const llvm::TypeSize& arg)
static inline usz get(const llvm::TypeSize& arg)
{
return arg;
}

2
rpcs3/Emu/Cell/Modules/StaticHLE.cpp
View file

@ -99,7 +99,7 @@ bool statichle_handler::load_patterns()
#define POLY 0x8408
uint16_t statichle_handler::gen_CRC16(const uint8_t* data_p, size_t length)
uint16_t statichle_handler::gen_CRC16(const uint8_t* data_p, usz length)
{
unsigned char i;
unsigned int data;

2
rpcs3/Emu/Cell/Modules/StaticHLE.h
View file

@ -26,7 +26,7 @@ public:
bool check_against_patterns(vm::cptr<u8>& data, u32 size, u32 addr);
protected:
uint16_t gen_CRC16(const uint8_t* data_p, size_t length);
uint16_t gen_CRC16(const uint8_t* data_p, usz length);
std::vector<shle_pattern> hle_patterns;
};

2
rpcs3/Emu/Cell/Modules/cellAudio.cpp
View file

@ -1071,7 +1071,7 @@ void cell_audio_thread::mix(float *out_buffer, s32 offset)
// 2x CVTPS2DQ (converts float to s32)
// PACKSSDW (converts s32 to s16 with signed saturation)
for (size_t i = 0; i < out_buffer_sz; i += 8)
for (usz i = 0; i < out_buffer_sz; i += 8)
{
const auto scale = _mm_set1_ps(0x8000);
_mm_store_ps(out_buffer + i / 2, _mm_castsi128_ps(_mm_packs_epi32(

2
rpcs3/Emu/Cell/Modules/cellCelp8Enc.h
View file

@ -60,7 +60,7 @@ struct CellCelp8EncResource
vm::bptr<void> startAddr;
be_t<u32> ppuThreadPriority;
be_t<u32> spuThreadPriority;
be_t<u32/*size_t*/> ppuThreadStackSize;
be_t<u32/*usz*/> ppuThreadStackSize;
};
struct CellCelp8EncParam

2
rpcs3/Emu/Cell/Modules/cellCelpEnc.h
View file

@ -55,7 +55,7 @@ struct CellCelpEncResource
vm::bptr<void> startAddr;
be_t<u32> ppuThreadPriority;
be_t<u32> spuThreadPriority;
be_t<u32/*size_t*/> ppuThreadStackSize;
be_t<u32/*usz*/> ppuThreadStackSize;
};
struct CellCelpEncParam

2
rpcs3/Emu/Cell/Modules/cellDmux.cpp
View file

@ -181,7 +181,7 @@ public:
const u32 spec; //addr
std::vector<u8> raw_data; // demultiplexed data stream (managed by demuxer thread)
std::size_t raw_pos = 0; // should be <= raw_data.size()
usz raw_pos = 0; // should be <= raw_data.size()
u64 last_dts = CODEC_TS_INVALID;
u64 last_pts = CODEC_TS_INVALID;

2
rpcs3/Emu/Cell/Modules/cellGcmSys.cpp
View file

@ -332,7 +332,7 @@ u32 cellGcmGetTiledPitchSize(u32 size)
{
cellGcmSys.trace("cellGcmGetTiledPitchSize(size=%d)", size);
for (size_t i = 0; i < std::size(tiled_pitches) - 1; i++) {
for (usz i = 0; i < std::size(tiled_pitches) - 1; i++) {
if (tiled_pitches[i] < size && size <= tiled_pitches[i + 1]) {
return tiled_pitches[i + 1];
}

8
rpcs3/Emu/Cell/Modules/cellImeJp.cpp
View file

@ -886,7 +886,7 @@ error_code cellImeJpGetConfirmYomiString(CellImeJpHandle hImeJpHandle, vm::ptr<u
pYomiString[i] = 0;
}
const size_t max_len = std::min<size_t>(CELL_IMEJP_STRING_MAXLENGTH - 1, manager->confirmed_string.length());
const usz max_len = std::min<usz>(CELL_IMEJP_STRING_MAXLENGTH - 1, manager->confirmed_string.length());
for (u32 i = 0; i < max_len; i++)
{
@ -918,7 +918,7 @@ error_code cellImeJpGetConfirmString(CellImeJpHandle hImeJpHandle, vm::ptr<u16>
pConfirmString[i] = 0;
}
const size_t max_len = std::min<size_t>(CELL_IMEJP_STRING_MAXLENGTH - 1, manager->confirmed_string.length());
const usz max_len = std::min<usz>(CELL_IMEJP_STRING_MAXLENGTH - 1, manager->confirmed_string.length());
for (u32 i = 0; i < max_len; i++)
{
@ -950,7 +950,7 @@ error_code cellImeJpGetConvertYomiString(CellImeJpHandle hImeJpHandle, vm::ptr<u
pYomiString[i] = 0;
}
const size_t max_len = std::min<size_t>(CELL_IMEJP_STRING_MAXLENGTH - 1, manager->input_string.length());
const usz max_len = std::min<usz>(CELL_IMEJP_STRING_MAXLENGTH - 1, manager->input_string.length());
for (u32 i = 0; i < max_len; i++)
{
@ -982,7 +982,7 @@ error_code cellImeJpGetConvertString(CellImeJpHandle hImeJpHandle, vm::ptr<u16>
pConvertString[i] = 0;
}
const size_t max_len = std::min<size_t>(CELL_IMEJP_STRING_MAXLENGTH - 1, manager->input_string.length());
const usz max_len = std::min<usz>(CELL_IMEJP_STRING_MAXLENGTH - 1, manager->input_string.length());
for (u32 i = 0; i < max_len; i++)
{

4
rpcs3/Emu/Cell/Modules/cellImeJp.h
View file

@ -118,8 +118,8 @@ struct ime_jp_manager
std::u16string confirmed_string;
std::u16string converted_string;
std::u16string input_string;
size_t cursor = 0;
size_t cursor_end = 0;
usz cursor = 0;
usz cursor_end = 0;
s16 fix_input_mode = CELL_IMEJP_FIXINMODE_OFF;
s16 input_char_type = CELL_IMEJP_DSPCHAR_HIRA;
s16 kana_input_mode = CELL_IMEJP_ROMAN_INPUT;

2
rpcs3/Emu/Cell/Modules/cellJpgDec.cpp
View file

@ -234,7 +234,7 @@ error_code cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data,
const bool flip = current_outParam.outputMode == CELL_JPGDEC_BOTTOM_TO_TOP;
const int bytesPerLine = static_cast<int>(dataCtrlParam->outputBytesPerLine);
size_t image_size = width * height;
usz image_size = width * height;
switch(current_outParam.outputColorSpace)
{

10
rpcs3/Emu/Cell/Modules/cellL10n.cpp
View file

@ -231,11 +231,11 @@ s32 _ConvertStr(s32 src_code, const void *src, s32 src_len, s32 dst_code, void *
#else
s32 retValue = ConversionOK;
iconv_t ict = iconv_open(dstCode, srcCode);
size_t srcLen = src_len;
usz srcLen = src_len;
if (dst != NULL)
{
size_t dstLen = *dst_len;
size_t ictd = iconv(ict, const_cast<char**>(reinterpret_cast<const char**>(&src)), &srcLen, reinterpret_cast<char**>(&dst), &dstLen);
usz dstLen = *dst_len;
usz ictd = iconv(ict, const_cast<char**>(reinterpret_cast<const char**>(&src)), &srcLen, reinterpret_cast<char**>(&dst), &dstLen);
*dst_len -= dstLen;
if (ictd == umax)
{
@ -259,8 +259,8 @@ s32 _ConvertStr(s32 src_code, const void *src, s32 src_len, s32 dst_code, void *
while (srcLen > 0)
{
char *bufPtr = buf;
size_t bufLeft = sizeof(buf);
size_t ictd = iconv(ict, const_cast<char**>(reinterpret_cast<const char**>(&src)), &srcLen, reinterpret_cast<char**>(&dst), &bufLeft);
usz bufLeft = sizeof(buf);
usz ictd = iconv(ict, const_cast<char**>(reinterpret_cast<const char**>(&src)), &srcLen, reinterpret_cast<char**>(&dst), &bufLeft);
*dst_len += sizeof(buf) - bufLeft;
if (ictd == umax && errno != E2BIG)
{

4
rpcs3/Emu/Cell/Modules/cellMic.h
View file

@ -182,7 +182,7 @@ struct CellMicStatus
// --- End of cell definitions ---
template <std::size_t S>
template <usz S>
class simple_ringbuf
{
public:
@ -337,7 +337,7 @@ private:
u32 sample_size = 0; // Determined at opening for internal use
static constexpr std::size_t inbuf_size = 400000; // Default value unknown
static constexpr usz inbuf_size = 400000; // Default value unknown
simple_ringbuf<inbuf_size> rbuf_raw;
simple_ringbuf<inbuf_size> rbuf_dsp;

2
rpcs3/Emu/Cell/Modules/cellPngDec.cpp
View file

@ -153,7 +153,7 @@ void pngDecInfoCallback(png_structp png_ptr, png_infop info)
return;
}
const size_t remaining = png_process_data_pause(png_ptr, false);
const usz remaining = png_process_data_pause(png_ptr, false);
stream->buffer->cursor += (stream->buffer->length - remaining);
}

4
rpcs3/Emu/Cell/Modules/cellPngDec.h
View file

@ -276,8 +276,8 @@ struct PngHandle
struct PngBuffer
{
// The cursor location and data pointer for reading from a buffer
size_t cursor;
size_t length;
usz cursor;
usz length;
vm::bptr<void> data;
// The file descriptor, and whether we need to read from a file descriptor

12
rpcs3/Emu/Cell/Modules/cellPngEnc.h
View file

@ -97,7 +97,7 @@ struct CellPngEncConfig
struct CellPngEncAttr
{
be_t<u32> memSize; // size_t
be_t<u32> memSize; // usz
u8 cmdQueueDepth;
be_t<u32> versionUpper;
be_t<u32> versionLower;
@ -106,7 +106,7 @@ struct CellPngEncAttr
struct CellPngEncResource
{
vm::bptr<void> memAddr;
be_t<u32> memSize; // size_t
be_t<u32> memSize; // usz
be_t<s32> ppuThreadPriority;
be_t<s32> spuThreadPriority;
};
@ -114,7 +114,7 @@ struct CellPngEncResource
struct CellPngEncResourceEx
{
vm::bptr<void> memAddr;
be_t<u32> memSize; // size_t
be_t<u32> memSize; // usz
be_t<s32> ppuThreadPriority;
vm::bptr<void> spurs; // CellSpurs
u8 priority[8];
@ -153,7 +153,7 @@ struct CellPngEncOutputParam
be_t<u32> location; // CellPngEncLocation
vm::bcptr<char> streamFileName;
vm::bptr<void> streamAddr;
be_t<u32> limitSize; // size_t
be_t<u32> limitSize; // usz
};
struct CellPngEncStreamInfo
@ -162,8 +162,8 @@ struct CellPngEncStreamInfo
be_t<u32> location; // CellPngEncLocation
vm::bcptr<char> streamFileName;
vm::bptr<void> streamAddr;
be_t<u32> limitSize; // size_t
be_t<u32> streamSize; // size_t
be_t<u32> limitSize; // usz
be_t<u32> streamSize; // usz
be_t<u32> processedLine;
be_t<u64> userData;
};

2
rpcs3/Emu/Cell/Modules/cellResc.h
View file

@ -87,7 +87,7 @@ struct CellRescDsts
struct CellRescInitConfig
{
be_t<u32> size; // size_t
be_t<u32> size; // usz
be_t<u32> resourcePolicy;
be_t<u32> supportModes;
be_t<u32> ratioMode;

2
rpcs3/Emu/Cell/Modules/cellSaveData.cpp
View file

@ -564,7 +564,7 @@ static NEVER_INLINE error_code savedata_op(ppu_thread& ppu, u32 operation, u32 v
}
// Simulate idle time while data is being sent to VSH
const auto lv2_sleep = [](ppu_thread& ppu, size_t sleep_time)
const auto lv2_sleep = [](ppu_thread& ppu, usz sleep_time)
{
lv2_obj::sleep(ppu);
std::this_thread::sleep_for(std::chrono::microseconds(sleep_time));

4
rpcs3/Emu/Cell/Modules/sceNpTrophy.cpp
View file

@ -163,7 +163,7 @@ void fmt_class_string<SceNpCommunicationSignature>::format(std::string& out, u64
// Format as a C byte array for ease of use
fmt::append(out, "{ ");
for (std::size_t i = 0;; i++)
for (usz i = 0;; i++)
{
if (i == std::size(sign.data) - 1)
{
@ -490,7 +490,7 @@ error_code sceNpTrophyRegisterContext(ppu_thread& ppu, u32 context, u32 handle,
}
// Rename or discard certain entries based on the files found
const size_t kTargetBufferLength = 31;
const usz kTargetBufferLength = 31;
char target[kTargetBufferLength + 1];
target[kTargetBufferLength] = 0;
strcpy_trunc(target, fmt::format("TROP_%02d.SFM", static_cast<s32>(g_cfg.sys.language)));

4
rpcs3/Emu/Cell/Modules/sceNpTus.cpp
View file

@ -17,7 +17,7 @@ static bool validateSlotIds(vm::cptr<SceNpTusSlotId> slotIdArray)
}
// TODO: how to properly iterate?
//for (size_t i = 0; i < slotIdArray.size(); ++i)
//for (usz i = 0; i < slotIdArray.size(); ++i)
//{
// if (slotIdArray[i] < 0)
// {
@ -66,7 +66,7 @@ sce_np_tus_title_context* sce_np_tus_manager::get_title_context(s32 titleCtxId)
s32 sce_np_tus_manager::add_transaction_context(s32 titleCtxId)
{
size_t transaction_count = 0;
usz transaction_count = 0;
for (const auto& title_context : title_contexts)
{

32
rpcs3/Emu/Cell/Modules/sys_libc_.cpp
View file

@ -16,47 +16,47 @@ struct ps3_fmt_src
ppu_thread* ctx;
u32 g_count;
bool test(std::size_t index) const
bool test(usz index) const
{
return true;
}
template <typename T>
T get(std::size_t index) const
T get(usz index) const
{
const u32 i = static_cast<u32>(index) + g_count;
return ppu_gpr_cast<T>(i < 8 ? ctx->gpr[3 + i] : +*ctx->get_stack_arg(i));
}
void skip(std::size_t extra)
void skip(usz extra)
{
g_count += static_cast<u32>(extra) + 1;
}
std::size_t fmt_string(std::string& out, std::size_t extra) const
usz fmt_string(std::string& out, usz extra) const
{
const std::size_t start = out.size();
const usz start = out.size();
out += vm::_ptr<const char>(get<u32>(extra));
return out.size() - start;
}
std::size_t type(std::size_t extra) const
usz type(usz extra) const
{
return 0;
}
static constexpr std::size_t size_char = 1;
static constexpr std::size_t size_short = 2;
static constexpr std::size_t size_int = 4;
static constexpr std::size_t size_long = 4;
static constexpr std::size_t size_llong = 8;
static constexpr std::size_t size_size = 4;
static constexpr std::size_t size_max = 8;
static constexpr std::size_t size_diff = 4;
static constexpr usz size_char = 1;
static constexpr usz size_short = 2;
static constexpr usz size_int = 4;
static constexpr usz size_long = 4;
static constexpr usz size_llong = 8;
static constexpr usz size_size = 4;
static constexpr usz size_max = 8;
static constexpr usz size_diff = 4;
};
template <>
f64 ps3_fmt_src::get<f64>(std::size_t index) const
f64 ps3_fmt_src::get<f64>(usz index) const
{
return std::bit_cast<f64>(get<u64>(index));
}
@ -404,7 +404,7 @@ s32 _sys_snprintf(ppu_thread& ppu, vm::ptr<char> dst, u32 count, vm::cptr<char>
}
else
{
count = static_cast<u32>(std::min<size_t>(count - 1, result.size()));
count = static_cast<u32>(std::min<usz>(count - 1, result.size()));
std::memcpy(dst.get_ptr(), result.c_str(), count);
dst[count] = 0;

4
rpcs3/Emu/Cell/PPUAnalyser.cpp
View file

@ -836,7 +836,7 @@ void ppu_module::analyse(u32 lib_toc, u32 entry)
}
// Main loop (func_queue may grow)
for (std::size_t i = 0; i < func_queue.size(); i++)
for (usz i = 0; i < func_queue.size(); i++)
{
ppu_function& func = func_queue[i];
@ -1187,7 +1187,7 @@ void ppu_module::analyse(u32 lib_toc, u32 entry)
const bool was_empty = block_queue.empty();
// Block loop (block_queue may grow, may be aborted via clearing)
for (std::size_t j = 0; j < block_queue.size(); j++)
for (usz j = 0; j < block_queue.size(); j++)
{
auto& block = block_queue[j].get();

8
rpcs3/Emu/Cell/PPUAnalyser.h
View file

@ -117,9 +117,9 @@ struct ppu_pattern
struct ppu_pattern_array
{
const ppu_pattern* ptr;
std::size_t count;
usz count;
template <std::size_t N>
template <usz N>
constexpr ppu_pattern_array(const ppu_pattern(&array)[N])
: ptr(array)
, count(N)
@ -140,9 +140,9 @@ struct ppu_pattern_array
struct ppu_pattern_matrix
{
const ppu_pattern_array* ptr;
std::size_t count;
usz count;
template <std::size_t N>
template <usz N>
constexpr ppu_pattern_matrix(const ppu_pattern_array(&array)[N])
: ptr(array)
, count(N)

6
rpcs3/Emu/Cell/PPUModule.cpp
View file

@ -698,7 +698,7 @@ static void ppu_check_patch_spu_images(const ppu_segment& seg)
{
const std::string_view seg_view{vm::get_super_ptr<char>(seg.addr), seg.size};
for (std::size_t i = seg_view.find("\177ELF"); i < seg.size; i = seg_view.find("\177ELF", i + 4))
for (usz i = seg_view.find("\177ELF"); i < seg.size; i = seg_view.find("\177ELF", i + 4))
{
const auto elf_header = vm::get_super_ptr<u8>(seg.addr + i);
@ -715,7 +715,7 @@ static void ppu_check_patch_spu_images(const ppu_segment& seg)
std::string name;
std::string dump;
std::size_t applied = 0;
usz applied = 0;
// Executable hash
sha1_context sha2;
@ -867,7 +867,7 @@ std::shared_ptr<lv2_prx> ppu_load_prx(const ppu_prx_object& elf, const std::stri
if (s.sh_type == 1u && addr && size) // TODO: some sections with addr=0 are valid
{
for (std::size_t i = 0; i < prx->segs.size(); i++)
for (usz i = 0; i < prx->segs.size(); i++)
{
const u32 saddr = static_cast<u32>(elf.progs[i].p_vaddr);
if (addr >= saddr && addr < saddr + elf.progs[i].p_memsz)

8
rpcs3/Emu/Cell/PPUThread.cpp
View file

@ -2105,7 +2105,7 @@ extern void ppu_initialize(const ppu_module& info)
std::vector<std::pair<std::string, u64>> globals;
// Split module into fragments <= 1 MiB
std::size_t fpos = 0;
usz fpos = 0;
// Difference between function name and current location
const u32 reloc = info.name.empty() ? 0 : info.segs.at(0).addr;
@ -2139,7 +2139,7 @@ extern void ppu_initialize(const ppu_module& info)
const u32 suffix = info.funcs.at(fstart).addr - reloc;
// Overall block size in bytes
std::size_t bsize = 0;
usz bsize = 0;
while (fpos < info.funcs.size())
{
@ -2455,7 +2455,7 @@ extern void ppu_initialize(const ppu_module& info)
}
else
{
std::size_t index = 0;
usz index = 0;
// Locate existing functions
for (const auto& func : info.funcs)
@ -2544,7 +2544,7 @@ static void ppu_initialize2(jit_compiler& jit, const ppu_module& module_part, co
//pm.add(createLintPass()); // Check
// Translate functions
for (size_t fi = 0, fmax = module_part.funcs.size(); fi < fmax; fi++)
for (usz fi = 0, fmax = module_part.funcs.size(); fi < fmax; fi++)
{
if (Emu.IsStopped())
{

2
rpcs3/Emu/Cell/PPUThread.h
View file

@ -137,7 +137,7 @@ public:
u8 bits[32];
u32 fields[8];
u8& operator [](std::size_t i)
u8& operator [](usz i)
{
return bits[i];
}

2
rpcs3/Emu/Cell/PPUTranslator.cpp
View file

@ -528,7 +528,7 @@ Value* PPUTranslator::Shuffle(Value* left, Value* right, std::initializer_list<u
const u32 mask = cast<VectorType>(type)->getNumElements() - 1;
// Transform indices (works for vectors with size 2^N)
for (std::size_t i = 0; i < indices.size(); i++)
for (usz i = 0; i < indices.size(); i++)
{
data.push_back(indices.end()[~i] ^ mask);
}

8
rpcs3/Emu/Cell/PPUTranslator.h
View file

@ -209,20 +209,20 @@ public:
// Create sign extension (with double size if type is nullptr)
llvm::Value* SExt(llvm::Value* value, llvm::Type* = nullptr);
template<std::size_t N>
template<usz N>
std::array<llvm::Value*, N> SExt(std::array<llvm::Value*, N> values, llvm::Type* type = nullptr)
{
for (std::size_t i = 0; i < N; i++) values[i] = SExt(values[i], type);
for (usz i = 0; i < N; i++) values[i] = SExt(values[i], type);
return values;
}
// Create zero extension (with double size if type is nullptr)
llvm::Value* ZExt(llvm::Value*, llvm::Type* = nullptr);
template<std::size_t N>
template<usz N>
std::array<llvm::Value*, N> ZExt(std::array<llvm::Value*, N> values, llvm::Type* type = nullptr)
{
for (std::size_t i = 0; i < N; i++) values[i] = ZExt(values[i], type);
for (usz i = 0; i < N; i++) values[i] = ZExt(values[i], type);
return values;
}

12
rpcs3/Emu/Cell/SPURecompiler.cpp
View file

@ -389,7 +389,7 @@ void spu_cache::initialize()
// Read cache
auto func_list = cache.get();
atomic_t<std::size_t> fnext{};
atomic_t<usz> fnext{};
atomic_t<u8> fail_flag{0};
if (g_cfg.core.spu_decoder == spu_decoder_type::fast || g_cfg.core.spu_decoder == spu_decoder_type::llvm)
@ -456,7 +456,7 @@ void spu_cache::initialize()
std::vector<be_t<u32>> ls(0x10000);
// Build functions
for (std::size_t func_i = fnext++; func_i < func_list.size(); func_i = fnext++)
for (usz func_i = fnext++; func_i < func_list.size(); func_i = fnext++)
{
const spu_program& func = std::as_const(func_list)[func_i];
@ -750,7 +750,7 @@ spu_function_t spu_runtime::rebuild_ubertrampoline(u32 id_inst)
// LS address starting from PC is already loaded into rcx (see spu_runtime::tr_all)
for (std::size_t i = 0; i < workload.size(); i++)
for (usz i = 0; i < workload.size(); i++)
{
// Get copy of the workload info
auto w = workload[i];
@ -1975,7 +1975,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point)
workload.push_back(pair.first);
m_bits[pair.first / 4] = true;
for (std::size_t i = 0; !reachable && i < workload.size(); i++)
for (usz i = 0; !reachable && i < workload.size(); i++)
{
for (u32 j = workload[i];; j -= 4)
{
@ -4492,7 +4492,7 @@ public:
m_function_table = new llvm::GlobalVariable(*m_module, llvm::ArrayType::get(entry_chunk->chunk->getType(), m_size / 4), true, llvm::GlobalValue::InternalLinkage, nullptr);
// Create function chunks
for (std::size_t fi = 0; fi < m_function_queue.size(); fi++)
for (usz fi = 0; fi < m_function_queue.size(); fi++)
{
// Initialize function info
m_entry = m_function_queue[fi];
@ -4506,7 +4506,7 @@ public:
m_ir->CreateBr(add_block(m_entry));
// Emit instructions for basic blocks
for (std::size_t bi = 0; bi < m_block_queue.size(); bi++)
for (usz bi = 0; bi < m_block_queue.size(); bi++)
{
// Initialize basic block info
const u32 baddr = m_block_queue[bi];

8
rpcs3/Emu/Cell/lv2/lv2.cpp
View file

@ -1226,7 +1226,7 @@ bool lv2_obj::awake_unlocked(cpu_thread* cpu, s32 prio)
case yield_cmd:
{
// Yield command
for (std::size_t i = 0;; i++)
for (usz i = 0;; i++)
{
if (i + 1 >= g_ppu.size())
{
@ -1235,7 +1235,7 @@ bool lv2_obj::awake_unlocked(cpu_thread* cpu, s32 prio)
if (const auto ppu = g_ppu[i]; ppu == cpu)
{
std::size_t j = i + 1;
usz j = i + 1;
for (; j < g_ppu.size(); j++)
{
@ -1325,7 +1325,7 @@ bool lv2_obj::awake_unlocked(cpu_thread* cpu, s32 prio)
}
// Suspend threads if necessary
for (std::size_t i = g_cfg.core.ppu_threads; changed_queue && i < g_ppu.size(); i++)
for (usz i = g_cfg.core.ppu_threads; changed_queue && i < g_ppu.size(); i++)
{
const auto target = g_ppu[i];
@ -1352,7 +1352,7 @@ void lv2_obj::schedule_all()
if (g_pending.empty())
{
// Wake up threads
for (std::size_t i = 0, x = std::min<std::size_t>(g_cfg.core.ppu_threads, g_ppu.size()); i < x; i++)
for (usz i = 0, x = std::min<usz>(g_cfg.core.ppu_threads, g_ppu.size()); i < x; i++)
{
const auto target = g_ppu[i];

8
rpcs3/Emu/Cell/lv2/sys_config.h
View file

@ -238,7 +238,7 @@ public:
const std::vector<u8> data;
// Constructors (should not be used directly)
lv2_config_service(sys_config_service_id _id, u64 _user_id, u64 _verbosity, u32 _padding, const u8 _data[], size_t size)
lv2_config_service(sys_config_service_id _id, u64 _user_id, u64 _verbosity, u32 _padding, const u8 _data[], usz size)
: timestamp(get_system_time())
, id(_id)
, user_id(_user_id)
@ -269,7 +269,7 @@ public:
void notify() const;
// Utilities
size_t get_size() const { return sizeof(sys_config_service_event_t)-1 + data.size(); }
usz get_size() const { return sizeof(sys_config_service_event_t)-1 + data.size(); }
std::shared_ptr<lv2_config_service> get_shared_ptr () const { return wkptr.lock(); };
u32 get_id() const { return idm_id; }
};
@ -304,7 +304,7 @@ public:
const std::vector<u8> data;
// Constructors (should not be used directly)
lv2_config_service_listener(std::shared_ptr<lv2_config_handle>& _handle, sys_config_service_id _service_id, u64 _min_verbosity, sys_config_service_listener_type _type, const u8 _data[], size_t size)
lv2_config_service_listener(std::shared_ptr<lv2_config_handle>& _handle, sys_config_service_id _service_id, u64 _min_verbosity, sys_config_service_listener_type _type, const u8 _data[], usz size)
: handle(_handle)
, service_id(_service_id)
, min_verbosity(_min_verbosity)
@ -406,7 +406,7 @@ public:
void write(sys_config_service_event_t *dst);
// Check if the buffer can fit the current event, return false otherwise
bool check_buffer_size(size_t size) const { return service->get_size() <= size; }
bool check_buffer_size(usz size) const { return service->get_size() <= size; }
};
/*

6
rpcs3/Emu/Cell/lv2/sys_fs.cpp
View file

@ -57,7 +57,7 @@ lv2_fs_mount_point* lv2_fs_object::get_mp(std::string_view filename)
{
std::string_view mp_name, vpath = filename;
for (std::size_t depth = 0;;)
for (usz depth = 0;;)
{
// Skip one or more '/'
const auto pos = vpath.find_first_not_of('/');
@ -833,7 +833,7 @@ error_code sys_fs_readdir(ppu_thread& ppu, u32 fd, vm::ptr<CellFsDirent> dir, vm
if (auto* info = directory->dir_read())
{
dir->d_type = info->is_directory ? CELL_FS_TYPE_DIRECTORY : CELL_FS_TYPE_REGULAR;
dir->d_namlen = u8(std::min<size_t>(info->name.size(), CELL_FS_MAX_FS_FILE_NAME_LENGTH));
dir->d_namlen = u8(std::min<usz>(info->name.size(), CELL_FS_MAX_FS_FILE_NAME_LENGTH));
strcpy_trunc(dir->d_name, info->name);
*nread = sizeof(CellFsDirent);
}
@ -1570,7 +1570,7 @@ error_code sys_fs_fcntl(ppu_thread& ppu, u32 fd, u32 op, vm::ptr<void> _arg, u32
}
entry.entry_name.d_type = info->is_directory ? CELL_FS_TYPE_DIRECTORY : CELL_FS_TYPE_REGULAR;
entry.entry_name.d_namlen = u8(std::min<size_t>(info->name.size(), CELL_FS_MAX_FS_FILE_NAME_LENGTH));
entry.entry_name.d_namlen = u8(std::min<usz>(info->name.size(), CELL_FS_MAX_FS_FILE_NAME_LENGTH));
strcpy_trunc(entry.entry_name.d_name, info->name);
}
}

6
rpcs3/Emu/Cell/lv2/sys_net.cpp
View file

@ -518,7 +518,7 @@ struct nt_p2p_port
}
}
static u16 tcp_checksum(const u16* buffer, std::size_t size)
static u16 tcp_checksum(const u16* buffer, usz size)
{
u32 cksum = 0;
while (size > 1)
@ -1051,7 +1051,7 @@ struct network_thread
std::lock_guard lock(s_nw_mutex);
for (std::size_t i = 0; i < socklist.size(); i++)
for (usz i = 0; i < socklist.size(); i++)
{
bs_t<lv2_socket::poll> events{};
@ -1114,7 +1114,7 @@ struct network_thread
socklist.emplace_back(idm::get_unlocked<lv2_socket>(id));
});
for (std::size_t i = 0; i < socklist.size(); i++)
for (usz i = 0; i < socklist.size(); i++)
{
#ifdef _WIN32
std::lock_guard lock(socklist[i]->mutex);

4
rpcs3/Emu/Cell/lv2/sys_net.h
View file

@ -382,7 +382,7 @@ struct lv2_socket final
};
static constexpr be_t<u32> U2S_sig = (static_cast<u32>('U') << 24 | static_cast<u32>('2') << 16 | static_cast<u32>('S') << 8 | static_cast<u32>('0'));
static constexpr std::size_t MAX_RECEIVED_BUFFER = (1024*1024*10);
static constexpr usz MAX_RECEIVED_BUFFER = (1024*1024*10);
// P2P stream socket specific
struct encapsulated_tcp
@ -407,7 +407,7 @@ struct lv2_socket final
stream_status status = stream_status::stream_closed;
std::size_t max_backlog = 0; // set on listen
usz max_backlog = 0; // set on listen
std::queue<s32> backlog;
u16 op_port = 0, op_vport = 0;

2
rpcs3/Emu/Cell/lv2/sys_overlay.h
View file

@ -13,7 +13,7 @@ struct lv2_overlay final : lv2_obj, ppu_module
error_code sys_overlay_load_module(vm::ptr<u32> ovlmid, vm::cptr<char> path, u64 flags, vm::ptr<u32> entry);
error_code sys_overlay_load_module_by_fd(vm::ptr<u32> ovlmid, u32 fd, u64 offset, u64 flags, vm::ptr<u32> entry);
error_code sys_overlay_unload_module(u32 ovlmid);
//error_code sys_overlay_get_module_list(sys_pid_t pid, size_t ovlmids_num, sys_overlay_t * ovlmids, size_t * num_of_modules);
//error_code sys_overlay_get_module_list(sys_pid_t pid, usz ovlmids_num, sys_overlay_t * ovlmids, usz * num_of_modules);
//error_code sys_overlay_get_module_info(sys_pid_t pid, sys_overlay_t ovlmid, sys_overlay_module_info_t * info);
//error_code sys_overlay_get_module_info2(sys_pid_t pid, sys_overlay_t ovlmid, sys_overlay_module_info2_t * info);//
//error_code sys_overlay_get_sdk_version(); //2 params

2
rpcs3/Emu/Cell/lv2/sys_process.cpp
View file

@ -267,7 +267,7 @@ error_code _sys_process_get_paramsfo(vm::ptr<char> buffer)
}
memset(buffer.get_ptr(), 0, 0x40);
memcpy(buffer.get_ptr() + 1, Emu.GetTitleID().c_str(), std::min<size_t>(Emu.GetTitleID().length(), 9));
memcpy(buffer.get_ptr() + 1, Emu.GetTitleID().c_str(), std::min<usz>(Emu.GetTitleID().length(), 9));
return CELL_OK;
}

6
rpcs3/Emu/Cell/lv2/sys_rsx.cpp
View file

@ -207,10 +207,10 @@ error_code sys_rsx_context_allocate(cpu_thread& cpu, vm::ptr<u32> context_id, vm
auto &reports = vm::_ref<RsxReports>(vm::cast(*lpar_reports));
std::memset(&reports, 0, sizeof(RsxReports));
for (size_t i = 0; i < std::size(reports.notify); ++i)
for (usz i = 0; i < std::size(reports.notify); ++i)
reports.notify[i].timestamp = -1;
for (size_t i = 0; i < std::size(reports.semaphore); i += 4)
for (usz i = 0; i < std::size(reports.semaphore); i += 4)
{
reports.semaphore[i + 0].val.raw() = 0x1337C0D3;
reports.semaphore[i + 1].val.raw() = 0x1337BABE;
@ -218,7 +218,7 @@ error_code sys_rsx_context_allocate(cpu_thread& cpu, vm::ptr<u32> context_id, vm
reports.semaphore[i + 3].val.raw() = 0x1337F001;
}
for (size_t i = 0; i < std::size(reports.report); ++i)
for (usz i = 0; i < std::size(reports.report); ++i)
{
reports.report[i].val = 0;
reports.report[i].timestamp = -1;

8
rpcs3/Emu/Cell/lv2/sys_tty.cpp
View file

@ -32,7 +32,7 @@ error_code sys_tty_read(s32 ch, vm::ptr<char> buf, u32 len, vm::ptr<u32> preadle
sys_tty.warning("sys_tty_read called with system channel %d", ch);
}
size_t chars_to_read = 0; // number of chars that will be read from the input string
usz chars_to_read = 0; // number of chars that will be read from the input string
std::string tty_read; // string for storage of read chars
if (len > 0)
@ -45,15 +45,15 @@ error_code sys_tty_read(s32 ch, vm::ptr<char> buf, u32 len, vm::ptr<u32> preadle
std::string& input = g_tty_input[ch].front();
// we have to stop reading at either a new line, the param len, or our input string size
size_t new_line_pos = input.find_first_of('\n');
usz new_line_pos = input.find_first_of('\n');
if (new_line_pos != input.npos)
{
chars_to_read = std::min(new_line_pos, static_cast<size_t>(len));
chars_to_read = std::min(new_line_pos, static_cast<usz>(len));
}
else
{
chars_to_read = std::min(input.size(), static_cast<size_t>(len));
chars_to_read = std::min(input.size(), static_cast<usz>(len));
}
// read the previously calculated number of chars from the beginning of the input string

10
rpcs3/Emu/GDB.cpp
View file

@ -350,7 +350,7 @@ void gdb_thread::send_cmd(const std::string& cmd)
std::string buf;
buf.reserve(cmd.length() + 4);
buf += "$";
for (std::size_t i = 0; i < cmd.length(); ++i)
for (usz i = 0; i < cmd.length(); ++i)
{
checksum = (checksum + append_encoded_char(cmd[i], buf)) % 256;
}
@ -590,7 +590,7 @@ bool gdb_thread::cmd_write_register(gdb_cmd& cmd)
auto th = selected_thread.lock();
if (th->id_type() == 1) {
auto ppu = static_cast<named_thread<ppu_thread>*>(th.get());
size_t eq_pos = cmd.data.find('=');
usz eq_pos = cmd.data.find('=');
if (eq_pos == umax) {
GDB.warning("Wrong write_register cmd data '%s'.", cmd.data);
return send_cmd_ack("E02");
@ -609,7 +609,7 @@ bool gdb_thread::cmd_write_register(gdb_cmd& cmd)
bool gdb_thread::cmd_read_memory(gdb_cmd& cmd)
{
size_t s = cmd.data.find(',');
usz s = cmd.data.find(',');
u32 addr = hex_to_u32(cmd.data.substr(0, s));
u32 len = hex_to_u32(cmd.data.substr(s + 1));
std::string result;
@ -631,8 +631,8 @@ bool gdb_thread::cmd_read_memory(gdb_cmd& cmd)
bool gdb_thread::cmd_write_memory(gdb_cmd& cmd)
{
size_t s = cmd.data.find(',');
size_t s2 = cmd.data.find(':');
usz s = cmd.data.find(',');
usz s2 = cmd.data.find(':');
if ((s == umax) || (s2 == umax)) {
GDB.warning("Malformed write memory request received: '%s'.", cmd.data);
return send_cmd_ack("E01");

4
rpcs3/Emu/Io/PadHandler.cpp
View file

@ -253,7 +253,7 @@ std::string PadHandlerBase::name_string() const
return m_name_string;
}
size_t PadHandlerBase::max_devices() const
usz PadHandlerBase::max_devices() const
{
return m_max_devices;
}
@ -615,7 +615,7 @@ void PadHandlerBase::get_mapping(const std::shared_ptr<PadDevice>& device, const
void PadHandlerBase::ThreadProc()
{
for (size_t i = 0; i < bindings.size(); ++i)
for (usz i = 0; i < bindings.size(); ++i)
{
auto device = bindings[i].first;
auto pad = bindings[i].second;

4
rpcs3/Emu/Io/PadHandler.h
View file

@ -62,7 +62,7 @@ protected:
std::array<bool, MAX_GAMEPADS> last_connection_status{{ false, false, false, false, false, false, false }};
std::string m_name_string;
size_t m_max_devices = 0;
usz m_max_devices = 0;
int m_trigger_threshold = 0;
int m_thumb_threshold = 0;
@ -132,7 +132,7 @@ public:
pad_handler m_type;
std::string name_string() const;
size_t max_devices() const;
usz max_devices() const;
bool has_config() const;
bool has_rumble() const;
bool has_deadzones() const;

2
rpcs3/Emu/Memory/vm.cpp
View file

@ -1103,7 +1103,7 @@ namespace vm
// Fill stack guards with STACKGRD
if (this->flags & 0x10)
{
auto fill64 = [](u8* ptr, u64 data, std::size_t count)
auto fill64 = [](u8* ptr, u64 data, usz count)
{
u64* target = reinterpret_cast<u64*>(ptr);

10
rpcs3/Emu/NP/fb_helpers.cpp
View file

@ -41,17 +41,17 @@ void np_handler::RoomGroup_to_SceNpMatching2RoomGroup(const flatbuffers::Vector<
void np_handler::UserInfo2_to_SceNpUserInfo2(const UserInfo2* user, SceNpUserInfo2* user_info)
{
if (user->npId())
memcpy(user_info->npId.handle.data, user->npId()->c_str(), std::min(sizeof(user_info->npId.handle.data), static_cast<std::size_t>(user->npId()->size())));
memcpy(user_info->npId.handle.data, user->npId()->c_str(), std::min(sizeof(user_info->npId.handle.data), static_cast<usz>(user->npId()->size())));
if (user->onlineName())
{
user_info->onlineName.set(allocate(sizeof(SceNpOnlineName)));
memcpy(user_info->onlineName->data, user->onlineName()->c_str(), std::min(sizeof(user_info->onlineName->data), static_cast<std::size_t>(user->onlineName()->size())));
memcpy(user_info->onlineName->data, user->onlineName()->c_str(), std::min(sizeof(user_info->onlineName->data), static_cast<usz>(user->onlineName()->size())));
}
if (user->avatarUrl())
{
user_info->avatarUrl.set(allocate(sizeof(SceNpAvatarUrl)));
memcpy(user_info->avatarUrl->data, user->avatarUrl()->c_str(), std::min(sizeof(user_info->avatarUrl->data), static_cast<std::size_t>(user->avatarUrl()->size())));
memcpy(user_info->avatarUrl->data, user->avatarUrl()->c_str(), std::min(sizeof(user_info->avatarUrl->data), static_cast<usz>(user->avatarUrl()->size())));
}
}
@ -283,7 +283,7 @@ void np_handler::RoomMemberUpdateInfo_to_SceNpMatching2RoomMemberUpdateInfo(cons
if (update_info->optData())
{
sce_update_info->optData.length = update_info->optData()->data()->size();
for (size_t i = 0; i < 16; i++)
for (usz i = 0; i < 16; i++)
{
sce_update_info->optData.data[i] = update_info->optData()->data()->Get(i);
}
@ -335,7 +335,7 @@ void np_handler::RoomUpdateInfo_to_SceNpMatching2RoomUpdateInfo(const RoomUpdate
if (update_info->optData())
{
sce_update_info->optData.length = update_info->optData()->data()->size();
for (size_t i = 0; i < 16; i++)
for (usz i = 0; i < 16; i++)
{
sce_update_info->optData.data[i] = update_info->optData()->data()->Get(i);
}

6
rpcs3/Emu/NP/np_handler.cpp
View file

@ -77,7 +77,7 @@ np_handler::np_handler()
// Init switch map for dns
auto swaps = fmt::split(g_cfg.net.swap_list.to_string(), {"&&"});
for (std::size_t i = 0; i < swaps.size(); i++)
for (usz i = 0; i < swaps.size(); i++)
{
auto host_and_ip = fmt::split(swaps[i], {"="});
if (host_and_ip.size() != 2)
@ -741,7 +741,7 @@ bool np_handler::reply_get_world_list(u32 req_id, std::vector<u8>& reply_data)
if (!world_list.empty())
{
world_info->world.set(allocate(sizeof(SceNpMatching2World) * world_list.size()));
for (size_t i = 0; i < world_list.size(); i++)
for (usz i = 0; i < world_list.size(); i++)
{
world_info->world[i].worldId = world_list[i];
world_info->world[i].numOfLobby = 1; // TODO
@ -1343,7 +1343,7 @@ u32 np_handler::generate_callback_info(SceNpMatching2ContextId ctx_id, vm::cptr<
return req_id;
}
u8* np_handler::allocate_req_result(u32 event_key, size_t size)
u8* np_handler::allocate_req_result(u32 event_key, usz size)
{
std::lock_guard lock(mutex_req_results);
match2_req_results[event_key] = std::vector<u8>(size, 0);

2
rpcs3/Emu/NP/np_handler.h
View file

@ -204,7 +204,7 @@ protected:
return match2_event_cnt.fetch_add(1);
}
shared_mutex mutex_req_results;
u8* allocate_req_result(u32 event_key, size_t size);
u8* allocate_req_result(u32 event_key, usz size);
// RPCN
rpcn_client rpcn;

22
rpcs3/Emu/NP/rpcn_client.cpp
View file

@ -91,11 +91,11 @@ void rpcn_client::disconnect()
server_info_received = false;
}
rpcn_client::recvn_result rpcn_client::recvn(u8* buf, std::size_t n)
rpcn_client::recvn_result rpcn_client::recvn(u8* buf, usz n)
{
u32 num_timeouts = 0;
size_t n_recv = 0;
usz n_recv = 0;
while (n_recv != n && !is_abort())
{
std::lock_guard lock(mutex_socket);
@ -136,7 +136,7 @@ rpcn_client::recvn_result rpcn_client::recvn(u8* buf, std::size_t n)
bool rpcn_client::send_packet(const std::vector<u8>& packet)
{
u32 num_timeouts = 0;
std::size_t n_sent = 0;
usz n_sent = 0;
while (n_sent != packet.size())
{
std::lock_guard lock(mutex_socket);
@ -723,7 +723,7 @@ bool rpcn_client::createjoin_room(u32 req_id, const SceNpCommunicationId& commun
builder.Finish(req_finished);
u8* buf = builder.GetBufferPointer();
size_t bufsize = builder.GetSize();
usz bufsize = builder.GetSize();
data.resize(COMMUNICATION_ID_SIZE + sizeof(u32) + bufsize);
memcpy(data.data(), communication_id.data, COMMUNICATION_ID_SIZE);
@ -767,7 +767,7 @@ bool rpcn_client::join_room(u32 req_id, const SceNpCommunicationId& communicatio
builder.Finish(req_finished);
u8* buf = builder.GetBufferPointer();
size_t bufsize = builder.GetSize();
usz bufsize = builder.GetSize();
data.resize(COMMUNICATION_ID_SIZE + sizeof(u32) + bufsize);
memcpy(data.data(), communication_id.data, COMMUNICATION_ID_SIZE);
@ -789,7 +789,7 @@ bool rpcn_client::leave_room(u32 req_id, const SceNpCommunicationId& communicati
auto req_finished = CreateLeaveRoomRequest(builder, req->roomId, final_optdata);
builder.Finish(req_finished);
u8* buf = builder.GetBufferPointer();
size_t bufsize = builder.GetSize();
usz bufsize = builder.GetSize();
data.resize(COMMUNICATION_ID_SIZE + sizeof(u32) + bufsize);
memcpy(data.data(), communication_id.data, COMMUNICATION_ID_SIZE);
@ -855,7 +855,7 @@ bool rpcn_client::search_room(u32 req_id, const SceNpCommunicationId& communicat
auto req_finished = s_req.Finish();
builder.Finish(req_finished);
u8* buf = builder.GetBufferPointer();
size_t bufsize = builder.GetSize();
usz bufsize = builder.GetSize();
data.resize(COMMUNICATION_ID_SIZE + bufsize + sizeof(u32));
memcpy(data.data(), communication_id.data, COMMUNICATION_ID_SIZE);
@ -910,7 +910,7 @@ bool rpcn_client::set_roomdata_external(u32 req_id, const SceNpCommunicationId&
builder.Finish(req_finished);
u8* buf = builder.GetBufferPointer();
size_t bufsize = builder.GetSize();
usz bufsize = builder.GetSize();
data.resize(COMMUNICATION_ID_SIZE + bufsize + sizeof(u32));
memcpy(data.data(), communication_id.data, COMMUNICATION_ID_SIZE);
@ -937,7 +937,7 @@ bool rpcn_client::get_roomdata_internal(u32 req_id, const SceNpCommunicationId&
builder.Finish(req_finished);
u8* buf = builder.GetBufferPointer();
size_t bufsize = builder.GetSize();
usz bufsize = builder.GetSize();
data.resize(COMMUNICATION_ID_SIZE + bufsize + sizeof(u32));
memcpy(data.data(), communication_id.data, COMMUNICATION_ID_SIZE);
@ -992,7 +992,7 @@ bool rpcn_client::set_roomdata_internal(u32 req_id, const SceNpCommunicationId&
builder.Finish(req_finished);
u8* buf = builder.GetBufferPointer();
size_t bufsize = builder.GetSize();
usz bufsize = builder.GetSize();
data.resize(COMMUNICATION_ID_SIZE + bufsize + sizeof(u32));
memcpy(data.data(), communication_id.data, COMMUNICATION_ID_SIZE);
@ -1051,7 +1051,7 @@ bool rpcn_client::send_room_message(u32 req_id, const SceNpCommunicationId& comm
builder.Finish(req_finished);
u8* buf = builder.GetBufferPointer();
size_t bufsize = builder.GetSize();
usz bufsize = builder.GetSize();
data.resize(COMMUNICATION_ID_SIZE + bufsize + sizeof(u32));
memcpy(data.data(), communication_id.data, COMMUNICATION_ID_SIZE);

8
rpcs3/Emu/NP/rpcn_client.h
View file

@ -27,7 +27,7 @@ class vec_stream
{
public:
vec_stream() = delete;
vec_stream(std::vector<u8>& _vec, size_t initial_index = 0)
vec_stream(std::vector<u8>& _vec, usz initial_index = 0)
: vec(_vec)
, i(initial_index){};
bool is_error() const
@ -86,7 +86,7 @@ public:
{
value = reinterpret_cast<le_t<T>>(value);
// resize + memcpy instead?
for (size_t index = 0; index < sizeof(T); index++)
for (usz index = 0; index < sizeof(T); index++)
{
vec.push_back(*(reinterpret_cast<u8*>(&value) + index));
}
@ -99,7 +99,7 @@ public:
protected:
std::vector<u8>& vec;
size_t i = 0;
usz i = 0;
bool error = false;
};
@ -207,7 +207,7 @@ protected:
recvn_fatal,
};
recvn_result recvn(u8* buf, std::size_t n);
recvn_result recvn(u8* buf, usz n);
bool get_reply(u32 expected_id, std::vector<u8>& data);

8
rpcs3/Emu/RSX/Capture/rsx_capture.cpp
View file

@ -78,7 +78,7 @@ namespace rsx
auto layout = get_subresources_layout(tex);
// todo: dont use this function and just get size somehow
size_t texSize = 0;
usz texSize = 0;
for (const auto& l : layout)
texSize += l.data.size();
@ -104,7 +104,7 @@ namespace rsx
auto layout = get_subresources_layout(tex);
// todo: dont use this function and just get size somehow
size_t texSize = 0;
usz texSize = 0;
for (const auto& l : layout)
texSize += l.data.size();
@ -147,7 +147,7 @@ namespace rsx
{
const auto& range = method_registers.current_draw_clause.get_range();
const u32 vertCount = range.count;
const size_t bufferSize = (vertCount - 1) * vertStride + vertSize;
const usz bufferSize = (vertCount - 1) * vertStride + vertSize;
frame_capture_data::memory_block block;
block.offset = base_address + (range.first * vertStride);
@ -186,7 +186,7 @@ namespace rsx
const u32 idxCount = range.count;
const u32 idxAddr = base_addr + (idxFirst * type_size);
const size_t bufferSize = idxCount * type_size;
const usz bufferSize = idxCount * type_size;
frame_capture_data::memory_block block;
block.offset = base_address + (idxFirst * type_size);

2
rpcs3/Emu/RSX/Capture/rsx_replay.cpp
View file

@ -185,7 +185,7 @@ namespace rsx
auto render = get_current_renderer();
auto last_flip = render->int_flip_index;
size_t stopIdx = 0;
usz stopIdx = 0;
for (const auto& replay_cmd : frame->replay_commands)
{
while (Emu.IsPaused())

8
rpcs3/Emu/RSX/CgBinaryProgram.h
View file

@ -121,7 +121,7 @@ class CgBinaryDisasm
std::string m_path; // used for FP decompiler thread, delete this later
u8* m_buffer = nullptr;
std::size_t m_buffer_size = 0;
usz m_buffer_size = 0;
std::string m_arb_shader;
std::string m_glsl_shader;
std::string m_dst_reg_name;
@ -138,8 +138,8 @@ class CgBinaryDisasm
// VP members
u32 m_sca_opcode;
u32 m_vec_opcode;
static const size_t m_max_instr_count = 512;
size_t m_instr_count;
static const usz m_max_instr_count = 512;
usz m_instr_count;
std::vector<u32> m_data;
public:
@ -298,7 +298,7 @@ public:
fs::file f(m_path);
if (!f) return;
size_t size = f.size();
usz size = f.size();
vm::init();
ptr = vm::alloc(static_cast<u32>(size), vm::main);
f.read(vm::base(ptr), size);

8
rpcs3/Emu/RSX/Common/FragmentProgramDecompiler.h
View file

@ -114,8 +114,8 @@ struct temp_register
/**
* This class is used to translate RSX Fragment program to GLSL/HLSL code
* Backend with text based shader can subclass this class and implement :
* - virtual std::string getFloatTypeName(size_t elementCount) = 0;
* - virtual std::string getHalfTypeName(size_t elementCount) = 0;
* - virtual std::string getFloatTypeName(usz elementCount) = 0;
* - virtual std::string getHalfTypeName(usz elementCount) = 0;
* - virtual std::string getFunction(enum class FUNCTION) = 0;
* - virtual std::string saturate(const std::string &code) = 0;
* - virtual std::string compareFunction(enum class COMPARE, const std::string &, const std::string &) = 0;
@ -214,11 +214,11 @@ protected:
/** returns the type name of float vectors.
*/
virtual std::string getFloatTypeName(size_t elementCount) = 0;
virtual std::string getFloatTypeName(usz elementCount) = 0;
/** returns the type name of half vectors.
*/
virtual std::string getHalfTypeName(size_t elementCount) = 0;
virtual std::string getHalfTypeName(usz elementCount) = 0;
/** returns string calling function where arguments are passed via
* $0 $1 $2 substring.

4
rpcs3/Emu/RSX/Common/GLSLCommon.h
View file

@ -135,7 +135,7 @@ namespace program_common
namespace glsl
{
static std::string getFloatTypeNameImpl(size_t elementCount)
static std::string getFloatTypeNameImpl(usz elementCount)
{
switch (elementCount)
{
@ -152,7 +152,7 @@ namespace glsl
}
}
static std::string getHalfTypeNameImpl(size_t elementCount)
static std::string getHalfTypeNameImpl(usz elementCount)
{
switch (elementCount)
{

28
rpcs3/Emu/RSX/Common/ProgramStateCache.cpp
View file

@ -7,12 +7,12 @@
using namespace program_hash_util;
size_t vertex_program_utils::get_vertex_program_ucode_hash(const RSXVertexProgram &program)
usz vertex_program_utils::get_vertex_program_ucode_hash(const RSXVertexProgram &program)
{
// 64-bit Fowler/Noll/Vo FNV-1a hash code
size_t hash = 0xCBF29CE484222325ULL;
usz hash = 0xCBF29CE484222325ULL;
const void* instbuffer = program.data.data();
size_t instIndex = 0;
usz instIndex = 0;
bool end = false;
for (unsigned i = 0; i < program.data.size() / 4; i++)
{
@ -248,9 +248,9 @@ vertex_program_utils::vertex_program_metadata vertex_program_utils::analyse_vert
return result;
}
size_t vertex_program_storage_hash::operator()(const RSXVertexProgram &program) const
usz vertex_program_storage_hash::operator()(const RSXVertexProgram &program) const
{
size_t hash = vertex_program_utils::get_vertex_program_ucode_hash(program);
usz hash = vertex_program_utils::get_vertex_program_ucode_hash(program);
hash ^= program.output_mask;
hash ^= program.texture_dimensions;
return hash;
@ -271,7 +271,7 @@ bool vertex_program_compare::operator()(const RSXVertexProgram &binary1, const R
const void* instBuffer1 = binary1.data.data();
const void* instBuffer2 = binary2.data.data();
size_t instIndex = 0;
usz instIndex = 0;
for (unsigned i = 0; i < binary1.data.size() / 4; i++)
{
const auto active = binary1.instruction_mask[instIndex];
@ -302,10 +302,10 @@ bool fragment_program_utils::is_constant(u32 sourceOperand)
return ((sourceOperand >> 8) & 0x3) == 2;
}
size_t fragment_program_utils::get_fragment_program_ucode_size(const void* ptr)
usz fragment_program_utils::get_fragment_program_ucode_size(const void* ptr)
{
const auto instBuffer = ptr;
size_t instIndex = 0;
usz instIndex = 0;
while (true)
{
const v128 inst = v128::loadu(instBuffer, instIndex);
@ -420,12 +420,12 @@ fragment_program_utils::fragment_program_metadata fragment_program_utils::analys
return result;
}
size_t fragment_program_utils::get_fragment_program_ucode_hash(const RSXFragmentProgram& program)
usz fragment_program_utils::get_fragment_program_ucode_hash(const RSXFragmentProgram& program)
{
// 64-bit Fowler/Noll/Vo FNV-1a hash code
size_t hash = 0xCBF29CE484222325ULL;
usz hash = 0xCBF29CE484222325ULL;
const void* instbuffer = program.get_data();
size_t instIndex = 0;
usz instIndex = 0;
while (true)
{
const auto inst = v128::loadu(instbuffer, instIndex);
@ -447,9 +447,9 @@ size_t fragment_program_utils::get_fragment_program_ucode_hash(const RSXFragment
return 0;
}
size_t fragment_program_storage_hash::operator()(const RSXFragmentProgram& program) const
usz fragment_program_storage_hash::operator()(const RSXFragmentProgram& program) const
{
size_t hash = fragment_program_utils::get_fragment_program_ucode_hash(program);
usz hash = fragment_program_utils::get_fragment_program_ucode_hash(program);
hash ^= program.ctrl;
hash ^= program.texture_dimensions;
hash ^= program.unnormalized_coords;
@ -469,7 +469,7 @@ bool fragment_program_compare::operator()(const RSXFragmentProgram& binary1, con
const void* instBuffer1 = binary1.get_data();
const void* instBuffer2 = binary2.get_data();
size_t instIndex = 0;
usz instIndex = 0;
while (true)
{
const auto inst1 = v128::loadu(instBuffer1, instIndex);

22
rpcs3/Emu/RSX/Common/ProgramStateCache.h
View file

@ -27,14 +27,14 @@ namespace program_hash_util
u32 referenced_textures_mask;
};
static size_t get_vertex_program_ucode_hash(const RSXVertexProgram &program);
static usz get_vertex_program_ucode_hash(const RSXVertexProgram &program);
static vertex_program_metadata analyse_vertex_program(const u32* data, u32 entry, RSXVertexProgram& dst_prog);
};
struct vertex_program_storage_hash
{
size_t operator()(const RSXVertexProgram &program) const;
usz operator()(const RSXVertexProgram &program) const;
};
struct vertex_program_compare
@ -61,16 +61,16 @@ namespace program_hash_util
*/
static bool is_constant(u32 sourceOperand);
static size_t get_fragment_program_ucode_size(const void* ptr);
static usz get_fragment_program_ucode_size(const void* ptr);
static fragment_program_metadata analyse_fragment_program(const void* ptr);
static size_t get_fragment_program_ucode_hash(const RSXFragmentProgram &program);
static usz get_fragment_program_ucode_hash(const RSXFragmentProgram &program);
};
struct fragment_program_storage_hash
{
size_t operator()(const RSXFragmentProgram &program) const;
usz operator()(const RSXFragmentProgram &program) const;
};
struct fragment_program_compare
@ -90,8 +90,8 @@ namespace program_hash_util
* - a typedef PipelineProperties to a type that encapsulate various state info relevant to program compilation (alpha test, primitive type,...)
* - a typedef ExtraData type that will be passed to the buildProgram function.
* It should also contains the following function member :
* - static void recompile_fragment_program(RSXFragmentProgram *RSXFP, FragmentProgramData& fragmentProgramData, size_t ID);
* - static void recompile_vertex_program(RSXVertexProgram *RSXVP, VertexProgramData& vertexProgramData, size_t ID);
* - static void recompile_fragment_program(RSXFragmentProgram *RSXFP, FragmentProgramData& fragmentProgramData, usz ID);
* - static void recompile_vertex_program(RSXVertexProgram *RSXVP, VertexProgramData& vertexProgramData, usz ID);
* - static PipelineData build_program(VertexProgramData &vertexProgramData, FragmentProgramData &fragmentProgramData, const PipelineProperties &pipelineProperties, const ExtraData& extraData);
* - static void validate_pipeline_properties(const VertexProgramData &vertexProgramData, const FragmentProgramData &fragmentProgramData, PipelineProperties& props);
*/
@ -116,9 +116,9 @@ class program_state_cache
struct pipeline_key_hash
{
size_t operator()(const pipeline_key &key) const
usz operator()(const pipeline_key &key) const
{
size_t hashValue = 0;
usz hashValue = 0;
hashValue ^= rpcs3::hash_base<unsigned>(key.vertex_program_id);
hashValue ^= rpcs3::hash_base<unsigned>(key.fragment_program_id);
hashValue ^= rpcs3::hash_struct<pipeline_properties>(key.properties);
@ -142,7 +142,7 @@ protected:
shared_mutex m_pipeline_mutex;
shared_mutex m_decompiler_mutex;
atomic_t<size_t> m_next_id = 0;
atomic_t<usz> m_next_id = 0;
bool m_cache_miss_flag; // Set if last lookup did not find any usable cached programs
binary_to_vertex_program m_vertex_shader_cache;
@ -407,7 +407,7 @@ public:
f32* dst = dst_buffer.data();
alignas(16) f32 tmp[4];
for (size_t offset_in_fragment_program : I->second.FragmentConstantOffsetCache)
for (usz offset_in_fragment_program : I->second.FragmentConstantOffsetCache)
{
char* data = static_cast<char*>(fragment_program.get_data()) + offset_in_fragment_program;
const __m128i vector = _mm_loadu_si128(reinterpret_cast<__m128i*>(data));

2
rpcs3/Emu/RSX/Common/ShaderParam.h
View file

@ -218,7 +218,7 @@ public:
}
}
size_t get_vector_size() const
usz get_vector_size() const
{
return swizzles[swizzles.size() - 1].length();
}

4
rpcs3/Emu/RSX/Common/TextGlyphs.h
View file

@ -176,7 +176,7 @@ private:
const auto glyph_data = font_glyph.substr(7);
if (glyph_data.length() == 32)
{
for (std::size_t n = 0; n < this_glyph.plot.size(); ++n)
for (usz n = 0; n < this_glyph.plot.size(); ++n)
{
const auto line = glyph_data.substr(n * 2, 2);
std::from_chars(line.data(), line.data() + line.size(), this_glyph.plot[n], 16);
@ -215,7 +215,7 @@ public:
{
entry.glyph_point_offset = ::size32(result);
for (std::size_t j = 0; j < entry.plot.size(); ++j)
for (usz j = 0; j < entry.plot.size(); ++j)
{
const auto &line = entry.plot[j];
if (line == 0)

42
rpcs3/Emu/RSX/Common/TextureUtils.cpp
View file

@ -317,7 +317,7 @@ namespace
u8 block_size_in_bytes = sizeof(SRC_TYPE);
std::vector<rsx::subresource_layout> result;
size_t offset_in_src = 0;
usz offset_in_src = 0;
u8 border_size = border ? (padded_row ? 1 : 4) : 0;
u32 src_pitch_in_block;
@ -383,30 +383,30 @@ namespace
}
template<typename T>
u32 get_row_pitch_in_block(u16 width_in_block, size_t alignment)
u32 get_row_pitch_in_block(u16 width_in_block, usz alignment)
{
if (const size_t pitch = width_in_block * sizeof(T);
if (const usz pitch = width_in_block * sizeof(T);
pitch == alignment)
{
return width_in_block;
}
else
{
size_t divided = (pitch + alignment - 1) / alignment;
usz divided = (pitch + alignment - 1) / alignment;
return static_cast<u32>(divided * alignment / sizeof(T));
}
}
u32 get_row_pitch_in_block(u16 block_size_in_bytes, u16 width_in_block, size_t alignment)
u32 get_row_pitch_in_block(u16 block_size_in_bytes, u16 width_in_block, usz alignment)
{
if (const size_t pitch = width_in_block * block_size_in_bytes;
if (const usz pitch = width_in_block * block_size_in_bytes;
pitch == alignment)
{
return width_in_block;
}
else
{
size_t divided = (pitch + alignment - 1) / alignment;
usz divided = (pitch + alignment - 1) / alignment;
return static_cast<u32>(divided * alignment / block_size_in_bytes);
}
}
@ -910,41 +910,41 @@ namespace rsx
return width_in_block * bytes_per_block;
}
size_t get_placed_texture_storage_size(u16 width, u16 height, u32 depth, u8 format, u16 mipmap, bool cubemap, size_t row_pitch_alignment, size_t mipmap_alignment)
usz get_placed_texture_storage_size(u16 width, u16 height, u32 depth, u8 format, u16 mipmap, bool cubemap, usz row_pitch_alignment, usz mipmap_alignment)
{
format &= ~(CELL_GCM_TEXTURE_LN | CELL_GCM_TEXTURE_UN);
size_t block_edge = get_format_block_size_in_texel(format);
size_t block_size_in_byte = get_format_block_size_in_bytes(format);
usz block_edge = get_format_block_size_in_texel(format);
usz block_size_in_byte = get_format_block_size_in_bytes(format);
size_t height_in_blocks = (height + block_edge - 1) / block_edge;
size_t width_in_blocks = (width + block_edge - 1) / block_edge;
usz height_in_blocks = (height + block_edge - 1) / block_edge;
usz width_in_blocks = (width + block_edge - 1) / block_edge;
size_t result = 0;
usz result = 0;
for (u16 i = 0; i < mipmap; ++i)
{
size_t rowPitch = align(block_size_in_byte * width_in_blocks, row_pitch_alignment);
usz rowPitch = align(block_size_in_byte * width_in_blocks, row_pitch_alignment);
result += align(rowPitch * height_in_blocks * depth, mipmap_alignment);
height_in_blocks = std::max<size_t>(height_in_blocks / 2, 1);
width_in_blocks = std::max<size_t>(width_in_blocks / 2, 1);
height_in_blocks = std::max<usz>(height_in_blocks / 2, 1);
width_in_blocks = std::max<usz>(width_in_blocks / 2, 1);
}
// Mipmap, height and width aren't allowed to be zero
return (ensure(result) * (cubemap ? 6 : 1));
}
size_t get_placed_texture_storage_size(const rsx::fragment_texture& texture, size_t row_pitch_alignment, size_t mipmap_alignment)
usz get_placed_texture_storage_size(const rsx::fragment_texture& texture, usz row_pitch_alignment, usz mipmap_alignment)
{
return get_placed_texture_storage_size(texture.width(), texture.height(), texture.depth(), texture.format(), texture.mipmap(), texture.cubemap(),
row_pitch_alignment, mipmap_alignment);
}
size_t get_placed_texture_storage_size(const rsx::vertex_texture& texture, size_t row_pitch_alignment, size_t mipmap_alignment)
usz get_placed_texture_storage_size(const rsx::vertex_texture& texture, usz row_pitch_alignment, usz mipmap_alignment)
{
return get_placed_texture_storage_size(texture.width(), texture.height(), texture.depth(), texture.format(), texture.mipmap(), texture.cubemap(),
row_pitch_alignment, mipmap_alignment);
}
static size_t get_texture_size(u32 format, u16 width, u16 height, u16 depth, u32 pitch, u16 mipmaps, u16 layers, u8 border)
static usz get_texture_size(u32 format, u16 width, u16 height, u16 depth, u32 pitch, u16 mipmaps, u16 layers, u8 border)
{
const auto gcm_format = format & ~(CELL_GCM_TEXTURE_LN | CELL_GCM_TEXTURE_UN);
const bool packed = !(format & CELL_GCM_TEXTURE_LN);
@ -1001,14 +1001,14 @@ namespace rsx
return size;
}
size_t get_texture_size(const rsx::fragment_texture& texture)
usz get_texture_size(const rsx::fragment_texture& texture)
{
return get_texture_size(texture.format(), texture.width(), texture.height(), texture.depth(),
texture.pitch(), texture.get_exact_mipmap_count(), texture.cubemap() ? 6 : 1,
texture.border_type() ^ 1);
}
size_t get_texture_size(const rsx::vertex_texture& texture)
usz get_texture_size(const rsx::vertex_texture& texture)
{
return get_texture_size(texture.format(), texture.width(), texture.height(), texture.depth(),
texture.pitch(), texture.get_exact_mipmap_count(), texture.cubemap() ? 6 : 1,

12
rpcs3/Emu/RSX/Common/TextureUtils.h
View file

@ -125,16 +125,16 @@ namespace rsx
bool supports_byteswap;
bool supports_vtc_decoding;
bool supports_hw_deswizzle;
size_t alignment;
usz alignment;
};
/**
* Get size to store texture in a linear fashion.
* Storage is assumed to use a rowPitchAlignment boundary for every row of texture.
*/
size_t get_placed_texture_storage_size(u16 width, u16 height, u32 depth, u8 format, u16 mipmap, bool cubemap, size_t row_pitch_alignment, size_t mipmap_alignment);
size_t get_placed_texture_storage_size(const rsx::fragment_texture &texture, size_t row_pitch_alignment, size_t mipmap_alignment = 0x200);
size_t get_placed_texture_storage_size(const rsx::vertex_texture &texture, size_t row_pitch_alignment, size_t mipmap_alignment = 0x200);
usz get_placed_texture_storage_size(u16 width, u16 height, u32 depth, u8 format, u16 mipmap, bool cubemap, usz row_pitch_alignment, usz mipmap_alignment);
usz get_placed_texture_storage_size(const rsx::fragment_texture &texture, usz row_pitch_alignment, usz mipmap_alignment = 0x200);
usz get_placed_texture_storage_size(const rsx::vertex_texture &texture, usz row_pitch_alignment, usz mipmap_alignment = 0x200);
/**
* get all rsx::subresource_layout for texture.
@ -162,8 +162,8 @@ namespace rsx
/**
* Get number of bytes occupied by texture in RSX mem
*/
size_t get_texture_size(const rsx::fragment_texture &texture);
size_t get_texture_size(const rsx::vertex_texture &texture);
usz get_texture_size(const rsx::fragment_texture &texture);
usz get_texture_size(const rsx::vertex_texture &texture);
/**
* Get packed pitch

10
rpcs3/Emu/RSX/Common/VertexProgramDecompiler.h
View file

@ -9,7 +9,7 @@
/**
* This class is used to translate RSX Vertex program to GLSL/HLSL code
* Backend with text based shader can subclass this class and implement :
* - virtual std::string getFloatTypeName(size_t elementCount) = 0;
* - virtual std::string getFloatTypeName(usz elementCount) = 0;
* - virtual std::string getFunction(enum class FUNCTION) = 0;
* - virtual std::string compareFunction(enum class COMPARE, const std::string &, const std::string &) = 0;
* - virtual void insertHeader(std::stringstream &OS) = 0;
@ -55,10 +55,10 @@ struct VertexProgramDecompiler
}
};
static const size_t m_max_instr_count = 512;
static const usz m_max_instr_count = 512;
Instruction m_instructions[m_max_instr_count];
Instruction* m_cur_instr;
size_t m_instr_count;
usz m_instr_count;
std::vector<std::string> m_body;
std::stack<u32> m_call_stack;
@ -91,11 +91,11 @@ struct VertexProgramDecompiler
protected:
/** returns the type name of float vectors.
*/
virtual std::string getFloatTypeName(size_t elementCount) = 0;
virtual std::string getFloatTypeName(usz elementCount) = 0;
/** returns the type name of int vectors.
*/
virtual std::string getIntTypeName(size_t elementCount) = 0;
virtual std::string getIntTypeName(usz elementCount) = 0;
/** returns string calling function where arguments are passed via
* $0 $1 $2 substring.

36
rpcs3/Emu/RSX/Common/ring_buffer_helper.h
View file

@ -17,10 +17,10 @@ protected:
* Does alloc cross get position ?
*/
template<int Alignment>
bool can_alloc(size_t size) const
bool can_alloc(usz size) const
{
size_t alloc_size = align(size, Alignment);
size_t aligned_put_pos = align(m_put_pos, Alignment);
usz alloc_size = align(size, Alignment);
usz aligned_put_pos = align(m_put_pos, Alignment);
if (aligned_put_pos + alloc_size < m_size)
{
// range before get
@ -45,17 +45,17 @@ protected:
}
// Grow the buffer to hold at least size bytes
virtual bool grow(size_t /*size*/)
virtual bool grow(usz /*size*/)
{
// Stub
return false;
}
size_t m_size;
size_t m_put_pos; // Start of free space
size_t m_min_guard_size; //If an allocation touches the guard region, reset the heap to avoid going over budget
size_t m_current_allocated_size;
size_t m_largest_allocated_pool;
usz m_size;
usz m_put_pos; // Start of free space
usz m_min_guard_size; //If an allocation touches the guard region, reset the heap to avoid going over budget
usz m_current_allocated_size;
usz m_largest_allocated_pool;
char* m_name;
public:
@ -64,9 +64,9 @@ public:
data_heap(const data_heap&) = delete;
data_heap(data_heap&&) = delete;
size_t m_get_pos; // End of free space
usz m_get_pos; // End of free space
void init(size_t heap_size, const char* buffer_name = "unnamed", size_t min_guard_size=0x10000)
void init(usz heap_size, const char* buffer_name = "unnamed", usz min_guard_size=0x10000)
{
m_name = const_cast<char*>(buffer_name);
@ -81,10 +81,10 @@ public:
}
template<int Alignment>
size_t alloc(size_t size)
usz alloc(usz size)
{
const size_t alloc_size = align(size, Alignment);
const size_t aligned_put_pos = align(m_put_pos, Alignment);
const usz alloc_size = align(size, Alignment);
const usz aligned_put_pos = align(m_put_pos, Alignment);
if (!can_alloc<Alignment>(size) && !grow(aligned_put_pos + alloc_size))
{
@ -92,7 +92,7 @@ public:
m_name, m_size, m_current_allocated_size, size, m_min_guard_size, m_largest_allocated_pool);
}
const size_t block_length = (aligned_put_pos - m_put_pos) + alloc_size;
const usz block_length = (aligned_put_pos - m_put_pos) + alloc_size;
m_current_allocated_size += block_length;
m_largest_allocated_pool = std::max(m_largest_allocated_pool, block_length);
@ -111,14 +111,14 @@ public:
/**
* return current putpos - 1
*/
size_t get_current_put_pos_minus_one() const
usz get_current_put_pos_minus_one() const
{
return (m_put_pos > 0) ? m_put_pos - 1 : m_size - 1;
}
virtual bool is_critical() const
{
const size_t guard_length = std::max(m_min_guard_size, m_largest_allocated_pool);
const usz guard_length = std::max(m_min_guard_size, m_largest_allocated_pool);
return (m_current_allocated_size + guard_length) >= m_size;
}
@ -142,7 +142,7 @@ public:
fmt::throw_exception("m_put_pos == m_get_pos!");
}
size_t size() const
usz size() const
{
return m_size;
}

4
rpcs3/Emu/RSX/Common/surface_store.cpp
View file

@ -19,7 +19,7 @@ namespace rsx
fmt::throw_exception("Wrong color_target");
}
size_t get_aligned_pitch(surface_color_format format, u32 width)
usz get_aligned_pitch(surface_color_format format, u32 width)
{
switch (format)
{
@ -41,7 +41,7 @@ namespace rsx
fmt::throw_exception("Unknown color surface format");
}
size_t get_packed_pitch(surface_color_format format, u32 width)
usz get_packed_pitch(surface_color_format format, u32 width)
{
switch (format)
{

10
rpcs3/Emu/RSX/Common/surface_store.h
View file

@ -10,8 +10,8 @@ namespace rsx
namespace utility
{
std::vector<u8> get_rtt_indexes(surface_target color_target);
size_t get_aligned_pitch(surface_color_format format, u32 width);
size_t get_packed_pitch(surface_color_format format, u32 width);
usz get_aligned_pitch(surface_color_format format, u32 width);
usz get_packed_pitch(surface_color_format format, u32 width);
}
template<typename Traits>
@ -426,7 +426,7 @@ namespace rsx
u32 address,
format_type format,
surface_antialiasing antialias,
size_t width, size_t height, size_t pitch,
usz width, usz height, usz pitch,
u8 bpp,
Args&&... extra_params)
{
@ -638,7 +638,7 @@ namespace rsx
u32 address,
surface_color_format color_format,
surface_antialiasing antialias,
size_t width, size_t height, size_t pitch,
usz width, usz height, usz pitch,
Args&&... extra_params)
{
return bind_surface_address<false>(
@ -653,7 +653,7 @@ namespace rsx
u32 address,
surface_depth_format2 depth_format,
surface_antialiasing antialias,
size_t width, size_t height, size_t pitch,
usz width, usz height, usz pitch,
Args&&... extra_params)
{
return bind_surface_address<true>(

2
rpcs3/Emu/RSX/Common/surface_utils.h
View file

@ -426,7 +426,7 @@ namespace rsx
});
// Try and optimize by omitting possible overlapped transfers
for (size_t i = old_contents.size() - 1; i > 0 /* Intentional */; i--)
for (usz i = old_contents.size() - 1; i > 0 /* Intentional */; i--)
{
old_contents[i].init_transfer(target);

12
rpcs3/Emu/RSX/Common/texture_cache.h
View file

@ -82,8 +82,8 @@ namespace rsx
#ifdef TEXTURE_CACHE_DEBUG
void check_pre_sanity() const
{
size_t flush_and_unprotect_count = sections_to_flush.size() + sections_to_unprotect.size();
size_t exclude_count = sections_to_exclude.size();
usz flush_and_unprotect_count = sections_to_flush.size() + sections_to_unprotect.size();
usz exclude_count = sections_to_exclude.size();
//-------------------------
// It is illegal to have only exclusions except when reading from a range with only RO sections
@ -381,7 +381,7 @@ namespace rsx
m_cache_update_tag = rsx::get_shared_tag();
}
template <typename CharT, std::size_t N, typename... Args>
template <typename CharT, usz N, typename... Args>
void emit_once(bool error, const CharT(&fmt)[N], const Args&... params)
{
const auto result = m_once_only_messages_set.emplace(fmt::format(fmt, params...));
@ -394,13 +394,13 @@ namespace rsx
rsx_log.warning("%s", *result.first);
}
template <typename CharT, std::size_t N, typename... Args>
template <typename CharT, usz N, typename... Args>
void err_once(const CharT(&fmt)[N], const Args&... params)
{
emit_once(true, fmt, params...);
}
template <typename CharT, std::size_t N, typename... Args>
template <typename CharT, usz N, typename... Args>
void warn_once(const CharT(&fmt)[N], const Args&... params)
{
emit_once(false, fmt, params...);
@ -737,7 +737,7 @@ namespace rsx
// naive check that sections are not duplicated in the results
for (auto &section1 : result.sections)
{
size_t count = 0;
usz count = 0;
for (auto &section2 : result.sections)
{
if (section1 == section2) count++;

10
rpcs3/Emu/RSX/Common/texture_cache_checker.h
View file

@ -69,17 +69,17 @@ namespace rsx {
// 4GB memory space / 4096 bytes per page = 1048576 pages
// Initialized to utils::protection::rw
static constexpr size_t num_pages = 0x1'0000'0000 / 4096;
static constexpr usz num_pages = 0x1'0000'0000 / 4096;
per_page_info_t _info[num_pages]{0};
static_assert(static_cast<u32>(utils::protection::rw) == 0, "utils::protection::rw must have value 0 for the above constructor to work");
static constexpr size_t rsx_address_to_index(u32 address)
static constexpr usz rsx_address_to_index(u32 address)
{
return (address / 4096);
}
static constexpr u32 index_to_rsx_address(size_t idx)
static constexpr u32 index_to_rsx_address(usz idx)
{
return static_cast<u32>(idx * 4096);
}
@ -96,7 +96,7 @@ namespace rsx {
constexpr u32 info_pointer_to_address(const per_page_info_t* ptr) const
{
return index_to_rsx_address(static_cast<size_t>(ptr - _info));
return index_to_rsx_address(static_cast<usz>(ptr - _info));
}
std::string prot_to_str(utils::protection prot) const
@ -199,7 +199,7 @@ namespace rsx {
void verify() const
{
for (size_t idx = 0; idx < num_pages; idx++)
for (usz idx = 0; idx < num_pages; idx++)
{
auto &elmnt = _info[idx];
if (!elmnt.verify())

10
rpcs3/Emu/RSX/Common/texture_cache_predictor.h
View file

@ -28,7 +28,7 @@ namespace rsx
m_size = 0;
}
size_t size() const
usz size() const
{
return m_size;
}
@ -404,11 +404,11 @@ namespace std
template <typename traits>
struct hash<rsx::texture_cache_predictor_key<traits>>
{
std::size_t operator()(const rsx::texture_cache_predictor_key<traits>& k) const
usz operator()(const rsx::texture_cache_predictor_key<traits>& k) const
{
size_t result = std::hash<utils::address_range>{}(k.cpu_range);
result ^= static_cast<size_t>(k.format);
result ^= (static_cast<size_t>(k.context) << 16);
usz result = std::hash<utils::address_range>{}(k.cpu_range);
result ^= static_cast<usz>(k.format);
result ^= (static_cast<usz>(k.context) << 16);
return result;
}
};

6
rpcs3/Emu/RSX/Common/texture_cache_utils.h
View file

@ -15,7 +15,7 @@ namespace rsx
* List of Arrays
* (avoids reallocation without the significant disadvantages of slow iteration through a list)
*/
template <typename section_storage_type, size_t array_size>
template <typename section_storage_type, usz array_size>
class ranged_storage_block_list
{
static_assert(array_size > 0, "array_elements must be positive non-zero");
@ -497,7 +497,7 @@ namespace rsx
return block_for(section.get_section_base());
}
inline block_type& operator[](size_t pos)
inline block_type& operator[](usz pos)
{
AUDIT(pos < num_blocks);
return blocks[pos];
@ -917,7 +917,7 @@ namespace rsx
address_range_vector flush_exclusions; // Address ranges that will be skipped during flush
predictor_type *m_predictor = nullptr;
size_t m_predictor_key_hash = 0;
usz m_predictor_key_hash = 0;
predictor_entry_type *m_predictor_entry = nullptr;
public:

6
rpcs3/Emu/RSX/GL/GLFragmentProgram.cpp
View file

@ -7,12 +7,12 @@
#include "../GCM.h"
#include "../Common/GLSLCommon.h"
std::string GLFragmentDecompilerThread::getFloatTypeName(size_t elementCount)
std::string GLFragmentDecompilerThread::getFloatTypeName(usz elementCount)
{
return glsl::getFloatTypeNameImpl(elementCount);
}
std::string GLFragmentDecompilerThread::getHalfTypeName(size_t elementCount)
std::string GLFragmentDecompilerThread::getHalfTypeName(usz elementCount)
{
return glsl::getHalfTypeNameImpl(elementCount);
}
@ -369,7 +369,7 @@ void GLFragmentProgram::Decompile(const RSXFragmentProgram& prog)
PT.type == "samplerCube")
continue;
size_t offset = atoi(PI.name.c_str() + 2);
usz offset = atoi(PI.name.c_str() + 2);
FragmentConstantOffsetCache.push_back(offset);
}
}

6
rpcs3/Emu/RSX/GL/GLFragmentProgram.h
View file

@ -33,8 +33,8 @@ public:
void Task();
protected:
std::string getFloatTypeName(size_t elementCount) override;
std::string getHalfTypeName(size_t elementCount) override;
std::string getFloatTypeName(usz elementCount) override;
std::string getHalfTypeName(usz elementCount) override;
std::string getFunction(FUNCTION) override;
std::string compareFunction(COMPARE, const std::string&, const std::string&) override;
@ -59,7 +59,7 @@ public:
ParamArray parr;
u32 id;
gl::glsl::shader shader;
std::vector<size_t> FragmentConstantOffsetCache;
std::vector<usz> FragmentConstantOffsetCache;
/**
* Decompile a fragment shader located in the PS3's Memory. This function operates synchronously.

4
rpcs3/Emu/RSX/GL/GLHelpers.cpp
View file

@ -298,13 +298,13 @@ namespace gl
glDrawElements(draw_mode(mode), count, static_cast<GLenum>(type), indices);
}
void fbo::draw_elements(rsx::primitive_type mode, GLsizei count, indices_type type, const buffer& indices, size_t indices_buffer_offset) const
void fbo::draw_elements(rsx::primitive_type mode, GLsizei count, indices_type type, const buffer& indices, usz indices_buffer_offset) const
{
indices.bind(buffer::target::element_array);
glDrawElements(draw_mode(mode), count, static_cast<GLenum>(type), reinterpret_cast<GLvoid*>(indices_buffer_offset));
}
void fbo::draw_elements(const buffer& buffer_, rsx::primitive_type mode, GLsizei count, indices_type type, const buffer& indices, size_t indices_buffer_offset) const
void fbo::draw_elements(const buffer& buffer_, rsx::primitive_type mode, GLsizei count, indices_type type, const buffer& indices, usz indices_buffer_offset) const
{
buffer_.bind(buffer::target::array);
draw_elements(mode, count, type, indices, indices_buffer_offset);

4
rpcs3/Emu/RSX/GL/GLHelpers.h
View file

@ -2179,8 +2179,8 @@ public:
void draw_elements(rsx::primitive_type mode, GLsizei count, indices_type type, const GLvoid *indices) const;
void draw_elements(const buffer& buffer, rsx::primitive_type mode, GLsizei count, indices_type type, const GLvoid *indices) const;
void draw_elements(rsx::primitive_type mode, GLsizei count, indices_type type, const buffer& indices, size_t indices_buffer_offset = 0) const;
void draw_elements(const buffer& buffer_, rsx::primitive_type mode, GLsizei count, indices_type type, const buffer& indices, size_t indices_buffer_offset = 0) const;
void draw_elements(rsx::primitive_type mode, GLsizei count, indices_type type, const buffer& indices, usz indices_buffer_offset = 0) const;
void draw_elements(const buffer& buffer_, rsx::primitive_type mode, GLsizei count, indices_type type, const buffer& indices, usz indices_buffer_offset = 0) const;
void draw_elements(rsx::primitive_type mode, GLsizei count, const GLubyte *indices) const;
void draw_elements(const buffer& buffer, rsx::primitive_type mode, GLsizei count, const GLubyte *indices) const;
void draw_elements(rsx::primitive_type mode, GLsizei count, const GLushort *indices) const;

4
rpcs3/Emu/RSX/GL/GLProgramBuffer.h
View file

@ -15,13 +15,13 @@ struct GLTraits
using pipeline_properties = void*;
static
void recompile_fragment_program(const RSXFragmentProgram &RSXFP, fragment_program_type& fragmentProgramData, size_t /*ID*/)
void recompile_fragment_program(const RSXFragmentProgram &RSXFP, fragment_program_type& fragmentProgramData, usz /*ID*/)
{
fragmentProgramData.Decompile(RSXFP);
}
static
void recompile_vertex_program(const RSXVertexProgram &RSXVP, vertex_program_type& vertexProgramData, size_t /*ID*/)
void recompile_vertex_program(const RSXVertexProgram &RSXVP, vertex_program_type& vertexProgramData, usz /*ID*/)
{
vertexProgramData.Decompile(RSXVP);
}

14
rpcs3/Emu/RSX/GL/GLRenderTargets.h
View file

@ -140,7 +140,7 @@ struct gl_render_target_traits
std::unique_ptr<gl::render_target> create_new_surface(
u32 address,
rsx::surface_color_format surface_color_format,
size_t width, size_t height, size_t pitch,
usz width, usz height, usz pitch,
rsx::surface_antialiasing antialias
)
{
@ -169,7 +169,7 @@ struct gl_render_target_traits
std::unique_ptr<gl::render_target> create_new_surface(
u32 address,
rsx::surface_depth_format2 surface_depth_format,
size_t width, size_t height, size_t pitch,
usz width, usz height, usz pitch,
rsx::surface_antialiasing antialias
)
{
@ -262,13 +262,13 @@ struct gl_render_target_traits
{}
static
bool surface_is_pitch_compatible(const std::unique_ptr<gl::render_target> &surface, size_t pitch)
bool surface_is_pitch_compatible(const std::unique_ptr<gl::render_target> &surface, usz pitch)
{
return surface->get_rsx_pitch() == pitch;
}
static
void invalidate_surface_contents(gl::command_context&, gl::render_target *surface, u32 address, size_t pitch)
void invalidate_surface_contents(gl::command_context&, gl::render_target *surface, u32 address, usz pitch)
{
surface->set_rsx_pitch(static_cast<u16>(pitch));
surface->queue_tag(address);
@ -305,7 +305,7 @@ struct gl_render_target_traits
bool int_surface_matches_properties(
const std::unique_ptr<gl::render_target> &surface,
gl::texture::internal_format format,
size_t width, size_t height,
usz width, usz height,
rsx::surface_antialiasing antialias,
bool check_refs = false)
{
@ -321,7 +321,7 @@ struct gl_render_target_traits
bool surface_matches_properties(
const std::unique_ptr<gl::render_target> &surface,
rsx::surface_color_format format,
size_t width, size_t height,
usz width, usz height,
rsx::surface_antialiasing antialias,
bool check_refs=false)
{
@ -333,7 +333,7 @@ struct gl_render_target_traits
bool surface_matches_properties(
const std::unique_ptr<gl::render_target> &surface,
rsx::surface_depth_format2 format,
size_t width, size_t height,
usz width, usz height,
rsx::surface_antialiasing antialias,
bool check_refs = false)
{

4
rpcs3/Emu/RSX/GL/GLTextOut.h
View file

@ -64,7 +64,7 @@ namespace gl
m_program.link();
}
void load_program(float scale_x, float scale_y, float *offsets, size_t nb_offsets, color4f color)
void load_program(float scale_x, float scale_y, float *offsets, usz nb_offsets, color4f color)
{
float scale[] = { scale_x, scale_y };
@ -88,7 +88,7 @@ namespace gl
GlyphManager glyph_source;
auto points = glyph_source.generate_point_map();
const size_t buffer_size = points.size() * sizeof(GlyphManager::glyph_point);
const usz buffer_size = points.size() * sizeof(GlyphManager::glyph_point);
m_text_buffer.data(buffer_size, points.data());
m_offsets = glyph_source.get_glyph_offsets();

2
rpcs3/Emu/RSX/GL/GLTexture.cpp
View file

@ -836,7 +836,7 @@ namespace gl
{
// Calculate staging buffer size
const u32 aligned_pitch = align<u32>(dst->pitch(), 4);
size_t texture_data_sz = dst->depth() * dst->height() * aligned_pitch;
usz texture_data_sz = dst->depth() * dst->height() * aligned_pitch;
std::vector<std::byte> data_upload_buf(texture_data_sz);
// TODO: GL drivers support byteswapping and this should be used instead of doing so manually

Some files were not shown because too many files have changed in this diff Show more