ShuriZma
/
rpcs3
mirror of https://github.com/RPCS3/rpcs3.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Try to get rid of SIZE_32 macro

This commit is contained in:
Nekotekina 2018-09-03 18:46:14 +03:00
parent 7bccdbf157
commit ce4c4696dd
18 changed files with 82 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Utilities/BEType.h
View File

@ -307,7 +307,7 @@ struct offset32_array<v128::masked_array_t<T, N, M>>
template <typename Arg>
static inline u32 index32(const Arg& arg)
{
return SIZE_32(T) * (static_cast<u32>(arg) ^ static_cast<u32>(M));
return u32{sizeof(T)} * (static_cast<u32>(arg) ^ static_cast<u32>(M));
}
};

7
Utilities/types.h
View File

@ -40,9 +40,6 @@
#define CHECK_MAX_SIZE(type, size) static_assert(sizeof(type) <= size, #type " type size is too big")
#define CHECK_SIZE_ALIGN(type, size, align) CHECK_SIZE(type, size); CHECK_ALIGN(type, align)
// Return 32 bit sizeof() to avoid widening/narrowing conversions with size_t
#define SIZE_32(...) static_cast<u32>(sizeof(__VA_ARGS__))
// Variant pattern matching helper
#define MATCH(arg, ...) constexpr(std::is_same_v<std::decay_t<decltype(arg)>, __VA_ARGS__>)
@ -421,7 +418,7 @@ struct offset32_array
template <typename Arg>
static inline u32 index32(const Arg& arg)
{
return SIZE_32(std::remove_extent_t<T>) * static_cast<u32>(arg);
return u32{sizeof(std::remove_extent_t<T>)} * static_cast<u32>(arg);
}
};
@ -431,7 +428,7 @@ struct offset32_array<std::array<T, N>>
template <typename Arg>
static inline u32 index32(const Arg& arg)
{
return SIZE_32(T) * static_cast<u32>(arg);
return u32{sizeof(T)} * static_cast<u32>(arg);
}
};

44
rpcs3/Crypto/unself.cpp
View File

