Merge branch 'master' of https://github.com/PCSX2/pcsx2

3rdparty/ccc/src/ccc/elf.cpp

@@ -93,7 +93,7 @@ const ElfProgramHeader* ElfFile::entry_point_segment() const
 	return entry_segment;
 }
 
-Result<std::span<const u8>> ElfFile::get_virtual(u32 address, u32 size) const
+std::optional<std::span<const u8>> ElfFile::get_virtual(u32 address, u32 size) const
 {
 	u32 end_address = address + size;
 
@@ -109,17 +109,19 @@ Result<std::span<const u8>> ElfFile::get_virtual(u32 address, u32 size) const
 		}
 	}
 
-	return CCC_FAILURE("No ELF segment for address range 0x%x to 0x%x.", address, end_address);
+	return std::nullopt;
 }
 
-Result<void> ElfFile::copy_virtual(u8* dest, u32 address, u32 size) const
+bool ElfFile::copy_virtual(u8* dest, u32 address, u32 size) const
 {
-	Result<std::span<const u8>> block = get_virtual(address, size);
-	CCC_RETURN_IF_ERROR(block);
+	std::optional<std::span<const u8>> block = get_virtual(address, size);
+	if(!block.has_value()) {
+		return false;
+	}
 
 	memcpy(dest, block->data(), size);
 
-	return Result<void>();
+	return true;
 }
 
 }

3rdparty/ccc/src/ccc/elf.h

