void VertexShaderManager::Init() { // Initialize state tracking variables nTransformMatricesChanged[0] = -1; nTransformMatricesChanged[1] = -1; nNormalMatricesChanged[0] = -1; nNormalMatricesChanged[1] = -1; nPostTransformMatricesChanged[0] = -1; nPostTransformMatricesChanged[1] = -1; nLightsChanged[0] = -1; nLightsChanged[1] = -1; nMaterialsChanged = BitSet32(0); bTexMatricesChanged[0] = false; bTexMatricesChanged[1] = false; bPosNormalMatrixChanged = false; bProjectionChanged = true; bViewportChanged = false; memset(&xfmem, 0, sizeof(xfmem)); memset(&constants, 0, sizeof(constants)); ResetView(); // TODO: should these go inside ResetView()? Matrix44::LoadIdentity(s_viewportCorrection); memset(g_fProjectionMatrix, 0, sizeof(g_fProjectionMatrix)); for (int i = 0; i < 4; ++i) g_fProjectionMatrix[i*5] = 1.0f; dirty = true; }
TEST(BitSet, Count) { u32 random_numbers[] = { 0x2cb0b5f3, 0x81ab32a6, 0xd9030dc5, 0x325ffe26, 0xb2fcaee3, 0x4ccf188a, 0xf8be36dc, 0xb2fcecd5, 0xb750c2e5, 0x31d19074, 0xf267644a, 0xac00a719, 0x6d45f19b, 0xf7e91c5b, 0xf687e694, 0x9057c24e, 0x5eb65c39, 0x85d3038b, 0x101f4e66, 0xc202d136 }; u32 counts[] = { 17, 14, 14, 19, 20, 14, 20, 20, 16, 13, 16, 12, 18, 20, 18, 14, 18, 14, 14, 12 }; for (size_t i = 0; i < 20; i++) { EXPECT_EQ(counts[i], BitSet32(random_numbers[i]).Count()); } u64 random_numbers_64[] = { 0xf86cd6f6ef09d7d4ULL, 0x6f2d8533255ead3cULL, 0x9da7941e0e52b345ULL, 0x06e4189be67d2b17ULL, 0x3eb0681f65cb6d25ULL, 0xccab8a7c74a51203ULL, 0x09d470516694c64bULL, 0x38cd077e075c778fULL, 0xd69ebfa6355ebfdeULL }; u32 counts_64[] = { 39, 34, 31, 32, 33, 29, 27, 35, 43 }; for (size_t i = 0; i < 9; i++) { EXPECT_EQ(counts_64[i], BitSet64(random_numbers_64[i]).Count()); } }
TEST(BitSet, Basics) { BitSet32 bs; BitSet64 bs2(1); BitSet64 bs3(2); EXPECT_EQ(true, !!bs2); EXPECT_EQ(false, !!bs); EXPECT_EQ(bs2, bs2); EXPECT_NE(bs2, bs3); EXPECT_EQ(BitSet32(0xfff), BitSet32::AllTrue(12)); EXPECT_EQ(BitSet64(0xffffffffffffffff), BitSet64::AllTrue(64)); }
TEST(BitSet, BitOps) { BitSet32 a(3), b(5), c; EXPECT_EQ(BitSet32(7), a | b); EXPECT_EQ(BitSet32(6), a ^ b); EXPECT_EQ(BitSet32(1), a & b); EXPECT_EQ(BitSet32(0xfffffffc), ~a); c = a; c |= b; EXPECT_EQ(BitSet32(7), c); c = a; c ^= b; EXPECT_EQ(BitSet32(6), c); c = a; c &= b; EXPECT_EQ(BitSet32(1), c); }
__forceinline void WriteToHardware(u32 em_address, const T data) { int segment = em_address >> 28; // Quick check for an address that can't meet any of the following conditions, // to speed up the MMU path. if (!BitSet32(0xCFC)[segment]) { // First, let's check for FIFO writes, since they are probably the most common // reason we end up in this function: if ((em_address & 0xFFFFF000) == 0xCC008000) { switch (sizeof(T)) { case 1: GPFifo::Write8((u8)data, em_address); return; case 2: GPFifo::Write16((u16)data, em_address); return; case 4: GPFifo::Write32((u32)data, em_address); return; case 8: GPFifo::Write64((u64)data, em_address); return; } } if ((em_address & 0xC8000000) == 0xC8000000) { if (em_address < 0xcc000000) { int x = (em_address & 0xfff) >> 2; int y = (em_address >> 12) & 0x3ff; // TODO figure out a way to send data without falling into the template trap if (em_address & 0x00400000) { g_video_backend->Video_AccessEFB(POKE_Z, x, y, (u32)data); DEBUG_LOG(MEMMAP, "EFB Z Write %08x @ %i, %i", (u32)data, x, y); } else { g_video_backend->Video_AccessEFB(POKE_COLOR, x, y, (u32)data); DEBUG_LOG(MEMMAP, "EFB Color Write %08x @ %i, %i", (u32)data, x, y); } return; } else { mmio_mapping->Write(em_address, data); return; } }
// Syncs the shader constant buffers with xfmem // TODO: A cleaner way to control the matrices without making a mess in the parameters field void VertexShaderManager::SetConstants() { if (nTransformMatricesChanged[0] >= 0) { int startn = nTransformMatricesChanged[0] / 4; int endn = (nTransformMatricesChanged[1] + 3) / 4; memcpy(constants.transformmatrices[startn], &xfmem.posMatrices[startn * 4], (endn - startn) * 16); dirty = true; nTransformMatricesChanged[0] = nTransformMatricesChanged[1] = -1; } if (nNormalMatricesChanged[0] >= 0) { int startn = nNormalMatricesChanged[0] / 3; int endn = (nNormalMatricesChanged[1] + 2) / 3; for (int i=startn; i<endn; i++) { memcpy(constants.normalmatrices[i], &xfmem.normalMatrices[3*i], 12); } dirty = true; nNormalMatricesChanged[0] = nNormalMatricesChanged[1] = -1; } if (nPostTransformMatricesChanged[0] >= 0) { int startn = nPostTransformMatricesChanged[0] / 4; int endn = (nPostTransformMatricesChanged[1] + 3 ) / 4; memcpy(constants.posttransformmatrices[startn], &xfmem.postMatrices[startn * 4], (endn - startn) * 16); dirty = true; nPostTransformMatricesChanged[0] = nPostTransformMatricesChanged[1] = -1; } if (nLightsChanged[0] >= 0) { // TODO: Outdated comment // lights don't have a 1 to 1 mapping, the color component needs to be converted to 4 floats int istart = nLightsChanged[0] / 0x10; int iend = (nLightsChanged[1] + 15) / 0x10; for (int i = istart; i < iend; ++i) { const Light& light = xfmem.lights[i]; VertexShaderConstants::Light& dstlight = constants.lights[i]; // xfmem.light.color is packed as abgr in u8[4], so we have to swap the order dstlight.color[0] = light.color[3]; dstlight.color[1] = light.color[2]; dstlight.color[2] = light.color[1]; dstlight.color[3] = light.color[0]; dstlight.cosatt[0] = light.cosatt[0]; dstlight.cosatt[1] = light.cosatt[1]; dstlight.cosatt[2] = light.cosatt[2]; if (fabs(light.distatt[0]) < 0.00001f && fabs(light.distatt[1]) < 0.00001f && fabs(light.distatt[2]) < 0.00001f) { // dist attenuation, make sure not equal to 0!!! dstlight.distatt[0] = .00001f; } else { dstlight.distatt[0] = light.distatt[0]; } dstlight.distatt[1] = light.distatt[1]; dstlight.distatt[2] = light.distatt[2]; dstlight.pos[0] = light.dpos[0]; dstlight.pos[1] = light.dpos[1]; dstlight.pos[2] = light.dpos[2]; double norm = double(light.ddir[0]) * double(light.ddir[0]) + double(light.ddir[1]) * double(light.ddir[1]) + double(light.ddir[2]) * double(light.ddir[2]); norm = 1.0 / sqrt(norm); float norm_float = static_cast<float>(norm); dstlight.dir[0] = light.ddir[0] * norm_float; dstlight.dir[1] = light.ddir[1] * norm_float; dstlight.dir[2] = light.ddir[2] * norm_float; } dirty = true; nLightsChanged[0] = nLightsChanged[1] = -1; } for (int i : nMaterialsChanged) { u32 data = i >= 2 ? xfmem.matColor[i - 2] : xfmem.ambColor[i]; constants.materials[i][0] = (data >> 24) & 0xFF; constants.materials[i][1] = (data >> 16) & 0xFF; constants.materials[i][2] = (data >> 8) & 0xFF; constants.materials[i][3] = data & 0xFF; dirty = true; } nMaterialsChanged = BitSet32(0); if (bPosNormalMatrixChanged) { bPosNormalMatrixChanged = false; const float *pos = (const float *)xfmem.posMatrices + g_main_cp_state.matrix_index_a.PosNormalMtxIdx * 4; const float *norm = (const float *)xfmem.normalMatrices + 3 * (g_main_cp_state.matrix_index_a.PosNormalMtxIdx & 31); memcpy(constants.posnormalmatrix, pos, 3*16); memcpy(constants.posnormalmatrix[3], norm, 12); memcpy(constants.posnormalmatrix[4], norm+3, 12); memcpy(constants.posnormalmatrix[5], norm+6, 12); dirty = true; } if (bTexMatricesChanged[0]) { bTexMatricesChanged[0] = false; const float *fptrs[] = { (const float *)&xfmem.posMatrices[g_main_cp_state.matrix_index_a.Tex0MtxIdx * 4], (const float *)&xfmem.posMatrices[g_main_cp_state.matrix_index_a.Tex1MtxIdx * 4], (const float *)&xfmem.posMatrices[g_main_cp_state.matrix_index_a.Tex2MtxIdx * 4], (const float *)&xfmem.posMatrices[g_main_cp_state.matrix_index_a.Tex3MtxIdx * 4] }; for (int i = 0; i < 4; ++i) { memcpy(constants.texmatrices[3*i], fptrs[i], 3*16); } dirty = true; } if (bTexMatricesChanged[1]) { bTexMatricesChanged[1] = false; const float *fptrs[] = { (const float *)&xfmem.posMatrices[g_main_cp_state.matrix_index_b.Tex4MtxIdx * 4], (const float *)&xfmem.posMatrices[g_main_cp_state.matrix_index_b.Tex5MtxIdx * 4], (const float *)&xfmem.posMatrices[g_main_cp_state.matrix_index_b.Tex6MtxIdx * 4], (const float *)&xfmem.posMatrices[g_main_cp_state.matrix_index_b.Tex7MtxIdx * 4] }; for (int i = 0; i < 4; ++i) { memcpy(constants.texmatrices[3*i+12], fptrs[i], 3*16); } dirty = true; } if (bViewportChanged) { bViewportChanged = false; // The console GPU places the pixel center at 7/12 unless antialiasing // is enabled, while D3D and OpenGL place it at 0.5. See the comment // in VertexShaderGen.cpp for details. // NOTE: If we ever emulate antialiasing, the sample locations set by // BP registers 0x01-0x04 need to be considered here. const float pixel_center_correction = 7.0f / 12.0f - 0.5f; const float pixel_size_x = 2.f / Renderer::EFBToScaledXf(2.f * xfmem.viewport.wd); const float pixel_size_y = 2.f / Renderer::EFBToScaledXf(2.f * xfmem.viewport.ht); constants.pixelcentercorrection[0] = pixel_center_correction * pixel_size_x; constants.pixelcentercorrection[1] = pixel_center_correction * pixel_size_y; dirty = true; // This is so implementation-dependent that we can't have it here. g_renderer->SetViewport(); // Update projection if the viewport isn't 1:1 useable if (!g_ActiveConfig.backend_info.bSupportsOversizedViewports) { ViewportCorrectionMatrix(s_viewportCorrection); bProjectionChanged = true; } } if (bProjectionChanged) { bProjectionChanged = false; float *rawProjection = xfmem.projection.rawProjection; switch (xfmem.projection.type) { case GX_PERSPECTIVE: g_fProjectionMatrix[0] = rawProjection[0] * g_ActiveConfig.fAspectRatioHackW; g_fProjectionMatrix[1] = 0.0f; g_fProjectionMatrix[2] = rawProjection[1]; g_fProjectionMatrix[3] = 0.0f; g_fProjectionMatrix[4] = 0.0f; g_fProjectionMatrix[5] = rawProjection[2] * g_ActiveConfig.fAspectRatioHackH; g_fProjectionMatrix[6] = rawProjection[3]; g_fProjectionMatrix[7] = 0.0f; g_fProjectionMatrix[8] = 0.0f; g_fProjectionMatrix[9] = 0.0f; g_fProjectionMatrix[10] = rawProjection[4]; g_fProjectionMatrix[11] = rawProjection[5]; g_fProjectionMatrix[12] = 0.0f; g_fProjectionMatrix[13] = 0.0f; // donkopunchstania suggested the GC GPU might round differently // He had thus changed this to -(1 + epsilon) to fix clipping issues. // I (neobrain) don't think his conjecture is true and thus reverted his change. g_fProjectionMatrix[14] = -1.0f; g_fProjectionMatrix[15] = 0.0f; SETSTAT_FT(stats.gproj_0, g_fProjectionMatrix[0]); SETSTAT_FT(stats.gproj_1, g_fProjectionMatrix[1]); SETSTAT_FT(stats.gproj_2, g_fProjectionMatrix[2]); SETSTAT_FT(stats.gproj_3, g_fProjectionMatrix[3]); SETSTAT_FT(stats.gproj_4, g_fProjectionMatrix[4]); SETSTAT_FT(stats.gproj_5, g_fProjectionMatrix[5]); SETSTAT_FT(stats.gproj_6, g_fProjectionMatrix[6]); SETSTAT_FT(stats.gproj_7, g_fProjectionMatrix[7]); SETSTAT_FT(stats.gproj_8, g_fProjectionMatrix[8]); SETSTAT_FT(stats.gproj_9, g_fProjectionMatrix[9]); SETSTAT_FT(stats.gproj_10, g_fProjectionMatrix[10]); SETSTAT_FT(stats.gproj_11, g_fProjectionMatrix[11]); SETSTAT_FT(stats.gproj_12, g_fProjectionMatrix[12]); SETSTAT_FT(stats.gproj_13, g_fProjectionMatrix[13]); SETSTAT_FT(stats.gproj_14, g_fProjectionMatrix[14]); SETSTAT_FT(stats.gproj_15, g_fProjectionMatrix[15]); break; case GX_ORTHOGRAPHIC: g_fProjectionMatrix[0] = rawProjection[0]; g_fProjectionMatrix[1] = 0.0f; g_fProjectionMatrix[2] = 0.0f; g_fProjectionMatrix[3] = rawProjection[1]; g_fProjectionMatrix[4] = 0.0f; g_fProjectionMatrix[5] = rawProjection[2]; g_fProjectionMatrix[6] = 0.0f; g_fProjectionMatrix[7] = rawProjection[3]; g_fProjectionMatrix[8] = 0.0f; g_fProjectionMatrix[9] = 0.0f; g_fProjectionMatrix[10] = (g_ProjHack1.value + rawProjection[4]) * ((g_ProjHack1.sign == 0) ? 1.0f : g_ProjHack1.sign); g_fProjectionMatrix[11] = (g_ProjHack2.value + rawProjection[5]) * ((g_ProjHack2.sign == 0) ? 1.0f : g_ProjHack2.sign); g_fProjectionMatrix[12] = 0.0f; g_fProjectionMatrix[13] = 0.0f; g_fProjectionMatrix[14] = 0.0f; g_fProjectionMatrix[15] = 1.0f + FLT_EPSILON; // hack to fix depth clipping precision issues (such as Sonic Unleashed UI) SETSTAT_FT(stats.g2proj_0, g_fProjectionMatrix[0]); SETSTAT_FT(stats.g2proj_1, g_fProjectionMatrix[1]); SETSTAT_FT(stats.g2proj_2, g_fProjectionMatrix[2]); SETSTAT_FT(stats.g2proj_3, g_fProjectionMatrix[3]); SETSTAT_FT(stats.g2proj_4, g_fProjectionMatrix[4]); SETSTAT_FT(stats.g2proj_5, g_fProjectionMatrix[5]); SETSTAT_FT(stats.g2proj_6, g_fProjectionMatrix[6]); SETSTAT_FT(stats.g2proj_7, g_fProjectionMatrix[7]); SETSTAT_FT(stats.g2proj_8, g_fProjectionMatrix[8]); SETSTAT_FT(stats.g2proj_9, g_fProjectionMatrix[9]); SETSTAT_FT(stats.g2proj_10, g_fProjectionMatrix[10]); SETSTAT_FT(stats.g2proj_11, g_fProjectionMatrix[11]); SETSTAT_FT(stats.g2proj_12, g_fProjectionMatrix[12]); SETSTAT_FT(stats.g2proj_13, g_fProjectionMatrix[13]); SETSTAT_FT(stats.g2proj_14, g_fProjectionMatrix[14]); SETSTAT_FT(stats.g2proj_15, g_fProjectionMatrix[15]); SETSTAT_FT(stats.proj_0, rawProjection[0]); SETSTAT_FT(stats.proj_1, rawProjection[1]); SETSTAT_FT(stats.proj_2, rawProjection[2]); SETSTAT_FT(stats.proj_3, rawProjection[3]); SETSTAT_FT(stats.proj_4, rawProjection[4]); SETSTAT_FT(stats.proj_5, rawProjection[5]); break; default: ERROR_LOG(VIDEO, "Unknown projection type: %d", xfmem.projection.type); } PRIM_LOG("Projection: %f %f %f %f %f %f\n", rawProjection[0], rawProjection[1], rawProjection[2], rawProjection[3], rawProjection[4], rawProjection[5]); if (g_ActiveConfig.bFreeLook && xfmem.projection.type == GX_PERSPECTIVE) { Matrix44 mtxA; Matrix44 mtxB; Matrix44 viewMtx; Matrix44::Translate(mtxA, s_fViewTranslationVector); Matrix44::LoadMatrix33(mtxB, s_viewRotationMatrix); Matrix44::Multiply(mtxB, mtxA, viewMtx); // view = rotation x translation Matrix44::Set(mtxB, g_fProjectionMatrix); Matrix44::Multiply(mtxB, viewMtx, mtxA); // mtxA = projection x view Matrix44::Multiply(s_viewportCorrection, mtxA, mtxB); // mtxB = viewportCorrection x mtxA memcpy(constants.projection, mtxB.data, 4*16); } else { Matrix44 projMtx; Matrix44::Set(projMtx, g_fProjectionMatrix); Matrix44 correctedMtx; Matrix44::Multiply(s_viewportCorrection, projMtx, correctedMtx); memcpy(constants.projection, correctedMtx.data, 4*16); } dirty = true; } }
__forceinline T ReadFromHardware(const u32 em_address) { int segment = em_address >> 28; // Quick check for an address that can't meet any of the following conditions, // to speed up the MMU path. if (!BitSet32(0xCFC)[segment]) { // TODO: Figure out the fastest order of tests for both read and write (they are probably different). if ((em_address & 0xC8000000) == 0xC8000000) { if (em_address < 0xcc000000) return EFB_Read(em_address); else return (T)mmio_mapping->Read<typename std::make_unsigned<T>::type>(em_address); } else if (segment == 0x8 || segment == 0xC || segment == 0x0) { return bswap((*(const T*)&m_pRAM[em_address & RAM_MASK])); } else if (m_pEXRAM && (segment == 0x9 || segment == 0xD || segment == 0x1)) { return bswap((*(const T*)&m_pEXRAM[em_address & EXRAM_MASK])); } else if (segment == 0xE && (em_address < (0xE0000000 + L1_CACHE_SIZE))) { return bswap((*(const T*)&m_pL1Cache[em_address & L1_CACHE_MASK])); } } if (bFakeVMEM && (segment == 0x7 || segment == 0x4)) { // fake VMEM return bswap((*(const T*)&m_pFakeVMEM[em_address & FAKEVMEM_MASK])); } // MMU: Do page table translation u32 tlb_addr = TranslateAddress<flag>(em_address); if (tlb_addr == 0) { if (flag == FLAG_READ) GenerateDSIException(em_address, false); return 0; } // Handle loads that cross page boundaries (ewwww) // The alignment check isn't strictly necessary, but since this is a rare slow path, it provides a faster // (1 instruction on x86) bailout. if (sizeof(T) > 1 && (em_address & (sizeof(T) - 1)) && (em_address & (HW_PAGE_SIZE - 1)) > HW_PAGE_SIZE - sizeof(T)) { // This could be unaligned down to the byte level... hopefully this is rare, so doing it this // way isn't too terrible. // TODO: floats on non-word-aligned boundaries should technically cause alignment exceptions. // Note that "word" means 32-bit, so paired singles or doubles might still be 32-bit aligned! u32 em_address_next_page = (em_address + sizeof(T) - 1) & ~(HW_PAGE_SIZE - 1); u32 tlb_addr_next_page = TranslateAddress<flag>(em_address_next_page); if (tlb_addr == 0 || tlb_addr_next_page == 0) { if (flag == FLAG_READ) GenerateDSIException(em_address_next_page, false); return 0; } T var = 0; for (u32 addr = em_address; addr < em_address + sizeof(T); addr++, tlb_addr++) { if (addr == em_address_next_page) tlb_addr = tlb_addr_next_page; var = (var << 8) | Memory::base[tlb_addr]; } return var; } // The easy case! return bswap(*(const T*)&Memory::base[tlb_addr]); }
// Syncs the shader constant buffers with xfmem // TODO: A cleaner way to control the matrices without making a mess in the parameters field void VertexShaderManager::SetConstants() { if (nTransformMatricesChanged[0] >= 0) { int startn = nTransformMatricesChanged[0] / 4; int endn = (nTransformMatricesChanged[1] + 3) / 4; memcpy(constants.transformmatrices[startn].data(), &xfmem.posMatrices[startn * 4], (endn - startn) * sizeof(float4)); dirty = true; nTransformMatricesChanged[0] = nTransformMatricesChanged[1] = -1; } if (nNormalMatricesChanged[0] >= 0) { int startn = nNormalMatricesChanged[0] / 3; int endn = (nNormalMatricesChanged[1] + 2) / 3; for (int i = startn; i < endn; i++) { memcpy(constants.normalmatrices[i].data(), &xfmem.normalMatrices[3 * i], 12); } dirty = true; nNormalMatricesChanged[0] = nNormalMatricesChanged[1] = -1; } if (nPostTransformMatricesChanged[0] >= 0) { int startn = nPostTransformMatricesChanged[0] / 4; int endn = (nPostTransformMatricesChanged[1] + 3) / 4; memcpy(constants.posttransformmatrices[startn].data(), &xfmem.postMatrices[startn * 4], (endn - startn) * sizeof(float4)); dirty = true; nPostTransformMatricesChanged[0] = nPostTransformMatricesChanged[1] = -1; } if (nLightsChanged[0] >= 0) { // TODO: Outdated comment // lights don't have a 1 to 1 mapping, the color component needs to be converted to 4 floats int istart = nLightsChanged[0] / 0x10; int iend = (nLightsChanged[1] + 15) / 0x10; for (int i = istart; i < iend; ++i) { const Light& light = xfmem.lights[i]; VertexShaderConstants::Light& dstlight = constants.lights[i]; // xfmem.light.color is packed as abgr in u8[4], so we have to swap the order dstlight.color[0] = light.color[3]; dstlight.color[1] = light.color[2]; dstlight.color[2] = light.color[1]; dstlight.color[3] = light.color[0]; dstlight.cosatt[0] = light.cosatt[0]; dstlight.cosatt[1] = light.cosatt[1]; dstlight.cosatt[2] = light.cosatt[2]; if (fabs(light.distatt[0]) < 0.00001f && fabs(light.distatt[1]) < 0.00001f && fabs(light.distatt[2]) < 0.00001f) { // dist attenuation, make sure not equal to 0!!! dstlight.distatt[0] = .00001f; } else { dstlight.distatt[0] = light.distatt[0]; } dstlight.distatt[1] = light.distatt[1]; dstlight.distatt[2] = light.distatt[2]; dstlight.pos[0] = light.dpos[0]; dstlight.pos[1] = light.dpos[1]; dstlight.pos[2] = light.dpos[2]; double norm = double(light.ddir[0]) * double(light.ddir[0]) + double(light.ddir[1]) * double(light.ddir[1]) + double(light.ddir[2]) * double(light.ddir[2]); norm = 1.0 / sqrt(norm); float norm_float = static_cast<float>(norm); dstlight.dir[0] = light.ddir[0] * norm_float; dstlight.dir[1] = light.ddir[1] * norm_float; dstlight.dir[2] = light.ddir[2] * norm_float; } dirty = true; nLightsChanged[0] = nLightsChanged[1] = -1; } for (int i : nMaterialsChanged) { u32 data = i >= 2 ? xfmem.matColor[i - 2] : xfmem.ambColor[i]; constants.materials[i][0] = (data >> 24) & 0xFF; constants.materials[i][1] = (data >> 16) & 0xFF; constants.materials[i][2] = (data >> 8) & 0xFF; constants.materials[i][3] = data & 0xFF; dirty = true; } nMaterialsChanged = BitSet32(0); if (bPosNormalMatrixChanged) { bPosNormalMatrixChanged = false; const float* pos = &xfmem.posMatrices[g_main_cp_state.matrix_index_a.PosNormalMtxIdx * 4]; const float* norm = &xfmem.normalMatrices[3 * (g_main_cp_state.matrix_index_a.PosNormalMtxIdx & 31)]; memcpy(constants.posnormalmatrix.data(), pos, 3 * sizeof(float4)); memcpy(constants.posnormalmatrix[3].data(), norm, 3 * sizeof(float)); memcpy(constants.posnormalmatrix[4].data(), norm + 3, 3 * sizeof(float)); memcpy(constants.posnormalmatrix[5].data(), norm + 6, 3 * sizeof(float)); dirty = true; } if (bTexMatricesChanged[0]) { bTexMatricesChanged[0] = false; const float* pos_matrix_ptrs[] = { &xfmem.posMatrices[g_main_cp_state.matrix_index_a.Tex0MtxIdx * 4], &xfmem.posMatrices[g_main_cp_state.matrix_index_a.Tex1MtxIdx * 4], &xfmem.posMatrices[g_main_cp_state.matrix_index_a.Tex2MtxIdx * 4], &xfmem.posMatrices[g_main_cp_state.matrix_index_a.Tex3MtxIdx * 4]}; for (size_t i = 0; i < ArraySize(pos_matrix_ptrs); ++i) { memcpy(constants.texmatrices[3 * i].data(), pos_matrix_ptrs[i], 3 * sizeof(float4)); } dirty = true; } if (bTexMatricesChanged[1]) { bTexMatricesChanged[1] = false; const float* pos_matrix_ptrs[] = { &xfmem.posMatrices[g_main_cp_state.matrix_index_b.Tex4MtxIdx * 4], &xfmem.posMatrices[g_main_cp_state.matrix_index_b.Tex5MtxIdx * 4], &xfmem.posMatrices[g_main_cp_state.matrix_index_b.Tex6MtxIdx * 4], &xfmem.posMatrices[g_main_cp_state.matrix_index_b.Tex7MtxIdx * 4]}; for (size_t i = 0; i < ArraySize(pos_matrix_ptrs); ++i) { memcpy(constants.texmatrices[3 * i + 12].data(), pos_matrix_ptrs[i], 3 * sizeof(float4)); } dirty = true; } if (bViewportChanged) { bViewportChanged = false; // The console GPU places the pixel center at 7/12 unless antialiasing // is enabled, while D3D and OpenGL place it at 0.5. See the comment // in VertexShaderGen.cpp for details. // NOTE: If we ever emulate antialiasing, the sample locations set by // BP registers 0x01-0x04 need to be considered here. const float pixel_center_correction = 7.0f / 12.0f - 0.5f; const bool bUseVertexRounding = g_ActiveConfig.bVertexRounding && g_ActiveConfig.iEFBScale != 1; const float viewport_width = bUseVertexRounding ? (2.f * xfmem.viewport.wd) : g_renderer->EFBToScaledXf(2.f * xfmem.viewport.wd); const float viewport_height = bUseVertexRounding ? (2.f * xfmem.viewport.ht) : g_renderer->EFBToScaledXf(2.f * xfmem.viewport.ht); const float pixel_size_x = 2.f / viewport_width; const float pixel_size_y = 2.f / viewport_height; constants.pixelcentercorrection[0] = pixel_center_correction * pixel_size_x; constants.pixelcentercorrection[1] = pixel_center_correction * pixel_size_y; // By default we don't change the depth value at all in the vertex shader. constants.pixelcentercorrection[2] = 1.0f; constants.pixelcentercorrection[3] = 0.0f; constants.viewport[0] = (2.f * xfmem.viewport.wd); constants.viewport[1] = (2.f * xfmem.viewport.ht); if (g_renderer->UseVertexDepthRange()) { // Oversized depth ranges are handled in the vertex shader. We need to reverse // the far value to use the reversed-Z trick. if (g_ActiveConfig.backend_info.bSupportsReversedDepthRange) { // Sometimes the console also tries to use the reversed-Z trick. We can only do // that with the expected accuracy if the backend can reverse the depth range. constants.pixelcentercorrection[2] = fabs(xfmem.viewport.zRange) / 16777215.0f; if (xfmem.viewport.zRange < 0.0f) constants.pixelcentercorrection[3] = xfmem.viewport.farZ / 16777215.0f; else constants.pixelcentercorrection[3] = 1.0f - xfmem.viewport.farZ / 16777215.0f; } else { // For backends that don't support reversing the depth range we can still render // cases where the console uses the reversed-Z trick. But we simply can't provide // the expected accuracy, which might result in z-fighting. constants.pixelcentercorrection[2] = xfmem.viewport.zRange / 16777215.0f; constants.pixelcentercorrection[3] = 1.0f - xfmem.viewport.farZ / 16777215.0f; } } dirty = true; BPFunctions::SetViewport(); // Update projection if the viewport isn't 1:1 useable if (!g_ActiveConfig.backend_info.bSupportsOversizedViewports) { ViewportCorrectionMatrix(s_viewportCorrection); bProjectionChanged = true; } } if (bProjectionChanged) { bProjectionChanged = false; float* rawProjection = xfmem.projection.rawProjection; switch (xfmem.projection.type) { case GX_PERSPECTIVE: g_fProjectionMatrix[0] = rawProjection[0] * g_ActiveConfig.fAspectRatioHackW; g_fProjectionMatrix[1] = 0.0f; g_fProjectionMatrix[2] = rawProjection[1] * g_ActiveConfig.fAspectRatioHackW; g_fProjectionMatrix[3] = 0.0f; g_fProjectionMatrix[4] = 0.0f; g_fProjectionMatrix[5] = rawProjection[2] * g_ActiveConfig.fAspectRatioHackH; g_fProjectionMatrix[6] = rawProjection[3] * g_ActiveConfig.fAspectRatioHackH; g_fProjectionMatrix[7] = 0.0f; g_fProjectionMatrix[8] = 0.0f; g_fProjectionMatrix[9] = 0.0f; g_fProjectionMatrix[10] = rawProjection[4]; g_fProjectionMatrix[11] = rawProjection[5]; g_fProjectionMatrix[12] = 0.0f; g_fProjectionMatrix[13] = 0.0f; g_fProjectionMatrix[14] = -1.0f; g_fProjectionMatrix[15] = 0.0f; SETSTAT_FT(stats.gproj_0, g_fProjectionMatrix[0]); SETSTAT_FT(stats.gproj_1, g_fProjectionMatrix[1]); SETSTAT_FT(stats.gproj_2, g_fProjectionMatrix[2]); SETSTAT_FT(stats.gproj_3, g_fProjectionMatrix[3]); SETSTAT_FT(stats.gproj_4, g_fProjectionMatrix[4]); SETSTAT_FT(stats.gproj_5, g_fProjectionMatrix[5]); SETSTAT_FT(stats.gproj_6, g_fProjectionMatrix[6]); SETSTAT_FT(stats.gproj_7, g_fProjectionMatrix[7]); SETSTAT_FT(stats.gproj_8, g_fProjectionMatrix[8]); SETSTAT_FT(stats.gproj_9, g_fProjectionMatrix[9]); SETSTAT_FT(stats.gproj_10, g_fProjectionMatrix[10]); SETSTAT_FT(stats.gproj_11, g_fProjectionMatrix[11]); SETSTAT_FT(stats.gproj_12, g_fProjectionMatrix[12]); SETSTAT_FT(stats.gproj_13, g_fProjectionMatrix[13]); SETSTAT_FT(stats.gproj_14, g_fProjectionMatrix[14]); SETSTAT_FT(stats.gproj_15, g_fProjectionMatrix[15]); break; case GX_ORTHOGRAPHIC: g_fProjectionMatrix[0] = rawProjection[0]; g_fProjectionMatrix[1] = 0.0f; g_fProjectionMatrix[2] = 0.0f; g_fProjectionMatrix[3] = rawProjection[1]; g_fProjectionMatrix[4] = 0.0f; g_fProjectionMatrix[5] = rawProjection[2]; g_fProjectionMatrix[6] = 0.0f; g_fProjectionMatrix[7] = rawProjection[3]; g_fProjectionMatrix[8] = 0.0f; g_fProjectionMatrix[9] = 0.0f; g_fProjectionMatrix[10] = rawProjection[4]; g_fProjectionMatrix[11] = rawProjection[5]; g_fProjectionMatrix[12] = 0.0f; g_fProjectionMatrix[13] = 0.0f; g_fProjectionMatrix[14] = 0.0f; g_fProjectionMatrix[15] = 1.0f; SETSTAT_FT(stats.g2proj_0, g_fProjectionMatrix[0]); SETSTAT_FT(stats.g2proj_1, g_fProjectionMatrix[1]); SETSTAT_FT(stats.g2proj_2, g_fProjectionMatrix[2]); SETSTAT_FT(stats.g2proj_3, g_fProjectionMatrix[3]); SETSTAT_FT(stats.g2proj_4, g_fProjectionMatrix[4]); SETSTAT_FT(stats.g2proj_5, g_fProjectionMatrix[5]); SETSTAT_FT(stats.g2proj_6, g_fProjectionMatrix[6]); SETSTAT_FT(stats.g2proj_7, g_fProjectionMatrix[7]); SETSTAT_FT(stats.g2proj_8, g_fProjectionMatrix[8]); SETSTAT_FT(stats.g2proj_9, g_fProjectionMatrix[9]); SETSTAT_FT(stats.g2proj_10, g_fProjectionMatrix[10]); SETSTAT_FT(stats.g2proj_11, g_fProjectionMatrix[11]); SETSTAT_FT(stats.g2proj_12, g_fProjectionMatrix[12]); SETSTAT_FT(stats.g2proj_13, g_fProjectionMatrix[13]); SETSTAT_FT(stats.g2proj_14, g_fProjectionMatrix[14]); SETSTAT_FT(stats.g2proj_15, g_fProjectionMatrix[15]); SETSTAT_FT(stats.proj_0, rawProjection[0]); SETSTAT_FT(stats.proj_1, rawProjection[1]); SETSTAT_FT(stats.proj_2, rawProjection[2]); SETSTAT_FT(stats.proj_3, rawProjection[3]); SETSTAT_FT(stats.proj_4, rawProjection[4]); SETSTAT_FT(stats.proj_5, rawProjection[5]); break; default: ERROR_LOG(VIDEO, "Unknown projection type: %d", xfmem.projection.type); } PRIM_LOG("Projection: %f %f %f %f %f %f", rawProjection[0], rawProjection[1], rawProjection[2], rawProjection[3], rawProjection[4], rawProjection[5]); if (g_ActiveConfig.bFreeLook && xfmem.projection.type == GX_PERSPECTIVE) { Matrix44 mtxA; Matrix44 mtxB; Matrix44 viewMtx; Matrix44::Translate(mtxA, s_fViewTranslationVector); Matrix44::LoadMatrix33(mtxB, s_viewRotationMatrix); Matrix44::Multiply(mtxB, mtxA, viewMtx); // view = rotation x translation Matrix44::Set(mtxB, g_fProjectionMatrix); Matrix44::Multiply(mtxB, viewMtx, mtxA); // mtxA = projection x view Matrix44::Multiply(s_viewportCorrection, mtxA, mtxB); // mtxB = viewportCorrection x mtxA memcpy(constants.projection.data(), mtxB.data, 4 * sizeof(float4)); } else { Matrix44 projMtx; Matrix44::Set(projMtx, g_fProjectionMatrix); Matrix44 correctedMtx; Matrix44::Multiply(s_viewportCorrection, projMtx, correctedMtx); memcpy(constants.projection.data(), correctedMtx.data, 4 * sizeof(float4)); } dirty = true; } if (bTexMtxInfoChanged) { bTexMtxInfoChanged = false; constants.xfmem_dualTexInfo = xfmem.dualTexTrans.enabled; for (size_t i = 0; i < ArraySize(xfmem.texMtxInfo); i++) constants.xfmem_pack1[i][0] = xfmem.texMtxInfo[i].hex; for (size_t i = 0; i < ArraySize(xfmem.postMtxInfo); i++) constants.xfmem_pack1[i][1] = xfmem.postMtxInfo[i].hex; dirty = true; } if (bLightingConfigChanged) { bLightingConfigChanged = false; for (size_t i = 0; i < 2; i++) { constants.xfmem_pack1[i][2] = xfmem.color[i].hex; constants.xfmem_pack1[i][3] = xfmem.alpha[i].hex; } constants.xfmem_numColorChans = xfmem.numChan.numColorChans; dirty = true; } }
__forceinline static void WriteToHardware(u32 em_address, const T data) { int segment = em_address >> 28; // Quick check for an address that can't meet any of the following conditions, // to speed up the MMU path. bool performTranslation = UReg_MSR(MSR).DR; if (!BitSet32(0xCFC)[segment] && performTranslation) { // First, let's check for FIFO writes, since they are probably the most common // reason we end up in this function. // Note that we must mask the address to correctly emulate certain games; // Pac-Man World 3 in particular is affected by this. if (flag == FLAG_WRITE && (em_address & 0xFFFFF000) == 0xCC008000) { switch (sizeof(T)) { case 1: GPFifo::Write8((u8)data); return; case 2: GPFifo::Write16((u16)data); return; case 4: GPFifo::Write32((u32)data); return; case 8: GPFifo::Write64((u64)data); return; } } if (flag == FLAG_WRITE && (em_address & 0xF8000000) == 0xC8000000) { if (em_address < 0xcc000000) { // TODO: This only works correctly for 32-bit writes. EFB_Write((u32)data, em_address); return; } else { Memory::mmio_mapping->Write(em_address & 0x0FFFFFFF, data); return; } } if (segment == 0x0 || segment == 0x8 || segment == 0xC) { // Handle RAM; the masking intentionally discards bits (essentially creating // mirrors of memory). // TODO: Only the first REALRAM_SIZE is supposed to be backed by actual memory. *(T*)&Memory::m_pRAM[em_address & Memory::RAM_MASK] = bswap(data); return; } if (Memory::m_pEXRAM && (segment == 0x9 || segment == 0xD) && (em_address & 0x0FFFFFFF) < Memory::EXRAM_SIZE) { // Handle EXRAM. // TODO: Is this supposed to be mirrored like main RAM? *(T*)&Memory::m_pEXRAM[em_address & 0x0FFFFFFF] = bswap(data); return; } if (segment == 0xE && (em_address < (0xE0000000 + Memory::L1_CACHE_SIZE))) { *(T*)&Memory::m_pL1Cache[em_address & 0x0FFFFFFF] = bswap(data); return; } } if (Memory::bFakeVMEM && performTranslation && (segment == 0x7 || segment == 0x4)) { // fake VMEM *(T*)&Memory::m_pFakeVMEM[em_address & Memory::FAKEVMEM_MASK] = bswap(data); return; } if (!performTranslation) { if (flag == FLAG_WRITE && (em_address & 0xFFFFF000) == 0x0C008000) { switch (sizeof(T)) { case 1: GPFifo::Write8((u8)data); return; case 2: GPFifo::Write16((u16)data); return; case 4: GPFifo::Write32((u32)data); return; case 8: GPFifo::Write64((u64)data); return; } } if (flag == FLAG_WRITE && (em_address & 0xF8000000) == 0x08000000) { if (em_address < 0x0c000000) { // TODO: This only works correctly for 32-bit writes. EFB_Write((u32)data, em_address); return; } else { Memory::mmio_mapping->Write(em_address, data); return; } } if (segment == 0x0) { // Handle RAM; the masking intentionally discards bits (essentially creating // mirrors of memory). // TODO: Only the first REALRAM_SIZE is supposed to be backed by actual memory. *(T*)&Memory::m_pRAM[em_address & Memory::RAM_MASK] = bswap(data); return; } if (Memory::m_pEXRAM && segment == 0x1 && (em_address & 0x0FFFFFFF) < Memory::EXRAM_SIZE) { *(T*)&Memory::m_pEXRAM[em_address & 0x0FFFFFFF] = bswap(data); return; } PanicAlert("Unable to resolve write address %x PC %x", em_address, PC); return; } // MMU: Do page table translation u32 tlb_addr = TranslateAddress<flag>(em_address); if (tlb_addr == 0) { if (flag == FLAG_WRITE) GenerateDSIException(em_address, true); return; } // Handle stores that cross page boundaries (ewwww) if (sizeof(T) > 1 && (em_address & (sizeof(T) - 1)) && (em_address & (HW_PAGE_SIZE - 1)) > HW_PAGE_SIZE - sizeof(T)) { T val = bswap(data); // We need to check both addresses before writing in case there's a DSI. u32 em_address_next_page = (em_address + sizeof(T) - 1) & ~(HW_PAGE_SIZE - 1); u32 tlb_addr_next_page = TranslateAddress<flag>(em_address_next_page); if (tlb_addr_next_page == 0) { if (flag == FLAG_WRITE) GenerateDSIException(em_address_next_page, true); return; } for (u32 addr = em_address; addr < em_address + sizeof(T); addr++, tlb_addr++, val >>= 8) { if (addr == em_address_next_page) tlb_addr = tlb_addr_next_page; Memory::physical_base[tlb_addr] = (u8)val; } return; }
__forceinline static T ReadFromHardware(const u32 em_address) { int segment = em_address >> 28; bool performTranslation = UReg_MSR(MSR).DR; // Quick check for an address that can't meet any of the following conditions, // to speed up the MMU path. if (!BitSet32(0xCFC)[segment] && performTranslation) { // TODO: Figure out the fastest order of tests for both read and write (they are probably different). if (flag == FLAG_READ && (em_address & 0xF8000000) == 0xC8000000) { if (em_address < 0xcc000000) return EFB_Read(em_address); else return (T)Memory::mmio_mapping->Read<typename std::make_unsigned<T>::type>(em_address & 0x0FFFFFFF); } if (segment == 0x0 || segment == 0x8 || segment == 0xC) { // Handle RAM; the masking intentionally discards bits (essentially creating // mirrors of memory). // TODO: Only the first REALRAM_SIZE is supposed to be backed by actual memory. return bswap((*(const T*)&Memory::m_pRAM[em_address & Memory::RAM_MASK])); } if (Memory::m_pEXRAM && (segment == 0x9 || segment == 0xD) && (em_address & 0x0FFFFFFF) < Memory::EXRAM_SIZE) { // Handle EXRAM. // TODO: Is this supposed to be mirrored like main RAM? return bswap((*(const T*)&Memory::m_pEXRAM[em_address & 0x0FFFFFFF])); } if (segment == 0xE && (em_address < (0xE0000000 + Memory::L1_CACHE_SIZE))) { return bswap((*(const T*)&Memory::m_pL1Cache[em_address & 0x0FFFFFFF])); } } if (Memory::bFakeVMEM && performTranslation && (segment == 0x7 || segment == 0x4)) { // fake VMEM return bswap((*(const T*)&Memory::m_pFakeVMEM[em_address & Memory::FAKEVMEM_MASK])); } if (!performTranslation) { if (flag == FLAG_READ && (em_address & 0xF8000000) == 0x08000000) { if (em_address < 0x0c000000) return EFB_Read(em_address); else return (T)Memory::mmio_mapping->Read<typename std::make_unsigned<T>::type>(em_address); } if (segment == 0x0) { // Handle RAM; the masking intentionally discards bits (essentially creating // mirrors of memory). // TODO: Only the first REALRAM_SIZE is supposed to be backed by actual memory. return bswap((*(const T*)&Memory::m_pRAM[em_address & Memory::RAM_MASK])); } if (Memory::m_pEXRAM && segment == 0x1 && (em_address & 0x0FFFFFFF) < Memory::EXRAM_SIZE) { return bswap((*(const T*)&Memory::m_pEXRAM[em_address & 0x0FFFFFFF])); } PanicAlert("Unable to resolve read address %x PC %x", em_address, PC); return 0; } // MMU: Do page table translation u32 tlb_addr = TranslateAddress<flag>(em_address); if (tlb_addr == 0) { if (flag == FLAG_READ) GenerateDSIException(em_address, false); return 0; } // Handle loads that cross page boundaries (ewwww) // The alignment check isn't strictly necessary, but since this is a rare slow path, it provides a faster // (1 instruction on x86) bailout. if (sizeof(T) > 1 && (em_address & (sizeof(T) - 1)) && (em_address & (HW_PAGE_SIZE - 1)) > HW_PAGE_SIZE - sizeof(T)) { // This could be unaligned down to the byte level... hopefully this is rare, so doing it this // way isn't too terrible. // TODO: floats on non-word-aligned boundaries should technically cause alignment exceptions. // Note that "word" means 32-bit, so paired singles or doubles might still be 32-bit aligned! u32 em_address_next_page = (em_address + sizeof(T) - 1) & ~(HW_PAGE_SIZE - 1); u32 tlb_addr_next_page = TranslateAddress<flag>(em_address_next_page); if (tlb_addr == 0 || tlb_addr_next_page == 0) { if (flag == FLAG_READ) GenerateDSIException(em_address_next_page, false); return 0; } T var = 0; for (u32 addr = em_address; addr < em_address + sizeof(T); addr++, tlb_addr++) { if (addr == em_address_next_page) tlb_addr = tlb_addr_next_page; var = (var << 8) | Memory::physical_base[tlb_addr]; } return var; } // The easy case! return bswap(*(const T*)&Memory::physical_base[tlb_addr]); }
// Syncs the shader constant buffers with xfmem // TODO: A cleaner way to control the matrices without making a mess in the parameters field void VertexShaderManager::SetConstants() { if (nTransformMatricesChanged[0] >= 0) { int startn = nTransformMatricesChanged[0] / 4; int endn = (nTransformMatricesChanged[1] + 3) / 4; memcpy(constants.transformmatrices[startn], &xfmem.posMatrices[startn * 4], (endn - startn) * sizeof(float4)); dirty = true; nTransformMatricesChanged[0] = nTransformMatricesChanged[1] = -1; } if (nNormalMatricesChanged[0] >= 0) { int startn = nNormalMatricesChanged[0] / 3; int endn = (nNormalMatricesChanged[1] + 2) / 3; for (int i = startn; i < endn; i++) { memcpy(constants.normalmatrices[i], &xfmem.normalMatrices[3 * i], 12); } dirty = true; nNormalMatricesChanged[0] = nNormalMatricesChanged[1] = -1; } if (nPostTransformMatricesChanged[0] >= 0) { int startn = nPostTransformMatricesChanged[0] / 4; int endn = (nPostTransformMatricesChanged[1] + 3) / 4; memcpy(constants.posttransformmatrices[startn], &xfmem.postMatrices[startn * 4], (endn - startn) * sizeof(float4)); dirty = true; nPostTransformMatricesChanged[0] = nPostTransformMatricesChanged[1] = -1; } if (nLightsChanged[0] >= 0) { // TODO: Outdated comment // lights don't have a 1 to 1 mapping, the color component needs to be converted to 4 floats int istart = nLightsChanged[0] / 0x10; int iend = (nLightsChanged[1] + 15) / 0x10; for (int i = istart; i < iend; ++i) { const Light& light = xfmem.lights[i]; VertexShaderConstants::Light& dstlight = constants.lights[i]; // xfmem.light.color is packed as abgr in u8[4], so we have to swap the order dstlight.color[0] = light.color[3]; dstlight.color[1] = light.color[2]; dstlight.color[2] = light.color[1]; dstlight.color[3] = light.color[0]; dstlight.cosatt[0] = light.cosatt[0]; dstlight.cosatt[1] = light.cosatt[1]; dstlight.cosatt[2] = light.cosatt[2]; if (fabs(light.distatt[0]) < 0.00001f && fabs(light.distatt[1]) < 0.00001f && fabs(light.distatt[2]) < 0.00001f) { // dist attenuation, make sure not equal to 0!!! dstlight.distatt[0] = .00001f; } else { dstlight.distatt[0] = light.distatt[0]; } dstlight.distatt[1] = light.distatt[1]; dstlight.distatt[2] = light.distatt[2]; dstlight.pos[0] = light.dpos[0]; dstlight.pos[1] = light.dpos[1]; dstlight.pos[2] = light.dpos[2]; double norm = double(light.ddir[0]) * double(light.ddir[0]) + double(light.ddir[1]) * double(light.ddir[1]) + double(light.ddir[2]) * double(light.ddir[2]); norm = 1.0 / sqrt(norm); float norm_float = static_cast<float>(norm); dstlight.dir[0] = light.ddir[0] * norm_float; dstlight.dir[1] = light.ddir[1] * norm_float; dstlight.dir[2] = light.ddir[2] * norm_float; } dirty = true; nLightsChanged[0] = nLightsChanged[1] = -1; } for (int i : nMaterialsChanged) { u32 data = i >= 2 ? xfmem.matColor[i - 2] : xfmem.ambColor[i]; constants.materials[i][0] = (data >> 24) & 0xFF; constants.materials[i][1] = (data >> 16) & 0xFF; constants.materials[i][2] = (data >> 8) & 0xFF; constants.materials[i][3] = data & 0xFF; dirty = true; } nMaterialsChanged = BitSet32(0); if (bPosNormalMatrixChanged) { bPosNormalMatrixChanged = false; const float* pos = &xfmem.posMatrices[g_main_cp_state.matrix_index_a.PosNormalMtxIdx * 4]; const float* norm = &xfmem.normalMatrices[3 * (g_main_cp_state.matrix_index_a.PosNormalMtxIdx & 31)]; memcpy(constants.posnormalmatrix, pos, 3 * sizeof(float4)); memcpy(constants.posnormalmatrix[3], norm, 3 * sizeof(float)); memcpy(constants.posnormalmatrix[4], norm + 3, 3 * sizeof(float)); memcpy(constants.posnormalmatrix[5], norm + 6, 3 * sizeof(float)); dirty = true; } if (bTexMatricesChanged[0]) { bTexMatricesChanged[0] = false; const float* pos_matrix_ptrs[] = { &xfmem.posMatrices[g_main_cp_state.matrix_index_a.Tex0MtxIdx * 4], &xfmem.posMatrices[g_main_cp_state.matrix_index_a.Tex1MtxIdx * 4], &xfmem.posMatrices[g_main_cp_state.matrix_index_a.Tex2MtxIdx * 4], &xfmem.posMatrices[g_main_cp_state.matrix_index_a.Tex3MtxIdx * 4]}; for (size_t i = 0; i < ArraySize(pos_matrix_ptrs); ++i) { memcpy(constants.texmatrices[3 * i], pos_matrix_ptrs[i], 3 * sizeof(float4)); } dirty = true; } if (bTexMatricesChanged[1]) { bTexMatricesChanged[1] = false; const float* pos_matrix_ptrs[] = { &xfmem.posMatrices[g_main_cp_state.matrix_index_b.Tex4MtxIdx * 4], &xfmem.posMatrices[g_main_cp_state.matrix_index_b.Tex5MtxIdx * 4], &xfmem.posMatrices[g_main_cp_state.matrix_index_b.Tex6MtxIdx * 4], &xfmem.posMatrices[g_main_cp_state.matrix_index_b.Tex7MtxIdx * 4]}; for (size_t i = 0; i < ArraySize(pos_matrix_ptrs); ++i) { memcpy(constants.texmatrices[3 * i + 12], pos_matrix_ptrs[i], 3 * sizeof(float4)); } dirty = true; } if (bViewportChanged) { bViewportChanged = false; // The console GPU places the pixel center at 7/12 unless antialiasing // is enabled, while D3D and OpenGL place it at 0.5. See the comment // in VertexShaderGen.cpp for details. // NOTE: If we ever emulate antialiasing, the sample locations set by // BP registers 0x01-0x04 need to be considered here. const float pixel_center_correction = 7.0f / 12.0f - 0.5f; const float pixel_size_x = 2.f / Renderer::EFBToScaledXf(2.f * xfmem.viewport.wd); const float pixel_size_y = 2.f / Renderer::EFBToScaledXf(2.f * xfmem.viewport.ht); constants.pixelcentercorrection[0] = pixel_center_correction * pixel_size_x; constants.pixelcentercorrection[1] = pixel_center_correction * pixel_size_y; // By default we don't change the depth value at all in the vertex shader. constants.pixelcentercorrection[2] = 1.0f; constants.pixelcentercorrection[3] = 0.0f; if (g_ActiveConfig.backend_info.bSupportsDepthClamp) { // Oversized depth ranges are handled in the vertex shader. We need to reverse // the far value to get a reversed depth range mapping. This is necessary // because the standard depth range equation pushes all depth values towards // the back of the depth buffer where conventionally depth buffers have the // least precision. if (g_ActiveConfig.backend_info.bSupportsReversedDepthRange) { if (fabs(xfmem.viewport.zRange) > 16777215.0f || fabs(xfmem.viewport.farZ) > 16777215.0f) { // For backends that support reversing the depth range we also support cases // where the console also uses reversed depth with the same accuracy. We need // to make sure the depth range is positive here and then reverse the depth in // the backend viewport. constants.pixelcentercorrection[2] = fabs(xfmem.viewport.zRange) / 16777215.0f; if (xfmem.viewport.zRange < 0.0f) constants.pixelcentercorrection[3] = xfmem.viewport.farZ / 16777215.0f; else constants.pixelcentercorrection[3] = 1.0f - xfmem.viewport.farZ / 16777215.0f; } } else { if (xfmem.viewport.zRange < 0.0f || xfmem.viewport.zRange > 16777215.0f || fabs(xfmem.viewport.farZ) > 16777215.0f) { // For backends that don't support reversing the depth range we can still render // cases where the console uses reversed depth correctly. But we simply can't // provide the same accuracy as the console. constants.pixelcentercorrection[2] = xfmem.viewport.zRange / 16777215.0f; constants.pixelcentercorrection[3] = 1.0f - xfmem.viewport.farZ / 16777215.0f; } } } dirty = true; // This is so implementation-dependent that we can't have it here. g_renderer->SetViewport(); // Update projection if the viewport isn't 1:1 useable if (!g_ActiveConfig.backend_info.bSupportsOversizedViewports) { ViewportCorrectionMatrix(s_viewportCorrection); bProjectionChanged = true; } } if (bProjectionChanged) { bProjectionChanged = false; float* rawProjection = xfmem.projection.rawProjection; switch (xfmem.projection.type) { case GX_PERSPECTIVE: g_fProjectionMatrix[0] = rawProjection[0] * g_ActiveConfig.fAspectRatioHackW; g_fProjectionMatrix[1] = 0.0f; g_fProjectionMatrix[2] = rawProjection[1]; g_fProjectionMatrix[3] = 0.0f; g_fProjectionMatrix[4] = 0.0f; g_fProjectionMatrix[5] = rawProjection[2] * g_ActiveConfig.fAspectRatioHackH; g_fProjectionMatrix[6] = rawProjection[3]; g_fProjectionMatrix[7] = 0.0f; g_fProjectionMatrix[8] = 0.0f; g_fProjectionMatrix[9] = 0.0f; g_fProjectionMatrix[10] = rawProjection[4]; g_fProjectionMatrix[11] = rawProjection[5]; g_fProjectionMatrix[12] = 0.0f; g_fProjectionMatrix[13] = 0.0f; g_fProjectionMatrix[14] = -1.0f; g_fProjectionMatrix[15] = 0.0f; // Heuristic to detect if a GameCube game is in 16:9 anamorphic widescreen mode. if (!SConfig::GetInstance().bWii) { bool viewport_is_4_3 = AspectIs4_3(xfmem.viewport.wd, xfmem.viewport.ht); if (AspectIs16_9(rawProjection[2], rawProjection[0]) && viewport_is_4_3) Core::g_aspect_wide = true; // Projection is 16:9 and viewport is 4:3, we are rendering // an anamorphic widescreen picture else if (AspectIs4_3(rawProjection[2], rawProjection[0]) && viewport_is_4_3) Core::g_aspect_wide = false; // Project and viewports are both 4:3, we are rendering a normal image. } SETSTAT_FT(stats.gproj_0, g_fProjectionMatrix[0]); SETSTAT_FT(stats.gproj_1, g_fProjectionMatrix[1]); SETSTAT_FT(stats.gproj_2, g_fProjectionMatrix[2]); SETSTAT_FT(stats.gproj_3, g_fProjectionMatrix[3]); SETSTAT_FT(stats.gproj_4, g_fProjectionMatrix[4]); SETSTAT_FT(stats.gproj_5, g_fProjectionMatrix[5]); SETSTAT_FT(stats.gproj_6, g_fProjectionMatrix[6]); SETSTAT_FT(stats.gproj_7, g_fProjectionMatrix[7]); SETSTAT_FT(stats.gproj_8, g_fProjectionMatrix[8]); SETSTAT_FT(stats.gproj_9, g_fProjectionMatrix[9]); SETSTAT_FT(stats.gproj_10, g_fProjectionMatrix[10]); SETSTAT_FT(stats.gproj_11, g_fProjectionMatrix[11]); SETSTAT_FT(stats.gproj_12, g_fProjectionMatrix[12]); SETSTAT_FT(stats.gproj_13, g_fProjectionMatrix[13]); SETSTAT_FT(stats.gproj_14, g_fProjectionMatrix[14]); SETSTAT_FT(stats.gproj_15, g_fProjectionMatrix[15]); break; case GX_ORTHOGRAPHIC: g_fProjectionMatrix[0] = rawProjection[0]; g_fProjectionMatrix[1] = 0.0f; g_fProjectionMatrix[2] = 0.0f; g_fProjectionMatrix[3] = rawProjection[1]; g_fProjectionMatrix[4] = 0.0f; g_fProjectionMatrix[5] = rawProjection[2]; g_fProjectionMatrix[6] = 0.0f; g_fProjectionMatrix[7] = rawProjection[3]; g_fProjectionMatrix[8] = 0.0f; g_fProjectionMatrix[9] = 0.0f; g_fProjectionMatrix[10] = (g_ProjHack1.value + rawProjection[4]) * ((g_ProjHack1.sign == 0) ? 1.0f : g_ProjHack1.sign); g_fProjectionMatrix[11] = (g_ProjHack2.value + rawProjection[5]) * ((g_ProjHack2.sign == 0) ? 1.0f : g_ProjHack2.sign); g_fProjectionMatrix[12] = 0.0f; g_fProjectionMatrix[13] = 0.0f; g_fProjectionMatrix[14] = 0.0f; g_fProjectionMatrix[15] = 1.0f; SETSTAT_FT(stats.g2proj_0, g_fProjectionMatrix[0]); SETSTAT_FT(stats.g2proj_1, g_fProjectionMatrix[1]); SETSTAT_FT(stats.g2proj_2, g_fProjectionMatrix[2]); SETSTAT_FT(stats.g2proj_3, g_fProjectionMatrix[3]); SETSTAT_FT(stats.g2proj_4, g_fProjectionMatrix[4]); SETSTAT_FT(stats.g2proj_5, g_fProjectionMatrix[5]); SETSTAT_FT(stats.g2proj_6, g_fProjectionMatrix[6]); SETSTAT_FT(stats.g2proj_7, g_fProjectionMatrix[7]); SETSTAT_FT(stats.g2proj_8, g_fProjectionMatrix[8]); SETSTAT_FT(stats.g2proj_9, g_fProjectionMatrix[9]); SETSTAT_FT(stats.g2proj_10, g_fProjectionMatrix[10]); SETSTAT_FT(stats.g2proj_11, g_fProjectionMatrix[11]); SETSTAT_FT(stats.g2proj_12, g_fProjectionMatrix[12]); SETSTAT_FT(stats.g2proj_13, g_fProjectionMatrix[13]); SETSTAT_FT(stats.g2proj_14, g_fProjectionMatrix[14]); SETSTAT_FT(stats.g2proj_15, g_fProjectionMatrix[15]); SETSTAT_FT(stats.proj_0, rawProjection[0]); SETSTAT_FT(stats.proj_1, rawProjection[1]); SETSTAT_FT(stats.proj_2, rawProjection[2]); SETSTAT_FT(stats.proj_3, rawProjection[3]); SETSTAT_FT(stats.proj_4, rawProjection[4]); SETSTAT_FT(stats.proj_5, rawProjection[5]); break; default: ERROR_LOG(VIDEO, "Unknown projection type: %d", xfmem.projection.type); } PRIM_LOG("Projection: %f %f %f %f %f %f", rawProjection[0], rawProjection[1], rawProjection[2], rawProjection[3], rawProjection[4], rawProjection[5]); if (g_ActiveConfig.bFreeLook && xfmem.projection.type == GX_PERSPECTIVE) { Matrix44 mtxA; Matrix44 mtxB; Matrix44 viewMtx; Matrix44::Translate(mtxA, s_fViewTranslationVector); Matrix44::LoadMatrix33(mtxB, s_viewRotationMatrix); Matrix44::Multiply(mtxB, mtxA, viewMtx); // view = rotation x translation Matrix44::Set(mtxB, g_fProjectionMatrix); Matrix44::Multiply(mtxB, viewMtx, mtxA); // mtxA = projection x view Matrix44::Multiply(s_viewportCorrection, mtxA, mtxB); // mtxB = viewportCorrection x mtxA memcpy(constants.projection, mtxB.data, 4 * sizeof(float4)); } else { Matrix44 projMtx; Matrix44::Set(projMtx, g_fProjectionMatrix); Matrix44 correctedMtx; Matrix44::Multiply(s_viewportCorrection, projMtx, correctedMtx); memcpy(constants.projection, correctedMtx.data, 4 * sizeof(float4)); } dirty = true; } }
u32 PPCAnalyzer::Analyze(u32 address, CodeBlock *block, CodeBuffer *buffer, u32 blockSize) { // Clear block stats memset(block->m_stats, 0, sizeof(BlockStats)); // Clear register stats block->m_gpa->any = true; block->m_fpa->any = false; block->m_gpa->Clear(); block->m_fpa->Clear(); // Set the blocks start address block->m_address = address; // Reset our block state block->m_broken = false; block->m_memory_exception = false; block->m_num_instructions = 0; if (address == 0) { // Memory exception occurred during instruction fetch block->m_memory_exception = true; return address; } if (SConfig::GetInstance().m_LocalCoreStartupParameter.bMMU && (address & JIT_ICACHE_VMEM_BIT)) { if (!Memory::TranslateAddress(address, Memory::FLAG_NO_EXCEPTION)) { // Memory exception occurred during instruction fetch block->m_memory_exception = true; return address; } } CodeOp *code = buffer->codebuffer; bool found_exit = false; u32 return_address = 0; u32 numFollows = 0; u32 num_inst = 0; for (u32 i = 0; i < blockSize; ++i) { UGeckoInstruction inst = JitInterface::ReadOpcodeJIT(address); if (inst.hex != 0) { num_inst++; memset(&code[i], 0, sizeof(CodeOp)); GekkoOPInfo *opinfo = GetOpInfo(inst); code[i].opinfo = opinfo; code[i].address = address; code[i].inst = inst; code[i].branchTo = -1; code[i].branchToIndex = -1; code[i].skip = false; block->m_stats->numCycles += opinfo->numCycles; SetInstructionStats(block, &code[i], opinfo, i); bool follow = false; u32 destination = 0; bool conditional_continue = false; // Do we inline leaf functions? if (HasOption(OPTION_LEAF_INLINE)) { if (inst.OPCD == 18 && blockSize > 1) { //Is bx - should we inline? yes! if (inst.AA) destination = SignExt26(inst.LI << 2); else destination = address + SignExt26(inst.LI << 2); if (destination != block->m_address) follow = true; } else if (inst.OPCD == 19 && inst.SUBOP10 == 16 && (inst.BO & (1 << 4)) && (inst.BO & (1 << 2)) && return_address != 0) { // bclrx with unconditional branch = return follow = true; destination = return_address; return_address = 0; if (inst.LK) return_address = address + 4; } else if (inst.OPCD == 31 && inst.SUBOP10 == 467) { // mtspr const u32 index = (inst.SPRU << 5) | (inst.SPRL & 0x1F); if (index == SPR_LR) { // We give up to follow the return address // because we have to check the register usage. return_address = 0; } } // TODO: Find the optimal value for FUNCTION_FOLLOWING_THRESHOLD. // If it is small, the performance will be down. // If it is big, the size of generated code will be big and // cache clearning will happen many times. // TODO: Investivate the reason why // "0" is fastest in some games, MP2 for example. if (numFollows > FUNCTION_FOLLOWING_THRESHOLD) follow = false; } if (HasOption(OPTION_CONDITIONAL_CONTINUE)) { if (inst.OPCD == 16 && ((inst.BO & BO_DONT_DECREMENT_FLAG) == 0 || (inst.BO & BO_DONT_CHECK_CONDITION) == 0)) { // bcx with conditional branch conditional_continue = true; } else if (inst.OPCD == 19 && inst.SUBOP10 == 16 && ((inst.BO & BO_DONT_DECREMENT_FLAG) == 0 || (inst.BO & BO_DONT_CHECK_CONDITION) == 0)) { // bclrx with conditional branch conditional_continue = true; } else if (inst.OPCD == 3 || (inst.OPCD == 31 && inst.SUBOP10 == 4)) { // tw/twi tests and raises an exception conditional_continue = true; } else if (inst.OPCD == 19 && inst.SUBOP10 == 528 && (inst.BO_2 & BO_DONT_CHECK_CONDITION) == 0) { // Rare bcctrx with conditional branch // Seen in NES games conditional_continue = true; } } if (!follow) { address += 4; if (!conditional_continue && opinfo->flags & FL_ENDBLOCK) //right now we stop early { found_exit = true; break; } } // XXX: We don't support inlining yet. #if 0 else { numFollows++; // We don't "code[i].skip = true" here // because bx may store a certain value to the link register. // Instead, we skip a part of bx in Jit**::bx(). address = destination; merged_addresses[size_of_merged_addresses++] = address; } #endif } else { // ISI exception or other critical memory exception occured (game over) ERROR_LOG(DYNA_REC, "Instruction hex was 0!"); break; } } block->m_num_instructions = num_inst; if (block->m_num_instructions > 1) ReorderInstructions(block->m_num_instructions, code); if ((!found_exit && num_inst > 0) || blockSize == 1) { // We couldn't find an exit block->m_broken = true; } // Scan for flag dependencies; assume the next block (or any branch that can leave the block) // wants flags, to be safe. bool wantsCR0 = true, wantsCR1 = true, wantsFPRF = true, wantsCA = true; BitSet32 fprInUse, gprInUse, gprInReg, fprInXmm; for (int i = block->m_num_instructions - 1; i >= 0; i--) { bool opWantsCR0 = code[i].wantsCR0; bool opWantsCR1 = code[i].wantsCR1; bool opWantsFPRF = code[i].wantsFPRF; bool opWantsCA = code[i].wantsCA; code[i].wantsCR0 = wantsCR0 || code[i].canEndBlock; code[i].wantsCR1 = wantsCR1 || code[i].canEndBlock; code[i].wantsFPRF = wantsFPRF || code[i].canEndBlock; code[i].wantsCA = wantsCA || code[i].canEndBlock; wantsCR0 |= opWantsCR0 || code[i].canEndBlock; wantsCR1 |= opWantsCR1 || code[i].canEndBlock; wantsFPRF |= opWantsFPRF || code[i].canEndBlock; wantsCA |= opWantsCA || code[i].canEndBlock; wantsCR0 &= !code[i].outputCR0 || opWantsCR0; wantsCR1 &= !code[i].outputCR1 || opWantsCR1; wantsFPRF &= !code[i].outputFPRF || opWantsFPRF; wantsCA &= !code[i].outputCA || opWantsCA; code[i].gprInUse = gprInUse; code[i].fprInUse = fprInUse; code[i].gprInReg = gprInReg; code[i].fprInXmm = fprInXmm; // TODO: if there's no possible endblocks or exceptions in between, tell the regcache // we can throw away a register if it's going to be overwritten later. gprInUse |= code[i].regsIn; gprInReg |= code[i].regsIn; fprInUse |= code[i].fregsIn; if (strncmp(code[i].opinfo->opname, "stfd", 4)) fprInXmm |= code[i].fregsIn; // For now, we need to count output registers as "used" though; otherwise the flush // will result in a redundant store (e.g. store to regcache, then store again to // the same location later). gprInUse |= code[i].regsOut; if (code[i].fregOut >= 0) fprInUse[code[i].fregOut] = true; } // Forward scan, for flags that need the other direction for calculation. BitSet32 fprIsSingle, fprIsDuplicated, fprIsStoreSafe; for (u32 i = 0; i < block->m_num_instructions; i++) { code[i].fprIsSingle = fprIsSingle; code[i].fprIsDuplicated = fprIsDuplicated; code[i].fprIsStoreSafe = fprIsStoreSafe; if (code[i].fregOut >= 0) { fprIsSingle[code[i].fregOut] = false; fprIsDuplicated[code[i].fregOut] = false; fprIsStoreSafe[code[i].fregOut] = false; // Single, duplicated, and doesn't need PPC_FP. if (code[i].opinfo->type == OPTYPE_SINGLEFP) { fprIsSingle[code[i].fregOut] = true; fprIsDuplicated[code[i].fregOut] = true; fprIsStoreSafe[code[i].fregOut] = true; } // Single and duplicated, but might be a denormal (not safe to skip PPC_FP). // TODO: if we go directly from a load to store, skip conversion entirely? // TODO: if we go directly from a load to a float instruction, and the value isn't used // for anything else, we can skip PPC_FP on a load too. if (!strncmp(code[i].opinfo->opname, "lfs", 3)) { fprIsSingle[code[i].fregOut] = true; fprIsDuplicated[code[i].fregOut] = true; } // Paired are still floats, but the top/bottom halves may differ. if (code[i].opinfo->type == OPTYPE_PS || code[i].opinfo->type == OPTYPE_LOADPS) { fprIsSingle[code[i].fregOut] = true; fprIsStoreSafe[code[i].fregOut] = true; } // Careful: changing the float mode in a block breaks this optimization, since // a previous float op might have had had FTZ off while the later store has FTZ // on. So, discard all information we have. if (!strncmp(code[i].opinfo->opname, "mtfs", 4)) fprIsStoreSafe = BitSet32(0); } } return address; }
void PPCAnalyzer::SetInstructionStats(CodeBlock *block, CodeOp *code, GekkoOPInfo *opinfo, u32 index) { code->wantsCR0 = false; code->wantsCR1 = false; if (opinfo->flags & FL_USE_FPU) block->m_fpa->any = true; if (opinfo->flags & FL_TIMER) block->m_gpa->anyTimer = true; // Does the instruction output CR0? if (opinfo->flags & FL_RC_BIT) code->outputCR0 = code->inst.hex & 1; //todo fix else if ((opinfo->flags & FL_SET_CRn) && code->inst.CRFD == 0) code->outputCR0 = true; else code->outputCR0 = (opinfo->flags & FL_SET_CR0) ? true : false; // Does the instruction output CR1? if (opinfo->flags & FL_RC_BIT_F) code->outputCR1 = code->inst.hex & 1; //todo fix else if ((opinfo->flags & FL_SET_CRn) && code->inst.CRFD == 1) code->outputCR1 = true; else code->outputCR1 = (opinfo->flags & FL_SET_CR1) ? true : false; code->wantsFPRF = (opinfo->flags & FL_READ_FPRF) ? true : false; code->outputFPRF = (opinfo->flags & FL_SET_FPRF) ? true : false; code->canEndBlock = (opinfo->flags & FL_ENDBLOCK) ? true : false; code->wantsCA = (opinfo->flags & FL_READ_CA) ? true : false; code->outputCA = (opinfo->flags & FL_SET_CA) ? true : false; // We're going to try to avoid storing carry in XER if we can avoid it -- keep it in the x86 carry flag! // If the instruction reads CA but doesn't write it, we still need to store CA in XER; we can't // leave it in flags. if (HasOption(OPTION_CARRY_MERGE)) code->wantsCAInFlags = code->wantsCA && code->outputCA && opinfo->type == OPTYPE_INTEGER; else code->wantsCAInFlags = false; // mfspr/mtspr can affect/use XER, so be super careful here // we need to note specifically that mfspr needs CA in XER, not in the x86 carry flag if (code->inst.OPCD == 31 && code->inst.SUBOP10 == 339) // mfspr code->wantsCA = ((code->inst.SPRU << 5) | (code->inst.SPRL & 0x1F)) == SPR_XER; if (code->inst.OPCD == 31 && code->inst.SUBOP10 == 467) // mtspr code->outputCA = ((code->inst.SPRU << 5) | (code->inst.SPRL & 0x1F)) == SPR_XER; code->regsIn = BitSet32(0); code->regsOut = BitSet32(0); if (opinfo->flags & FL_OUT_A) { code->regsOut[code->inst.RA] = true; block->m_gpa->SetOutputRegister(code->inst.RA, index); } if (opinfo->flags & FL_OUT_D) { code->regsOut[code->inst.RD] = true; block->m_gpa->SetOutputRegister(code->inst.RD, index); } if (opinfo->flags & FL_OUT_S) { code->regsOut[code->inst.RS] = true; block->m_gpa->SetOutputRegister(code->inst.RS, index); } if ((opinfo->flags & FL_IN_A) || ((opinfo->flags & FL_IN_A0) && code->inst.RA != 0)) { code->regsIn[code->inst.RA] = true; block->m_gpa->SetInputRegister(code->inst.RA, index); } if (opinfo->flags & FL_IN_B) { code->regsIn[code->inst.RB] = true; block->m_gpa->SetInputRegister(code->inst.RB, index); } if (opinfo->flags & FL_IN_C) { code->regsIn[code->inst.RC] = true; block->m_gpa->SetInputRegister(code->inst.RC, index); } if (opinfo->flags & FL_IN_S) { code->regsIn[code->inst.RS] = true; block->m_gpa->SetInputRegister(code->inst.RS, index); } if (code->inst.OPCD == 46) // lmw { for (int iReg = code->inst.RD; iReg < 32; ++iReg) { code->regsOut[iReg] = true; block->m_gpa->SetOutputRegister(iReg, index); } } else if (code->inst.OPCD == 47) //stmw { for (int iReg = code->inst.RS; iReg < 32; ++iReg) { code->regsIn[iReg] = true; block->m_gpa->SetInputRegister(iReg, index); } } code->fregOut = -1; if (opinfo->flags & FL_OUT_FLOAT_D) code->fregOut = code->inst.FD; else if (opinfo->flags & FL_OUT_FLOAT_S) code->fregOut = code->inst.FS; code->fregsIn = BitSet32(0); if (opinfo->flags & FL_IN_FLOAT_A) code->fregsIn[code->inst.FA] = true; if (opinfo->flags & FL_IN_FLOAT_B) code->fregsIn[code->inst.FB] = true; if (opinfo->flags & FL_IN_FLOAT_C) code->fregsIn[code->inst.FC] = true; if (opinfo->flags & FL_IN_FLOAT_D) code->fregsIn[code->inst.FD] = true; if (opinfo->flags & FL_IN_FLOAT_S) code->fregsIn[code->inst.FS] = true; switch (opinfo->type) { case OPTYPE_INTEGER: case OPTYPE_LOAD: case OPTYPE_STORE: case OPTYPE_LOADFP: case OPTYPE_STOREFP: break; case OPTYPE_SINGLEFP: case OPTYPE_DOUBLEFP: break; case OPTYPE_BRANCH: if (code->inst.hex == 0x4e800020) { // For analysis purposes, we can assume that blr eats opinfo->flags. code->outputCR0 = true; code->outputCR1 = true; } break; case OPTYPE_SYSTEM: case OPTYPE_SYSTEMFP: break; } }