Mirror/ppsspp
1
0 Fork 0
mirror of https://github.com/hrydgard/ppsspp.git synced 2026-10-01 14:58:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove std::string from memblockinfo

Browse Source
This commit is contained in:
Henrik Rydgård committed 2021-03-13 17:12:30 +01:00
1 parent 2d2036d4d0
commit 797cc41a1c
4 files changed
+54 -31
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Core/Debugger/MemBlockInfo.cpp
+27 -19
View File
@@ -16,6 +16,7 @@
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
#include <mutex>
#include "Common/Log.h"
#include "Common/Serialize/Serializer.h"
#include "Common/Serialize/SerializeFuncs.h"
@@ -23,13 +24,14 @@
#include "Core/Debugger/Breakpoints.h"
#include "Core/Debugger/MemBlockInfo.h"
#include "Core/MIPS/MIPS.h"
#include "Common/StringUtils.h"
class MemSlabMap {
public:
MemSlabMap();
~MemSlabMap();
bool Mark(uint32_t addr, uint32_t size, uint64_t ticks, uint32_t pc, bool allocated, const std::string &tag);
bool Mark(uint32_t addr, uint32_t size, uint64_t ticks, uint32_t pc, bool allocated, const char *tag);
bool Find(MemBlockFlags flags, uint32_t addr, uint32_t size, std::vector<MemBlockInfo> &results);
void Reset();
void DoState(PointerWrap &p);
@@ -41,7 +43,7 @@ private:
uint64_t ticks = 0;
uint32_t pc = 0;
bool allocated = false;
std::string tag;
char tag[32]{};
Slab *prev = nullptr;
Slab *next = nullptr;
@@ -72,8 +74,9 @@ struct PendingNotifyMem {
uint32_t size;
uint64_t ticks;
uint32_t pc;
std::string tag;
char tag[32];
};
static_assert(sizeof(PendingNotifyMem) == 64, "...");
static constexpr size_t MAX_PENDING_NOTIFIES = 512;
static MemSlabMap allocMap;
@@ -91,7 +94,7 @@ MemSlabMap::~MemSlabMap() {
Clear();
}
bool MemSlabMap::Mark(uint32_t addr, uint32_t size, uint64_t ticks, uint32_t pc, bool allocated, const std::string &tag) {
bool MemSlabMap::Mark(uint32_t addr, uint32_t size, uint64_t ticks, uint32_t pc, bool allocated, const char *tag) {
uint32_t end = addr + size;
Slab *slab = FindSlab(addr);
Slab *firstMatch = nullptr;
@@ -108,8 +111,8 @@ bool MemSlabMap::Mark(uint32_t addr, uint32_t size, uint64_t ticks, uint32_t pc,
slab->ticks = ticks;
slab->pc = pc;
}
if (!tag.empty())
slab->tag = tag;
if (tag)
truncate_cpy(slab->tag, tag);
// Move on to the next one.
if (firstMatch == nullptr)
@@ -130,7 +133,7 @@ bool MemSlabMap::Find(MemBlockFlags flags, uint32_t addr, uint32_t size, std::ve
Slab *slab = FindSlab(addr);
bool found = false;
while (slab != nullptr && slab->start < end) {
if (slab->pc != 0 || !slab->tag.empty()) {
if (slab->pc != 0 || strlen(slab->tag)) {
results.push_back({ flags, slab->start, slab->end - slab->start, slab->ticks, slab->pc, slab->tag, slab->allocated });
found = true;
}
@@ -242,7 +245,7 @@ MemSlabMap::Slab *MemSlabMap::Split(Slab *slab, uint32_t size) {
next->ticks = slab->ticks;
next->pc = slab->pc;
next->allocated = slab->allocated;
next->tag = slab->tag;
truncate_cpy(next->tag, slab->tag);
next->prev = slab;
next->next = slab->next;
@@ -330,14 +333,14 @@ void FlushPendingMemInfo() {
allocMap.Mark(info.start, info.size, info.ticks, info.pc, true, info.tag);
} else if (info.flags & MemBlockFlags::FREE) {
// Maintain the previous allocation tag for debugging.
allocMap.Mark(info.start, info.size, info.ticks, 0, false, "");
suballocMap.Mark(info.start, info.size, info.ticks, 0, false, "");
allocMap.Mark(info.start, info.size, info.ticks, 0, false, nullptr);
suballocMap.Mark(info.start, info.size, info.ticks, 0, false, nullptr);
}
if (info.flags & MemBlockFlags::SUB_ALLOC) {
suballocMap.Mark(info.start, info.size, info.ticks, info.pc, true, info.tag);
} else if (info.flags & MemBlockFlags::SUB_FREE) {
// Maintain the previous allocation tag for debugging.
suballocMap.Mark(info.start, info.size, info.ticks, 0, false, "");
suballocMap.Mark(info.start, info.size, info.ticks, 0, false, nullptr);
}
if (info.flags & MemBlockFlags::TEXTURE) {
textureMap.Mark(info.start, info.size, info.ticks, info.pc, true, info.tag);
@@ -349,11 +352,7 @@ void FlushPendingMemInfo() {
pendingNotifies.clear();
}
void NotifyMemInfo(MemBlockFlags flags, uint32_t start, uint32_t size, const std::string &tag) {
NotifyMemInfoPC(flags, start, size, currentMIPS->pc, tag);
}
void NotifyMemInfoPC(MemBlockFlags flags, uint32_t start, uint32_t size, uint32_t pc, const std::string &tag) {
void NotifyMemInfoPC(MemBlockFlags flags, uint32_t start, uint32_t size, uint32_t pc, const char *tagStr, size_t strLength) {
if (size == 0) {
return;
}
@@ -363,7 +362,12 @@ void NotifyMemInfoPC(MemBlockFlags flags, uint32_t start, uint32_t size, uint32_
PendingNotifyMem info{ flags, start, size };
info.ticks = CoreTiming::GetTicks();
info.pc = pc;
info.tag = tag;
size_t copyLength = strLength;
if (copyLength >= sizeof(info.tag)) {
copyLength = sizeof(info.tag) - 1;
}
memcpy(info.tag, tagStr, copyLength);
info.tag[copyLength] = 0;
bool needFlush = false;
{
@@ -377,12 +381,16 @@ void NotifyMemInfoPC(MemBlockFlags flags, uint32_t start, uint32_t size, uint32_
}
if (flags & MemBlockFlags::WRITE) {
CBreakPoints::ExecMemCheck(start, true, size, pc, tag.c_str());
CBreakPoints::ExecMemCheck(start, true, size, pc, tagStr);
} else if (flags & MemBlockFlags::READ) {
CBreakPoints::ExecMemCheck(start, false, size, pc, tag.c_str());
CBreakPoints::ExecMemCheck(start, false, size, pc, tagStr);
}
}
void NotifyMemInfo(MemBlockFlags flags, uint32_t start, uint32_t size, const char *str, size_t strLength) {
NotifyMemInfoPC(flags, start, size, currentMIPS->pc, str, strLength);
}
std::vector<MemBlockInfo> FindMemInfo(uint32_t start, uint32_t size) {
FlushPendingMemInfo();
start &= ~0xC0000000;
Core/Debugger/MemBlockInfo.h
+12 -2
View File
@@ -46,8 +46,18 @@ struct MemBlockInfo {
bool allocated;
};
void NotifyMemInfo(MemBlockFlags flags, uint32_t start, uint32_t size, const std::string &tag);
void NotifyMemInfoPC(MemBlockFlags flags, uint32_t start, uint32_t size, uint32_t pc, const std::string &tag);
void NotifyMemInfo(MemBlockFlags flags, uint32_t start, uint32_t size, const char *str, size_t strLength);
// This lets us avoid calling strlen on string constants, instead the string length (including null)
// is computed at compile time.
template<size_t count>
inline void NotifyMemInfo(MemBlockFlags flags, uint32_t start, uint32_t size, const char(&str)[count]) {
NotifyMemInfo(flags, start, size, str, count);
}
inline void NotifyMemInfo(MemBlockFlags flags, uint32_t start, uint32_t size, const std::string &str) {
NotifyMemInfo(flags, start, size, str.c_str(), str.size() + 1);
}
std::vector<MemBlockInfo> FindMemInfo(uint32_t start, uint32_t size);
std::vector<MemBlockInfo> FindMemInfoByFlag(MemBlockFlags flags, uint32_t start, uint32_t size);
Core/MemMap.cpp
+2 -2
View File
@@ -459,7 +459,7 @@ void Write_Opcode_JIT(const u32 _Address, const Opcode& _Value)
Memory::WriteUnchecked_U32(_Value.encoding, _Address);
}
void Memset(const u32 _Address, const u8 _iValue, const u32 _iLength, const std::string &tag) {
void Memset(const u32 _Address, const u8 _iValue, const u32 _iLength, const char *tag) {
if (IsValidRange(_Address, _iLength)) {
uint8_t *ptr = GetPointerUnchecked(_Address);
memset(ptr, _iValue, _iLength);
@@ -468,7 +468,7 @@ void Memset(const u32 _Address, const u8 _iValue, const u32 _iLength, const std:
Write_U8(_iValue, (u32)(_Address + i));
}
NotifyMemInfo(MemBlockFlags::WRITE, _Address, _iLength, tag);
NotifyMemInfo(MemBlockFlags::WRITE, _Address, _iLength, tag, strlen(tag));
}
} // namespace
Core/MemMapHelpers.h
+13 -8
View File
@@ -17,6 +17,8 @@
#pragma once
#include <cstring>
#include "Common/CommonTypes.h"
#include "Core/Debugger/MemBlockInfo.h"
#include "Core/MemMap.h"
@@ -28,31 +30,34 @@ extern MIPSState *currentMIPS;
namespace Memory
{
inline void Memcpy(const u32 to_address, const void *from_data, const u32 len, const std::string &tag = "Memcpy") {
inline void Memcpy(const u32 to_address, const void *from_data, const u32 len, const char *tag = "Memcpy") {
u8 *to = GetPointer(to_address);
if (to) {
memcpy(to, from_data, len);
NotifyMemInfo(MemBlockFlags::WRITE, to_address, len, tag);
size_t tagLen = strlen(tag);
NotifyMemInfo(MemBlockFlags::WRITE, to_address, len, tag, tagLen);
}
// if not, GetPointer will log.
}
inline void Memcpy(void *to_data, const u32 from_address, const u32 len, const std::string &tag = "Memcpy") {
inline void Memcpy(void *to_data, const u32 from_address, const u32 len, const char *tag = "Memcpy") {
const u8 *from = GetPointer(from_address);
if (from) {
memcpy(to_data, from, len);
NotifyMemInfo(MemBlockFlags::READ, from_address, len, tag);
size_t tagLen = strlen(tag);
NotifyMemInfo(MemBlockFlags::READ, from_address, len, tag, tagLen);
}
// if not, GetPointer will log.
}
inline void Memcpy(const u32 to_address, const u32 from_address, const u32 len, const std::string &tag = "Memcpy") {
inline void Memcpy(const u32 to_address, const u32 from_address, const u32 len, const char *tag = "Memcpy") {
Memcpy(GetPointer(to_address), from_address, len);
NotifyMemInfo(MemBlockFlags::READ, from_address, len, tag);
NotifyMemInfo(MemBlockFlags::WRITE, to_address, len, tag);
size_t tagLen = strlen(tag);
NotifyMemInfo(MemBlockFlags::READ, from_address, len, tag, tagLen);
NotifyMemInfo(MemBlockFlags::WRITE, to_address, len, tag, tagLen);
}
void Memset(const u32 _Address, const u8 _Data, const u32 _iLength, const std::string &tag = "Memset");
void Memset(const u32 _Address, const u8 _Data, const u32 _iLength, const char *tag = "Memset");
template<class T>
void ReadStruct(u32 address, T *ptr)