@ -674,17 +674,16 @@ bool SCEDecrypter::LoadHeaders()
bool SCEDecrypter::LoadMetadata(const u8 erk[32], const u8 riv[16])
{
aes_context aes;
u32 metadata_info_size = SIZE_32(meta_info);
auto metadata_info = std::make_unique<u8[]>(metadata_info_size);
u32 metadata_headers_size = sce_hdr.se_hsize - (SIZE_32(sce_hdr) + sce_hdr.se_meta + SIZE_32(meta_info));
auto metadata_headers = std::make_unique<u8[]>(metadata_headers_size);
const auto metadata_info = std::make_unique<u8[]>(sizeof(meta_info));
const auto metadata_headers_size = sce_hdr.se_hsize - (sizeof(sce_hdr) + sce_hdr.se_meta + sizeof(meta_info));
const auto metadata_headers = std::make_unique<u8[]>(metadata_headers_size);
// Locate and read the encrypted metadata info.
sce_f.seek(sce_hdr.se_meta + sizeof(sce_hdr));
sce_f.read(metadata_info.get(), metadata_info_size);
sce_f.read(metadata_info.get(), sizeof(meta_info));
// Locate and read the encrypted metadata header and section header.
sce_f.seek(sce_hdr.se_meta + sizeof(sce_hdr) + metadata_info_size);
sce_f.seek(sce_hdr.se_meta + sizeof(sce_hdr) + sizeof(meta_info));
sce_f.read(metadata_headers.get(), metadata_headers_size);
// Copy the necessary parameters.
@ -698,7 +697,7 @@ bool SCEDecrypter::LoadMetadata(const u8 erk[32], const u8 riv[16])
{
// Decrypt the metadata info.
aes_setkey_dec(&aes, metadata_key, 256); // AES-256
aes_crypt_cbc(&aes, AES_DECRYPT, metadata_info_size, metadata_iv, metadata_info.get(), metadata_info.get());
aes_crypt_cbc(&aes, AES_DECRYPT, sizeof(meta_info), metadata_iv, metadata_info.get(), metadata_info.get());
}
// Load the metadata info.
@ -1105,7 +1104,7 @@ bool SELFDecrypter::DecryptNPDRM(u8 *metadata, u32 metadata_size)
// Use klicensee if available.
if (key_v.GetKlicenseeKey() != nullptr)
memcpy(npdrm_key, key_v.GetKlicenseeKey(), 0x10);
else
else
memcpy(npdrm_key, NP_KLIC_FREE, 0x10);
}
else
@ -1131,17 +1130,16 @@ bool SELFDecrypter::DecryptNPDRM(u8 *metadata, u32 metadata_size)
bool SELFDecrypter::LoadMetadata(u8* klic_key)
{
aes_context aes;
u32 metadata_info_size = SIZE_32(meta_info);
auto metadata_info = std::make_unique<u8[]>(metadata_info_size);
u32 metadata_headers_size = sce_hdr.se_hsize - (SIZE_32(sce_hdr) + sce_hdr.se_meta + SIZE_32(meta_info));
auto metadata_headers = std::make_unique<u8[]>(metadata_headers_size);
const auto metadata_info = std::make_unique<u8[]>(sizeof(meta_info));
const auto metadata_headers_size = sce_hdr.se_hsize - (sizeof(sce_hdr) + sce_hdr.se_meta + sizeof(meta_info));
const auto metadata_headers = std::make_unique<u8[]>(metadata_headers_size);
// Locate and read the encrypted metadata info.
self_f.seek(sce_hdr.se_meta + sizeof(sce_hdr));
self_f.read(metadata_info.get(), metadata_info_size);
self_f.read(metadata_info.get(), sizeof(meta_info));
// Locate and read the encrypted metadata header and section header.
self_f.seek(sce_hdr.se_meta + sizeof(sce_hdr) + metadata_info_size);
self_f.seek(sce_hdr.se_meta + sizeof(sce_hdr) + sizeof(meta_info));
self_f.read(metadata_headers.get(), metadata_headers_size);
// Find the right keyset from the key vault.
@ -1161,12 +1159,12 @@ bool SELFDecrypter::LoadMetadata(u8* klic_key)
if ((sce_hdr.se_flags & 0x8000) != 0x8000)
{
// Decrypt the NPDRM layer.
if (!DecryptNPDRM(metadata_info.get(), metadata_info_size))
if (!DecryptNPDRM(metadata_info.get(), sizeof(meta_info)))
return false;
// Decrypt the metadata info.
aes_setkey_dec(&aes, metadata_key, 256); // AES-256
aes_crypt_cbc(&aes, AES_DECRYPT, metadata_info_size, metadata_iv, metadata_info.get(), metadata_info.get());
aes_crypt_cbc(&aes, AES_DECRYPT, sizeof(meta_info), metadata_iv, metadata_info.get(), metadata_info.get());
}
// Load the metadata info.
@ -1325,7 +1323,7 @@ static bool IsSelfElf32(const fs::file& f)
SelfHeader sh;
hdr.Load(f);
sh.Load(f);
// Locate the class byte and check it.
u8 elf_class[0x8];
@ -1377,12 +1375,12 @@ static bool CheckDebugSelf(fs::file& s)
}
extern fs::file decrypt_self(fs::file elf_or_self, u8* klic_key)
{
if (!elf_or_self)
{
if (!elf_or_self)
{
return fs::file{};
}
elf_or_self.seek(0);
// Check SELF header first. Check for a debug SELF.
@ -1400,21 +1398,21 @@ extern fs::file decrypt_self(fs::file elf_or_self, u8* klic_key)
LOG_ERROR(LOADER, "SELF: Failed to load SELF file headers!");
return fs::file{};
}
// Load and decrypt the SELF file metadata.
if (!self_dec.LoadMetadata(klic_key))
{
LOG_ERROR(LOADER, "SELF: Failed to load SELF file metadata!");
return fs::file{};
}
// Decrypt the SELF file data.
if (!self_dec.DecryptData())
{
LOG_ERROR(LOADER, "SELF: Failed to decrypt SELF file data!");
return fs::file{};
}
// Make a new ELF file from this SELF.
return self_dec.MakeElf(isElf32);
}

