Skip to content

Commit

Permalink
Browse files Browse the repository at this point in the history
Merge pull request #646 from lioncash/warnings 
Core: Fix warnings in JitRegCache
  • Loading branch information
@Parlane
Parlane committed Jul 21, 2014
2 parents 4f78ba6 + 98f352a commit 38d5197
Show file tree
Hide file tree
Showing 2 changed files with 51 additions and 47 deletions.
54 changes: 29 additions & 25 deletions Source/Core/Core/PowerPC/Jit64/JitRegCache.cpp
View file
Expand Up @@ -2,6 +2,8 @@
// Licensed under GPLv2
// Refer to the license.txt file included.

#include <cinttypes>

#include "Core/PowerPC/Jit64/Jit.h"
#include "Core/PowerPC/Jit64/JitAsm.h"
#include "Core/PowerPC/Jit64/JitRegCache.h"
Expand All @@ -20,7 +22,7 @@ void RegCache::Start()
xreg.free = true;
xreg.dirty = false;
xreg.locked = false;
xreg.ppcReg = -1;
xreg.ppcReg = INVALID_REG;
}
for (size_t i = 0; i < regs.size(); i++)
{
Expand Down Expand Up @@ -81,9 +83,9 @@ void RegCache::UnlockAllX()

X64Reg RegCache::GetFreeXReg()
{
int aCount;
const int *aOrder = GetAllocationOrder(aCount);
for (int i = 0; i < aCount; i++)
size_t aCount;
const int* aOrder = GetAllocationOrder(aCount);
for (size_t i = 0; i < aCount; i++)
{
X64Reg xr = (X64Reg)aOrder[i];
if (!xregs[xr].locked && xregs[xr].free)
Expand All @@ -94,12 +96,12 @@ X64Reg RegCache::GetFreeXReg()
//Okay, not found :( Force grab one

//TODO - add a pass to grab xregs whose ppcreg is not used in the next 3 instructions
for (int i = 0; i < aCount; i++)
for (size_t i = 0; i < aCount; i++)
{
X64Reg xr = (X64Reg)aOrder[i];
if (xregs[xr].locked)
continue;
int preg = xregs[xr].ppcReg;
size_t preg = xregs[xr].ppcReg;
if (!regs[preg].locked)
{
StoreFromRegister(preg);
Expand All @@ -108,7 +110,7 @@ X64Reg RegCache::GetFreeXReg()
}
//Still no dice? Die!
_assert_msg_(DYNA_REC, 0, "Regcache ran out of regs");
return (X64Reg) -1;
return INVALID_REG;
}

void RegCache::FlushR(X64Reg reg)
Expand Down Expand Up @@ -136,34 +138,36 @@ int RegCache::SanityCheck() const
return 2;
}
else if (regs[i].location.IsImm())
{
return 3;
}
}
}
return 0;
}

void RegCache::DiscardRegContentsIfCached(int preg)
void RegCache::DiscardRegContentsIfCached(size_t preg)
{
if (IsBound(preg))
{
X64Reg xr = regs[preg].location.GetSimpleReg();
xregs[xr].free = true;
xregs[xr].dirty = false;
xregs[xr].ppcReg = -1;
xregs[xr].ppcReg = INVALID_REG;
regs[preg].away = false;
regs[preg].location = GetDefaultLocation(preg);
}
}


void GPRRegCache::SetImmediate32(int preg, u32 immValue)
void GPRRegCache::SetImmediate32(size_t preg, u32 immValue)
{
DiscardRegContentsIfCached(preg);
regs[preg].away = true;
regs[preg].location = Imm32(immValue);
}

