ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Arm64: Use PRIi64/PRIx64 for printf

This commit is contained in:
Michael Maltese 2017-03-25 14:04:02 -07:00
parent 4d8d0451e3
commit c58ba93503
2 changed files with 26 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
Source/Core/Common/Arm64Emitter.cpp
View File

@ -4,6 +4,7 @@
#include <algorithm> #include <algorithm>
#include <array> #include <array>
#include <cinttypes>
#include <cstring> #include <cstring>
#include <vector> #include <vector>
@ -480,13 +481,13 @@ void ARM64XEmitter::EncodeCompareBranchInst(u32 op, ARM64Reg Rt, const void* ptr
bool b64Bit = Is64Bit(Rt); bool b64Bit = Is64Bit(Rt);
s64 distance = (s64)ptr - (s64)m_code; s64 distance = (s64)ptr - (s64)m_code;
_assert_msg_(DYNA_REC, !(distance & 0x3), "%s: distance must be a multiple of 4: %lx", _assert_msg_(DYNA_REC, !(distance & 0x3), "%s: distance must be a multiple of 4: %" PRIx64,
__FUNCTION__, distance); __FUNCTION__, distance);
distance >>= 2; distance >>= 2;
_assert_msg_(DYNA_REC, distance >= -0x40000 && distance <= 0x3FFFF, _assert_msg_(DYNA_REC, distance >= -0x40000 && distance <= 0x3FFFF,
"%s: Received too large distance: %lx", __FUNCTION__, distance); "%s: Received too large distance: %" PRIx64, __FUNCTION__, distance);
Rt = DecodeReg(Rt); Rt = DecodeReg(Rt);
Write32((b64Bit << 31) | (0x34 << 24) | (op << 24) | (((u32)distance << 5) & 0xFFFFE0) | Rt); Write32((b64Bit << 31) | (0x34 << 24) | (op << 24) | (((u32)distance << 5) & 0xFFFFE0) | Rt);
@ -497,13 +498,13 @@ void ARM64XEmitter::EncodeTestBranchInst(u32 op, ARM64Reg Rt, u8 bits, const voi
bool b64Bit = Is64Bit(Rt); bool b64Bit = Is64Bit(Rt);
s64 distance = (s64)ptr - (s64)m_code; s64 distance = (s64)ptr - (s64)m_code;
_assert_msg_(DYNA_REC, !(distance & 0x3), "%s: distance must be a multiple of 4: %lx", _assert_msg_(DYNA_REC, !(distance & 0x3), "%s: distance must be a multiple of 4: %" PRIx64,
__FUNCTION__, distance); __FUNCTION__, distance);
distance >>= 2; distance >>= 2;
_assert_msg_(DYNA_REC, distance >= -0x3FFF && distance < 0x3FFF, _assert_msg_(DYNA_REC, distance >= -0x3FFF && distance < 0x3FFF,
"%s: Received too large distance: %lx", __FUNCTION__, distance); "%s: Received too large distance: %" PRIx64, __FUNCTION__, distance);
Rt = DecodeReg(Rt); Rt = DecodeReg(Rt);
Write32((b64Bit << 31) | (0x36 << 24) | (op << 24) | (bits << 19) | Write32((b64Bit << 31) | (0x36 << 24) | (op << 24) | (bits << 19) |
@ -514,13 +515,13 @@ void ARM64XEmitter::EncodeUnconditionalBranchInst(u32 op, const void* ptr)
{ {
s64 distance = (s64)ptr - s64(m_code); s64 distance = (s64)ptr - s64(m_code);
_assert_msg_(DYNA_REC, !(distance & 0x3), "%s: distance must be a multiple of 4: %lx", _assert_msg_(DYNA_REC, !(distance & 0x3), "%s: distance must be a multiple of 4: %" PRIx64,
__FUNCTION__, distance); __FUNCTION__, distance);
distance >>= 2; distance >>= 2;
_assert_msg_(DYNA_REC, distance >= -0x2000000LL && distance <= 0x1FFFFFFLL, _assert_msg_(DYNA_REC, distance >= -0x2000000LL && distance <= 0x1FFFFFFLL,
"%s: Received too large distance: %lx", __FUNCTION__, distance); "%s: Received too large distance: %" PRIx64, __FUNCTION__, distance);
Write32((op << 31) | (0x5 << 26) | (distance & 0x3FFFFFF)); Write32((op << 31) | (0x5 << 26) | (distance & 0x3FFFFFF));
} }
@ -902,37 +903,42 @@ void ARM64XEmitter::SetJumpTarget(FixupBranch const& branch)
Not = true; Not = true;
case 0: // CBZ case 0: // CBZ
{ {
_assert_msg_(DYNA_REC, IsInRangeImm19(distance), "%s(%d): Received too large distance: %lx", _assert_msg_(DYNA_REC, IsInRangeImm19(distance),
__FUNCTION__, branch.type, distance); "%s(%d): Received too large distance: %" PRIx64, __FUNCTION__, branch.type,
distance);
bool b64Bit = Is64Bit(branch.reg); bool b64Bit = Is64Bit(branch.reg);
ARM64Reg reg = DecodeReg(branch.reg); ARM64Reg reg = DecodeReg(branch.reg);
inst = (b64Bit << 31) | (0x1A << 25) | (Not << 24) | (MaskImm19(distance) << 5) | reg; inst = (b64Bit << 31) | (0x1A << 25) | (Not << 24) | (MaskImm19(distance) << 5) | reg;
} }
break; break;
case 2: // B (conditional) case 2: // B (conditional)
_assert_msg_(DYNA_REC, IsInRangeImm19(distance), "%s(%d): Received too large distance: %lx", _assert_msg_(DYNA_REC, IsInRangeImm19(distance),
__FUNCTION__, branch.type, distance); "%s(%d): Received too large distance: %" PRIx64, __FUNCTION__, branch.type,
distance);
inst = (0x2A << 25) | (MaskImm19(distance) << 5) | branch.cond; inst = (0x2A << 25) | (MaskImm19(distance) << 5) | branch.cond;
break; break;
case 4: // TBNZ case 4: // TBNZ
Not = true; Not = true;
case 3: // TBZ case 3: // TBZ
{ {
_assert_msg_(DYNA_REC, IsInRangeImm14(distance), "%s(%d): Received too large distance: %lx", _assert_msg_(DYNA_REC, IsInRangeImm14(distance),
__FUNCTION__, branch.type, distance); "%s(%d): Received too large distance: %" PRIx64, __FUNCTION__, branch.type,
distance);
ARM64Reg reg = DecodeReg(branch.reg); ARM64Reg reg = DecodeReg(branch.reg);
inst = ((branch.bit & 0x20) << 26) | (0x1B << 25) | (Not << 24) | ((branch.bit & 0x1F) << 19) | inst = ((branch.bit & 0x20) << 26) | (0x1B << 25) | (Not << 24) | ((branch.bit & 0x1F) << 19) |
(MaskImm14(distance) << 5) | reg; (MaskImm14(distance) << 5) | reg;
} }
break; break;
case 5: // B (uncoditional) case 5: // B (uncoditional)
_assert_msg_(DYNA_REC, IsInRangeImm26(distance), "%s(%d): Received too large distance: %lx", _assert_msg_(DYNA_REC, IsInRangeImm26(distance),
__FUNCTION__, branch.type, distance); "%s(%d): Received too large distance: %" PRIx64, __FUNCTION__, branch.type,
distance);
inst = (0x5 << 26) | MaskImm26(distance); inst = (0x5 << 26) | MaskImm26(distance);
break; break;
case 6: // BL (unconditional) case 6: // BL (unconditional)
_assert_msg_(DYNA_REC, IsInRangeImm26(distance), "%s(%d): Received too large distance: %lx", _assert_msg_(DYNA_REC, IsInRangeImm26(distance),
__FUNCTION__, branch.type, distance); "%s(%d): Received too large distance: %" PRIx64, __FUNCTION__, branch.type,
distance);
inst = (0x25 << 26) | MaskImm26(distance); inst = (0x25 << 26) | MaskImm26(distance);
break; break;
} }
@ -1021,8 +1027,8 @@ void ARM64XEmitter::B(CCFlags cond, const void* ptr)
distance >>= 2; distance >>= 2;
_assert_msg_(DYNA_REC, IsInRangeImm19(distance), _assert_msg_(DYNA_REC, IsInRangeImm19(distance),
"%s: Received too large distance: %p->%p %ld %lx", __FUNCTION__, m_code, ptr, "%s: Received too large distance: %p->%p %" PRIi64 " %" PRIx64, __FUNCTION__, m_code,
distance, distance); ptr, distance, distance);
Write32((0x54 << 24) | (MaskImm19(distance) << 5) | cond); Write32((0x54 << 24) | (MaskImm19(distance) << 5) | cond);
} }