8
rpcs3/Emu/Cell/Modules/cellAdec.cpp
View File

@ -857,7 +857,7 @@ s32 cellAdecGetPcmItem(u32 handle, vm::pptr<CellAdecPcmItem> pcmItem)
}
pcm->pcmHandle = 0; // ???
pcm->pcmAttr.bsiInfo_addr = pcm.addr() + SIZE_32(CellAdecPcmItem);
pcm->pcmAttr.bsiInfo_addr = pcm.addr() + u32{sizeof(CellAdecPcmItem)};
pcm->startAddr = 0x00000312; // invalid address (no output)
pcm->size = af.size;
pcm->status = CELL_OK;
@ -869,10 +869,10 @@ s32 cellAdecGetPcmItem(u32 handle, vm::pptr<CellAdecPcmItem> pcmItem)
if (adecIsAtracX(adec->type))
{
auto atx = vm::ptr<CellAdecAtracXInfo>::make(pcm.addr() + SIZE_32(CellAdecPcmItem));
auto atx = vm::ptr<CellAdecAtracXInfo>::make(pcm.addr() + u32{sizeof(CellAdecPcmItem)});
atx->samplingFreq = frame->sample_rate;
atx->nbytes = frame->nb_samples * SIZE_32(float);
atx->nbytes = frame->nb_samples * u32{sizeof(float)};
if (frame->channels == 1)
{
atx->channelConfigIndex = 1;
@ -897,7 +897,7 @@ s32 cellAdecGetPcmItem(u32 handle, vm::pptr<CellAdecPcmItem> pcmItem)
}
else if (adec->type == CELL_ADEC_TYPE_MP3)
{
auto mp3 = vm::ptr<CellAdecMP3Info>::make(pcm.addr() + SIZE_32(CellAdecPcmItem));
auto mp3 = vm::ptr<CellAdecMP3Info>::make(pcm.addr() + u32{sizeof(CellAdecPcmItem)});
// TODO
memset(mp3.get_ptr(), 0, sizeof(CellAdecMP3Info));

6
rpcs3/Emu/Cell/Modules/cellAudio.cpp
View File

@ -832,7 +832,7 @@ error_code cellAudioAddData(u32 portNum, vm::ptr<float> src, u32 samples, float
const audio_port& port = g_audio->ports[portNum];
const auto dst = vm::ptr<float>::make(port.addr.addr() + u32(port.tag % port.block) * port.channel * 256 * SIZE_32(float));
const auto dst = vm::ptr<float>::make(port.addr.addr() + u32(port.tag % port.block) * port.channel * 256 * u32{sizeof(float)});
for (u32 i = 0; i < samples * port.channel; i++)
{
@ -867,7 +867,7 @@ error_code cellAudioAdd2chData(u32 portNum, vm::ptr<float> src, u32 samples, flo
const audio_port& port = g_audio->ports[portNum];
const auto dst = vm::ptr<float>::make(port.addr.addr() + s32(port.tag % port.block) * port.channel * 256 * SIZE_32(float));
const auto dst = vm::ptr<float>::make(port.addr.addr() + s32(port.tag % port.block) * port.channel * 256 * u32{sizeof(float)});
if (port.channel == 2)
{
@ -929,7 +929,7 @@ error_code cellAudioAdd6chData(u32 portNum, vm::ptr<float> src, float volume)
const audio_port& port = g_audio->ports[portNum];
const auto dst = vm::ptr<float>::make(port.addr.addr() + s32(port.tag % port.block) * port.channel * 256 * SIZE_32(float));
const auto dst = vm::ptr<float>::make(port.addr.addr() + s32(port.tag % port.block) * port.channel * 256 * u32{sizeof(float)});
if (port.channel == 6)
{

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

@ -824,7 +824,7 @@ void ElementaryStream::push_au(u32 size, u64 dts, u64 pts, u64 userdata, bool ra
info->reserved = 0;
info->userData = userdata;
auto spec = vm::ptr<u32>::make(put + SIZE_32(CellDmuxAuInfoEx));
auto spec = vm::ptr<u32>::make(put + u32{sizeof(CellDmuxAuInfoEx)});
*spec = specific;
auto inf = vm::ptr<CellDmuxAuInfo>::make(put + 64);

2
rpcs3/Emu/Cell/Modules/cellGifDec.cpp
View File

@ -66,7 +66,7 @@ s32 cellGifDecOpen(PMainHandle mainHandle, PPSubHandle subHandle, PSrc src, POpe
}
}
subHandle->set(vm::alloc(SIZE_32(GifStream), vm::main));
subHandle->set(vm::alloc(sizeof(GifStream), vm::main));
**subHandle = current_subHandle;

14
rpcs3/Emu/Cell/Modules/cellSpurs.cpp
View File

@ -1845,7 +1845,7 @@ s32 _spurs::trace_initialize(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<
return CELL_SPURS_CORE_ERROR_ALIGN;
}
if (size < SIZE_32(CellSpursTraceInfo) || mode & ~(CELL_SPURS_TRACE_MODE_FLAG_MASK))
if (size < sizeof(CellSpursTraceInfo) || mode & ~(CELL_SPURS_TRACE_MODE_FLAG_MASK))
{
return CELL_SPURS_CORE_ERROR_INVAL;
}
@ -1855,7 +1855,7 @@ s32 _spurs::trace_initialize(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<
return CELL_SPURS_CORE_ERROR_STAT;
}
spurs->traceDataSize = size - SIZE_32(CellSpursTraceInfo);
spurs->traceDataSize = size - u32{sizeof(CellSpursTraceInfo)};
for (u32 i = 0; i < 8; i++)
{
buffer->spuThread[i] = spurs->spus[i];
@ -1867,7 +1867,7 @@ s32 _spurs::trace_initialize(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<
spurs->traceBuffer.set(buffer.addr() | (mode & CELL_SPURS_TRACE_MODE_FLAG_WRAP_BUFFER ? 1 : 0));
spurs->traceMode = mode;
u32 spuTraceDataCount = (u32)((spurs->traceDataSize / SIZE_32(CellSpursTracePacket)) / spurs->nSpus);
u32 spuTraceDataCount = ::narrow<u32>((spurs->traceDataSize / sizeof(CellSpursTracePacket)) / spurs->nSpus, HERE);
for (u32 i = 0, j = 8; i < 6; i++)
{
spurs->traceStartIndex[i] = j;
@ -3372,7 +3372,7 @@ s32 cellSpursCreateTasksetWithAttribute(ppu_thread& ppu, vm::ptr<CellSpurs> spur
auto rc = _spurs::create_taskset(ppu, spurs, taskset, attr->args, attr.ptr(&CellSpursTasksetAttribute::priority), attr->max_contention, attr->name, attr->taskset_size, attr->enable_clear_ls);
if (attr->taskset_size >= SIZE_32(CellSpursTaskset2))
if (attr->taskset_size >= sizeof(CellSpursTaskset2))
{
// TODO: Implement this
}
@ -3384,7 +3384,7 @@ s32 cellSpursCreateTaskset(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<Ce
{
cellSpurs.warning("cellSpursCreateTaskset(spurs=*0x%x, taskset=*0x%x, args=0x%llx, priority=*0x%x, maxContention=%d)", spurs, taskset, args, priority, maxContention);
return _spurs::create_taskset(ppu, spurs, taskset, args, priority, maxContention, vm::null, SIZE_32(CellSpursTaskset), 0);
return _spurs::create_taskset(ppu, spurs, taskset, args, priority, maxContention, vm::null, sizeof(CellSpursTaskset), 0);
}
s32 cellSpursJoinTaskset(vm::ptr<CellSpursTaskset> taskset)
@ -3658,7 +3658,7 @@ s32 cellSpursTasksetAttributeSetTasksetSize(vm::ptr<CellSpursTasksetAttribute> a
return CELL_SPURS_TASK_ERROR_ALIGN;
}
if (size != SIZE_32(CellSpursTaskset) && size != SIZE_32(CellSpursTaskset2))
if (size != sizeof(CellSpursTaskset) && size != sizeof(CellSpursTaskset2))
{
return CELL_SPURS_TASK_ERROR_INVAL;
}
@ -3789,7 +3789,7 @@ s32 cellSpursCreateTaskset2(ppu_thread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<C
_cellSpursTasksetAttribute2Initialize(attr, 0);
}
if (s32 rc = _spurs::create_taskset(ppu, spurs, taskset, attr->args, attr.ptr(&CellSpursTasksetAttribute2::priority), attr->max_contention, attr->name, SIZE_32(CellSpursTaskset2), attr->enable_clear_ls))
if (s32 rc = _spurs::create_taskset(ppu, spurs, taskset, attr->args, attr.ptr(&CellSpursTasksetAttribute2::priority), attr->max_contention, attr->name, sizeof(CellSpursTaskset2), attr->enable_clear_ls))
{
return rc;
}

8
rpcs3/Emu/Cell/Modules/cellVdec.cpp
View File

@ -751,11 +751,11 @@ s32 cellVdecGetPicItem(u32 handle, vm::pptr<CellVdecPicItem> picItem)
info->auUserData[1] = 0;
info->status = CELL_OK;
info->attr = CELL_VDEC_PICITEM_ATTR_NORMAL;
info->picInfo_addr = info.addr() + SIZE_32(CellVdecPicItem);
info->picInfo_addr = info.addr() + u32{sizeof(CellVdecPicItem)};
if (vdec->type == CELL_VDEC_CODEC_TYPE_AVC)
{
const vm::ptr<CellVdecAvcInfo> avc = vm::cast(info.addr() + SIZE_32(CellVdecPicItem));
const vm::ptr<CellVdecAvcInfo> avc = vm::cast(info.addr() + u32{sizeof(CellVdecPicItem)});
avc->horizontalSize = frame->width;
avc->verticalSize = frame->height;
@ -811,7 +811,7 @@ s32 cellVdecGetPicItem(u32 handle, vm::pptr<CellVdecPicItem> picItem)
}
else if (vdec->type == CELL_VDEC_CODEC_TYPE_DIVX)
{
const vm::ptr<CellVdecDivxInfo> dvx = vm::cast(info.addr() + SIZE_32(CellVdecPicItem));
const vm::ptr<CellVdecDivxInfo> dvx = vm::cast(info.addr() + u32{sizeof(CellVdecPicItem)});
switch (s32 pct = frame->pict_type)
{
@ -847,7 +847,7 @@ s32 cellVdecGetPicItem(u32 handle, vm::pptr<CellVdecPicItem> picItem)
}
else if (vdec->type == CELL_VDEC_CODEC_TYPE_MPEG2)
{
const vm::ptr<CellVdecMpeg2Info> mp2 = vm::cast(info.addr() + SIZE_32(CellVdecPicItem));
const vm::ptr<CellVdecMpeg2Info> mp2 = vm::cast(info.addr() + u32{sizeof(CellVdecPicItem)});
std::memset(mp2.get_ptr(), 0, sizeof(CellVdecMpeg2Info));
mp2->horizontal_size = frame->width;

2
rpcs3/Emu/Cell/PPUModule.cpp
View File

@ -1436,7 +1436,7 @@ void ppu_load_exec(const ppu_exec_object& elf)
g_ps3_sdk_version = sdk_version;
// Initialize process arguments
auto args = vm::ptr<u64>::make(vm::alloc(SIZE_32(u64) * (::size32(Emu.argv) + ::size32(Emu.envp) + 2), vm::main));
auto args = vm::ptr<u64>::make(vm::alloc(u32{sizeof(u64)} * (::size32(Emu.argv) + ::size32(Emu.envp) + 2), vm::main));
auto argv = args;
for (const auto& arg : Emu.argv)

28
rpcs3/Emu/Memory/vm_ptr.h
View File

@ -69,7 +69,7 @@ namespace vm
template <typename MT, typename T2, typename ET = std::remove_extent_t<MT>, typename = if_comparable_t<T, T2>>
_ptr_base<ET> ptr(MT T2::*const mptr, u32 index) const
{
return vm::cast(vm::cast(m_addr, HERE) + offset32(mptr) + SIZE_32(ET) * index);
return vm::cast(vm::cast(m_addr, HERE) + offset32(mptr) + u32{sizeof(ET)} * index);
}
// Get vm reference to a struct member
@ -83,7 +83,7 @@ namespace vm
template <typename MT, typename T2, typename ET = std::remove_extent_t<MT>, typename = if_comparable_t<T, T2>>
_ref_base<ET> ref(MT T2::*const mptr, u32 index) const
{
return vm::cast(vm::cast(m_addr, HERE) + offset32(mptr) + SIZE_32(ET) * index);
return vm::cast(vm::cast(m_addr, HERE) + offset32(mptr) + u32{sizeof(ET)} * index);
}
// Get vm reference
@ -109,7 +109,7 @@ namespace vm
std::add_lvalue_reference_t<T> operator [](u32 index) const
{
return *static_cast<T*>(vm::base(vm::cast(m_addr, HERE) + SIZE_32(T) * index));
return *static_cast<T*>(vm::base(vm::cast(m_addr, HERE) + u32{sizeof(T)} * index));
}
// Test address for arbitrary alignment: (addr & (align - 1)) == 0
@ -127,7 +127,7 @@ namespace vm
// Get type size
static constexpr u32 size()
{
return SIZE_32(T);
return sizeof(T);
}
// Get type alignment
@ -149,61 +149,61 @@ namespace vm
_ptr_base<T, u32> operator +(u32 count) const
{
return vm::cast(vm::cast(m_addr, HERE) + count * SIZE_32(T));
return vm::cast(vm::cast(m_addr, HERE) + count * size());
}
_ptr_base<T, u32> operator -(u32 count) const
{
return vm::cast(vm::cast(m_addr, HERE) - count * SIZE_32(T));
return vm::cast(vm::cast(m_addr, HERE) - count * size());
}
friend _ptr_base<T, u32> operator +(u32 count, const _ptr_base& ptr)
{
return vm::cast(vm::cast(ptr.m_addr, HERE) + count * SIZE_32(T));
return vm::cast(vm::cast(ptr.m_addr, HERE) + count * size());
}
// Pointer difference operator
template<typename T2, typename AT2>
std::enable_if_t<std::is_object<T2>::value && std::is_same<std::decay_t<T>, std::decay_t<T2>>::value, s32> operator -(const _ptr_base<T2, AT2>& right) const
{
return static_cast<s32>(vm::cast(m_addr, HERE) - vm::cast(right.m_addr, HERE)) / SIZE_32(T);
return static_cast<s32>(vm::cast(m_addr, HERE) - vm::cast(right.m_addr, HERE)) / size();
}
_ptr_base operator ++(int)
{
_ptr_base result = *this;
m_addr = vm::cast(m_addr, HERE) + SIZE_32(T);
m_addr = vm::cast(m_addr, HERE) + size();
return result;
}
_ptr_base& operator ++()
{
m_addr = vm::cast(m_addr, HERE) + SIZE_32(T);
m_addr = vm::cast(m_addr, HERE) + size();
return *this;
}
_ptr_base operator --(int)
{
_ptr_base result = *this;
m_addr = vm::cast(m_addr, HERE) - SIZE_32(T);
m_addr = vm::cast(m_addr, HERE) - size();
return result;
}
_ptr_base& operator --()
{
m_addr = vm::cast(m_addr, HERE) - SIZE_32(T);
m_addr = vm::cast(m_addr, HERE) - size();
return *this;
}
_ptr_base& operator +=(s32 count)
{
m_addr = vm::cast(m_addr, HERE) + count * SIZE_32(T);
m_addr = vm::cast(m_addr, HERE) + count * size();
return *this;
}
_ptr_base& operator -=(s32 count)
{
m_addr = vm::cast(m_addr, HERE) - count * SIZE_32(T);
m_addr = vm::cast(m_addr, HERE) - count * size();
return *this;
}
};

10
rpcs3/Emu/Memory/vm_var.h
View File

@ -43,7 +43,7 @@ namespace vm
_var_base(const _var_base&) = delete;
_var_base()
: pointer(A::alloc(SIZE_32(T), alignof(T)))
: pointer(A::alloc(sizeof(T), alignof(T)))
{
}
@ -57,7 +57,7 @@ namespace vm
{
if (pointer::addr())
{
A::dealloc(pointer::addr(), SIZE_32(T));
A::dealloc(pointer::addr(), sizeof(T));
}
}
};
@ -75,8 +75,8 @@ namespace vm
_var_base(const _var_base&) = delete;
_var_base(u32 count)
: pointer(A::alloc(SIZE_32(T) * count, alignof(T)))
, m_size(SIZE_32(T) * count)
: pointer(A::alloc(u32{sizeof(T)} * count, alignof(T)))
, m_size(u32{sizeof(T)} * count)
{
}
@ -101,7 +101,7 @@ namespace vm
u32 get_count() const
{
return m_size / SIZE_32(T);
return m_size / u32{sizeof(T)};
}
auto begin() const

4
rpcs3/Emu/RSX/CgBinaryProgram.h
View File

@ -309,7 +309,7 @@ public:
m_arb_shader += fmt::format("#%d ", i) + param_type + param_name + param_semantic + param_const + "\n";
offset += SIZE_32(CgBinaryParameter);
offset += sizeof(CgBinaryParameter);
}
m_arb_shader += "\n";
@ -366,7 +366,7 @@ public:
m_arb_shader += fmt::format("#%d ", i) + param_type + param_name + param_semantic + param_const + "\n";
offset += SIZE_32(CgBinaryParameter);
offset += sizeof(CgBinaryParameter);
}
m_arb_shader += "\n";

4
rpcs3/Emu/RSX/Common/FragmentProgramDecompiler.cpp
View File

@ -183,7 +183,7 @@ std::string FragmentProgramDecompiler::AddConst()
return name;
}
auto data = (be_t<u32>*) ((char*)m_prog.addr + m_size + 4 * SIZE_32(u32));
auto data = (be_t<u32>*) ((char*)m_prog.addr + m_size + 4 * u32{sizeof(u32)});
m_offset = 2 * 4 * sizeof(u32);
u32 x = GetData(data[0]);
@ -264,7 +264,7 @@ std::string FragmentProgramDecompiler::ClampValue(const std::string& code, u32 p
bool FragmentProgramDecompiler::DstExpectsSca()
{
int writes = 0;
if (dst.mask_x) writes++;
if (dst.mask_y) writes++;
if (dst.mask_z) writes++;

4
rpcs3/Emu/RSX/GCM.h
View File

@ -173,7 +173,7 @@ namespace rsx
*dst++ = cmd.as<u32>();
}
return SIZE_32(u32) * (static_cast<u32>(values.size()) + 1);
return u32{sizeof(u32)} * (static_cast<u32>(values.size()) + 1);
}
template<typename AT>
@ -181,6 +181,6 @@ namespace rsx
{
*dst++ = RSX_METHOD_OLD_JUMP_CMD | offset;
return SIZE_32(u32);
return sizeof(u32);
}
}

12
rpcs3/Loader/ELF.h
View File

@ -297,18 +297,18 @@ public:
header.e_machine = Machine;
header.e_version = 1;
header.e_entry = this->header.e_entry;
header.e_phoff = SIZE_32(ehdr_t);
header.e_shoff = SIZE_32(ehdr_t) + SIZE_32(phdr_t) * ::size32(progs);
header.e_phoff = u32{sizeof(ehdr_t)};
header.e_shoff = u32{sizeof(ehdr_t)} + u32{sizeof(phdr_t)} * ::size32(progs);
header.e_flags = this->header.e_flags;
header.e_ehsize = SIZE_32(ehdr_t);
header.e_phentsize = SIZE_32(phdr_t);
header.e_ehsize = u32{sizeof(ehdr_t)};
header.e_phentsize = u32{sizeof(phdr_t)};
header.e_phnum = ::size32(progs);
header.e_shentsize = SIZE_32(shdr_t);
header.e_shentsize = u32{sizeof(shdr_t)};
header.e_shnum = ::size32(shdrs);
header.e_shstrndx = this->header.e_shstrndx;
stream.write(header);
sz_t off = header.e_shoff + SIZE_32(shdr_t) * ::size32(shdrs);
sz_t off = header.e_shoff + u32{sizeof(shdr_t)} * ::size32(shdrs);
for (phdr_t phdr : progs)
{

2
rpcs3/Loader/PSF.cpp
View File

@ -92,7 +92,7 @@ namespace psf
return std::min(m_max_size, ::narrow<u32>(m_value_string.size() + (m_type == format::string)));
case format::integer:
return SIZE_32(u32);
return sizeof(u32);
}
fmt::throw_exception("Invalid format (0x%x)" HERE, m_type);

10
rpcs3/Loader/TROPUSR.cpp
View File

@ -169,8 +169,8 @@ bool TROPUSRLoader::Generate(const std::string& filepath, const std::string& con
default: trophy_grade = 0;
}
TROPUSREntry4 entry4 = { 4, SIZE_32(TROPUSREntry4) - 0x10, (u32)m_table4.size(), 0, trophy_id, trophy_grade, 0xFFFFFFFF };
TROPUSREntry6 entry6 = { 6, SIZE_32(TROPUSREntry6) - 0x10, (u32)m_table6.size(), 0, trophy_id };
TROPUSREntry4 entry4 = { 4, u32{sizeof(TROPUSREntry4)} - 0x10, (u32)m_table4.size(), 0, trophy_id, trophy_grade, 0xFFFFFFFF };
TROPUSREntry6 entry6 = { 6, u32{sizeof(TROPUSREntry6)} - 0x10, (u32)m_table6.size(), 0, trophy_id };
m_table4.push_back(entry4);
m_table6.push_back(entry6);
@ -178,9 +178,9 @@ bool TROPUSRLoader::Generate(const std::string& filepath, const std::string& con
}
u64 offset = sizeof(TROPUSRHeader) + 2 * sizeof(TROPUSRTableHeader);
TROPUSRTableHeader table4header = { 4, SIZE_32(TROPUSREntry4) - 0x10, 1, (u32)m_table4.size(), offset };
TROPUSRTableHeader table4header = { 4, u32{sizeof(TROPUSREntry4)} - 0x10, 1, (u32)m_table4.size(), offset };
offset += m_table4.size() * sizeof(TROPUSREntry4);
TROPUSRTableHeader table6header = { 6, SIZE_32(TROPUSREntry6) - 0x10, 1, (u32)m_table6.size(), offset };
TROPUSRTableHeader table6header = { 6, u32{sizeof(TROPUSREntry6)} - 0x10, 1, (u32)m_table6.size(), offset };
offset += m_table6.size() * sizeof(TROPUSREntry6);
m_tableHeaders.clear();
@ -234,7 +234,7 @@ u64 TROPUSRLoader::GetTrophyTimestamp(u32 id)
return 0;
}
// TODO: What timestamp does sceNpTrophyGetTrophyInfo want, timestamp1 or timestamp2?
// TODO: What timestamp does sceNpTrophyGetTrophyInfo want, timestamp1 or timestamp2?
return m_table6[id].timestamp2; // Let's assume the trophies are stored ordered
}