@@ -125,29 +125,33 @@ struct ElfFile {
 	const ElfProgramHeader* entry_point_segment() const;
 
 	// Retrieve a block of data in an ELF file given its address and size.
-	Result<std::span<const u8>> get_virtual(u32 address, u32 size) const;
+	std::optional<std::span<const u8>> get_virtual(u32 address, u32 size) const;
 
 	// Copy a block of data in an ELF file to the destination buffer given its
 	// address and size.
-	Result<void> copy_virtual(u8* dest, u32 address, u32 size) const;
+	bool copy_virtual(u8* dest, u32 address, u32 size) const;
 
 	// Retrieve an object of type T from an ELF file given its address.
 	template <typename T>
-	Result<T> get_object_virtual(u32 address) const
+	std::optional<T> get_object_virtual(u32 address) const
 	{
-		Result<std::span<const u8>> result = get_virtual(address, sizeof(T));
-		CCC_RETURN_IF_ERROR(result);
+		std::optional<std::span<const u8>> result = get_virtual(address, sizeof(T));
+		if(!result.has_value()) {
+			return std::nullopt;
+		}
 
 		return *(T*) result->data();
 	}
 
 	// Retrieve an array of objects of type T from an ELF file given its
 	// address and element count.
 	template <typename T>
-	Result<std::span<const T>> get_array_virtual(u32 address, u32 element_count) const
+	std::optional<std::span<const T>> get_array_virtual(u32 address, u32 element_count) const
 	{
-		Result<std::span<const u8>> result = get_virtual(address, element_count * sizeof(T));
-		CCC_RETURN_IF_ERROR(result);
+		std::optional<std::span<const u8>> result = get_virtual(address, element_count * sizeof(T));
+		if(!result.has_value()) {
+			return std::nullopt;
+		}
 
 		return std::span<const T>((T*) result->data(), (T*) (result->data() + result->size()));
 	}

3rdparty/ccc/src/ccc/symbol_database.h

@@ -435,7 +435,7 @@ class Label : public Symbol {
 public:
 	static constexpr const SymbolDescriptor DESCRIPTOR = LABEL;
 	static constexpr const char* NAME = "Label";
-	static constexpr u32 FLAGS = WITH_ADDRESS_MAP;
+	static constexpr u32 FLAGS = WITH_ADDRESS_MAP | WITH_NAME_MAP;
 
 	LabelHandle handle() const { return m_handle; }
 

3rdparty/ccc/src/ccc/symbol_table.cpp

@@ -100,16 +100,18 @@ Result<std::unique_ptr<SymbolTable>> create_elf_symbol_table(
 
 Result<ModuleHandle> import_symbol_tables(
 	SymbolDatabase& database,
-	std::string module_name,
 	const std::vector<std::unique_ptr<SymbolTable>>& symbol_tables,
+	std::string module_name,
+	Address base_address,
 	u32 importer_flags,
 	DemanglerFunctions demangler,
 	const std::atomic_bool* interrupt)
 {
 	Result<SymbolSourceHandle> module_source = database.get_symbol_source("Symbol Table Importer");
 	CCC_RETURN_IF_ERROR(module_source);
 
-	Result<Module*> module_symbol = database.modules.create_symbol(std::move(module_name), *module_source, nullptr);
+	Result<Module*> module_symbol = database.modules.create_symbol(
+		std::move(module_name), base_address, *module_source, nullptr);
 	CCC_RETURN_IF_ERROR(module_symbol);
 
 	ModuleHandle module_handle = (*module_symbol)->handle();

3rdparty/ccc/src/ccc/symbol_table.h

@@ -71,8 +71,9 @@ Result<std::unique_ptr<SymbolTable>> create_elf_symbol_table(
 // and to generate a module handle.
 Result<ModuleHandle> import_symbol_tables(
 	SymbolDatabase& database,
-	std::string module_name,
 	const std::vector<std::unique_ptr<SymbolTable>>& symbol_tables,
+	std::string module_name,
+	Address base_address,
 	u32 importer_flags,
 	DemanglerFunctions demangler,
 	const std::atomic_bool* interrupt);

pcsx2-qt/Debugger/BreakpointDialog.cpp

@@ -80,6 +80,8 @@ void BreakpointDialog::onRdoButtonToggled()
 
 void BreakpointDialog::accept()
 {
+	std::string error;
+
 	if (m_purpose == PURPOSE::CREATE)
 	{
 		if (m_ui.rdoExecute->isChecked())
@@ -93,9 +95,9 @@ void BreakpointDialog::accept()
 		PostfixExpression expr;
 
 		u64 address;
-		if (!m_cpu->evaluateExpression(m_ui.txtAddress->text().toStdString().c_str(), address))
+		if (!m_cpu->evaluateExpression(m_ui.txtAddress->text().toStdString().c_str(), address, error))
 		{
-			QMessageBox::warning(this, tr("Invalid Address"), getExpressionError());
+			QMessageBox::warning(this, tr("Invalid Address"), QString::fromStdString(error));
 			return;
 		}
 
@@ -108,9 +110,9 @@ void BreakpointDialog::accept()
 			bp->hasCond = true;
 			bp->cond.debug = m_cpu;
 
-			if (!m_cpu->initExpression(m_ui.txtCondition->text().toStdString().c_str(), expr))
+			if (!m_cpu->initExpression(m_ui.txtCondition->text().toStdString().c_str(), expr, error))
 			{
-				QMessageBox::warning(this, tr("Invalid Condition"), getExpressionError());
+				QMessageBox::warning(this, tr("Invalid Condition"), QString::fromStdString(error));
 				return;
 			}
 
@@ -121,16 +123,16 @@ void BreakpointDialog::accept()
 	if (auto* mc = std::get_if<MemCheck>(&m_bp_mc))
 	{
 		u64 startAddress;
-		if (!m_cpu->evaluateExpression(m_ui.txtAddress->text().toStdString().c_str(), startAddress))
+		if (!m_cpu->evaluateExpression(m_ui.txtAddress->text().toStdString().c_str(), startAddress, error))
 		{
-			QMessageBox::warning(this, tr("Invalid Address"), getExpressionError());
+			QMessageBox::warning(this, tr("Invalid Address"), QString::fromStdString(error));
 			return;
 		}
 
 		u64 size;
-		if (!m_cpu->evaluateExpression(m_ui.txtSize->text().toStdString().c_str(), size) || !size)
+		if (!m_cpu->evaluateExpression(m_ui.txtSize->text().toStdString().c_str(), size, error) || !size)
 		{
-			QMessageBox::warning(this, tr("Invalid Size"), getExpressionError());
+			QMessageBox::warning(this, tr("Invalid Size"), QString::fromStdString(error));
 			return;
 		}
 
@@ -143,9 +145,9 @@ void BreakpointDialog::accept()
 			mc->cond.debug = m_cpu;
 
 			PostfixExpression expr;
-			if (!m_cpu->initExpression(m_ui.txtCondition->text().toStdString().c_str(), expr))
+			if (!m_cpu->initExpression(m_ui.txtCondition->text().toStdString().c_str(), expr, error))
 			{
-				QMessageBox::warning(this, tr("Invalid Condition"), getExpressionError());
+				QMessageBox::warning(this, tr("Invalid Condition"), QString::fromStdString(error));
 				return;
 			}
 

pcsx2-qt/Debugger/DisassemblyWidget.cpp

@@ -170,9 +170,10 @@ void DisassemblyWidget::contextGoToAddress()
 		return;
 
 	u64 address = 0;
-	if (!m_cpu->evaluateExpression(targetString.toStdString().c_str(), address))
+	std::string error;
+	if (!m_cpu->evaluateExpression(targetString.toStdString().c_str(), address, error))
 	{
-		QMessageBox::warning(this, tr("Cannot Go To"), getExpressionError());
+		QMessageBox::warning(this, tr("Cannot Go To"), QString::fromStdString(error));
 		return;
 	}
 

pcsx2-qt/Debugger/MemoryViewWidget.cpp

@@ -599,9 +599,10 @@ void MemoryViewWidget::contextGoToAddress()
 		return;
 
 	u64 address = 0;
-	if (!m_cpu->evaluateExpression(targetString.toStdString().c_str(), address))
+	std::string error;
+	if (!m_cpu->evaluateExpression(targetString.toStdString().c_str(), address, error))
 	{
-		QMessageBox::warning(this, tr("Cannot Go To"), getExpressionError());
+		QMessageBox::warning(this, tr("Cannot Go To"), QString::fromStdString(error));
 		return;
 	}
 

pcsx2-qt/Debugger/Models/BreakpointModel.cpp

@@ -273,6 +273,8 @@ Qt::ItemFlags BreakpointModel::flags(const QModelIndex& index) const
 
 bool BreakpointModel::setData(const QModelIndex& index, const QVariant& value, int role)
 {
+	std::string error;
+
 	if (role == Qt::CheckStateRole && index.column() == BreakpointColumns::ENABLED)
 	{
 		auto bp_mc = m_breakpoints.at(index.row());
@@ -314,9 +316,9 @@ bool BreakpointModel::setData(const QModelIndex& index, const QVariant& value, i
 			{
 				PostfixExpression expr;
 
-				if (!m_cpu.initExpression(condValue.toLocal8Bit().constData(), expr))
+				if (!m_cpu.initExpression(condValue.toLocal8Bit().constData(), expr, error))
 				{
-					QMessageBox::warning(nullptr, "Condition Error", QString(getExpressionError()));
+					QMessageBox::warning(nullptr, "Condition Error", QString::fromStdString(error));
 					return false;
 				}
 
@@ -347,9 +349,9 @@ bool BreakpointModel::setData(const QModelIndex& index, const QVariant& value, i
 			{
 				PostfixExpression expr;
 
-				if (!m_cpu.initExpression(condValue.toLocal8Bit().constData(), expr))
+				if (!m_cpu.initExpression(condValue.toLocal8Bit().constData(), expr, error))
 				{
-					QMessageBox::warning(nullptr, "Condition Error", QString(getExpressionError()));
+					QMessageBox::warning(nullptr, "Condition Error", QString::fromStdString(error));
 					return false;
 				}
 
@@ -456,17 +458,20 @@ void BreakpointModel::refreshData()
 
 void BreakpointModel::loadBreakpointFromFieldList(QStringList fields)
 {
+	std::string error;
+
 	bool ok;
-	if (fields.size() != BreakpointModel::BreakpointColumns::COLUMN_COUNT)
+	if (fields.size() != BreakpointColumns::COLUMN_COUNT)
 	{
 		Console.WriteLn("Debugger Breakpoint Model: Invalid number of columns, skipping");
 		return;
 	}
 
-	const int type = fields[BreakpointModel::BreakpointColumns::TYPE].toUInt(&ok);
+	const int type = fields[BreakpointColumns::TYPE].toUInt(&ok);
 	if (!ok)
 	{
-		Console.WriteLn("Debugger Breakpoint Model: Failed to parse type '%s', skipping", fields[BreakpointModel::BreakpointColumns::TYPE].toUtf8().constData());
+		Console.WriteLn("Debugger Breakpoint Model: Failed to parse type '%s', skipping",
+			fields[BreakpointColumns::TYPE].toUtf8().constData());
 		return;
 	}
 
@@ -476,34 +481,37 @@ void BreakpointModel::loadBreakpointFromFieldList(QStringList fields)
 		BreakPoint bp;
 
 		// Address
-		bp.addr = fields[BreakpointModel::BreakpointColumns::OFFSET].toUInt(&ok, 16);
+		bp.addr = fields[BreakpointColumns::OFFSET].toUInt(&ok, 16);
 		if (!ok)
 		{
-			Console.WriteLn("Debugger Breakpoint Model: Failed to parse address '%s', skipping", fields[BreakpointModel::BreakpointColumns::OFFSET].toUtf8().constData());
+			Console.WriteLn("Debugger Breakpoint Model: Failed to parse address '%s', skipping",
+				fields[BreakpointColumns::OFFSET].toUtf8().constData());
 			return;
 		}
 
 		// Condition
-		if (!fields[BreakpointModel::BreakpointColumns::CONDITION].isEmpty())
+		if (!fields[BreakpointColumns::CONDITION].isEmpty())
 		{
 			PostfixExpression expr;
 			bp.hasCond = true;
 			bp.cond.debug = &m_cpu;
 
-			if (!m_cpu.initExpression(fields[BreakpointModel::BreakpointColumns::CONDITION].toUtf8().constData(), expr))
+			if (!m_cpu.initExpression(fields[BreakpointColumns::CONDITION].toUtf8().constData(), expr, error))
 			{
-				Console.WriteLn("Debugger Breakpoint Model: Failed to parse cond '%s', skipping", fields[BreakpointModel::BreakpointColumns::CONDITION].toUtf8().constData());
+				Console.WriteLn("Debugger Breakpoint Model: Failed to parse cond '%s', skipping",
+					fields[BreakpointModel::CONDITION].toUtf8().constData());
 				return;
 			}
 			bp.cond.expression = expr;
-			bp.cond.expressionString = fields[BreakpointModel::BreakpointColumns::CONDITION].toStdString();
+			bp.cond.expressionString = fields[BreakpointColumns::CONDITION].toStdString();
 		}
 
 		// Enabled
-		bp.enabled = fields[BreakpointModel::BreakpointColumns::ENABLED].toUInt(&ok);
+		bp.enabled = fields[BreakpointColumns::ENABLED].toUInt(&ok);
 		if (!ok)
 		{
-			Console.WriteLn("Debugger Breakpoint Model: Failed to parse enable flag '%s', skipping", fields[BreakpointModel::BreakpointColumns::ENABLED].toUtf8().constData());
+			Console.WriteLn("Debugger Breakpoint Model: Failed to parse enable flag '%s', skipping",
+				fields[BreakpointColumns::ENABLED].toUtf8().constData());
 			return;
 		}
 
@@ -515,49 +523,54 @@ void BreakpointModel::loadBreakpointFromFieldList(QStringList fields)
 		// Mode
 		if (type >= MEMCHECK_INVALID)
 		{
-			Console.WriteLn("Debugger Breakpoint Model: Failed to parse cond type '%s', skipping", fields[BreakpointModel::BreakpointColumns::TYPE].toUtf8().constData());
+			Console.WriteLn("Debugger Breakpoint Model: Failed to parse cond type '%s', skipping",
+				fields[BreakpointColumns::TYPE].toUtf8().constData());
 			return;
 		}
 		mc.memCond = static_cast<MemCheckCondition>(type);
 
 		// Address
-		QString test = fields[BreakpointModel::BreakpointColumns::OFFSET];
-		mc.start = fields[BreakpointModel::BreakpointColumns::OFFSET].toUInt(&ok, 16);
+		QString test = fields[BreakpointColumns::OFFSET];
+		mc.start = fields[BreakpointColumns::OFFSET].toUInt(&ok, 16);
 		if (!ok)
 		{
-			Console.WriteLn("Debugger Breakpoint Model: Failed to parse address '%s', skipping", fields[BreakpointModel::BreakpointColumns::OFFSET].toUtf8().constData());
+			Console.WriteLn("Debugger Breakpoint Model: Failed to parse address '%s', skipping",
+				fields[BreakpointColumns::OFFSET].toUtf8().constData());
 			return;
 		}
 
 		// Size
-		mc.end = fields[BreakpointModel::BreakpointColumns::SIZE_LABEL].toUInt(&ok) + mc.start;
+		mc.end = fields[BreakpointColumns::SIZE_LABEL].toUInt(&ok) + mc.start;
 		if (!ok)
 		{
-			Console.WriteLn("Debugger Breakpoint Model: Failed to parse length '%s', skipping", fields[BreakpointModel::BreakpointColumns::SIZE_LABEL].toUtf8().constData());
+			Console.WriteLn("Debugger Breakpoint Model: Failed to parse length '%s', skipping",
+				fields[BreakpointColumns::SIZE_LABEL].toUtf8().constData());
 			return;
 		}
 
 		// Condition
-		if (!fields[BreakpointModel::BreakpointColumns::CONDITION].isEmpty())
+		if (!fields[BreakpointColumns::CONDITION].isEmpty())
 		{
 			PostfixExpression expr;
 			mc.hasCond = true;
 			mc.cond.debug = &m_cpu;
 
-			if (!m_cpu.initExpression(fields[BreakpointModel::BreakpointColumns::CONDITION].toUtf8().constData(), expr))
+			if (!m_cpu.initExpression(fields[BreakpointColumns::CONDITION].toUtf8().constData(), expr, error))
 			{
-				Console.WriteLn("Debugger Breakpoint Model: Failed to parse cond '%s', skipping", fields[BreakpointModel::BreakpointColumns::CONDITION].toUtf8().constData());
+				Console.WriteLn("Debugger Breakpoint Model: Failed to parse cond '%s', skipping",
+					fields[BreakpointColumns::CONDITION].toUtf8().constData());
 				return;
 			}
 			mc.cond.expression = expr;
-			mc.cond.expressionString = fields[BreakpointModel::BreakpointColumns::CONDITION].toStdString();
+			mc.cond.expressionString = fields[BreakpointColumns::CONDITION].toStdString();
 		}
 
 		// Result
-		const int result = fields[BreakpointModel::BreakpointColumns::ENABLED].toUInt(&ok);
+		const int result = fields[BreakpointColumns::ENABLED].toUInt(&ok);
 		if (!ok)
 		{
-			Console.WriteLn("Debugger Breakpoint Model: Failed to parse result flag '%s', skipping", fields[BreakpointModel::BreakpointColumns::ENABLED].toUtf8().constData());
+			Console.WriteLn("Debugger Breakpoint Model: Failed to parse result flag '%s', skipping",
+				fields[BreakpointColumns::ENABLED].toUtf8().constData());
 			return;
 		}
 		mc.result = static_cast<MemCheckResult>(result);