archive/Cemu
1
0
Fork 0
mirror of https://github.com/cemu-project/Cemu.git synced 2025-07-03 21:41:19 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

No type inference when calling std::rotl and std::rotr.

Browse source
This commit is contained in:
Tom Lally 2022-09-01 19:01:47 +01:00
parent 53e3ed946e
commit e2eedc7b2c
11 changed files with 54 additions and 54 deletions
Download patch file Download diff file Expand all files Collapse all files

26
src/Cafe/HW/Latte/Core/FetchShader.cpp
View file

@ -81,31 +81,31 @@ void LatteShader_calculateFSKey(LatteFetchShader* fetchShader)
{
LatteParsedFetchShaderAttribute_t* attrib = group.attrib + f;
key += (uint64)attrib->endianSwap;
key = std::rotl(key, 3);
key = std::rotl<uint64>(key, 3);
key += (uint64)attrib->nfa;
key = std::rotl(key, 3);
key = std::rotl<uint64>(key, 3);
key += (uint64)(attrib->isSigned?1:0);
key = std::rotl(key, 1);
key = std::rotl<uint64>(key, 1);
key += (uint64)attrib->format;
key = std::rotl(key, 7);
key = std::rotl<uint64>(key, 7);
key += (uint64)attrib->fetchType;
key = std::rotl(key, 8);
key = std::rotl<uint64>(key, 8);
key += (uint64)attrib->ds[0];
key = std::rotl(key, 2);
key = std::rotl<uint64>(key, 2);
key += (uint64)attrib->ds[1];
key = std::rotl(key, 2);
key = std::rotl<uint64>(key, 2);
key += (uint64)attrib->ds[2];
key = std::rotl(key, 2);
key = std::rotl<uint64>(key, 2);
key += (uint64)attrib->ds[3];
key = std::rotl(key, 2);
key = std::rotl<uint64>(key, 2);
key += (uint64)(attrib->aluDivisor+1);
key = std::rotl(key, 2);
key = std::rotl<uint64>(key, 2);
key += (uint64)attrib->attributeBufferIndex;
key = std::rotl(key, 8);
key = std::rotl<uint64>(key, 8);
key += (uint64)attrib->semanticId;
key = std::rotl(key, 8);
key = std::rotl<uint64>(key, 8);
key += (uint64)(attrib->offset & 3);
key = std::rotl(key, 2);
key = std::rotl<uint64>(key, 2);
}
}
// todo - also hash invalid buffer groups?

2
src/Cafe/HW/Latte/Core/LatteBufferCache.cpp
View file

@ -743,7 +743,7 @@ private:
//h ^= *memU64;
//memU64++;
h = std::rotr(h, 7);
h = std::rotr<uint64>(h, 7);
h += (*memU64 + (uint64)i);
memU64++;
}

6
src/Cafe/HW/Latte/Core/LatteRenderTarget.cpp
View file