3
Source/Core/Core/PowerPC/JitArm64/JitArm64_BackPatch.cpp
View File

@ -2,6 +2,7 @@
// Licensed under GPLv2+ // Licensed under GPLv2+
// Refer to the license.txt file included. // Refer to the license.txt file included.
#include <cinttypes>
#include <string> #include <string>
#include "Common/BitSet.h" #include "Common/BitSet.h"
@ -38,7 +39,7 @@ void JitArm64::DoBacktrace(uintptr_t access_address, SContext* ctx)
Common::swap32(*(u32*)(pc + 4)), Common::swap32(*(u32*)(pc + 8)), Common::swap32(*(u32*)(pc + 4)), Common::swap32(*(u32*)(pc + 8)),
Common::swap32(*(u32*)(pc + 12))); Common::swap32(*(u32*)(pc + 12)));
ERROR_LOG(DYNA_REC, "0x%016lx: %08x %08x %08x %08x", pc, *(u32*)pc, *(u32*)(pc + 4), ERROR_LOG(DYNA_REC, "0x%016" PRIx64 ": %08x %08x %08x %08x", pc, *(u32*)pc, *(u32*)(pc + 4),
*(u32*)(pc + 8), *(u32*)(pc + 12)); *(u32*)(pc + 8), *(u32*)(pc + 12));
} }