const int *GPRRegCache::GetAllocationOrder(int &count)
const int* GPRRegCache::GetAllocationOrder(size_t& count)
{
static const int allocationOrder[] =
{
Expand All @@ -182,7 +186,7 @@ const int *GPRRegCache::GetAllocationOrder(int &count)
return allocationOrder;
}

const int *FPURegCache::GetAllocationOrder(int &count)
const int* FPURegCache::GetAllocationOrder(size_t& count)
{
static const int allocationOrder[] =
{
Expand All @@ -196,17 +200,17 @@ const int *FPURegCache::GetAllocationOrder(int &count)
return allocationOrder;
}

OpArg GPRRegCache::GetDefaultLocation(int reg) const
OpArg GPRRegCache::GetDefaultLocation(size_t reg) const
{
return M(&ppcState.gpr[reg]);
}

OpArg FPURegCache::GetDefaultLocation(int reg) const
OpArg FPURegCache::GetDefaultLocation(size_t reg) const
{
return M(&ppcState.ps[reg][0]);
}

void RegCache::KillImmediate(int preg, bool doLoad, bool makeDirty)
void RegCache::KillImmediate(size_t preg, bool doLoad, bool makeDirty)
{
if (regs[preg].away)
{
Expand All @@ -217,7 +221,7 @@ void RegCache::KillImmediate(int preg, bool doLoad, bool makeDirty)
}
}

void RegCache::BindToRegister(int i, bool doLoad, bool makeDirty)
void RegCache::BindToRegister(size_t i, bool doLoad, bool makeDirty)
{
if (!regs[i].away && regs[i].location.IsImm())
PanicAlert("Bad immediate");
Expand All @@ -232,7 +236,7 @@ void RegCache::BindToRegister(int i, bool doLoad, bool makeDirty)
xregs[xr].dirty = makeDirty || regs[i].location.IsImm();
if (doLoad)
LoadRegister(i, xr);
for (int j = 0; j < (int)regs.size(); j++)
for (size_t j = 0; j < regs.size(); j++)
{
if (i != j && regs[j].location.IsSimpleReg() && regs[j].location.GetSimpleReg() == xr)
{
Expand All @@ -255,7 +259,7 @@ void RegCache::BindToRegister(int i, bool doLoad, bool makeDirty)
}
}

void RegCache::StoreFromRegister(int i, FlushMode mode)
void RegCache::StoreFromRegister(size_t i, FlushMode mode)
{
if (regs[i].away)
{
Expand All @@ -267,7 +271,7 @@ void RegCache::StoreFromRegister(int i, FlushMode mode)
if (mode == FLUSH_ALL)
{
xregs[xr].free = true;
xregs[xr].ppcReg = -1;
xregs[xr].ppcReg = INVALID_REG;
xregs[xr].dirty = false;
}
}
Expand All @@ -287,17 +291,17 @@ void RegCache::StoreFromRegister(int i, FlushMode mode)
}
}

void GPRRegCache::LoadRegister(int preg, X64Reg newLoc)
void GPRRegCache::LoadRegister(size_t preg, X64Reg newLoc)
{
emit->MOV(32, ::Gen::R(newLoc), regs[preg].location);
}

void GPRRegCache::StoreRegister(int preg, OpArg newLoc)
void GPRRegCache::StoreRegister(size_t preg, OpArg newLoc)
{
emit->MOV(32, newLoc, regs[preg].location);
}

void FPURegCache::LoadRegister(int preg, X64Reg newLoc)
void FPURegCache::LoadRegister(size_t preg, X64Reg newLoc)
{
if (!regs[preg].location.IsImm() && (regs[preg].location.offset & 0xF))
{
Expand All @@ -306,7 +310,7 @@ void FPURegCache::LoadRegister(int preg, X64Reg newLoc)
emit->MOVAPD(newLoc, regs[preg].location);
}

void FPURegCache::StoreRegister(int preg, OpArg newLoc)
void FPURegCache::StoreRegister(size_t preg, OpArg newLoc)
{
emit->MOVAPD(newLoc, regs[preg].location.GetSimpleReg());
}
Expand All @@ -323,7 +327,7 @@ void RegCache::Flush(FlushMode mode)
{
if (regs[i].locked)
{
PanicAlert("Someone forgot to unlock PPC reg %zu (X64 reg %i).", i, RX(i));
PanicAlert("Someone forgot to unlock PPC reg %" PRIx64 " (X64 reg %i).", i, RX(i));
}
if (regs[i].away)
{
Expand All @@ -333,7 +337,7 @@ void RegCache::Flush(FlushMode mode)
}
else
{
_assert_msg_(DYNA_REC,0,"Jit64 - Flush unhandled case, reg %zu PC: %08x", i, PC);
_assert_msg_(DYNA_REC,0,"Jit64 - Flush unhandled case, reg %" PRIx64 " PC: %08x", i, PC);
}
}
}
Expand Down
44 changes: 22 additions & 22 deletions Source/Core/Core/PowerPC/Jit64/JitRegCache.h
View file
Expand Up @@ -25,7 +25,7 @@ struct PPCCachedReg

struct X64CachedReg
{
int ppcReg;
size_t ppcReg;
bool dirty;
bool free;
bool locked;
Expand All @@ -46,7 +46,7 @@ class RegCache
std::array<PPCCachedReg, 32> regs;
std::array<X64CachedReg, NUMXREGS> xregs;

virtual const int *GetAllocationOrder(int &count) = 0;
virtual const int *GetAllocationOrder(size_t& count) = 0;

XEmitter *emit;

Expand All @@ -56,7 +56,7 @@ class RegCache
virtual ~RegCache() {}
void Start();

void DiscardRegContentsIfCached(int preg);
void DiscardRegContentsIfCached(size_t preg);
void SetEmitter(XEmitter *emitter) {emit = emitter;}

void FlushR(X64Reg reg);
Expand All @@ -72,37 +72,37 @@ class RegCache
void Flush(FlushMode mode = FLUSH_ALL);
void Flush(PPCAnalyst::CodeOp *op) {Flush();}
int SanityCheck() const;
void KillImmediate(int preg, bool doLoad, bool makeDirty);
void KillImmediate(size_t preg, bool doLoad, bool makeDirty);

//TODO - instead of doload, use "read", "write"
//read only will not set dirty flag
void BindToRegister(int preg, bool doLoad = true, bool makeDirty = true);
void StoreFromRegister(int preg, FlushMode mode = FLUSH_ALL);
virtual void StoreRegister(int preg, OpArg newLoc) = 0;
virtual void LoadRegister(int preg, X64Reg newLoc) = 0;
void BindToRegister(size_t preg, bool doLoad = true, bool makeDirty = true);
void StoreFromRegister(size_t preg, FlushMode mode = FLUSH_ALL);
virtual void StoreRegister(size_t preg, OpArg newLoc) = 0;
virtual void LoadRegister(size_t preg, X64Reg newLoc) = 0;

const OpArg &R(int preg) const {return regs[preg].location;}
X64Reg RX(int preg) const
const OpArg &R(size_t preg) const {return regs[preg].location;}
X64Reg RX(size_t preg) const
{
if (IsBound(preg))
return regs[preg].location.GetSimpleReg();
PanicAlert("Not so simple - %i", preg);
return (X64Reg)-1;
}
virtual OpArg GetDefaultLocation(int reg) const = 0;
virtual OpArg GetDefaultLocation(size_t reg) const = 0;

// Register locking.
void Lock(int p1, int p2=0xff, int p3=0xff, int p4=0xff);
void LockX(int x1, int x2=0xff, int x3=0xff, int x4=0xff);
void UnlockAll();
void UnlockAllX();

bool IsFreeX(int xreg) const
bool IsFreeX(size_t xreg) const
{
return xregs[xreg].free && !xregs[xreg].locked;
}

bool IsBound(int preg) const
bool IsBound(size_t preg) const
{
return regs[preg].away && regs[preg].location.IsSimpleReg();
}
Expand All @@ -114,19 +114,19 @@ class RegCache
class GPRRegCache : public RegCache
{
public:
void StoreRegister(int preg, OpArg newLoc) override;
void LoadRegister(int preg, X64Reg newLoc) override;
OpArg GetDefaultLocation(int reg) const override;
const int *GetAllocationOrder(int &count) override;
void SetImmediate32(int preg, u32 immValue);
void StoreRegister(size_t preg, OpArg newLoc) override;
void LoadRegister(size_t preg, X64Reg newLoc) override;
OpArg GetDefaultLocation(size_t reg) const override;
const int* GetAllocationOrder(size_t& count) override;
void SetImmediate32(size_t preg, u32 immValue);
};


class FPURegCache : public RegCache
{
public:
void StoreRegister(int preg, OpArg newLoc) override;
void LoadRegister(int preg, X64Reg newLoc) override;
const int *GetAllocationOrder(int &count) override;
OpArg GetDefaultLocation(int reg) const override;
void StoreRegister(size_t preg, OpArg newLoc) override;
void LoadRegister(size_t preg, X64Reg newLoc) override;
const int* GetAllocationOrder(size_t& count) override;
OpArg GetDefaultLocation(size_t reg) const override;
};

0 comments on commit 38d5197

Please sign in to comment.