@ -158,15 +158,15 @@ void LatteMRT::ApplyCurrentState()
if (colorView)
{
key += ((uint64)colorView);
key = std::rotl(key, 5);
key = std::rotl<uint64>(key, 5);
fboLookupView = colorView;
}
key = std::rotl(key, 7);
key = std::rotl<uint64>(key, 7);
}
if (sLatteCurrentRendertargets.depthBuffer.view)
{
key += ((uint64)sLatteCurrentRendertargets.depthBuffer.view);
key = std::rotl(key, 5);
key = std::rotl<uint64>(key, 5);
key += (sLatteCurrentRendertargets.depthBuffer.hasStencil);
if (fboLookupView == NULL)
{

6
src/Cafe/HW/Latte/Core/LatteShader.cpp
View file

@ -263,7 +263,7 @@ void LatteShader_UpdatePSInputs(uint32* contextRegisters)
cemu_assert_debug(psSemanticId != 0xFF);
key += (uint64)psInputControl;
key = std::rotl(key, 7);
key = std::rotl<uint64>(key, 7);
if (spi0_positionEnable && f == spi0_positionAddr)
{
_activePSImportTable.import[f].semanticId = LATTE_ANALYZER_IMPORT_INDEX_SPIPOSITION;
@ -546,7 +546,7 @@ uint64 LatteSHRC_CalcVSAuxHash(LatteDecompilerShader* vertexShader, uint32* cont
if(!vertexShader->streamoutBufferWriteMask2[i])
continue;
uint32 bufferStride = contextRegisters[mmVGT_STRMOUT_VTX_STRIDE_0 + i * 4];
auxHash = std::rotl(auxHash, 7);
auxHash = std::rotl<uint64>(auxHash, 7);
auxHash += (uint64)bufferStride;
}
}
@ -559,7 +559,7 @@ uint64 LatteSHRC_CalcVSAuxHash(LatteDecompilerShader* vertexShader, uint32* cont
if ((word4 & 0x300) == 0x100)
{
// integer format
auxHashTex = std::rotl(auxHashTex, 7);
auxHashTex = std::rotl<uint64>(auxHashTex, 7);
auxHashTex += 0x333;
}
}

4
src/Cafe/HW/Latte/Renderer/OpenGL/OpenGLRendererUniformData.cpp
View file

@ -44,9 +44,9 @@ void OpenGLRenderer::uniformData_update()
for (sint32 f = 0; f < remappedArraySize; f++)
{
uniformDataHash[0] ^= remappedUniformData64[0];
uniformDataHash[0] = std::rotl(uniformDataHash[0], 11);
uniformDataHash[0] = std::rotl<uint64>(uniformDataHash[0], 11);
uniformDataHash[1] ^= remappedUniformData64[1];
uniformDataHash[1] = std::rotl(uniformDataHash[1], 11);
uniformDataHash[1] = std::rotl<uint64>(uniformDataHash[1], 11);
remappedUniformData64 += 2;
}
if (shader->uniformDataHash64[0] != uniformDataHash[0] || shader->uniformDataHash64[1] != uniformDataHash[1])

2
src/Cafe/HW/Latte/Renderer/RendererShader.cpp
View file

@ -8,7 +8,7 @@ uint32 RendererShader::GeneratePrecompiledCacheId()
const char* s = EMULATOR_VERSION_SUFFIX;
while (*s)
{
v = std::rotl(v, 7);
v = std::rotl<uint32>(v, 7);
v += (uint32)(*s);
s++;
}

4
src/Cafe/HW/Latte/Renderer/Vulkan/VulkanRenderer.cpp
View file

@ -4050,13 +4050,13 @@ VKRObjectRenderPass::VKRObjectRenderPass(AttachmentInfo_t& attachmentInfo, sint3
if (attachmentInfo.colorAttachment[i].isPresent || attachmentInfo.colorAttachment[i].viewObj)
{
stateHash += attachmentInfo.colorAttachment[i].format + i * 31;
stateHash = std::rotl(stateHash, 7);
stateHash = std::rotl<uint64>(stateHash, 7);
}
}
if (attachmentInfo.depthAttachment.isPresent || attachmentInfo.depthAttachment.viewObj)
{
stateHash += attachmentInfo.depthAttachment.format;
stateHash = std::rotl(stateHash, 7);
stateHash = std::rotl<uint64>(stateHash, 7);
}
m_hashForPipeline = stateHash;

36
src/Cafe/HW/Latte/Renderer/Vulkan/VulkanRendererCore.cpp
View file

@ -24,18 +24,18 @@ uint64 VulkanRenderer::draw_calculateMinimalGraphicsPipelineHash(const LatteFetc
for (auto& group : fetchShader->bufferGroups)
{
uint32 bufferStride = group.getCurrentBufferStride(lcr.GetRawView());
stateHash = std::rotl(stateHash, 7);
stateHash = std::rotl<uint64>(stateHash, 7);
stateHash += bufferStride * 3;
}
stateHash += fetchShader->getVkPipelineHashFragment();
stateHash = std::rotl(stateHash, 7);
stateHash = std::rotl<uint64>(stateHash, 7);
stateHash += lcr.GetRawView()[mmVGT_PRIMITIVE_TYPE];
stateHash = std::rotl(stateHash, 7);
stateHash = std::rotl<uint64>(stateHash, 7);
stateHash += lcr.GetRawView()[mmVGT_STRMOUT_EN];
stateHash = std::rotl(stateHash, 7);
stateHash = std::rotl<uint64>(stateHash, 7);
if(lcr.PA_CL_CLIP_CNTL.get_DX_RASTERIZATION_KILL())
stateHash += 0x333333;
@ -66,24 +66,24 @@ uint64 VulkanRenderer::draw_calculateGraphicsPipelineHash(const LatteFetchShader
if (vertexShader)
stateHash += vertexShader->baseHash;
stateHash = std::rotl(stateHash, 13);
stateHash = std::rotl<uint64>(stateHash, 13);
if (geometryShader)
stateHash += geometryShader->baseHash;
stateHash = std::rotl(stateHash, 13);
stateHash = std::rotl<uint64>(stateHash, 13);
if (pixelShader)
stateHash += pixelShader->baseHash + pixelShader->auxHash;
stateHash = std::rotl(stateHash, 13);
stateHash = std::rotl<uint64>(stateHash, 13);
uint32 polygonCtrl = lcr.PA_SU_SC_MODE_CNTL.getRawValue();
stateHash += polygonCtrl;
stateHash = std::rotl(stateHash, 7);
stateHash = std::rotl<uint64>(stateHash, 7);
stateHash += ctxRegister[Latte::REGADDR::PA_CL_CLIP_CNTL];
stateHash = std::rotl(stateHash, 7);
stateHash = std::rotl<uint64>(stateHash, 7);
const auto colorControlReg = ctxRegister[Latte::REGADDR::CB_COLOR_CONTROL];
stateHash += colorControlReg;
@ -97,7 +97,7 @@ uint64 VulkanRenderer::draw_calculateGraphicsPipelineHash(const LatteFetchShader
{
if (((blendEnableMask & (1 << i))) == 0)
continue;
stateHash = std::rotl(stateHash, 7);
stateHash = std::rotl<uint64>(stateHash, 7);
stateHash += ctxRegister[Latte::REGADDR::CB_BLEND0_CONTROL + i];
}
}
@ -109,11 +109,11 @@ uint64 VulkanRenderer::draw_calculateGraphicsPipelineHash(const LatteFetchShader
if (stencilTestEnable)
{
stateHash += ctxRegister[mmDB_STENCILREFMASK];
stateHash = std::rotl(stateHash, 17);
stateHash = std::rotl<uint64>(stateHash, 17);
if(depthControl & (1<<7)) // back stencil enable
{
stateHash += ctxRegister[mmDB_STENCILREFMASK_BF];
stateHash = std::rotl(stateHash, 13);
stateHash = std::rotl<uint64>(stateHash, 13);
}
}
else
@ -122,7 +122,7 @@ uint64 VulkanRenderer::draw_calculateGraphicsPipelineHash(const LatteFetchShader
depthControl &= 0xFF;
}
stateHash = std::rotl(stateHash, 17);
stateHash = std::rotl<uint64>(stateHash, 17);
stateHash += depthControl;
// polygon offset
@ -542,16 +542,16 @@ uint64 VulkanRenderer::GetDescriptorSetStateHash(LatteDecompilerShader* shader)
{
samplerIndex += LatteDecompiler_getTextureSamplerBaseIndex(shader->shaderType);
hash += LatteGPUState.contextRegister[Latte::REGADDR::SQ_TEX_SAMPLER_WORD0_0 + samplerIndex * 3 + 0];
hash = std::rotl(hash, 7);
hash = std::rotl<uint64>(hash, 7);
hash += LatteGPUState.contextRegister[Latte::REGADDR::SQ_TEX_SAMPLER_WORD0_0 + samplerIndex * 3 + 1];
hash = std::rotl(hash, 7);
hash = std::rotl<uint64>(hash, 7);
hash += LatteGPUState.contextRegister[Latte::REGADDR::SQ_TEX_SAMPLER_WORD0_0 + samplerIndex * 3 + 2];
hash = std::rotl(hash, 7);
hash = std::rotl<uint64>(hash, 7);
}
hash = std::rotl(hash, 7);
hash = std::rotl<uint64>(hash, 7);
// hash view id + swizzle mask
hash += (uint64)texture->GetUniqueId();
hash = std::rotr(hash, 21);
hash = std::rotr<uint64>(hash, 21);
hash += (uint64)(word4 & 0x0FFF0000);
}

6
src/Cafe/HW/Latte/Renderer/Vulkan/VulkanSurfaceCopy.cpp
View file

@ -108,12 +108,12 @@ uint64 VulkanRenderer::copySurface_getPipelineStateHash(VkCopySurfaceState_t& st
uint64 h = 0;
h += (uintptr_t)state.destinationTexture->GetFormat();
h = std::rotr(h, 7);
h = std::rotr<uint64>(h, 7);
h += state.sourceTexture->isDepth ? 0x1111ull : 0;
h = std::rotr(h, 7);
h = std::rotr<uint64>(h, 7);
h += state.destinationTexture->isDepth ? 0x1112ull : 0;
h = std::rotr(h, 7);
h = std::rotr<uint64>(h, 7);
return h;
}

8
src/Cafe/OS/RPL/rpl.cpp
View file

@ -713,8 +713,8 @@ void _calculateMappedImportNameHash(const char* rplName, const char* funcName, u
uint64 v = (uint64)*rplName;
h1 += v;
h2 ^= v;
h1 = std::rotl(h1, 3);
h2 = std::rotl(h2, 7);
h1 = std::rotl<uint64>(h1, 3);
h2 = std::rotl<uint64>(h2, 7);
rplName++;
}
// funcName
@ -723,8 +723,8 @@ void _calculateMappedImportNameHash(const char* rplName, const char* funcName, u
uint64 v = (uint64)*funcName;
h1 += v;
h2 ^= v;
h1 = std::rotl(h1, 3);
h2 = std::rotl(h2, 7);
h1 = std::rotl<uint64>(h1, 3);
h2 = std::rotl<uint64>(h2, 7);
funcName++;
}
*h1Out = h1;

8
src/util/crypto/aes128.cpp
View file

@ -332,25 +332,25 @@ void InvMixColumns(aes128Ctx_t* aesCtx)
b = stateVal(0, 1);
c = stateVal(0, 2);
d = stateVal(0, 3);
stateValU32(0) = lookupTable_multiply[a] ^ std::rotl(lookupTable_multiply[b], 8) ^ std::rotl(lookupTable_multiply[c], 16) ^ std::rotl(lookupTable_multiply[d], 24);
stateValU32(0) = lookupTable_multiply[a] ^ std::rotl<uint32>(lookupTable_multiply[b], 8) ^ std::rotl<uint32>(lookupTable_multiply[c], 16) ^ std::rotl<uint32>(lookupTable_multiply[d], 24);
// i1
a = stateVal(1, 0);
b = stateVal(1, 1);
c = stateVal(1, 2);
d = stateVal(1, 3);
stateValU32(1) = lookupTable_multiply[a] ^ std::rotl(lookupTable_multiply[b], 8) ^ std::rotl(lookupTable_multiply[c], 16) ^ std::rotl(lookupTable_multiply[d], 24);
stateValU32(1) = lookupTable_multiply[a] ^ std::rotl<uint32>(lookupTable_multiply[b], 8) ^ std::rotl<uint32>(lookupTable_multiply[c], 16) ^ std::rotl<uint32>(lookupTable_multiply[d], 24);
// i2
a = stateVal(2, 0);
b = stateVal(2, 1);
c = stateVal(2, 2);
d = stateVal(2, 3);
stateValU32(2) = lookupTable_multiply[a] ^ std::rotl(lookupTable_multiply[b], 8) ^ std::rotl(lookupTable_multiply[c], 16) ^ std::rotl(lookupTable_multiply[d], 24);
stateValU32(2) = lookupTable_multiply[a] ^ std::rotl<uint32>(lookupTable_multiply[b], 8) ^ std::rotl<uint32>(lookupTable_multiply[c], 16) ^ std::rotl<uint32>(lookupTable_multiply[d], 24);
// i3
a = stateVal(3, 0);
b = stateVal(3, 1);
c = stateVal(3, 2);
d = stateVal(3, 3);
stateValU32(3) = lookupTable_multiply[a] ^ std::rotl(lookupTable_multiply[b], 8) ^ std::rotl(lookupTable_multiply[c], 16) ^ std::rotl(lookupTable_multiply[d], 24);
stateValU32(3) = lookupTable_multiply[a] ^ std::rotl<uint32>(lookupTable_multiply[b], 8) ^ std::rotl<uint32>(lookupTable_multiply[c], 16) ^ std::rotl<uint32>(lookupTable_multiply[d], 24);
}
// The SubBytes Function Substitutes the values in the