summaryrefslogtreecommitdiff
path: root/Source/Core/VideoCommon/OpcodeDecoding.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'Source/Core/VideoCommon/OpcodeDecoding.cpp')
-rw-r--r--Source/Core/VideoCommon/OpcodeDecoding.cpp205
1 files changed, 110 insertions, 95 deletions
diff --git a/Source/Core/VideoCommon/OpcodeDecoding.cpp b/Source/Core/VideoCommon/OpcodeDecoding.cpp
index 2e40b6d863..69e5f1ea01 100644
--- a/Source/Core/VideoCommon/OpcodeDecoding.cpp
+++ b/Source/Core/VideoCommon/OpcodeDecoding.cpp
@@ -9,15 +9,14 @@
// Super Mario Galaxy has nearly all geometry and more than half of the state in DLs (great!)
// Note that it IS NOT GENERALLY POSSIBLE to precompile display lists! You can compile them as they
-// are
-// while interpreting them, and hope that the vertex format doesn't change, though, if you do it
-// right
-// when they are called. The reason is that the vertex format affects the sizes of the vertices.
+// are while interpreting them, and hope that the vertex format doesn't change, though, if you do
+// it right when they are called. The reason is that the vertex format affects the sizes of the
+// vertices.
#include "VideoCommon/OpcodeDecoding.h"
+
#include "Common/CommonTypes.h"
#include "Common/Logging/Log.h"
-#include "Common/MsgHandler.h"
#include "Core/FifoPlayer/FifoRecorder.h"
#include "Core/HW/Memmap.h"
#include "VideoCommon/BPMemory.h"
@@ -27,33 +26,32 @@
#include "VideoCommon/Fifo.h"
#include "VideoCommon/Statistics.h"
#include "VideoCommon/VertexLoaderManager.h"
-#include "VideoCommon/VideoCommon.h"
#include "VideoCommon/XFMemory.h"
-bool g_bRecordFifoData = false;
-
namespace OpcodeDecoder
{
-static bool s_bFifoErrorSeen = false;
+namespace
+{
+bool s_is_fifo_error_seen = false;
-static u32 InterpretDisplayList(u32 address, u32 size)
+u32 InterpretDisplayList(u32 address, u32 size)
{
- u8* startAddress;
+ u8* start_address;
if (Fifo::UseDeterministicGPUThread())
- startAddress = (u8*)Fifo::PopFifoAuxBuffer(size);
+ start_address = static_cast<u8*>(Fifo::PopFifoAuxBuffer(size));
else
- startAddress = Memory::GetPointer(address);
+ start_address = Memory::GetPointer(address);
u32 cycles = 0;
// Avoid the crash if Memory::GetPointer failed ..
- if (startAddress != nullptr)
+ if (start_address != nullptr)
{
// temporarily swap dl and non-dl (small "hack" for the stats)
g_stats.SwapDL();
- Run(DataReader(startAddress, startAddress + size), &cycles, true);
+ Run(DataReader(start_address, start_address + size), &cycles, true);
INCSTAT(g_stats.this_frame.num_dlists_called);
// un-swap
@@ -63,57 +61,70 @@ static u32 InterpretDisplayList(u32 address, u32 size)
return cycles;
}
-static void InterpretDisplayListPreprocess(u32 address, u32 size)
+void InterpretDisplayListPreprocess(u32 address, u32 size)
{
- u8* startAddress = Memory::GetPointer(address);
+ u8* const start_address = Memory::GetPointer(address);
- Fifo::PushFifoAuxBuffer(startAddress, size);
+ Fifo::PushFifoAuxBuffer(start_address, size);
- if (startAddress != nullptr)
- {
- Run<true>(DataReader(startAddress, startAddress + size), nullptr, true);
- }
+ if (start_address == nullptr)
+ return;
+
+ Run<true>(DataReader(start_address, start_address + size), nullptr, true);
}
+} // Anonymous namespace
+
+bool g_record_fifo_data = false;
void Init()
{
- s_bFifoErrorSeen = false;
+ s_is_fifo_error_seen = false;
}
template <bool is_preprocess>
u8* Run(DataReader src, u32* cycles, bool in_display_list)
{
- u32 totalCycles = 0;
- u8* opcodeStart;
+ u32 total_cycles = 0;
+ u8* opcode_start = nullptr;
+
+ const auto finish_up = [cycles, &opcode_start, &total_cycles] {
+ if (cycles != nullptr)
+ {
+ *cycles = total_cycles;
+ }
+ return opcode_start;
+ };
+
while (true)
{
- opcodeStart = src.GetPointer();
+ opcode_start = src.GetPointer();
if (!src.size())
- goto end;
+ return finish_up();
- u8 cmd_byte = src.Read<u8>();
- int refarray;
+ const u8 cmd_byte = src.Read<u8>();
switch (cmd_byte)
{
case GX_NOP:
- totalCycles += 6; // Hm, this means that we scan over nop streams pretty slowly...
+ total_cycles += 6; // Hm, this means that we scan over nop streams pretty slowly...
break;
case GX_UNKNOWN_RESET:
- totalCycles += 6; // Datel software uses this command
+ total_cycles += 6; // Datel software uses this command
DEBUG_LOG(VIDEO, "GX Reset?: %08x", cmd_byte);
break;
case GX_LOAD_CP_REG:
{
if (src.size() < 1 + 4)
- goto end;
- totalCycles += 12;
- u8 sub_cmd = src.Read<u8>();
- u32 value = src.Read<u32>();
+ return finish_up();
+
+ total_cycles += 12;
+
+ const u8 sub_cmd = src.Read<u8>();
+ const u32 value = src.Read<u32>();
LoadCPReg(sub_cmd, value, is_preprocess);
- if (!is_preprocess)
+ if constexpr (!is_preprocess)
INCSTAT(g_stats.this_frame.num_cp_loads);
}
break;
@@ -121,15 +132,18 @@ u8* Run(DataReader src, u32* cycles, bool in_display_list)
case GX_LOAD_XF_REG:
{
if (src.size() < 4)
- goto end;
- u32 Cmd2 = src.Read<u32>();
- int transfer_size = ((Cmd2 >> 16) & 15) + 1;
+ return finish_up();
+
+ const u32 cmd2 = src.Read<u32>();
+ const u32 transfer_size = ((cmd2 >> 16) & 15) + 1;
if (src.size() < transfer_size * sizeof(u32))
- goto end;
- totalCycles += 18 + 6 * transfer_size;
- if (!is_preprocess)
+ return finish_up();
+
+ total_cycles += 18 + 6 * transfer_size;
+
+ if constexpr (!is_preprocess)
{
- u32 xf_address = Cmd2 & 0xFFFF;
+ const u32 xf_address = cmd2 & 0xFFFF;
LoadXFReg(transfer_size, xf_address, src);
INCSTAT(g_stats.this_frame.num_xf_loads);
@@ -138,58 +152,61 @@ u8* Run(DataReader src, u32* cycles, bool in_display_list)
}
break;
- case GX_LOAD_INDX_A: // used for position matrices
- refarray = 0xC;
- goto load_indx;
- case GX_LOAD_INDX_B: // used for normal matrices
- refarray = 0xD;
- goto load_indx;
- case GX_LOAD_INDX_C: // used for postmatrices
- refarray = 0xE;
- goto load_indx;
- case GX_LOAD_INDX_D: // used for lights
- refarray = 0xF;
- goto load_indx;
- load_indx:
+ case GX_LOAD_INDX_A: // Used for position matrices
+ case GX_LOAD_INDX_B: // Used for normal matrices
+ case GX_LOAD_INDX_C: // Used for postmatrices
+ case GX_LOAD_INDX_D: // Used for lights
+ {
if (src.size() < 4)
- goto end;
- totalCycles += 6;
- if (is_preprocess)
- PreprocessIndexedXF(src.Read<u32>(), refarray);
+ return finish_up();
+
+ total_cycles += 6;
+
+ // Map the command byte to its ref array.
+ // GX_LOAD_INDX_A (32) -> 0xC
+ // GX_LOAD_INDX_B (40) -> 0xD
+ // GX_LOAD_INDX_C (48) -> 0xE
+ // GX_LOAD_INDX_D (56) -> 0xF
+ const int ref_array = (cmd_byte / 8) + 8;
+
+ if constexpr (is_preprocess)
+ PreprocessIndexedXF(src.Read<u32>(), ref_array);
else
- LoadIndexedXF(src.Read<u32>(), refarray);
- break;
+ LoadIndexedXF(src.Read<u32>(), ref_array);
+ }
+ break;
case GX_CMD_CALL_DL:
{
if (src.size() < 8)
- goto end;
- u32 address = src.Read<u32>();
- u32 count = src.Read<u32>();
+ return finish_up();
+
+ const u32 address = src.Read<u32>();
+ const u32 count = src.Read<u32>();
if (in_display_list)
{
- totalCycles += 6;
+ total_cycles += 6;
INFO_LOG(VIDEO, "recursive display list detected");
}
else
{
- if (is_preprocess)
+ if constexpr (is_preprocess)
InterpretDisplayListPreprocess(address, count);
else
- totalCycles += 6 + InterpretDisplayList(address, count);
+ total_cycles += 6 + InterpretDisplayList(address, count);
}
}
break;
case GX_CMD_UNKNOWN_METRICS: // zelda 4 swords calls it and checks the metrics registers after
// that
- totalCycles += 6;
+ total_cycles += 6;
DEBUG_LOG(VIDEO, "GX 0x44: %08x", cmd_byte);
break;
case GX_CMD_INVL_VC: // Invalidate Vertex Cache
- totalCycles += 6;
+ total_cycles += 6;
DEBUG_LOG(VIDEO, "Invalidate (vertex cache?)");
break;
@@ -198,10 +215,12 @@ u8* Run(DataReader src, u32* cycles, bool in_display_list)
// tokens and stuff. TODO: Call a much simplified LoadBPReg instead.
{
if (src.size() < 4)
- goto end;
- totalCycles += 12;
- u32 bp_cmd = src.Read<u32>();
- if (is_preprocess)
+ return finish_up();
+
+ total_cycles += 12;
+
+ const u32 bp_cmd = src.Read<u32>();
+ if constexpr (is_preprocess)
{
LoadBPRegPreprocess(bp_cmd);
}
@@ -219,47 +238,43 @@ u8* Run(DataReader src, u32* cycles, bool in_display_list)
{
// load vertices
if (src.size() < 2)
- goto end;
- u16 num_vertices = src.Read<u16>();
- int bytes = VertexLoaderManager::RunVertices(
+ return finish_up();
+
+ const u16 num_vertices = src.Read<u16>();
+ const int bytes = VertexLoaderManager::RunVertices(
cmd_byte & GX_VAT_MASK, // Vertex loader index (0 - 7)
(cmd_byte & GX_PRIMITIVE_MASK) >> GX_PRIMITIVE_SHIFT, num_vertices, src, is_preprocess);
if (bytes < 0)
- goto end;
+ return finish_up();
src.Skip(bytes);
// 4 GPU ticks per vertex, 3 CPU ticks per GPU tick
- totalCycles += num_vertices * 4 * 3 + 6;
+ total_cycles += num_vertices * 4 * 3 + 6;
}
else
{
- if (!s_bFifoErrorSeen)
- CommandProcessor::HandleUnknownOpcode(cmd_byte, opcodeStart, is_preprocess);
+ if (!s_is_fifo_error_seen)
+ CommandProcessor::HandleUnknownOpcode(cmd_byte, opcode_start, is_preprocess);
ERROR_LOG(VIDEO, "FIFO: Unknown Opcode(0x%02x @ %p, preprocessing = %s)", cmd_byte,
- opcodeStart, is_preprocess ? "yes" : "no");
- s_bFifoErrorSeen = true;
- totalCycles += 1;
+ opcode_start, is_preprocess ? "yes" : "no");
+ s_is_fifo_error_seen = true;
+ total_cycles += 1;
}
break;
}
// Display lists get added directly into the FIFO stream
- if (!is_preprocess && g_bRecordFifoData && cmd_byte != GX_CMD_CALL_DL)
+ if constexpr (!is_preprocess)
{
- u8* opcodeEnd;
- opcodeEnd = src.GetPointer();
- FifoRecorder::GetInstance().WriteGPCommand(opcodeStart, u32(opcodeEnd - opcodeStart));
+ if (g_record_fifo_data && cmd_byte != GX_CMD_CALL_DL)
+ {
+ const u8* const opcode_end = src.GetPointer();
+ FifoRecorder::GetInstance().WriteGPCommand(opcode_start, u32(opcode_end - opcode_start));
+ }
}
}
-
-end:
- if (cycles)
- {
- *cycles = totalCycles;
- }
- return opcodeStart;
}
template u8* Run<true>(DataReader src, u32* cycles, bool in_display_list);
generated by cgit v1.2.3 (git 2.25.1) at 2026-08-13 04:01:43 +0000