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

Moving byte order/memory access to poly.

This commit is contained in:
Ben Vanik 2014-07-17 19:20:17 -07:00
parent ce70978ef6
commit ec4f41fec4
42 changed files with 608 additions and 486 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
src/alloy/backend/ivm/ivm_intcode.cc
View File

@ -1405,7 +1405,7 @@ uint32_t IntCode_LOAD_I16(IntCodeState& ics, const IntCode* i) {
uint32_t address = ics.rf[i->src1_reg].u32; uint32_t address = ics.rf[i->src1_reg].u32;
if (DYNAMIC_REGISTER_ACCESS_CHECK(address)) { if (DYNAMIC_REGISTER_ACCESS_CHECK(address)) {
ics.rf[i->dest_reg].i16 = ics.rf[i->dest_reg].i16 =
XESWAP16(ics.thread_state->memory()->LoadI16(address)); poly::byte_swap(ics.thread_state->memory()->LoadI16(address));
return IA_NEXT; return IA_NEXT;
} }
DPRINT("%d (%X) = load.i16 %.8X\n", *((int16_t*)(ics.membase + address)), DPRINT("%d (%X) = load.i16 %.8X\n", *((int16_t*)(ics.membase + address)),
@ -1418,7 +1418,7 @@ uint32_t IntCode_LOAD_I32(IntCodeState& ics, const IntCode* i) {
uint32_t address = ics.rf[i->src1_reg].u32; uint32_t address = ics.rf[i->src1_reg].u32;
if (DYNAMIC_REGISTER_ACCESS_CHECK(address)) { if (DYNAMIC_REGISTER_ACCESS_CHECK(address)) {
ics.rf[i->dest_reg].i32 = ics.rf[i->dest_reg].i32 =
XESWAP32(ics.thread_state->memory()->LoadI32(address)); poly::byte_swap(ics.thread_state->memory()->LoadI32(address));
return IA_NEXT; return IA_NEXT;
} }
DFLUSH(); DFLUSH();
@ -1432,7 +1432,7 @@ uint32_t IntCode_LOAD_I64(IntCodeState& ics, const IntCode* i) {
uint32_t address = ics.rf[i->src1_reg].u32; uint32_t address = ics.rf[i->src1_reg].u32;
if (DYNAMIC_REGISTER_ACCESS_CHECK(address)) { if (DYNAMIC_REGISTER_ACCESS_CHECK(address)) {
ics.rf[i->dest_reg].i64 = ics.rf[i->dest_reg].i64 =
XESWAP64(ics.thread_state->memory()->LoadI64(address)); poly::byte_swap(ics.thread_state->memory()->LoadI64(address));
return IA_NEXT; return IA_NEXT;
} }
DPRINT("%lld (%llX) = load.i64 %.8X\n", *((int64_t*)(ics.membase + address)), DPRINT("%lld (%llX) = load.i64 %.8X\n", *((int64_t*)(ics.membase + address)),
@ -1498,8 +1498,8 @@ uint32_t IntCode_STORE_I8(IntCodeState& ics, const IntCode* i) {
uint32_t IntCode_STORE_I16(IntCodeState& ics, const IntCode* i) { uint32_t IntCode_STORE_I16(IntCodeState& ics, const IntCode* i) {
uint32_t address = ics.rf[i->src1_reg].u32; uint32_t address = ics.rf[i->src1_reg].u32;
if (DYNAMIC_REGISTER_ACCESS_CHECK(address)) { if (DYNAMIC_REGISTER_ACCESS_CHECK(address)) {
ics.thread_state->memory()->StoreI16(address, ics.thread_state->memory()->StoreI16(
XESWAP16(ics.rf[i->src2_reg].i16)); address, poly::byte_swap(ics.rf[i->src2_reg].i16));
return IA_NEXT; return IA_NEXT;
} }
DPRINT("store.i16 %.8X = %d (%X)\n", address, ics.rf[i->src2_reg].i16, DPRINT("store.i16 %.8X = %d (%X)\n", address, ics.rf[i->src2_reg].i16,
@ -1512,8 +1512,8 @@ uint32_t IntCode_STORE_I16(IntCodeState& ics, const IntCode* i) {
uint32_t IntCode_STORE_I32(IntCodeState& ics, const IntCode* i) { uint32_t IntCode_STORE_I32(IntCodeState& ics, const IntCode* i) {
uint32_t address = ics.rf[i->src1_reg].u32; uint32_t address = ics.rf[i->src1_reg].u32;
if (DYNAMIC_REGISTER_ACCESS_CHECK(address)) { if (DYNAMIC_REGISTER_ACCESS_CHECK(address)) {
ics.thread_state->memory()->StoreI32(address, ics.thread_state->memory()->StoreI32(
XESWAP32(ics.rf[i->src2_reg].i32)); address, poly::byte_swap(ics.rf[i->src2_reg].i32));
return IA_NEXT; return IA_NEXT;
} }
DPRINT("store.i32 %.8X = %d (%X)\n", address, ics.rf[i->src2_reg].i32, DPRINT("store.i32 %.8X = %d (%X)\n", address, ics.rf[i->src2_reg].i32,
@ -1526,8 +1526,8 @@ uint32_t IntCode_STORE_I32(IntCodeState& ics, const IntCode* i) {
uint32_t IntCode_STORE_I64(IntCodeState& ics, const IntCode* i) { uint32_t IntCode_STORE_I64(IntCodeState& ics, const IntCode* i) {
uint32_t address = ics.rf[i->src1_reg].u32; uint32_t address = ics.rf[i->src1_reg].u32;
if (DYNAMIC_REGISTER_ACCESS_CHECK(address)) { if (DYNAMIC_REGISTER_ACCESS_CHECK(address)) {
ics.thread_state->memory()->StoreI64(address, ics.thread_state->memory()->StoreI64(
XESWAP64(ics.rf[i->src2_reg].i64)); address, poly::byte_swap(ics.rf[i->src2_reg].i64));
return IA_NEXT; return IA_NEXT;
} }
DPRINT("store.i64 %.8X = %lld (%llX)\n", address, ics.rf[i->src2_reg].i64, DPRINT("store.i64 %.8X = %lld (%llX)\n", address, ics.rf[i->src2_reg].i64,
@ -2210,13 +2210,13 @@ int Translate_VECTOR_COMPARE_SGT(TranslationContext& ctx, Instr* i) {
return DispatchToC(ctx, i, fns[i->flags]); return DispatchToC(ctx, i, fns[i->flags]);
} }
uint32_t IntCode_VECTOR_COMPARE_SGE_I8(IntCodeState& ics, const IntCode* i) { uint32_t IntCode_VECTOR_COMPARE_SGE_I8(IntCodeState& ics, const IntCode* i){
VECTOR_COMPARER(int8_t, b16, b16, 16, >= )}; VECTOR_COMPARER(int8_t, b16, b16, 16, >= )};
uint32_t IntCode_VECTOR_COMPARE_SGE_I16(IntCodeState& ics, const IntCode* i) { uint32_t IntCode_VECTOR_COMPARE_SGE_I16(IntCodeState& ics, const IntCode* i){
VECTOR_COMPARER(int16_t, s8, s8, 8, >= )}; VECTOR_COMPARER(int16_t, s8, s8, 8, >= )};
uint32_t IntCode_VECTOR_COMPARE_SGE_I32(IntCodeState& ics, const IntCode* i) { uint32_t IntCode_VECTOR_COMPARE_SGE_I32(IntCodeState& ics, const IntCode* i){
VECTOR_COMPARER(int32_t, i4, i4, 4, >= )}; VECTOR_COMPARER(int32_t, i4, i4, 4, >= )};
uint32_t IntCode_VECTOR_COMPARE_SGE_F32(IntCodeState& ics, const IntCode* i) { uint32_t IntCode_VECTOR_COMPARE_SGE_F32(IntCodeState& ics, const IntCode* i){
VECTOR_COMPARER(float, f4, i4, 4, >= )}; VECTOR_COMPARER(float, f4, i4, 4, >= )};
int Translate_VECTOR_COMPARE_SGE(TranslationContext& ctx, Instr* i) { int Translate_VECTOR_COMPARE_SGE(TranslationContext& ctx, Instr* i) {
static IntCodeFn fns[] = { static IntCodeFn fns[] = {
@ -2228,13 +2228,13 @@ int Translate_VECTOR_COMPARE_SGE(TranslationContext& ctx, Instr* i) {
return DispatchToC(ctx, i, fns[i->flags]); return DispatchToC(ctx, i, fns[i->flags]);
} }
uint32_t IntCode_VECTOR_COMPARE_UGT_I8(IntCodeState& ics, const IntCode* i) { uint32_t IntCode_VECTOR_COMPARE_UGT_I8(IntCodeState& ics, const IntCode* i){
VECTOR_COMPARER(uint8_t, b16, b16, 16, > )}; VECTOR_COMPARER(uint8_t, b16, b16, 16, > )};
uint32_t IntCode_VECTOR_COMPARE_UGT_I16(IntCodeState& ics, const IntCode* i) { uint32_t IntCode_VECTOR_COMPARE_UGT_I16(IntCodeState& ics, const IntCode* i){
VECTOR_COMPARER(uint16_t, s8, s8, 8, > )}; VECTOR_COMPARER(uint16_t, s8, s8, 8, > )};
uint32_t IntCode_VECTOR_COMPARE_UGT_I32(IntCodeState& ics, const IntCode* i) { uint32_t IntCode_VECTOR_COMPARE_UGT_I32(IntCodeState& ics, const IntCode* i){
VECTOR_COMPARER(uint32_t, i4, i4, 4, > )}; VECTOR_COMPARER(uint32_t, i4, i4, 4, > )};
uint32_t IntCode_VECTOR_COMPARE_UGT_F32(IntCodeState& ics, const IntCode* i) { uint32_t IntCode_VECTOR_COMPARE_UGT_F32(IntCodeState& ics, const IntCode* i){
VECTOR_COMPARER(float, f4, i4, 4, > )}; VECTOR_COMPARER(float, f4, i4, 4, > )};
int Translate_VECTOR_COMPARE_UGT(TranslationContext& ctx, Instr* i) { int Translate_VECTOR_COMPARE_UGT(TranslationContext& ctx, Instr* i) {
static IntCodeFn fns[] = { static IntCodeFn fns[] = {
@ -2246,13 +2246,13 @@ int Translate_VECTOR_COMPARE_UGT(TranslationContext& ctx, Instr* i) {
return DispatchToC(ctx, i, fns[i->flags]); return DispatchToC(ctx, i, fns[i->flags]);
} }
uint32_t IntCode_VECTOR_COMPARE_UGE_I8(IntCodeState& ics, const IntCode* i) { uint32_t IntCode_VECTOR_COMPARE_UGE_I8(IntCodeState& ics, const IntCode* i){
VECTOR_COMPARER(uint8_t, b16, b16, 16, >= )}; VECTOR_COMPARER(uint8_t, b16, b16, 16, >= )};
uint32_t IntCode_VECTOR_COMPARE_UGE_I16(IntCodeState& ics, const IntCode* i) { uint32_t IntCode_VECTOR_COMPARE_UGE_I16(IntCodeState& ics, const IntCode* i){
VECTOR_COMPARER(uint16_t, s8, s8, 8, >= )}; VECTOR_COMPARER(uint16_t, s8, s8, 8, >= )};
uint32_t IntCode_VECTOR_COMPARE_UGE_I32(IntCodeState& ics, const IntCode* i) { uint32_t IntCode_VECTOR_COMPARE_UGE_I32(IntCodeState& ics, const IntCode* i){
VECTOR_COMPARER(uint32_t, i4, i4, 4, >= )}; VECTOR_COMPARER(uint32_t, i4, i4, 4, >= )};
uint32_t IntCode_VECTOR_COMPARE_UGE_F32(IntCodeState& ics, const IntCode* i) { uint32_t IntCode_VECTOR_COMPARE_UGE_F32(IntCodeState& ics, const IntCode* i){
VECTOR_COMPARER(float, f4, i4, 4, >= )}; VECTOR_COMPARER(float, f4, i4, 4, >= )};
int Translate_VECTOR_COMPARE_UGE(TranslationContext& ctx, Instr* i) { int Translate_VECTOR_COMPARE_UGE(TranslationContext& ctx, Instr* i) {
static IntCodeFn fns[] = { static IntCodeFn fns[] = {
@ -3526,22 +3526,22 @@ int Translate_ROTATE_LEFT(TranslationContext& ctx, Instr* i) {
} }
uint32_t IntCode_BYTE_SWAP_I16(IntCodeState& ics, const IntCode* i) { uint32_t IntCode_BYTE_SWAP_I16(IntCodeState& ics, const IntCode* i) {
ics.rf[i->dest_reg].i16 = XESWAP16(ics.rf[i->src1_reg].i16); ics.rf[i->dest_reg].i16 = poly::byte_swap(ics.rf[i->src1_reg].i16);
return IA_NEXT; return IA_NEXT;
} }
uint32_t IntCode_BYTE_SWAP_I32(IntCodeState& ics, const IntCode* i) { uint32_t IntCode_BYTE_SWAP_I32(IntCodeState& ics, const IntCode* i) {
ics.rf[i->dest_reg].i32 = XESWAP32(ics.rf[i->src1_reg].i32); ics.rf[i->dest_reg].i32 = poly::byte_swap(ics.rf[i->src1_reg].i32);
return IA_NEXT; return IA_NEXT;
} }
uint32_t IntCode_BYTE_SWAP_I64(IntCodeState& ics, const IntCode* i) { uint32_t IntCode_BYTE_SWAP_I64(IntCodeState& ics, const IntCode* i) {
ics.rf[i->dest_reg].i64 = XESWAP64(ics.rf[i->src1_reg].i64); ics.rf[i->dest_reg].i64 = poly::byte_swap(ics.rf[i->src1_reg].i64);
return IA_NEXT; return IA_NEXT;
} }
uint32_t IntCode_BYTE_SWAP_V128(IntCodeState& ics, const IntCode* i) { uint32_t IntCode_BYTE_SWAP_V128(IntCodeState& ics, const IntCode* i) {
const vec128_t& src1 = ics.rf[i->src1_reg].v128; const vec128_t& src1 = ics.rf[i->src1_reg].v128;
vec128_t& dest = ics.rf[i->dest_reg].v128; vec128_t& dest = ics.rf[i->dest_reg].v128;
for (int n = 0; n < 4; n++) { for (int n = 0; n < 4; n++) {
VECI4(dest, n) = XESWAP32(VECI4(src1, n)); VECI4(dest, n) = poly::byte_swap(VECI4(src1, n));
} }
return IA_NEXT; return IA_NEXT;
} }

1
src/alloy/core.h
View File

@ -11,7 +11,6 @@
#define ALLOY_CORE_H_ #define ALLOY_CORE_H_
// TODO(benvanik): move the common stuff into here? // TODO(benvanik): move the common stuff into here?
#include <xenia/byte_order.h>
#include <xenia/config.h> #include <xenia/config.h>
#include <xenia/logging.h> #include <xenia/logging.h>
#include <xenia/malloc.h> #include <xenia/malloc.h>

4
src/alloy/frontend/ppc/ppc_emit_altivec.cc
View File

@ -1343,7 +1343,9 @@ int InstrEmit_vsldoi_(PPCHIRBuilder& f, uint32_t vd, uint32_t va, uint32_t vb,
// (ABCD ABCD) << 4b = (BCDA) // (ABCD ABCD) << 4b = (BCDA)
// (VA << SH) OR (VB >> (16 - SH)) // (VA << SH) OR (VB >> (16 - SH))
vec128_t shift = *((vec128_t*)(__vsldoi_table[sh])); vec128_t shift = *((vec128_t*)(__vsldoi_table[sh]));
for (int i = 0; i < 4; ++i) shift.i4[i] = XESWAP32BE(shift.i4[i]); for (int i = 0; i < 4; ++i) {
shift.i4[i] = poly::byte_swap(shift.i4[i]);
}
Value* control = f.LoadConstant(shift); Value* control = f.LoadConstant(shift);
Value* v = f.Permute(control, f.LoadVR(va), f.LoadVR(vb), INT8_TYPE); Value* v = f.Permute(control, f.LoadVR(va), f.LoadVR(vb), INT8_TYPE);
f.StoreVR(vd, v); f.StoreVR(vd, v);

2
src/alloy/frontend/ppc/ppc_hir_builder.cc
View File

@ -81,7 +81,7 @@ int PPCHIRBuilder::Emit(FunctionInfo* symbol_info, bool with_debug_info) {
for (uint64_t address = start_address, offset = 0; address <= end_address; for (uint64_t address = start_address, offset = 0; address <= end_address;
address += 4, offset++) { address += 4, offset++) {
i.address = address; i.address = address;
i.code = XEGETUINT32BE(p + address); i.code = poly::load_and_swap<uint32_t>(p + address);
// TODO(benvanik): find a way to avoid using the opcode tables. // TODO(benvanik): find a way to avoid using the opcode tables.
i.type = GetInstrType(i.code); i.type = GetInstrType(i.code);

5
src/alloy/frontend/ppc/ppc_scanner.cc
View File

@ -14,6 +14,7 @@
#include <alloy/frontend/ppc/ppc_frontend.h> #include <alloy/frontend/ppc/ppc_frontend.h>
#include <alloy/frontend/ppc/ppc_instr.h> #include <alloy/frontend/ppc/ppc_instr.h>
#include <alloy/runtime/runtime.h> #include <alloy/runtime/runtime.h>
#include <poly/memory.h>
namespace alloy { namespace alloy {
namespace frontend { namespace frontend {
@ -58,7 +59,7 @@ int PPCScanner::FindExtents(FunctionInfo* symbol_info) {
InstrData i; InstrData i;
while (true) { while (true) {
i.address = address; i.address = address;
i.code = XEGETUINT32BE(p + address); i.code = poly::load_and_swap<uint32_t>(p + address);
// If we fetched 0 assume that we somehow hit one of the awesome // If we fetched 0 assume that we somehow hit one of the awesome
// 'no really we meant to end after that bl' functions. // 'no really we meant to end after that bl' functions.
@ -291,7 +292,7 @@ std::vector<BlockInfo> PPCScanner::FindBlocks(FunctionInfo* symbol_info) {
InstrData i; InstrData i;
for (uint64_t address = start_address; address <= end_address; address += 4) { for (uint64_t address = start_address; address <= end_address; address += 4) {
i.address = address; i.address = address;
i.code = XEGETUINT32BE(p + address); i.code = poly::load_and_swap<uint32_t>(p + address);
if (!i.code) { if (!i.code) {
continue; continue;
} }

2
src/alloy/frontend/ppc/ppc_translator.cc
View File

@ -174,7 +174,7 @@ void PPCTranslator::DumpSource(runtime::FunctionInfo* symbol_info,
for (uint64_t address = start_address, offset = 0; address <= end_address; for (uint64_t address = start_address, offset = 0; address <= end_address;
address += 4, offset++) { address += 4, offset++) {
i.address = address; i.address = address;
i.code = XEGETUINT32BE(p + address); i.code = poly::load_and_swap<uint32_t>(p + address);
// TODO(benvanik): find a way to avoid using the opcode tables. // TODO(benvanik): find a way to avoid using the opcode tables.
i.type = GetInstrType(i.code); i.type = GetInstrType(i.code);

8
src/alloy/hir/value.cc
View File

@ -572,17 +572,17 @@ void Value::ByteSwap() {
constant.i8 = constant.i8; constant.i8 = constant.i8;
break; break;
case INT16_TYPE: case INT16_TYPE:
constant.i16 = XESWAP16(constant.i16); constant.i16 = poly::byte_swap(constant.i16);
break; break;
case INT32_TYPE: case INT32_TYPE:
constant.i32 = XESWAP32(constant.i32); constant.i32 = poly::byte_swap(constant.i32);
break; break;
case INT64_TYPE: case INT64_TYPE:
constant.i64 = XESWAP64(constant.i64); constant.i64 = poly::byte_swap(constant.i64);
break; break;
case VEC128_TYPE: case VEC128_TYPE:
for (int n = 0; n < 4; n++) { for (int n = 0; n < 4; n++) {
constant.v128.i4[n] = XESWAP32(constant.v128.i4[n]); constant.v128.i4[n] = poly::byte_swap(constant.v128.i4[n]);
} }
break; break;
default: default:

61
src/poly/byte_order.h Normal file
View File

@ -0,0 +1,61 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2014 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef POLY_BYTE_ORDER_H_
#define POLY_BYTE_ORDER_H_
#include <cstdint>
#include <poly/config.h>
#include <poly/platform.h>
#if XE_LIKE_OSX
#include <libkern/OSByteOrder.h>
#endif // XE_LIKE_OSX
namespace poly {
#if XE_COMPILER_MSVC
#define POLY_BYTE_SWAP_16 _byteswap_ushort
#define POLY_BYTE_SWAP_32 _byteswap_ulong
#define POLY_BYTE_SWAP_64 _byteswap_uint64
#elif XE_LIKE_OSX
#define POLY_BYTE_SWAP_16 OSSwapInt16
#define POLY_BYTE_SWAP_32 OSSwapInt32
#define POLY_BYTE_SWAP_64 OSSwapInt64
#else
#define POLY_BYTE_SWAP_16 __bswap_16
#define POLY_BYTE_SWAP_32 __bswap_32
#define POLY_BYTE_SWAP_64 __bswap_64
#endif // XE_COMPILER_MSVC
inline int16_t byte_swap(int16_t value) {
return static_cast<int16_t>(POLY_BYTE_SWAP_16(static_cast<int16_t>(value)));
}
inline uint16_t byte_swap(uint16_t value) { return POLY_BYTE_SWAP_16(value); }
inline int32_t byte_swap(int32_t value) {
return static_cast<int32_t>(POLY_BYTE_SWAP_32(static_cast<int32_t>(value)));
}
inline uint32_t byte_swap(uint32_t value) { return POLY_BYTE_SWAP_32(value); }
inline int64_t byte_swap(int64_t value) {
return static_cast<int64_t>(POLY_BYTE_SWAP_64(static_cast<int64_t>(value)));
}
inline uint64_t byte_swap(uint64_t value) { return POLY_BYTE_SWAP_64(value); }
inline float byte_swap(float value) {
uint32_t temp = byte_swap(*reinterpret_cast<uint32_t *>(&value));
return *reinterpret_cast<float *>(&temp);
}
inline double byte_swap(double value) {
uint64_t temp = byte_swap(*reinterpret_cast<uint64_t *>(&value));
return *reinterpret_cast<double *>(&temp);
}
} // namespace poly
#endif // POLY_BYTE_ORDER_H_

175
src/poly/memory.h
View File

@ -10,13 +10,184 @@
#ifndef POLY_MEMORY_H_ #ifndef POLY_MEMORY_H_
#define POLY_MEMORY_H_ #define POLY_MEMORY_H_
#include <poly/config.h> #include <poly/byte_order.h>
#include <poly/platform.h>
namespace poly { namespace poly {
size_t page_size(); size_t page_size();
template <typename T>
T load(const void* mem);
template <>
inline int8_t load<int8_t>(const void* mem) {
return *reinterpret_cast<const int8_t*>(mem);
}
template <>
inline uint8_t load<uint8_t>(const void* mem) {
return *reinterpret_cast<const uint8_t*>(mem);
}
template <>
inline int16_t load<int16_t>(const void* mem) {
return *reinterpret_cast<const int16_t*>(mem);
}
template <>
inline uint16_t load<uint16_t>(const void* mem) {
return *reinterpret_cast<const uint16_t*>(mem);
}
template <>
inline int32_t load<int32_t>(const void* mem) {
return *reinterpret_cast<const int32_t*>(mem);
}
template <>
inline uint32_t load<uint32_t>(const void* mem) {
return *reinterpret_cast<const uint32_t*>(mem);
}
template <>
inline int64_t load<int64_t>(const void* mem) {
return *reinterpret_cast<const int64_t*>(mem);
}
template <>
inline uint64_t load<uint64_t>(const void* mem) {
return *reinterpret_cast<const uint64_t*>(mem);
}
template <>
inline float load<float>(const void* mem) {
return *reinterpret_cast<const float*>(mem);
}
template <>
inline double load<double>(const void* mem) {
return *reinterpret_cast<const double*>(mem);
}
template <typename T>
T load_and_swap(const void* mem);
template <>
inline int8_t load_and_swap<int8_t>(const void* mem) {
return *reinterpret_cast<const int8_t*>(mem);
}
template <>
inline uint8_t load_and_swap<uint8_t>(const void* mem) {
return *reinterpret_cast<const uint8_t*>(mem);
}
template <>
inline int16_t load_and_swap<int16_t>(const void* mem) {
return byte_swap(*reinterpret_cast<const int16_t*>(mem));
}
template <>
inline uint16_t load_and_swap<uint16_t>(const void* mem) {
return byte_swap(*reinterpret_cast<const uint16_t*>(mem));
}
template <>
inline int32_t load_and_swap<int32_t>(const void* mem) {
return byte_swap(*reinterpret_cast<const int32_t*>(mem));
}
template <>
inline uint32_t load_and_swap<uint32_t>(const void* mem) {
return byte_swap(*reinterpret_cast<const uint32_t*>(mem));
}
template <>
inline int64_t load_and_swap<int64_t>(const void* mem) {
return byte_swap(*reinterpret_cast<const int64_t*>(mem));
}
template <>
inline uint64_t load_and_swap<uint64_t>(const void* mem) {
return byte_swap(*reinterpret_cast<const uint64_t*>(mem));
}
template <>
inline float load_and_swap<float>(const void* mem) {
return byte_swap(*reinterpret_cast<const float*>(mem));
}
template <>
inline double load_and_swap<double>(const void* mem) {
return byte_swap(*reinterpret_cast<const double*>(mem));
}
template <typename T>
void store(void* mem, T value);
template <>
inline void store<int8_t>(void* mem, int8_t value) {
*reinterpret_cast<int8_t*>(mem) = value;
}
template <>
inline void store<uint8_t>(void* mem, uint8_t value) {
*reinterpret_cast<uint8_t*>(mem) = value;
}
template <>
inline void store<int16_t>(void* mem, int16_t value) {
*reinterpret_cast<int16_t*>(mem) = value;
}
template <>
inline void store<uint16_t>(void* mem, uint16_t value) {
*reinterpret_cast<uint16_t*>(mem) = value;
}
template <>
inline void store<int32_t>(void* mem, int32_t value) {
*reinterpret_cast<int32_t*>(mem) = value;
}
template <>
inline void store<uint32_t>(void* mem, uint32_t value) {
*reinterpret_cast<uint32_t*>(mem) = value;
}
template <>
inline void store<int64_t>(void* mem, int64_t value) {
*reinterpret_cast<int64_t*>(mem) = value;
}
template <>
inline void store<uint64_t>(void* mem, uint64_t value) {
*reinterpret_cast<uint64_t*>(mem) = value;
}
template <>
inline void store<float>(void* mem, float value) {
*reinterpret_cast<float*>(mem) = value;
}
template <>
inline void store<double>(void* mem, double value) {
*reinterpret_cast<double*>(mem) = value;
}
template <typename T>
void store_and_swap(void* mem, T value);
template <>
inline void store_and_swap<int8_t>(void* mem, int8_t value) {
*reinterpret_cast<int8_t*>(mem) = value;
}
template <>
inline void store_and_swap<uint8_t>(void* mem, uint8_t value) {
*reinterpret_cast<uint8_t*>(mem) = value;
}
template <>
inline void store_and_swap<int16_t>(void* mem, int16_t value) {
*reinterpret_cast<int16_t*>(mem) = byte_swap(value);
}
template <>
inline void store_and_swap<uint16_t>(void* mem, uint16_t value) {
*reinterpret_cast<uint16_t*>(mem) = byte_swap(value);
}
template <>
inline void store_and_swap<int32_t>(void* mem, int32_t value) {
*reinterpret_cast<int32_t*>(mem) = byte_swap(value);
}
template <>
inline void store_and_swap<uint32_t>(void* mem, uint32_t value) {
*reinterpret_cast<uint32_t*>(mem) = byte_swap(value);
}
template <>
inline void store_and_swap<int64_t>(void* mem, int64_t value) {
*reinterpret_cast<int64_t*>(mem) = byte_swap(value);
}
template <>
inline void store_and_swap<uint64_t>(void* mem, uint64_t value) {
*reinterpret_cast<uint64_t*>(mem) = byte_swap(value);
}
template <>
inline void store_and_swap<float>(void* mem, float value) {
*reinterpret_cast<float*>(mem) = byte_swap(value);
}
template <>
inline void store_and_swap<double>(void* mem, double value) {
*reinterpret_cast<double*>(mem) = byte_swap(value);
}
} // namespace poly } // namespace poly
#endif // POLY_MEMORY_H_ #endif // POLY_MEMORY_H_

1
src/poly/poly.h
View File

@ -12,6 +12,7 @@
#include <poly/assert.h> #include <poly/assert.h>
#include <poly/atomic.h> #include <poly/atomic.h>
#include <poly/byte_order.h>
#include <poly/config.h> #include <poly/config.h>
#include <poly/cxx_compat.h> #include <poly/cxx_compat.h>
#include <poly/math.h> #include <poly/math.h>

1
src/poly/sources.gypi
View File

@ -3,6 +3,7 @@
'sources': [ 'sources': [
'assert.h', 'assert.h',
'atomic.h', 'atomic.h',
'byte_order.h',
'config.h', 'config.h',
'cxx_compat.h', 'cxx_compat.h',
'math.cc', 'math.cc',

2
src/xenia/apu/audio_system.cc
View File

@ -149,7 +149,7 @@ X_STATUS AudioSystem::RegisterClient(
uint32_t ptr = (uint32_t)memory()->HeapAlloc(0, 0x4, 0); uint32_t ptr = (uint32_t)memory()->HeapAlloc(0, 0x4, 0);
auto mem = memory()->membase(); auto mem = memory()->membase();
XESETUINT32BE(mem + ptr, callback_arg); poly::store_and_swap<uint32_t>(mem + ptr, callback_arg);
clients_[index] = { driver, callback, callback_arg, ptr }; clients_[index] = { driver, callback, callback_arg, ptr };

2
src/xenia/apu/xaudio2/xaudio2_audio_driver.cc
View File

@ -131,7 +131,7 @@ void XAudio2AudioDriver::SubmitFrame(uint32_t frame_ptr) {
// interleave the data // interleave the data
for (int index = 0, o = 0; index < channel_samples_; ++index) { for (int index = 0, o = 0; index < channel_samples_; ++index) {
for (int channel = 0, table = 0; channel < interleave_channels; ++channel, table += channel_samples_) { for (int channel = 0, table = 0; channel < interleave_channels; ++channel, table += channel_samples_) {
output_frame[o++] = XESWAPF32BE(input_frame[table + index]); output_frame[o++] = poly::byte_swap(input_frame[table + index]);
} }
} }

120
src/xenia/byte_order.h
View File

@ -1,120 +0,0 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_BYTE_ORDER_H_
#define XENIA_BYTE_ORDER_H_
#include <cstdint>
#include <xenia/platform.h>
#include <xenia/types.h>
#if XE_COMPILER_MSVC
#define XESWAP16 _byteswap_ushort
#define XESWAP32 _byteswap_ulong
#define XESWAP64 _byteswap_uint64
#elif XE_LIKE_OSX
#include <libkern/OSByteOrder.h>
#define XESWAP16 OSSwapInt16
#define XESWAP32 OSSwapInt32
#define XESWAP64 OSSwapInt64
#else
#define XESWAP16 __bswap_16
#define XESWAP32 __bswap_32
#define XESWAP64 __bswap_64
#endif
#if XE_CPU_BIGENDIAN
#define XESWAP16BE(p) (p)
#define XESWAP32BE(p) (p)
#define XESWAP64BE(p) (p)
#define XESWAP16LE(p) XESWAP16(p)
#define XESWAP32LE(p) XESWAP32(p)
#define XESWAP64LE(p) XESWAP64(p)
#else
#define XESWAP16BE(p) XESWAP16(p)
#define XESWAP32BE(p) XESWAP32(p)
#define XESWAP64BE(p) XESWAP64(p)
#define XESWAP16LE(p) (p)
#define XESWAP32LE(p) (p)
#define XESWAP64LE(p) (p)
#endif
#if XE_CPU_BIGENDIAN
#define XESWAPF32BE(p) (p)
#define XESWAPF64BE(p) (p)
XEFORCEINLINE float XESWAPF32LE(float value) {
uint32_t dummy = XESWAP32LE(*reinterpret_cast<uint32_t *>(&value));
return *reinterpret_cast<float *>(&dummy);
}
XEFORCEINLINE double XESWAPF64LE(double value) {
uint64_t dummy = XESWAP64LE(*reinterpret_cast<uint64_t *>(&value));
return *reinterpret_cast<double *>(&dummy);
}
#else
XEFORCEINLINE float XESWAPF32BE(float value) {
uint32_t dummy = XESWAP32BE(*reinterpret_cast<uint32_t *>(&value));
return *reinterpret_cast<float *>(&dummy);
}
XEFORCEINLINE double XESWAPF64BE(double value) {
uint64_t dummy = XESWAP64BE(*reinterpret_cast<uint64_t *>(&value));
return *reinterpret_cast<double *>(&dummy);
}
#define XESWAPF32LE(p) (p)
#define XESWAPF64LE(p) (p)
#endif
#define XEGETINT8BE(p) ( (int8_t)(*(p)))
#define XEGETUINT8BE(p) ( (uint8_t)(*(p)))
#define XEGETINT16BE(p) ( (int16_t)XESWAP16BE(*(uint16_t*)(p)))
#define XEGETUINT16BE(p) ((uint16_t)XESWAP16BE(*(uint16_t*)(p)))
#define XEGETUINT24BE(p) \
(((uint32_t)XEGETUINT8BE((p) + 0) << 16) | \
((uint32_t)XEGETUINT8BE((p) + 1) << 8) | \
(uint32_t)XEGETUINT8BE((p) + 2))
#define XEGETINT32BE(p) ( (int32_t)XESWAP32BE(*(uint32_t*)(p)))
#define XEGETUINT32BE(p) ((uint32_t)XESWAP32BE(*(uint32_t*)(p)))
#define XEGETINT64BE(p) ( (int64_t)XESWAP64BE(*(uint64_t*)(p)))
#define XEGETUINT64BE(p) ((uint64_t)XESWAP64BE(*(uint64_t*)(p)))
#define XEGETINT8LE(p) ( (int8_t)(*(p)))
#define XEGETUINT8LE(p) ( (uint8_t)(*(p)))
#define XEGETINT16LE(p) ( (int16_t)XESWAP16LE(*(uint16_t*)(p)))
#define XEGETUINT16LE(p) ((uint16_t)XESWAP16LE(*(uint16_t*)(p)))
#define XEGETUINT24LE(p) \
(((uint32_t)XEGETUINT8LE((p) + 2) << 16) | \
((uint32_t)XEGETUINT8LE((p) + 1) << 8) | \
(uint32_t)XEGETUINT8LE((p) + 0))
#define XEGETINT32LE(p) ( (int32_t)XESWAP32LE(*(uint32_t*)(p)))
#define XEGETUINT32LE(p) ((uint32_t)XESWAP32LE(*(uint32_t*)(p)))
#define XEGETINT64LE(p) ( (int64_t)XESWAP64LE(*(uint64_t*)(p)))
#define XEGETUINT64LE(p) ((uint64_t)XESWAP64LE(*(uint64_t*)(p)))
#define XESETINT8BE(p, v) (*( (int8_t*)(p)) = (int8_t)v)
#define XESETUINT8BE(p, v) (*( (uint8_t*)(p)) = (uint8_t)v)
#define XESETINT16BE(p, v) (*( (int16_t*)(p)) = XESWAP16BE( (int16_t)v))
#define XESETUINT16BE(p, v) (*((uint16_t*)(p)) = XESWAP16BE((uint16_t)v))
#define XESETINT32BE(p, v) (*( (int32_t*)(p)) = XESWAP32BE( (int32_t)v))
#define XESETUINT32BE(p, v) (*((uint32_t*)(p)) = XESWAP32BE((uint32_t)v))
#define XESETINT64BE(p, v) (*( (int64_t*)(p)) = XESWAP64BE( (int64_t)v))
#define XESETUINT64BE(p, v) (*((uint64_t*)(p)) = XESWAP64BE((uint64_t)v))
#define XESETINT8LE(p, v) (*( (int8_t*)(p)) = (int8_t)v)
#define XESETUINT8LE(p, v) (*( (uint8_t*)(p)) = (uint8_t)v)
#define XESETINT16LE(p, v) (*( (int16_t*)(p)) = (int16_t)v)
#define XESETUINT16LE(p, v) (*((uint16_t*)(p)) = (uint16_t)v)
#define XESETINT32LE(p, v) (*( (int32_t*)(p)) = (int32_t)v)
#define XESETUINT32LE(p, v) (*((uint32_t*)(p)) = (uint32_t)v)
#define XESETINT64LE(p, v) (*( (int64_t*)(p)) = (int64_t)v)
#define XESETUINT64LE(p, v) (*((uint64_t*)(p)) = (uint64_t)v)
#endif // XENIA_BYTE_ORDER_H_

3
src/xenia/common.h
View File

@ -12,8 +12,9 @@
#include <poly/assert.h> #include <poly/assert.h>
#include <poly/atomic.h> #include <poly/atomic.h>
#include <poly/byte_order.h>
#include <poly/memory.h>
#include <xenia/byte_order.h>
#include <xenia/config.h> #include <xenia/config.h>
#include <xenia/logging.h> #include <xenia/logging.h>
#include <xenia/malloc.h> #include <xenia/malloc.h>

2
src/xenia/core/crc32.cc
View File

@ -300,7 +300,7 @@ uint32_t xe_crc32(const void* data, size_t length, uint32_t previous_crc) {
const uint32_t* current = (const uint32_t*)data; const uint32_t* current = (const uint32_t*)data;
while (length >= 8) { while (length >= 8) {
#if XE_CPU_BIGENDIAN #if XE_CPU_BIGENDIAN
uint32_t one = *current++ ^ XESWAP32(crc); uint32_t one = *current++ ^ poly::byte_swap(crc);
uint32_t two = *current++; uint32_t two = *current++;
crc = xe_crc32_lookup_[0][ two & 0xFF] ^ crc = xe_crc32_lookup_[0][ two & 0xFF] ^
xe_crc32_lookup_[1][(two>> 8) & 0xFF] ^ xe_crc32_lookup_[1][(two>> 8) & 0xFF] ^

14
src/xenia/core/hash.cc
View File

@ -86,8 +86,8 @@ XEFORCEINLINE uint32_t UNALIGNED_LOAD32(const char *p) {
#endif #endif
#if XE_CPU_BIGENDIAN #if XE_CPU_BIGENDIAN
#define uint32_t_in_expected_order(x) (XESWAP32(x)) #define uint32_t_in_expected_order(x) (poly::byte_swap(x))
#define uint64_in_expected_order(x) (XESWAP64(x)) #define uint64_in_expected_order(x) (poly::byte_swap(x))
#else #else
#define uint32_t_in_expected_order(x) (x) #define uint32_t_in_expected_order(x) (x)
#define uint64_in_expected_order(x) (x) #define uint64_in_expected_order(x) (x)
@ -227,9 +227,9 @@ uint32_t CityHash32(const char *s, size_t len) {
h = Rotate32(h, 19); h = Rotate32(h, 19);
h = h * 5 + 0xe6546b64; h = h * 5 + 0xe6546b64;
g ^= a4; g ^= a4;
g = XESWAP32(g) * 5; g = poly::byte_swap(g) * 5;
h += a4 * 5; h += a4 * 5;
h = XESWAP32(h); h = poly::byte_swap(h);
f += a0; f += a0;
PERMUTE3(f, h, g); PERMUTE3(f, h, g);
s += 20; s += 20;
@ -346,11 +346,11 @@ static uint64_t HashLen33to64(const char *s, size_t len) {
uint64_t h = Fetch64(s + len - 16) * mul; uint64_t h = Fetch64(s + len - 16) * mul;
uint64_t u = Rotate(a + g, 43) + (Rotate(b, 30) + c) * 9; uint64_t u = Rotate(a + g, 43) + (Rotate(b, 30) + c) * 9;
uint64_t v = ((a + g) ^ d) + f + 1; uint64_t v = ((a + g) ^ d) + f + 1;
uint64_t w = XESWAP64((u + v) * mul) + h; uint64_t w = poly::byte_swap((u + v) * mul) + h;
uint64_t x = Rotate(e + f, 42) + c; uint64_t x = Rotate(e + f, 42) + c;
uint64_t y = (XESWAP64((v + w) * mul) + g) * mul; uint64_t y = (poly::byte_swap((v + w) * mul) + g) * mul;
uint64_t z = e + f + c; uint64_t z = e + f + c;
a = XESWAP64((x + z) * mul + y) + b; a = poly::byte_swap((x + z) * mul + y) + b;
b = ShiftMix((z + a) * mul + d + h) * mul; b = ShiftMix((z + a) * mul + d + h) * mul;
return b + x; return b + x;
} }

2
src/xenia/cpu/processor.cc
View File

@ -144,7 +144,7 @@ uint64_t Processor::ExecuteInterrupt(
// Set 0x10C(r13) to the current CPU ID. // Set 0x10C(r13) to the current CPU ID.
uint8_t* p = memory_->membase(); uint8_t* p = memory_->membase();
XESETUINT8BE(p + interrupt_thread_block_ + 0x10C, cpu); poly::store_and_swap<uint8_t>(p + interrupt_thread_block_ + 0x10C, cpu);
// Execute interrupt. // Execute interrupt.
uint64_t result = Execute(interrupt_thread_state_, address, args, arg_count); uint64_t result = Execute(interrupt_thread_state_, address, args, arg_count);

12
src/xenia/cpu/xenon_memory.cc
View File

@ -180,13 +180,13 @@ LONG CALLBACK CheckMMIOHandler(PEXCEPTION_POINTERS ex_info) {
*reg_ptr = static_cast<uint8_t>(value); *reg_ptr = static_cast<uint8_t>(value);
break; break;
case 16: case 16:
*reg_ptr = XESWAP16(static_cast<uint16_t>(value)); *reg_ptr = poly::byte_swap(static_cast<uint16_t>(value));
break; break;
case 32: case 32:
*reg_ptr = XESWAP32(static_cast<uint32_t>(value)); *reg_ptr = poly::byte_swap(static_cast<uint32_t>(value));
break; break;
case 64: case 64:
*reg_ptr = XESWAP64(static_cast<uint64_t>(value)); *reg_ptr = poly::byte_swap(static_cast<uint64_t>(value));
break; break;
} }
ex_info->ContextRecord->Rip += len; ex_info->ContextRecord->Rip += len;
@ -207,13 +207,13 @@ LONG CALLBACK CheckMMIOHandler(PEXCEPTION_POINTERS ex_info) {
value = static_cast<uint8_t>(value); value = static_cast<uint8_t>(value);
break; break;
case 16: case 16:
value = XESWAP16(static_cast<uint16_t>(value)); value = poly::byte_swap(static_cast<uint16_t>(value));
break; break;
case 32: case 32:
value = XESWAP32(static_cast<uint32_t>(value)); value = poly::byte_swap(static_cast<uint32_t>(value));
break; break;
case 64: case 64:
value = XESWAP64(static_cast<uint64_t>(value)); value = poly::byte_swap(static_cast<uint64_t>(value));
break; break;
} }
range.write(range.context, address & 0xFFFFFFFF, value); range.write(range.context, address & 0xFFFFFFFF, value);

16
src/xenia/cpu/xex_module.cc
View File

@ -132,20 +132,20 @@ int XexModule::SetupLibraryImports(const xe_xex2_import_library_t* library) {
if (kernel_export->type == KernelExport::Function) { if (kernel_export->type == KernelExport::Function) {
// Not exactly sure what this should be... // Not exactly sure what this should be...
if (info->thunk_address) { if (info->thunk_address) {
*slot = XESWAP32BE(info->thunk_address); *slot = poly::byte_swap(info->thunk_address);
} else { } else {
// TODO(benvanik): find out what import variables are. // TODO(benvanik): find out what import variables are.
XELOGW("kernel import variable not defined %.8X %s", XELOGW("kernel import variable not defined %.8X %s",
info->value_address, kernel_export->name); info->value_address, kernel_export->name);
*slot = XESWAP32BE(0xF00DF00D); *slot = poly::byte_swap(0xF00DF00D);
} }
} else { } else {
if (kernel_export->is_implemented) { if (kernel_export->is_implemented) {
// Implemented - replace with pointer. // Implemented - replace with pointer.
XESETUINT32BE(slot, kernel_export->variable_ptr); poly::store_and_swap<uint32_t>(slot, kernel_export->variable_ptr);
} else { } else {
// Not implemented - write with a dummy value. // Not implemented - write with a dummy value.
XESETUINT32BE(slot, 0xD000BEEF | (kernel_export->ordinal & 0xFFF) << 16); poly::store_and_swap<uint32_t>(slot, 0xD000BEEF | (kernel_export->ordinal & 0xFFF) << 16);
XELOGCPU("WARNING: imported a variable with no value: %s", XELOGCPU("WARNING: imported a variable with no value: %s",
kernel_export->name); kernel_export->name);
} }
@ -175,10 +175,10 @@ int XexModule::SetupLibraryImports(const xe_xex2_import_library_t* library) {
// nop // nop
// nop // nop
uint8_t* p = memory()->Translate(info->thunk_address); uint8_t* p = memory()->Translate(info->thunk_address);
XESETUINT32BE(p + 0x0, 0x44000002); poly::store_and_swap<uint32_t>(p + 0x0, 0x44000002);
XESETUINT32BE(p + 0x4, 0x4E800020); poly::store_and_swap<uint32_t>(p + 0x4, 0x4E800020);
XESETUINT32BE(p + 0x8, 0x60000000); poly::store_and_swap<uint32_t>(p + 0x8, 0x60000000);
XESETUINT32BE(p + 0xC, 0x60000000); poly::store_and_swap<uint32_t>(p + 0xC, 0x60000000);
FunctionInfo::ExternHandler handler = 0; FunctionInfo::ExternHandler handler = 0;
void* handler_data = 0; void* handler_data = 0;

22
src/xenia/gpu/command_processor.cc
View File

@ -118,7 +118,7 @@ void CommandProcessor::Pump() {
// TODO(benvanik): use read_ptr_update_freq_ and only issue after moving // TODO(benvanik): use read_ptr_update_freq_ and only issue after moving
// that many indices. // that many indices.
if (read_ptr_writeback_ptr_) { if (read_ptr_writeback_ptr_) {
XESETUINT32BE(p + read_ptr_writeback_ptr_, read_ptr_index_); poly::store_and_swap<uint32_t>(p + read_ptr_writeback_ptr_, read_ptr_index_);
} }
} }
@ -174,7 +174,7 @@ void CommandProcessor::ExecuteIndirectBuffer(uint32_t ptr, uint32_t length) {
for (uint32_t __m = 0; __m < count; __m++) { \ for (uint32_t __m = 0; __m < count; __m++) { \
XETRACECP("[%.8X] %.8X", \ XETRACECP("[%.8X] %.8X", \
packet_ptr + (1 + __m) * 4, \ packet_ptr + (1 + __m) * 4, \
XEGETUINT32BE(packet_base + 1 * 4 + __m * 4)); \ poly::load_and_swap<uint32_t>(packet_base + 1 * 4 + __m * 4)); \
} }
void CommandProcessor::AdvancePtr(PacketArgs& args, uint32_t n) { void CommandProcessor::AdvancePtr(PacketArgs& args, uint32_t n) {
@ -186,9 +186,9 @@ void CommandProcessor::AdvancePtr(PacketArgs& args, uint32_t n) {
} }
#define ADVANCE_PTR(n) AdvancePtr(args, n) #define ADVANCE_PTR(n) AdvancePtr(args, n)
#define PEEK_PTR() \ #define PEEK_PTR() \
XEGETUINT32BE(p + args.ptr) poly::load_and_swap<uint32_t>(p + args.ptr)
#define READ_PTR() \ #define READ_PTR() \
XEGETUINT32BE(p + args.ptr); ADVANCE_PTR(1); poly::load_and_swap<uint32_t>(p + args.ptr); ADVANCE_PTR(1);
uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) { uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) {
uint8_t* p = memory_->membase(); uint8_t* p = memory_->membase();
@ -339,7 +339,7 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) {
// Memory. // Memory.
XE_GPU_ENDIAN endianness = (XE_GPU_ENDIAN)(poll_reg_addr & 0x3); XE_GPU_ENDIAN endianness = (XE_GPU_ENDIAN)(poll_reg_addr & 0x3);
poll_reg_addr &= ~0x3; poll_reg_addr &= ~0x3;
value = XEGETUINT32LE(p + GpuToCpu(packet_ptr, poll_reg_addr)); value = poly::load<uint32_t>(p + GpuToCpu(packet_ptr, poll_reg_addr));
value = GpuSwap(value, endianness); value = GpuSwap(value, endianness);
} else { } else {
// Register. // Register.
@ -434,7 +434,7 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) {
// Memory. // Memory.
XE_GPU_ENDIAN endianness = (XE_GPU_ENDIAN)(poll_reg_addr & 0x3); XE_GPU_ENDIAN endianness = (XE_GPU_ENDIAN)(poll_reg_addr & 0x3);
poll_reg_addr &= ~0x3; poll_reg_addr &= ~0x3;
value = XEGETUINT32LE(p + GpuToCpu(packet_ptr, poll_reg_addr)); value = poly::load<uint32_t>(p + GpuToCpu(packet_ptr, poll_reg_addr));
value = GpuSwap(value, endianness); value = GpuSwap(value, endianness);
} else { } else {
// Register. // Register.
@ -475,8 +475,8 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) {
XE_GPU_ENDIAN endianness = (XE_GPU_ENDIAN)(write_reg_addr & 0x3); XE_GPU_ENDIAN endianness = (XE_GPU_ENDIAN)(write_reg_addr & 0x3);
write_reg_addr &= ~0x3; write_reg_addr &= ~0x3;
write_data = GpuSwap(write_data, endianness); write_data = GpuSwap(write_data, endianness);
XESETUINT32LE(p + GpuToCpu(packet_ptr, write_reg_addr), poly::store(p + GpuToCpu(packet_ptr, write_reg_addr),
write_data); write_data);
} else { } else {
// Register. // Register.
WriteRegister(packet_ptr, write_reg_addr, write_data); WriteRegister(packet_ptr, write_reg_addr, write_data);
@ -524,7 +524,7 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) {
XE_GPU_ENDIAN endianness = (XE_GPU_ENDIAN)(address & 0x3); XE_GPU_ENDIAN endianness = (XE_GPU_ENDIAN)(address & 0x3);
address &= ~0x3; address &= ~0x3;
data_value = GpuSwap(data_value, endianness); data_value = GpuSwap(data_value, endianness);
XESETUINT32LE(p + GpuToCpu(address), data_value); poly::store(p + GpuToCpu(address), data_value);
} }
break; break;
@ -637,7 +637,7 @@ uint32_t CommandProcessor::ExecutePacket(PacketArgs& args) {
size &= 0xFFF; size &= 0xFFF;
index += 0x4000; // alu constants index += 0x4000; // alu constants
for (uint32_t n = 0; n < size; n++, index++) { for (uint32_t n = 0; n < size; n++, index++) {
uint32_t data = XEGETUINT32BE( uint32_t data = poly::load_and_swap<uint32_t>(
p + GpuToCpu(packet_ptr, address + n * 4)); p + GpuToCpu(packet_ptr, address + n * 4));
const char* reg_name = regs->GetRegisterName(index); const char* reg_name = regs->GetRegisterName(index);
XETRACECP("[%.8X] %.8X -> %.4X %s", XETRACECP("[%.8X] %.8X -> %.4X %s",
@ -769,7 +769,7 @@ void CommandProcessor::WriteRegister(
uint8_t* p = memory_->membase(); uint8_t* p = memory_->membase();
uint32_t scratch_addr = regs->values[XE_GPU_REG_SCRATCH_ADDR].u32; uint32_t scratch_addr = regs->values[XE_GPU_REG_SCRATCH_ADDR].u32;
uint32_t mem_addr = scratch_addr + (scratch_reg * 4); uint32_t mem_addr = scratch_addr + (scratch_reg * 4);
XESETUINT32BE(p + GpuToCpu(primary_buffer_ptr_, mem_addr), value); poly::store_and_swap<uint32_t>(p + GpuToCpu(primary_buffer_ptr_, mem_addr), value);
} }
} }
} }

6
src/xenia/gpu/d3d11/d3d11_buffer_resource.cc
View File

@ -69,7 +69,7 @@ int D3D11IndexBufferResource::InvalidateRegion(
memory_range_.host_base); memory_range_.host_base);
uint32_t* dest = reinterpret_cast<uint32_t*>(res.pData); uint32_t* dest = reinterpret_cast<uint32_t*>(res.pData);
for (uint32_t n = 0; n < index_count; n++) { for (uint32_t n = 0; n < index_count; n++) {
dest[n] = XESWAP32(src[n]); dest[n] = poly::byte_swap(src[n]);
} }
} else { } else {
uint32_t index_count = memory_range_.length / 2; uint32_t index_count = memory_range_.length / 2;
@ -77,7 +77,7 @@ int D3D11IndexBufferResource::InvalidateRegion(
memory_range_.host_base); memory_range_.host_base);
uint16_t* dest = reinterpret_cast<uint16_t*>(res.pData); uint16_t* dest = reinterpret_cast<uint16_t*>(res.pData);
for (uint32_t n = 0; n < index_count; n++) { for (uint32_t n = 0; n < index_count; n++) {
dest[n] = XESWAP16(src[n]); dest[n] = poly::byte_swap(src[n]);
} }
} }
resource_cache_->context()->Unmap(handle_, 0); resource_cache_->context()->Unmap(handle_, 0);
@ -138,7 +138,7 @@ int D3D11VertexBufferResource::InvalidateRegion(
uint32_t o = 0; uint32_t o = 0;
for (uint32_t i = 0; i < count; i++) { for (uint32_t i = 0; i < count; i++) {
for (uint32_t j = 0; j < el.size_words; j++) { for (uint32_t j = 0; j < el.size_words; j++) {
dest_ptr[o + j] = XESWAP32(src_ptr[o + j]); dest_ptr[o + j] = poly::byte_swap(src_ptr[o + j]);
} }
o += stride; o += stride;
} }

2
src/xenia/gpu/shader_resource.cc
View File

@ -35,7 +35,7 @@ ShaderResource::ShaderResource(const MemoryRange& memory_range,
size_t byte_size = dword_count_ * sizeof(uint32_t); size_t byte_size = dword_count_ * sizeof(uint32_t);
dwords_ = (uint32_t*)xe_malloc(byte_size); dwords_ = (uint32_t*)xe_malloc(byte_size);
for (uint32_t n = 0; n < dword_count_; n++) { for (uint32_t n = 0; n < dword_count_; n++) {
dwords_[n] = XEGETUINT32BE(memory_range.host_base + n * 4); dwords_[n] = poly::load_and_swap<uint32_t>(memory_range.host_base + n * 4);
} }
// Disassemble, for debugging. // Disassemble, for debugging.

4
src/xenia/gpu/texture_resource.cc
View File

@ -307,12 +307,12 @@ void TextureResource::TextureSwap(uint8_t* dest, const uint8_t* src,
switch (info_.endianness) { switch (info_.endianness) {
case XE_GPU_ENDIAN_8IN16: case XE_GPU_ENDIAN_8IN16:
for (uint32_t i = 0; i < pitch; i += 2, src += 2, dest += 2) { for (uint32_t i = 0; i < pitch; i += 2, src += 2, dest += 2) {
*(uint16_t*)dest = XESWAP16(*(uint16_t*)src); *(uint16_t*)dest = poly::byte_swap(*(uint16_t*)src);
} }
break; break;
case XE_GPU_ENDIAN_8IN32: // Swap bytes. case XE_GPU_ENDIAN_8IN32: // Swap bytes.
for (uint32_t i = 0; i < pitch; i += 4, src += 4, dest += 4) { for (uint32_t i = 0; i < pitch; i += 4, src += 4, dest += 4) {
*(uint32_t*)dest = XESWAP32(*(uint32_t*)src); *(uint32_t*)dest = poly::byte_swap(*(uint32_t*)src);
} }
break; break;
case XE_GPU_ENDIAN_16IN32: // Swap half words. case XE_GPU_ENDIAN_16IN32: // Swap half words.

2
src/xenia/gpu/xenos/xenos.h
View File

@ -83,7 +83,7 @@ XEFORCEINLINE uint32_t GpuSwap(uint32_t value, XE_GPU_ENDIAN endianness) {
((value >> 8) & 0x00FF00FF); ((value >> 8) & 0x00FF00FF);
case XE_GPU_ENDIAN_8IN32: // Swap bytes. case XE_GPU_ENDIAN_8IN32: // Swap bytes.
// NOTE: we are likely doing two swaps here. Wasteful. Oh well. // NOTE: we are likely doing two swaps here. Wasteful. Oh well.
return XESWAP32(value); return poly::byte_swap(value);
case XE_GPU_ENDIAN_16IN32: // Swap half words. case XE_GPU_ENDIAN_16IN32: // Swap half words.
return ((value >> 16) & 0xFFFF) | (value << 16); return ((value >> 16) & 0xFFFF) | (value << 16);
} }

16
src/xenia/kernel/fs/gdfx.cc
View File

@ -122,8 +122,8 @@ GDFX::Error GDFX::Verify(ParseState& state) {
return kErrorReadError; return kErrorReadError;
} }
uint8_t* fs_ptr = state.ptr + state.game_offset + (32 * kXESectorSize); uint8_t* fs_ptr = state.ptr + state.game_offset + (32 * kXESectorSize);
state.root_sector = XEGETUINT32LE(fs_ptr + 20); state.root_sector = poly::load<uint32_t>(fs_ptr + 20);
state.root_size = XEGETUINT32LE(fs_ptr + 24); state.root_size = poly::load<uint32_t>(fs_ptr + 24);
state.root_offset = state.game_offset + (state.root_sector * kXESectorSize); state.root_offset = state.game_offset + (state.root_sector * kXESectorSize);
if (state.root_size < 13 || if (state.root_size < 13 ||
state.root_size > 32 * 1024 * 1024) { state.root_size > 32 * 1024 * 1024) {
@ -157,12 +157,12 @@ bool GDFX::ReadEntry(ParseState& state, const uint8_t* buffer,
uint16_t entry_ordinal, GDFXEntry* parent) { uint16_t entry_ordinal, GDFXEntry* parent) {
const uint8_t* p = buffer + (entry_ordinal * 4); const uint8_t* p = buffer + (entry_ordinal * 4);
uint16_t node_l = XEGETUINT16LE(p + 0); uint16_t node_l = poly::load<uint16_t>(p + 0);
uint16_t node_r = XEGETUINT16LE(p + 2); uint16_t node_r = poly::load<uint16_t>(p + 2);
size_t sector = XEGETUINT32LE(p + 4); size_t sector = poly::load<uint32_t>(p + 4);
size_t length = XEGETUINT32LE(p + 8); size_t length = poly::load<uint32_t>(p + 8);
uint8_t attributes = XEGETUINT8LE(p + 12); uint8_t attributes = poly::load<uint8_t>(p + 12);
uint8_t name_length = XEGETUINT8LE(p + 13); uint8_t name_length = poly::load<uint8_t>(p + 13);
char* name = (char*)(p + 14); char* name = (char*)(p + 14);
if (node_l && !ReadEntry(state, buffer, node_l, parent)) { if (node_l && !ReadEntry(state, buffer, node_l, parent)) {

78
src/xenia/kernel/fs/stfs.cc
View File

@ -16,21 +16,29 @@ using namespace xe;
using namespace xe::kernel; using namespace xe::kernel;
using namespace xe::kernel::fs; using namespace xe::kernel::fs;
#define XEGETUINT24BE(p) \
(((uint32_t)poly::load_and_swap<uint8_t>((p) + 0) << 16) | \
((uint32_t)poly::load_and_swap<uint8_t>((p) + 1) << 8) | \
(uint32_t)poly::load_and_swap<uint8_t>((p) + 2))
#define XEGETUINT24LE(p) \
(((uint32_t)poly::load<uint8_t>((p) + 2) << 16) | \
((uint32_t)poly::load<uint8_t>((p) + 1) << 8) | \
(uint32_t)poly::load<uint8_t>((p) + 0))
bool STFSVolumeDescriptor::Read(const uint8_t* p) { bool STFSVolumeDescriptor::Read(const uint8_t* p) {
descriptor_size = XEGETUINT8BE(p + 0x00); descriptor_size = poly::load_and_swap<uint8_t>(p + 0x00);
if (descriptor_size != 0x24) { if (descriptor_size != 0x24) {
XELOGE("STFS volume descriptor size mismatch, expected 0x24 but got 0x%X", XELOGE("STFS volume descriptor size mismatch, expected 0x24 but got 0x%X",
descriptor_size); descriptor_size);
return false; return false;
} }
reserved = XEGETUINT8BE(p + 0x01); reserved = poly::load_and_swap<uint8_t>(p + 0x01);
block_separation = XEGETUINT8BE(p + 0x02); block_separation = poly::load_and_swap<uint8_t>(p + 0x02);
file_table_block_count = XEGETUINT16BE(p + 0x03); file_table_block_count = poly::load_and_swap<uint16_t>(p + 0x03);
file_table_block_number = XEGETUINT24BE(p + 0x05); file_table_block_number = XEGETUINT24BE(p + 0x05);
xe_copy_struct(top_hash_table_hash, p + 0x08, 0x14); xe_copy_struct(top_hash_table_hash, p + 0x08, 0x14);
total_allocated_block_count = XEGETUINT32BE(p + 0x1C); total_allocated_block_count = poly::load_and_swap<uint32_t>(p + 0x1C);
total_unallocated_block_count = XEGETUINT32BE(p + 0x20); total_unallocated_block_count = poly::load_and_swap<uint32_t>(p + 0x20);
return true; return true;
}; };
@ -38,29 +46,29 @@ bool STFSVolumeDescriptor::Read(const uint8_t* p) {
bool STFSHeader::Read(const uint8_t* p) { bool STFSHeader::Read(const uint8_t* p) {
xe_copy_struct(license_entries, p + 0x22C, 0x100); xe_copy_struct(license_entries, p + 0x22C, 0x100);
xe_copy_struct(header_hash, p + 0x32C, 0x14); xe_copy_struct(header_hash, p + 0x32C, 0x14);
header_size = XEGETUINT32BE(p + 0x340); header_size = poly::load_and_swap<uint32_t>(p + 0x340);
content_type = (STFSContentType)XEGETUINT32BE(p + 0x344); content_type = (STFSContentType)poly::load_and_swap<uint32_t>(p + 0x344);
metadata_version = XEGETUINT32BE(p + 0x348); metadata_version = poly::load_and_swap<uint32_t>(p + 0x348);
if (metadata_version > 1) { if (metadata_version > 1) {
// This is a variant of thumbnail data/etc. // This is a variant of thumbnail data/etc.
// Can just ignore it for now (until we parse thumbnails). // Can just ignore it for now (until we parse thumbnails).
XELOGW("STFSContainer doesn't support version %d yet", metadata_version); XELOGW("STFSContainer doesn't support version %d yet", metadata_version);
} }
content_size = XEGETUINT32BE(p + 0x34C); content_size = poly::load_and_swap<uint32_t>(p + 0x34C);
media_id = XEGETUINT32BE(p + 0x354); media_id = poly::load_and_swap<uint32_t>(p + 0x354);
version = XEGETUINT32BE(p + 0x358); version = poly::load_and_swap<uint32_t>(p + 0x358);
base_version = XEGETUINT32BE(p + 0x35C); base_version = poly::load_and_swap<uint32_t>(p + 0x35C);
title_id = XEGETUINT32BE(p + 0x360); title_id = poly::load_and_swap<uint32_t>(p + 0x360);
platform = (STFSPlatform)XEGETUINT8BE(p + 0x364); platform = (STFSPlatform)poly::load_and_swap<uint8_t>(p + 0x364);
executable_type = XEGETUINT8BE(p + 0x365); executable_type = poly::load_and_swap<uint8_t>(p + 0x365);
disc_number = XEGETUINT8BE(p + 0x366); disc_number = poly::load_and_swap<uint8_t>(p + 0x366);
disc_in_set = XEGETUINT8BE(p + 0x367); disc_in_set = poly::load_and_swap<uint8_t>(p + 0x367);
save_game_id = XEGETUINT32BE(p + 0x368); save_game_id = poly::load_and_swap<uint32_t>(p + 0x368);
xe_copy_struct(console_id, p + 0x36C, 0x5); xe_copy_struct(console_id, p + 0x36C, 0x5);
xe_copy_struct(profile_id, p + 0x371, 0x8); xe_copy_struct(profile_id, p + 0x371, 0x8);
data_file_count = XEGETUINT32BE(p + 0x39D); data_file_count = poly::load_and_swap<uint32_t>(p + 0x39D);
data_file_combined_size = XEGETUINT64BE(p + 0x3A1); data_file_combined_size = poly::load_and_swap<uint64_t>(p + 0x3A1);
descriptor_type = (STFSDescriptorType)XEGETUINT8BE(p + 0x3A9); descriptor_type = (STFSDescriptorType)poly::load_and_swap<uint8_t>(p + 0x3A9);
if (descriptor_type != STFS_DESCRIPTOR_STFS) { if (descriptor_type != STFS_DESCRIPTOR_STFS) {
XELOGE("STFS descriptor format not supported: %d", descriptor_type); XELOGE("STFS descriptor format not supported: %d", descriptor_type);
return false; return false;
@ -70,16 +78,16 @@ bool STFSHeader::Read(const uint8_t* p) {
} }
xe_copy_struct(device_id, p + 0x3FD, 0x14); xe_copy_struct(device_id, p + 0x3FD, 0x14);
for (size_t n = 0; n < 0x900 / 2; n++) { for (size_t n = 0; n < 0x900 / 2; n++) {
display_names[n] = XEGETUINT16BE(p + 0x411 + n * 2); display_names[n] = poly::load_and_swap<uint16_t>(p + 0x411 + n * 2);
display_descs[n] = XEGETUINT16BE(p + 0xD11 + n * 2); display_descs[n] = poly::load_and_swap<uint16_t>(p + 0xD11 + n * 2);
} }
for (size_t n = 0; n < 0x80 / 2; n++) { for (size_t n = 0; n < 0x80 / 2; n++) {
publisher_name[n] = XEGETUINT16BE(p + 0x1611 + n * 2); publisher_name[n] = poly::load_and_swap<uint16_t>(p + 0x1611 + n * 2);
title_name[n] = XEGETUINT16BE(p + 0x1691 + n * 2); title_name[n] = poly::load_and_swap<uint16_t>(p + 0x1691 + n * 2);
} }
transfer_flags = XEGETUINT8BE(p + 0x1711); transfer_flags = poly::load_and_swap<uint8_t>(p + 0x1711);
thumbnail_image_size = XEGETUINT32BE(p + 0x1712); thumbnail_image_size = poly::load_and_swap<uint32_t>(p + 0x1712);
title_thumbnail_image_size = XEGETUINT32BE(p + 0x1716); title_thumbnail_image_size = poly::load_and_swap<uint32_t>(p + 0x1716);
xe_copy_struct(thumbnail_image, p + 0x171A, 0x4000); xe_copy_struct(thumbnail_image, p + 0x171A, 0x4000);
xe_copy_struct(title_thumbnail_image, p + 0x571A, 0x4000); xe_copy_struct(title_thumbnail_image, p + 0x571A, 0x4000);
return true; return true;
@ -203,13 +211,13 @@ STFS::Error STFS::ReadAllEntries(const uint8_t* map_ptr) {
// Done. // Done.
break; break;
} }
uint8_t filename_length_flags = XEGETUINT8BE(p + 0x28); uint8_t filename_length_flags = poly::load_and_swap<uint8_t>(p + 0x28);
uint32_t allocated_block_count = XEGETUINT24LE(p + 0x29); uint32_t allocated_block_count = XEGETUINT24LE(p + 0x29);
uint32_t start_block_index = XEGETUINT24LE(p + 0x2F); uint32_t start_block_index = XEGETUINT24LE(p + 0x2F);
uint16_t path_indicator = XEGETUINT16BE(p + 0x32); uint16_t path_indicator = poly::load_and_swap<uint16_t>(p + 0x32);
uint32_t file_size = XEGETUINT32BE(p + 0x34); uint32_t file_size = poly::load_and_swap<uint32_t>(p + 0x34);
uint32_t update_timestamp = XEGETUINT32BE(p + 0x38); uint32_t update_timestamp = poly::load_and_swap<uint32_t>(p + 0x38);
uint32_t access_timestamp = XEGETUINT32BE(p + 0x3C); uint32_t access_timestamp = poly::load_and_swap<uint32_t>(p + 0x3C);
p += 0x40; p += 0x40;
STFSEntry* entry = new STFSEntry(); STFSEntry* entry = new STFSEntry();
@ -337,7 +345,7 @@ STFS::BlockHash_t STFS::GetBlockHash(
//table_index += table_offset - (1 << table_size_shift_); //table_index += table_offset - (1 << table_size_shift_);
const uint8_t* hash_data = map_ptr + BlockToOffset(table_index); const uint8_t* hash_data = map_ptr + BlockToOffset(table_index);
const uint8_t* record_data = hash_data + record * 0x18; const uint8_t* record_data = hash_data + record * 0x18;
uint32_t info = XEGETUINT8BE(record_data + 0x14); uint32_t info = poly::load_and_swap<uint8_t>(record_data + 0x14);
uint32_t next_block_index = XEGETUINT24BE(record_data + 0x15); uint32_t next_block_index = XEGETUINT24BE(record_data + 0x15);
return{ next_block_index, info }; return{ next_block_index, info };
} }

24
src/xenia/kernel/native_list.cc
View File

@ -21,40 +21,40 @@ NativeList::NativeList(Memory* memory) :
void NativeList::Insert(uint32_t ptr) { void NativeList::Insert(uint32_t ptr) {
uint8_t* mem = memory_->membase(); uint8_t* mem = memory_->membase();
XESETUINT32BE(mem + ptr + 0, head_); poly::store_and_swap<uint32_t>(mem + ptr + 0, head_);
XESETUINT32BE(mem + ptr + 4, 0); poly::store_and_swap<uint32_t>(mem + ptr + 4, 0);
if (head_) { if (head_) {
XESETUINT32BE(mem + head_ + 4, ptr); poly::store_and_swap<uint32_t>(mem + head_ + 4, ptr);
} }
head_ = ptr; head_ = ptr;
} }
bool NativeList::IsQueued(uint32_t ptr) { bool NativeList::IsQueued(uint32_t ptr) {
uint8_t* mem = memory_->membase(); uint8_t* mem = memory_->membase();
uint32_t flink = XEGETUINT32BE(mem + ptr + 0); uint32_t flink = poly::load_and_swap<uint32_t>(mem + ptr + 0);
uint32_t blink = XEGETUINT32BE(mem + ptr + 4); uint32_t blink = poly::load_and_swap<uint32_t>(mem + ptr + 4);
return head_ == ptr || flink || blink; return head_ == ptr || flink || blink;
} }
void NativeList::Remove(uint32_t ptr) { void NativeList::Remove(uint32_t ptr) {
uint8_t* mem = memory_->membase(); uint8_t* mem = memory_->membase();
uint32_t flink = XEGETUINT32BE(mem + ptr + 0); uint32_t flink = poly::load_and_swap<uint32_t>(mem + ptr + 0);
uint32_t blink = XEGETUINT32BE(mem + ptr + 4); uint32_t blink = poly::load_and_swap<uint32_t>(mem + ptr + 4);
if (ptr == head_) { if (ptr == head_) {
head_ = flink; head_ = flink;
if (flink) { if (flink) {
XESETUINT32BE(mem + flink + 4, 0); poly::store_and_swap<uint32_t>(mem + flink + 4, 0);
} }
} else { } else {
if (blink) { if (blink) {
XESETUINT32BE(mem + blink + 0, flink); poly::store_and_swap<uint32_t>(mem + blink + 0, flink);
} }
if (flink) { if (flink) {
XESETUINT32BE(mem + flink + 4, blink); poly::store_and_swap<uint32_t>(mem + flink + 4, blink);
} }
} }
XESETUINT32BE(mem + ptr + 0, 0); poly::store_and_swap<uint32_t>(mem + ptr + 0, 0);
XESETUINT32BE(mem + ptr + 4, 0); poly::store_and_swap<uint32_t>(mem + ptr + 4, 0);
} }
uint32_t NativeList::Shift() { uint32_t NativeList::Shift() {

50
src/xenia/kernel/objects/xfile.h
View File

@ -33,14 +33,14 @@ public:
X_FILE_ATTRIBUTES attributes; X_FILE_ATTRIBUTES attributes;
void Write(uint8_t* base, uint32_t p) { void Write(uint8_t* base, uint32_t p) {
XESETUINT64BE(base + p, creation_time); poly::store_and_swap<uint64_t>(base + p, creation_time);
XESETUINT64BE(base + p + 8, last_access_time); poly::store_and_swap<uint64_t>(base + p + 8, last_access_time);
XESETUINT64BE(base + p + 16, last_write_time); poly::store_and_swap<uint64_t>(base + p + 16, last_write_time);
XESETUINT64BE(base + p + 24, change_time); poly::store_and_swap<uint64_t>(base + p + 24, change_time);
XESETUINT64BE(base + p + 32, allocation_size); poly::store_and_swap<uint64_t>(base + p + 32, allocation_size);
XESETUINT64BE(base + p + 40, file_length); poly::store_and_swap<uint64_t>(base + p + 40, file_length);
XESETUINT32BE(base + p + 48, attributes); poly::store_and_swap<uint32_t>(base + p + 48, attributes);
XESETUINT32BE(base + p + 52, 0); // pad poly::store_and_swap<uint32_t>(base + p + 52, 0); // pad
} }
}; };
@ -65,16 +65,16 @@ public:
XDirectoryInfo* info; XDirectoryInfo* info;
do { do {
info = (XDirectoryInfo*)src; info = (XDirectoryInfo*)src;
XESETUINT32BE(dst, info->next_entry_offset); poly::store_and_swap<uint32_t>(dst, info->next_entry_offset);
XESETUINT32BE(dst + 4, info->file_index); poly::store_and_swap<uint32_t>(dst + 4, info->file_index);
XESETUINT64BE(dst + 8, info->creation_time); poly::store_and_swap<uint64_t>(dst + 8, info->creation_time);
XESETUINT64BE(dst + 16, info->last_access_time); poly::store_and_swap<uint64_t>(dst + 16, info->last_access_time);
XESETUINT64BE(dst + 24, info->last_write_time); poly::store_and_swap<uint64_t>(dst + 24, info->last_write_time);
XESETUINT64BE(dst + 32, info->change_time); poly::store_and_swap<uint64_t>(dst + 32, info->change_time);
XESETUINT64BE(dst + 40, info->end_of_file); poly::store_and_swap<uint64_t>(dst + 40, info->end_of_file);
XESETUINT64BE(dst + 48, info->allocation_size); poly::store_and_swap<uint64_t>(dst + 48, info->allocation_size);
XESETUINT32BE(dst + 56, info->attributes); poly::store_and_swap<uint32_t>(dst + 56, info->attributes);
XESETUINT32BE(dst + 60, info->file_name_length); poly::store_and_swap<uint32_t>(dst + 60, info->file_name_length);
xe_copy_memory(dst + 64, info->file_name_length, info->file_name, info->file_name_length); xe_copy_memory(dst + 64, info->file_name_length, info->file_name, info->file_name_length);
dst += info->next_entry_offset; dst += info->next_entry_offset;
src += info->next_entry_offset; src += info->next_entry_offset;
@ -95,10 +95,10 @@ public:
void Write(uint8_t* base, uint32_t p) { void Write(uint8_t* base, uint32_t p) {
uint8_t* dst = base + p; uint8_t* dst = base + p;
XESETUINT64BE(dst + 0, this->creation_time); poly::store_and_swap<uint64_t>(dst + 0, this->creation_time);
XESETUINT32BE(dst + 8, this->serial_number); poly::store_and_swap<uint32_t>(dst + 8, this->serial_number);
XESETUINT32BE(dst + 12, this->label_length); poly::store_and_swap<uint32_t>(dst + 12, this->label_length);
XESETUINT32BE(dst + 16, this->supports_objects); poly::store_and_swap<uint32_t>(dst + 16, this->supports_objects);
xe_copy_memory(dst + 20, this->label_length, this->label, this->label_length); xe_copy_memory(dst + 20, this->label_length, this->label, this->label_length);
} }
}; };
@ -115,9 +115,9 @@ public:
void Write(uint8_t* base, uint32_t p) { void Write(uint8_t* base, uint32_t p) {
uint8_t* dst = base + p; uint8_t* dst = base + p;
XESETUINT32BE(dst + 0, this->attributes); poly::store_and_swap<uint32_t>(dst + 0, this->attributes);
XESETUINT32BE(dst + 4, this->maximum_component_name_length); poly::store_and_swap<uint32_t>(dst + 4, this->maximum_component_name_length);
XESETUINT32BE(dst + 8, this->fs_name_length); poly::store_and_swap<uint32_t>(dst + 8, this->fs_name_length);
xe_copy_memory(dst + 12, this->fs_name_length, this->fs_name, this->fs_name_length); xe_copy_memory(dst + 12, this->fs_name_length, this->fs_name, this->fs_name_length);
} }
}; };

52
src/xenia/kernel/objects/xthread.cc
View File

@ -120,7 +120,7 @@ uint32_t XThread::GetCurrentThreadHandle() {
} }
uint32_t XThread::GetCurrentThreadId(const uint8_t* thread_state_block) { uint32_t XThread::GetCurrentThreadId(const uint8_t* thread_state_block) {
return XEGETUINT32BE(thread_state_block + 0x14C); return poly::load_and_swap<uint32_t>(thread_state_block + 0x14C);
} }
uint32_t XThread::thread_state() { uint32_t XThread::thread_state() {
@ -133,12 +133,12 @@ uint32_t XThread::thread_id() {
uint32_t XThread::last_error() { uint32_t XThread::last_error() {
uint8_t *p = memory()->Translate(thread_state_address_); uint8_t *p = memory()->Translate(thread_state_address_);
return XEGETUINT32BE(p + 0x160); return poly::load_and_swap<uint32_t>(p + 0x160);
} }
void XThread::set_last_error(uint32_t error_code) { void XThread::set_last_error(uint32_t error_code) {
uint8_t *p = memory()->Translate(thread_state_address_); uint8_t *p = memory()->Translate(thread_state_address_);
XESETUINT32BE(p + 0x160, error_code); poly::store_and_swap<uint32_t>(p + 0x160, error_code);
} }
void XThread::set_name(const char* name) { void XThread::set_name(const char* name) {
@ -221,11 +221,11 @@ X_STATUS XThread::Create() {
// Setup the thread state block (last error/etc). // Setup the thread state block (last error/etc).
uint8_t *p = memory()->Translate(thread_state_address_); uint8_t *p = memory()->Translate(thread_state_address_);
XESETUINT32BE(p + 0x000, tls_address_); poly::store_and_swap<uint32_t>(p + 0x000, tls_address_);
XESETUINT32BE(p + 0x100, thread_state_address_); poly::store_and_swap<uint32_t>(p + 0x100, thread_state_address_);
XESETUINT32BE(p + 0x14C, thread_id_); poly::store_and_swap<uint32_t>(p + 0x14C, thread_id_);
XESETUINT32BE(p + 0x150, 0); // ? poly::store_and_swap<uint32_t>(p + 0x150, 0); // ?
XESETUINT32BE(p + 0x160, 0); // last error poly::store_and_swap<uint32_t>(p + 0x160, 0); // last error
// Allocate processor thread state. // Allocate processor thread state.
// This is thread safe. // This is thread safe.
@ -440,25 +440,25 @@ void XThread::DeliverAPCs(void* data) {
// Calling the routine may delete the memory/overwrite it. // Calling the routine may delete the memory/overwrite it.
uint32_t apc_address = apc_list->Shift() - 8; uint32_t apc_address = apc_list->Shift() - 8;
uint8_t* apc_ptr = membase + apc_address; uint8_t* apc_ptr = membase + apc_address;
uint32_t kernel_routine = XEGETUINT32BE(apc_ptr + 16); uint32_t kernel_routine = poly::load_and_swap<uint32_t>(apc_ptr + 16);
uint32_t normal_routine = XEGETUINT32BE(apc_ptr + 24); uint32_t normal_routine = poly::load_and_swap<uint32_t>(apc_ptr + 24);
uint32_t normal_context = XEGETUINT32BE(apc_ptr + 28); uint32_t normal_context = poly::load_and_swap<uint32_t>(apc_ptr + 28);
uint32_t system_arg1 = XEGETUINT32BE(apc_ptr + 32); uint32_t system_arg1 = poly::load_and_swap<uint32_t>(apc_ptr + 32);
uint32_t system_arg2 = XEGETUINT32BE(apc_ptr + 36); uint32_t system_arg2 = poly::load_and_swap<uint32_t>(apc_ptr + 36);
// Mark as uninserted so that it can be reinserted again by the routine. // Mark as uninserted so that it can be reinserted again by the routine.
uint32_t old_flags = XEGETUINT32BE(apc_ptr + 40); uint32_t old_flags = poly::load_and_swap<uint32_t>(apc_ptr + 40);
XESETUINT32BE(apc_ptr + 40, old_flags & ~0xFF00); poly::store_and_swap<uint32_t>(apc_ptr + 40, old_flags & ~0xFF00);
// Call kernel routine. // Call kernel routine.
// The routine can modify all of its arguments before passing it on. // The routine can modify all of its arguments before passing it on.
// Since we need to give guest accessible pointers over, we copy things // Since we need to give guest accessible pointers over, we copy things
// into and out of scratch. // into and out of scratch.
uint8_t* scratch_ptr = membase + thread->scratch_address_; uint8_t* scratch_ptr = membase + thread->scratch_address_;
XESETUINT32BE(scratch_ptr + 0, normal_routine); poly::store_and_swap<uint32_t>(scratch_ptr + 0, normal_routine);
XESETUINT32BE(scratch_ptr + 4, normal_context); poly::store_and_swap<uint32_t>(scratch_ptr + 4, normal_context);
XESETUINT32BE(scratch_ptr + 8, system_arg1); poly::store_and_swap<uint32_t>(scratch_ptr + 8, system_arg1);
XESETUINT32BE(scratch_ptr + 12, system_arg2); poly::store_and_swap<uint32_t>(scratch_ptr + 12, system_arg2);
// kernel_routine(apc_address, &normal_routine, &normal_context, &system_arg1, &system_arg2) // kernel_routine(apc_address, &normal_routine, &normal_context, &system_arg1, &system_arg2)
uint64_t kernel_args[] = { uint64_t kernel_args[] = {
apc_address, apc_address,
@ -469,10 +469,10 @@ void XThread::DeliverAPCs(void* data) {
}; };
processor->ExecuteInterrupt( processor->ExecuteInterrupt(
0, kernel_routine, kernel_args, XECOUNT(kernel_args)); 0, kernel_routine, kernel_args, XECOUNT(kernel_args));
normal_routine = XEGETUINT32BE(scratch_ptr + 0); normal_routine = poly::load_and_swap<uint32_t>(scratch_ptr + 0);
normal_context = XEGETUINT32BE(scratch_ptr + 4); normal_context = poly::load_and_swap<uint32_t>(scratch_ptr + 4);
system_arg1 = XEGETUINT32BE(scratch_ptr + 8); system_arg1 = poly::load_and_swap<uint32_t>(scratch_ptr + 8);
system_arg2 = XEGETUINT32BE(scratch_ptr + 12); system_arg2 = poly::load_and_swap<uint32_t>(scratch_ptr + 12);
// Call the normal routine. Note that it may have been killed by the kernel // Call the normal routine. Note that it may have been killed by the kernel
// routine. // routine.
@ -496,11 +496,11 @@ void XThread::RundownAPCs() {
// Calling the routine may delete the memory/overwrite it. // Calling the routine may delete the memory/overwrite it.
uint32_t apc_address = apc_list_->Shift() - 8; uint32_t apc_address = apc_list_->Shift() - 8;
uint8_t* apc_ptr = membase + apc_address; uint8_t* apc_ptr = membase + apc_address;
uint32_t rundown_routine = XEGETUINT32BE(apc_ptr + 20); uint32_t rundown_routine = poly::load_and_swap<uint32_t>(apc_ptr + 20);
// Mark as uninserted so that it can be reinserted again by the routine. // Mark as uninserted so that it can be reinserted again by the routine.
uint32_t old_flags = XEGETUINT32BE(apc_ptr + 40); uint32_t old_flags = poly::load_and_swap<uint32_t>(apc_ptr + 40);
XESETUINT32BE(apc_ptr + 40, old_flags & ~0xFF00); poly::store_and_swap<uint32_t>(apc_ptr + 40, old_flags & ~0xFF00);
// Call the rundown routine. // Call the rundown routine.
if (rundown_routine) { if (rundown_routine) {

24
src/xenia/kernel/util/shim_utils.h
View File

@ -35,15 +35,15 @@ using PPCContext = alloy::frontend::ppc::PPCContext;
#define SHIM_MEM_ADDR(a) (a ? (ppc_state->membase + a) : NULL) #define SHIM_MEM_ADDR(a) (a ? (ppc_state->membase + a) : NULL)
#define SHIM_MEM_8(a) (*(uint8_t*)SHIM_MEM_ADDR(a)) #define SHIM_MEM_8(a) (*(uint8_t*)SHIM_MEM_ADDR(a))
#define SHIM_MEM_16(a) (uint16_t)XEGETUINT16BE(SHIM_MEM_ADDR(a)) #define SHIM_MEM_16(a) (uint16_t)poly::load_and_swap<uint16_t>(SHIM_MEM_ADDR(a))
#define SHIM_MEM_32(a) (uint32_t)XEGETUINT32BE(SHIM_MEM_ADDR(a)) #define SHIM_MEM_32(a) (uint32_t)poly::load_and_swap<uint32_t>(SHIM_MEM_ADDR(a))
#define SHIM_MEM_64(a) (uint64_t)XEGETUINT64BE(SHIM_MEM_ADDR(a)) #define SHIM_MEM_64(a) (uint64_t)poly::load_and_swap<uint64_t>(SHIM_MEM_ADDR(a))
#define SHIM_SET_MEM_8(a, v) (*(uint8_t*)SHIM_MEM_ADDR(a)) = v #define SHIM_SET_MEM_8(a, v) (*(uint8_t*)SHIM_MEM_ADDR(a)) = v
#define SHIM_SET_MEM_16(a, v) (*(uint16_t*)SHIM_MEM_ADDR(a)) = XESWAP16(v) #define SHIM_SET_MEM_16(a, v) (*(uint16_t*)SHIM_MEM_ADDR(a)) = poly::byte_swap(v)
#define SHIM_SET_MEM_32(a, v) (*(uint32_t*)SHIM_MEM_ADDR(a)) = XESWAP32(v) #define SHIM_SET_MEM_32(a, v) (*(uint32_t*)SHIM_MEM_ADDR(a)) = poly::byte_swap(v)
#define SHIM_SET_MEM_64(a, v) (*(uint64_t*)SHIM_MEM_ADDR(a)) = XESWAP64(v) #define SHIM_SET_MEM_64(a, v) (*(uint64_t*)SHIM_MEM_ADDR(a)) = poly::byte_swap(v)
#define SHIM_SET_MEM_F32(a, v) (*(float*)SHIM_MEM_ADDR(a)) = XESWAPF32BE(v) #define SHIM_SET_MEM_F32(a, v) (*(float*)SHIM_MEM_ADDR(a)) = poly::byte_swap(v)
#define SHIM_SET_MEM_F64(a, v) (*(double*)SHIM_MEM_ADDR(a)) = XESWAPF64BE(v) #define SHIM_SET_MEM_F64(a, v) (*(double*)SHIM_MEM_ADDR(a)) = poly::byte_swap(v)
#define SHIM_GPR_8(n) (uint8_t)(ppc_state->r[n]) #define SHIM_GPR_8(n) (uint8_t)(ppc_state->r[n])
#define SHIM_GPR_16(n) (uint16_t)(ppc_state->r[n]) #define SHIM_GPR_16(n) (uint16_t)(ppc_state->r[n])
@ -63,11 +63,11 @@ using PPCContext = alloy::frontend::ppc::PPCContext;
#define IMPL_MEM_ADDR(a) (a ? state->memory()->Translate(a) : NULL) #define IMPL_MEM_ADDR(a) (a ? state->memory()->Translate(a) : NULL)
#define IMPL_MEM_8(a) (*(uint8_t*)(IMPL_MEM_ADDR(a))) #define IMPL_MEM_8(a) (*(uint8_t*)(IMPL_MEM_ADDR(a)))
#define IMPL_MEM_16(a) (uint16_t)XEGETUINT16BE(IMPL_MEM_ADDR(a)) #define IMPL_MEM_16(a) (uint16_t)poly::load_and_swap<uint16_t>(IMPL_MEM_ADDR(a))
#define IMPL_MEM_32(a) (uint32_t)XEGETUINT32BE(IMPL_MEM_ADDR(a)) #define IMPL_MEM_32(a) (uint32_t)poly::load_and_swap<uint32_t>(IMPL_MEM_ADDR(a))
#define IMPL_SET_MEM_8(a, v) (*(uint8_t*)IMPL_MEM_ADDR(a)) = v #define IMPL_SET_MEM_8(a, v) (*(uint8_t*)IMPL_MEM_ADDR(a)) = v
#define IMPL_SET_MEM_16(a, v) (*(uint16_t*)IMPL_MEM_ADDR(a)) = XESWAP16(v) #define IMPL_SET_MEM_16(a, v) (*(uint16_t*)IMPL_MEM_ADDR(a)) = poly::byte_swap(v)
#define IMPL_SET_MEM_32(a, v) (*(uint32_t*)IMPL_MEM_ADDR(a)) = XESWAP32(v) #define IMPL_SET_MEM_32(a, v) (*(uint32_t*)IMPL_MEM_ADDR(a)) = poly::byte_swap(v)
} // namespace kernel } // namespace kernel

140
src/xenia/kernel/util/xex2.cc
View File

@ -125,21 +125,21 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
const uint8_t *ps; const uint8_t *ps;
xe_xex2_loader_info_t *ldr; xe_xex2_loader_info_t *ldr;
header->xex2 = XEGETUINT32BE(p + 0x00); header->xex2 = poly::load_and_swap<uint32_t>(p + 0x00);
if (header->xex2 != 0x58455832) { if (header->xex2 != 0x58455832) {
return 1; return 1;
} }
header->module_flags = (xe_xex2_module_flags)XEGETUINT32BE(p + 0x04); header->module_flags = (xe_xex2_module_flags)poly::load_and_swap<uint32_t>(p + 0x04);
header->exe_offset = XEGETUINT32BE(p + 0x08); header->exe_offset = poly::load_and_swap<uint32_t>(p + 0x08);
header->unknown0 = XEGETUINT32BE(p + 0x0C); header->unknown0 = poly::load_and_swap<uint32_t>(p + 0x0C);
header->certificate_offset = XEGETUINT32BE(p + 0x10); header->certificate_offset = poly::load_and_swap<uint32_t>(p + 0x10);
header->header_count = XEGETUINT32BE(p + 0x14); header->header_count = poly::load_and_swap<uint32_t>(p + 0x14);
for (size_t n = 0; n < header->header_count; n++) { for (size_t n = 0; n < header->header_count; n++) {
const uint8_t *ph = p + 0x18 + (n * 8); const uint8_t *ph = p + 0x18 + (n * 8);
const uint32_t key = XEGETUINT32BE(ph + 0x00); const uint32_t key = poly::load_and_swap<uint32_t>(ph + 0x00);
const uint32_t data_offset = XEGETUINT32BE(ph + 0x04); const uint32_t data_offset = poly::load_and_swap<uint32_t>(ph + 0x04);
xe_xex2_opt_header_t *opt_header = &header->headers[n]; xe_xex2_opt_header_t *opt_header = &header->headers[n];
opt_header->key = key; opt_header->key = key;
@ -151,7 +151,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
break; break;
case 0xFF: case 0xFF:
// dataOffset = offset (first dword in data is size) // dataOffset = offset (first dword in data is size)
opt_header->length = XEGETUINT32BE(p + data_offset); opt_header->length = poly::load_and_swap<uint32_t>(p + data_offset);
opt_header->offset = data_offset; opt_header->offset = data_offset;
break; break;
default: default:
@ -176,8 +176,8 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
auto& res = header->resource_infos[n]; auto& res = header->resource_infos[n];
XEEXPECTZERO(xe_copy_memory(res.name, XEEXPECTZERO(xe_copy_memory(res.name,
sizeof(res.name), ph + 0x00, 8)); sizeof(res.name), ph + 0x00, 8));
res.address = XEGETUINT32BE(ph + 0x08); res.address = poly::load_and_swap<uint32_t>(ph + 0x08);
res.size = XEGETUINT32BE(ph + 0x0C); res.size = poly::load_and_swap<uint32_t>(ph + 0x0C);
ph += 16; ph += 16;
} }
} }
@ -185,41 +185,41 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
case XEX_HEADER_EXECUTION_INFO: case XEX_HEADER_EXECUTION_INFO:
{ {
xe_xex2_execution_info_t *ex = &header->execution_info; xe_xex2_execution_info_t *ex = &header->execution_info;
ex->media_id = XEGETUINT32BE(pp + 0x00); ex->media_id = poly::load_and_swap<uint32_t>(pp + 0x00);
ex->version.value = XEGETUINT32BE(pp + 0x04); ex->version.value = poly::load_and_swap<uint32_t>(pp + 0x04);
ex->base_version.value = XEGETUINT32BE(pp + 0x08); ex->base_version.value = poly::load_and_swap<uint32_t>(pp + 0x08);
ex->title_id = XEGETUINT32BE(pp + 0x0C); ex->title_id = poly::load_and_swap<uint32_t>(pp + 0x0C);
ex->platform = XEGETUINT8BE(pp + 0x10); ex->platform = poly::load_and_swap<uint8_t>(pp + 0x10);
ex->executable_table = XEGETUINT8BE(pp + 0x11); ex->executable_table = poly::load_and_swap<uint8_t>(pp + 0x11);
ex->disc_number = XEGETUINT8BE(pp + 0x12); ex->disc_number = poly::load_and_swap<uint8_t>(pp + 0x12);
ex->disc_count = XEGETUINT8BE(pp + 0x13); ex->disc_count = poly::load_and_swap<uint8_t>(pp + 0x13);
ex->savegame_id = XEGETUINT32BE(pp + 0x14); ex->savegame_id = poly::load_and_swap<uint32_t>(pp + 0x14);
} }
break; break;
case XEX_HEADER_GAME_RATINGS: case XEX_HEADER_GAME_RATINGS:
{ {
xe_xex2_game_ratings_t *ratings = &header->game_ratings; xe_xex2_game_ratings_t *ratings = &header->game_ratings;
ratings->esrb = (xe_xex2_rating_esrb_value)XEGETUINT8BE(pp + 0x00); ratings->esrb = (xe_xex2_rating_esrb_value)poly::load_and_swap<uint8_t>(pp + 0x00);
ratings->pegi = (xe_xex2_rating_pegi_value)XEGETUINT8BE(pp + 0x01); ratings->pegi = (xe_xex2_rating_pegi_value)poly::load_and_swap<uint8_t>(pp + 0x01);
ratings->pegifi = (xe_xex2_rating_pegi_fi_value)XEGETUINT8BE(pp + 0x02); ratings->pegifi = (xe_xex2_rating_pegi_fi_value)poly::load_and_swap<uint8_t>(pp + 0x02);
ratings->pegipt = (xe_xex2_rating_pegi_pt_value)XEGETUINT8BE(pp + 0x03); ratings->pegipt = (xe_xex2_rating_pegi_pt_value)poly::load_and_swap<uint8_t>(pp + 0x03);
ratings->bbfc = (xe_xex2_rating_bbfc_value)XEGETUINT8BE(pp + 0x04); ratings->bbfc = (xe_xex2_rating_bbfc_value)poly::load_and_swap<uint8_t>(pp + 0x04);
ratings->cero = (xe_xex2_rating_cero_value)XEGETUINT8BE(pp + 0x05); ratings->cero = (xe_xex2_rating_cero_value)poly::load_and_swap<uint8_t>(pp + 0x05);
ratings->usk = (xe_xex2_rating_usk_value)XEGETUINT8BE(pp + 0x06); ratings->usk = (xe_xex2_rating_usk_value)poly::load_and_swap<uint8_t>(pp + 0x06);
ratings->oflcau = (xe_xex2_rating_oflc_au_value)XEGETUINT8BE(pp + 0x07); ratings->oflcau = (xe_xex2_rating_oflc_au_value)poly::load_and_swap<uint8_t>(pp + 0x07);
ratings->oflcnz = (xe_xex2_rating_oflc_nz_value)XEGETUINT8BE(pp + 0x08); ratings->oflcnz = (xe_xex2_rating_oflc_nz_value)poly::load_and_swap<uint8_t>(pp + 0x08);
ratings->kmrb = (xe_xex2_rating_kmrb_value)XEGETUINT8BE(pp + 0x09); ratings->kmrb = (xe_xex2_rating_kmrb_value)poly::load_and_swap<uint8_t>(pp + 0x09);
ratings->brazil = (xe_xex2_rating_brazil_value)XEGETUINT8BE(pp + 0x0A); ratings->brazil = (xe_xex2_rating_brazil_value)poly::load_and_swap<uint8_t>(pp + 0x0A);
ratings->fpb = (xe_xex2_rating_fpb_value)XEGETUINT8BE(pp + 0x0B); ratings->fpb = (xe_xex2_rating_fpb_value)poly::load_and_swap<uint8_t>(pp + 0x0B);
} }
break; break;
case XEX_HEADER_TLS_INFO: case XEX_HEADER_TLS_INFO:
{ {
xe_xex2_tls_info_t *tls = &header->tls_info; xe_xex2_tls_info_t *tls = &header->tls_info;
tls->slot_count = XEGETUINT32BE(pp + 0x00); tls->slot_count = poly::load_and_swap<uint32_t>(pp + 0x00);
tls->raw_data_address = XEGETUINT32BE(pp + 0x04); tls->raw_data_address = poly::load_and_swap<uint32_t>(pp + 0x04);
tls->data_size = XEGETUINT32BE(pp + 0x08); tls->data_size = poly::load_and_swap<uint32_t>(pp + 0x08);
tls->raw_data_size = XEGETUINT32BE(pp + 0x0C); tls->raw_data_size = poly::load_and_swap<uint32_t>(pp + 0x0C);
} }
break; break;
case XEX_HEADER_IMAGE_BASE_ADDRESS: case XEX_HEADER_IMAGE_BASE_ADDRESS:
@ -237,7 +237,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
case XEX_HEADER_IMPORT_LIBRARIES: case XEX_HEADER_IMPORT_LIBRARIES:
{ {
const size_t max_count = XECOUNT(header->import_libraries); const size_t max_count = XECOUNT(header->import_libraries);
size_t count = XEGETUINT32BE(pp + 0x08); size_t count = poly::load_and_swap<uint32_t>(pp + 0x08);
assert_true(count <= max_count); assert_true(count <= max_count);
if (count > max_count) { if (count > max_count) {
XELOGW("ignoring %zu extra entries in XEX_HEADER_IMPORT_LIBRARIES", XELOGW("ignoring %zu extra entries in XEX_HEADER_IMPORT_LIBRARIES",
@ -246,7 +246,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
} }
header->import_library_count = count; header->import_library_count = count;
uint32_t string_table_size = XEGETUINT32BE(pp + 0x04); uint32_t string_table_size = poly::load_and_swap<uint32_t>(pp + 0x04);
const char *string_table = (const char*)(pp + 0x0C); const char *string_table = (const char*)(pp + 0x0C);
pp += 12 + string_table_size; pp += 12 + string_table_size;
@ -254,11 +254,11 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
xe_xex2_import_library_t *library = &header->import_libraries[m]; xe_xex2_import_library_t *library = &header->import_libraries[m];
XEEXPECTZERO(xe_copy_memory(library->digest, sizeof(library->digest), XEEXPECTZERO(xe_copy_memory(library->digest, sizeof(library->digest),
pp + 0x04, 20)); pp + 0x04, 20));
library->import_id = XEGETUINT32BE(pp + 0x18); library->import_id = poly::load_and_swap<uint32_t>(pp + 0x18);
library->version.value = XEGETUINT32BE(pp + 0x1C); library->version.value = poly::load_and_swap<uint32_t>(pp + 0x1C);
library->min_version.value = XEGETUINT32BE(pp + 0x20); library->min_version.value = poly::load_and_swap<uint32_t>(pp + 0x20);
const uint16_t name_index = XEGETUINT16BE(pp + 0x24) & 0xFF; const uint16_t name_index = poly::load_and_swap<uint16_t>(pp + 0x24) & 0xFF;
for (size_t i = 0, j = 0; i < string_table_size;) { for (size_t i = 0, j = 0; i < string_table_size;) {
assert_true(j <= 0xFF); assert_true(j <= 0xFF);
if (j == name_index) { if (j == name_index) {
@ -277,13 +277,13 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
} }
} }
library->record_count = XEGETUINT16BE(pp + 0x26); library->record_count = poly::load_and_swap<uint16_t>(pp + 0x26);
library->records = (uint32_t*)xe_calloc( library->records = (uint32_t*)xe_calloc(
library->record_count * sizeof(uint32_t)); library->record_count * sizeof(uint32_t));
XEEXPECTNOTNULL(library->records); XEEXPECTNOTNULL(library->records);
pp += 0x28; pp += 0x28;
for (size_t i = 0; i < library->record_count; i++) { for (size_t i = 0; i < library->record_count; i++) {
library->records[i] = XEGETUINT32BE(pp); library->records[i] = poly::load_and_swap<uint32_t>(pp);
pp += 4; pp += 4;
} }
} }
@ -306,10 +306,10 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
XEEXPECTZERO(xe_copy_memory(library->name, sizeof(library->name), XEEXPECTZERO(xe_copy_memory(library->name, sizeof(library->name),
pp + 0x00, 8)); pp + 0x00, 8));
library->name[8] = 0; library->name[8] = 0;
library->major = XEGETUINT16BE(pp + 0x08); library->major = poly::load_and_swap<uint16_t>(pp + 0x08);
library->minor = XEGETUINT16BE(pp + 0x0A); library->minor = poly::load_and_swap<uint16_t>(pp + 0x0A);
library->build = XEGETUINT16BE(pp + 0x0C); library->build = poly::load_and_swap<uint16_t>(pp + 0x0C);
uint16_t qfeapproval = XEGETUINT16BE(pp + 0x0E); uint16_t qfeapproval = poly::load_and_swap<uint16_t>(pp + 0x0E);
library->approval = (xe_xex2_approval_type)(qfeapproval & 0x8000); library->approval = (xe_xex2_approval_type)(qfeapproval & 0x8000);
library->qfe = qfeapproval & ~0x8000; library->qfe = qfeapproval & ~0x8000;
pp += 16; pp += 16;
@ -320,9 +320,9 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
{ {
xe_xex2_file_format_info_t *fmt = &header->file_format_info; xe_xex2_file_format_info_t *fmt = &header->file_format_info;
fmt->encryption_type = fmt->encryption_type =
(xe_xex2_encryption_type)XEGETUINT16BE(pp + 0x04); (xe_xex2_encryption_type)poly::load_and_swap<uint16_t>(pp + 0x04);
fmt->compression_type = fmt->compression_type =
(xe_xex2_compression_type)XEGETUINT16BE(pp + 0x06); (xe_xex2_compression_type)poly::load_and_swap<uint16_t>(pp + 0x06);
switch (fmt->compression_type) { switch (fmt->compression_type) {
case XEX_COMPRESSION_NONE: case XEX_COMPRESSION_NONE:
// TODO: XEX_COMPRESSION_NONE // TODO: XEX_COMPRESSION_NONE
@ -332,7 +332,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
{ {
xe_xex2_file_basic_compression_info_t *comp_info = xe_xex2_file_basic_compression_info_t *comp_info =
&fmt->compression_info.basic; &fmt->compression_info.basic;
uint32_t info_size = XEGETUINT32BE(pp + 0x00); uint32_t info_size = poly::load_and_swap<uint32_t>(pp + 0x00);
comp_info->block_count = (info_size - 8) / 8; comp_info->block_count = (info_size - 8) / 8;
comp_info->blocks = (xe_xex2_file_basic_compression_block_t*) comp_info->blocks = (xe_xex2_file_basic_compression_block_t*)
xe_calloc(comp_info->block_count * xe_calloc(comp_info->block_count *
@ -341,8 +341,8 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
for (size_t m = 0; m < comp_info->block_count; m++) { for (size_t m = 0; m < comp_info->block_count; m++) {
xe_xex2_file_basic_compression_block_t *block = xe_xex2_file_basic_compression_block_t *block =
&comp_info->blocks[m]; &comp_info->blocks[m];
block->data_size = XEGETUINT32BE(pp + 0x08 + (m * 8)); block->data_size = poly::load_and_swap<uint32_t>(pp + 0x08 + (m * 8));
block->zero_size = XEGETUINT32BE(pp + 0x0C + (m * 8)); block->zero_size = poly::load_and_swap<uint32_t>(pp + 0x0C + (m * 8));
} }
} }
break; break;
@ -350,7 +350,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
{ {
xe_xex2_file_normal_compression_info_t *comp_info = xe_xex2_file_normal_compression_info_t *comp_info =
&fmt->compression_info.normal; &fmt->compression_info.normal;
uint32_t window_size = XEGETUINT32BE(pp + 0x08); uint32_t window_size = poly::load_and_swap<uint32_t>(pp + 0x08);
uint32_t window_bits = 0; uint32_t window_bits = 0;
for (size_t m = 0; m < 32; m++, window_bits++) { for (size_t m = 0; m < 32; m++, window_bits++) {
window_size <<= 1; window_size <<= 1;
@ -358,9 +358,9 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
break; break;
} }
} }
comp_info->window_size = XEGETUINT32BE(pp + 0x08); comp_info->window_size = poly::load_and_swap<uint32_t>(pp + 0x08);
comp_info->window_bits = window_bits; comp_info->window_bits = window_bits;
comp_info->block_size = XEGETUINT32BE(pp + 0x0C); comp_info->block_size = poly::load_and_swap<uint32_t>(pp + 0x0C);
XEEXPECTZERO(xe_copy_memory(comp_info->block_hash, XEEXPECTZERO(xe_copy_memory(comp_info->block_hash,
sizeof(comp_info->block_hash), sizeof(comp_info->block_hash),
pp + 0x10, 20)); pp + 0x10, 20));
@ -379,16 +379,16 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
// Loader info. // Loader info.
pc = p + header->certificate_offset; pc = p + header->certificate_offset;
ldr = &header->loader_info; ldr = &header->loader_info;
ldr->header_size = XEGETUINT32BE(pc + 0x000); ldr->header_size = poly::load_and_swap<uint32_t>(pc + 0x000);
ldr->image_size = XEGETUINT32BE(pc + 0x004); ldr->image_size = poly::load_and_swap<uint32_t>(pc + 0x004);
XEEXPECTZERO(xe_copy_memory(ldr->rsa_signature, sizeof(ldr->rsa_signature), XEEXPECTZERO(xe_copy_memory(ldr->rsa_signature, sizeof(ldr->rsa_signature),
pc + 0x008, 256)); pc + 0x008, 256));
ldr->unklength = XEGETUINT32BE(pc + 0x108); ldr->unklength = poly::load_and_swap<uint32_t>(pc + 0x108);
ldr->image_flags = (xe_xex2_image_flags)XEGETUINT32BE(pc + 0x10C); ldr->image_flags = (xe_xex2_image_flags)poly::load_and_swap<uint32_t>(pc + 0x10C);
ldr->load_address = XEGETUINT32BE(pc + 0x110); ldr->load_address = poly::load_and_swap<uint32_t>(pc + 0x110);
XEEXPECTZERO(xe_copy_memory(ldr->section_digest, sizeof(ldr->section_digest), XEEXPECTZERO(xe_copy_memory(ldr->section_digest, sizeof(ldr->section_digest),
pc + 0x114, 20)); pc + 0x114, 20));
ldr->import_table_count = XEGETUINT32BE(pc + 0x128); ldr->import_table_count = poly::load_and_swap<uint32_t>(pc + 0x128);
XEEXPECTZERO(xe_copy_memory(ldr->import_table_digest, XEEXPECTZERO(xe_copy_memory(ldr->import_table_digest,
sizeof(ldr->import_table_digest), sizeof(ldr->import_table_digest),
pc + 0x12C, 20)); pc + 0x12C, 20));
@ -396,22 +396,22 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length,
pc + 0x140, 16)); pc + 0x140, 16));
XEEXPECTZERO(xe_copy_memory(ldr->file_key, sizeof(ldr->file_key), XEEXPECTZERO(xe_copy_memory(ldr->file_key, sizeof(ldr->file_key),
pc + 0x150, 16)); pc + 0x150, 16));
ldr->export_table = XEGETUINT32BE(pc + 0x160); ldr->export_table = poly::load_and_swap<uint32_t>(pc + 0x160);
XEEXPECTZERO(xe_copy_memory(ldr->header_digest, sizeof(ldr->header_digest), XEEXPECTZERO(xe_copy_memory(ldr->header_digest, sizeof(ldr->header_digest),
pc + 0x164, 20)); pc + 0x164, 20));
ldr->game_regions = (xe_xex2_region_flags)XEGETUINT32BE(pc + 0x178); ldr->game_regions = (xe_xex2_region_flags)poly::load_and_swap<uint32_t>(pc + 0x178);
ldr->media_flags = (xe_xex2_media_flags)XEGETUINT32BE(pc + 0x17C); ldr->media_flags = (xe_xex2_media_flags)poly::load_and_swap<uint32_t>(pc + 0x17C);
// Section info follows loader info. // Section info follows loader info.
ps = p + header->certificate_offset + 0x180; ps = p + header->certificate_offset + 0x180;
header->section_count = XEGETUINT32BE(ps + 0x000); header->section_count = poly::load_and_swap<uint32_t>(ps + 0x000);
ps += 4; ps += 4;
header->sections = (xe_xex2_section_t*)xe_calloc( header->sections = (xe_xex2_section_t*)xe_calloc(
header->section_count * sizeof(xe_xex2_section_t)); header->section_count * sizeof(xe_xex2_section_t));
XEEXPECTNOTNULL(header->sections); XEEXPECTNOTNULL(header->sections);
for (size_t n = 0; n < header->section_count; n++) { for (size_t n = 0; n < header->section_count; n++) {
xe_xex2_section_t *section = &header->sections[n]; xe_xex2_section_t *section = &header->sections[n];
section->info.value = XEGETUINT32BE(ps); section->info.value = poly::load_and_swap<uint32_t>(ps);
ps += 4; ps += 4;
XEEXPECTZERO(xe_copy_memory(section->digest, sizeof(section->digest), ps, XEEXPECTZERO(xe_copy_memory(section->digest, sizeof(section->digest), ps,
sizeof(section->digest))); sizeof(section->digest)));
@ -717,7 +717,7 @@ int xe_xex2_read_image_compressed(const xe_xex2_header_t *header,
block_size = header->file_format_info.compression_info.normal.block_size; block_size = header->file_format_info.compression_info.normal.block_size;
while (block_size) { while (block_size) {
const uint8_t *pnext = p + block_size; const uint8_t *pnext = p + block_size;
const size_t next_size = XEGETINT32BE(p); const size_t next_size = poly::load_and_swap<int32_t>(p);
p += 4; p += 4;
p += 20; // skip 20b hash p += 20; // skip 20b hash
@ -935,7 +935,7 @@ int xe_xex2_find_import_infos(xe_xex2_ref xex,
size_t info_count = 0; size_t info_count = 0;
for (size_t n = 0; n < library->record_count; n++) { for (size_t n = 0; n < library->record_count; n++) {
const uint32_t record = library->records[n]; const uint32_t record = library->records[n];
const uint32_t value = XEGETUINT32BE(mem + record); const uint32_t value = poly::load_and_swap<uint32_t>(mem + record);
if (value & 0xFF000000) { if (value & 0xFF000000) {
// Thunk for previous record - ignore. // Thunk for previous record - ignore.
} else { } else {
@ -954,7 +954,7 @@ int xe_xex2_find_import_infos(xe_xex2_ref xex,
// Construct infos. // Construct infos.
for (size_t n = 0, i = 0; n < library->record_count; n++) { for (size_t n = 0, i = 0; n < library->record_count; n++) {
const uint32_t record = library->records[n]; const uint32_t record = library->records[n];
const uint32_t value = XEGETUINT32BE(mem + record); const uint32_t value = poly::load_and_swap<uint32_t>(mem + record);
const uint32_t type = (value & 0xFF000000) >> 24; const uint32_t type = (value & 0xFF000000) >> 24;
// Verify library index matches given library. // Verify library index matches given library.

2
src/xenia/kernel/xboxkrnl_audio.cc
View File

@ -125,7 +125,7 @@ SHIM_CALL XAudioRegisterRenderDriverClient_shim(
} }
assert_true(!(index & ~0x0000FFFF)); assert_true(!(index & ~0x0000FFFF));
SHIM_SET_MEM_32(driver_ptr, 0x41550000 | (index & 0x0000FFFF)); SHIM_SET_MEM_32(driver_ptr, 0x41550000 | (static_cast<uint32_t>(index) & 0x0000FFFF));
SHIM_SET_RETURN_32(X_ERROR_SUCCESS); SHIM_SET_RETURN_32(X_ERROR_SUCCESS);
} }

2
src/xenia/kernel/xboxkrnl_io.cc
View File

@ -435,7 +435,7 @@ SHIM_CALL NtQueryInformationFile_shim(
if (XSUCCEEDED(result)) { if (XSUCCEEDED(result)) {
if (bytes_read == sizeof(magic)) { if (bytes_read == sizeof(magic)) {
info = 4; info = 4;
SHIM_SET_MEM_32(file_info_ptr, magic == XESWAP32BE(0x0FF512ED)); SHIM_SET_MEM_32(file_info_ptr, magic == poly::byte_swap(0x0FF512ED));
} }
else { else {
result = X_STATUS_UNSUCCESSFUL; result = X_STATUS_UNSUCCESSFUL;

26
src/xenia/kernel/xboxkrnl_module.cc
View File

@ -63,7 +63,7 @@ XboxkrnlModule::XboxkrnlModule(Emulator* emulator, KernelState* kernel_state) :
export_resolver_->SetVariableMapping( export_resolver_->SetVariableMapping(
"xboxkrnl.exe", ordinals::KeDebugMonitorData, "xboxkrnl.exe", ordinals::KeDebugMonitorData,
pKeDebugMonitorData); pKeDebugMonitorData);
XESETUINT32BE(mem + pKeDebugMonitorData, 0); poly::store_and_swap<uint32_t>(mem + pKeDebugMonitorData, 0);
// KeCertMonitorData (?*) // KeCertMonitorData (?*)
// Always set to zero, ignored. // Always set to zero, ignored.
@ -71,7 +71,7 @@ XboxkrnlModule::XboxkrnlModule(Emulator* emulator, KernelState* kernel_state) :
export_resolver_->SetVariableMapping( export_resolver_->SetVariableMapping(
"xboxkrnl.exe", ordinals::KeCertMonitorData, "xboxkrnl.exe", ordinals::KeCertMonitorData,
pKeCertMonitorData); pKeCertMonitorData);
XESETUINT32BE(mem + pKeCertMonitorData, 0); poly::store_and_swap<uint32_t>(mem + pKeCertMonitorData, 0);
// XboxHardwareInfo (XboxHardwareInfo_t, 16b) // XboxHardwareInfo (XboxHardwareInfo_t, 16b)
// flags cpu# ? ? ? ? ? ? // flags cpu# ? ? ? ? ? ?
@ -82,8 +82,8 @@ XboxkrnlModule::XboxkrnlModule(Emulator* emulator, KernelState* kernel_state) :
export_resolver_->SetVariableMapping( export_resolver_->SetVariableMapping(
"xboxkrnl.exe", ordinals::XboxHardwareInfo, "xboxkrnl.exe", ordinals::XboxHardwareInfo,
pXboxHardwareInfo); pXboxHardwareInfo);
XESETUINT32BE(mem + pXboxHardwareInfo + 0, 0x00000000); // flags poly::store_and_swap<uint32_t>(mem + pXboxHardwareInfo + 0, 0x00000000); // flags
XESETUINT8BE (mem + pXboxHardwareInfo + 4, 0x06); // cpu count poly::store_and_swap<uint8_t> (mem + pXboxHardwareInfo + 4, 0x06); // cpu count
// Remaining 11b are zeroes? // Remaining 11b are zeroes?
// XexExecutableModuleHandle (?**) // XexExecutableModuleHandle (?**)
@ -101,8 +101,8 @@ XboxkrnlModule::XboxkrnlModule(Emulator* emulator, KernelState* kernel_state) :
ppXexExecutableModuleHandle); ppXexExecutableModuleHandle);
uint32_t pXexExecutableModuleHandle = uint32_t pXexExecutableModuleHandle =
(uint32_t)memory_->HeapAlloc(0, 256, 0); (uint32_t)memory_->HeapAlloc(0, 256, 0);
XESETUINT32BE(mem + ppXexExecutableModuleHandle, pXexExecutableModuleHandle); poly::store_and_swap<uint32_t>(mem + ppXexExecutableModuleHandle, pXexExecutableModuleHandle);
XESETUINT32BE(mem + pXexExecutableModuleHandle + 0x58, 0x80101100); poly::store_and_swap<uint32_t>(mem + pXexExecutableModuleHandle + 0x58, 0x80101100);
// ExLoadedCommandLine (char*) // ExLoadedCommandLine (char*)
// The name of the xex. Not sure this is ever really used on real devices. // The name of the xex. Not sure this is ever really used on real devices.
@ -123,19 +123,19 @@ XboxkrnlModule::XboxkrnlModule(Emulator* emulator, KernelState* kernel_state) :
export_resolver_->SetVariableMapping( export_resolver_->SetVariableMapping(
"xboxkrnl.exe", ordinals::XboxKrnlVersion, "xboxkrnl.exe", ordinals::XboxKrnlVersion,
pXboxKrnlVersion); pXboxKrnlVersion);
XESETUINT16BE(mem + pXboxKrnlVersion + 0, 2); poly::store_and_swap<uint16_t>(mem + pXboxKrnlVersion + 0, 2);
XESETUINT16BE(mem + pXboxKrnlVersion + 2, 0xFFFF); poly::store_and_swap<uint16_t>(mem + pXboxKrnlVersion + 2, 0xFFFF);
XESETUINT16BE(mem + pXboxKrnlVersion + 4, 0xFFFF); poly::store_and_swap<uint16_t>(mem + pXboxKrnlVersion + 4, 0xFFFF);
XESETUINT16BE(mem + pXboxKrnlVersion + 6, 0xFFFF); poly::store_and_swap<uint16_t>(mem + pXboxKrnlVersion + 6, 0xFFFF);
// KeTimeStampBundle (ad) // KeTimeStampBundle (ad)
uint32_t pKeTimeStampBundle = (uint32_t)memory_->HeapAlloc(0, 24, 0); uint32_t pKeTimeStampBundle = (uint32_t)memory_->HeapAlloc(0, 24, 0);
export_resolver_->SetVariableMapping( export_resolver_->SetVariableMapping(
"xboxkrnl.exe", ordinals::KeTimeStampBundle, "xboxkrnl.exe", ordinals::KeTimeStampBundle,
pKeTimeStampBundle); pKeTimeStampBundle);
XESETUINT64BE(mem + pKeTimeStampBundle + 0, 0); poly::store_and_swap<uint64_t>(mem + pKeTimeStampBundle + 0, 0);
XESETUINT64BE(mem + pKeTimeStampBundle + 8, 0); poly::store_and_swap<uint64_t>(mem + pKeTimeStampBundle + 8, 0);
XESETUINT32BE(mem + pKeTimeStampBundle + 12, 0); poly::store_and_swap<uint32_t>(mem + pKeTimeStampBundle + 12, 0);
} }
XboxkrnlModule::~XboxkrnlModule() { XboxkrnlModule::~XboxkrnlModule() {

2
src/xenia/kernel/xboxkrnl_modules.cc
View File

@ -97,7 +97,7 @@ X_STATUS xeExGetXConfigSetting(
} }
if (buffer) { if (buffer) {
XESETUINT32BE(buffer, value); poly::store_and_swap<uint32_t>(buffer, value);
} }
if (required_size) { if (required_size) {
*required_size = setting_size; *required_size = setting_size;

8
src/xenia/kernel/xboxkrnl_rtl.cc
View File

@ -91,7 +91,7 @@ uint32_t xeRtlCompareMemoryUlong(uint32_t source_ptr, uint32_t length,
// TODO(benvanik): ensure byte order of pattern is correct. // TODO(benvanik): ensure byte order of pattern is correct.
// Since we are doing byte-by-byte comparison we may not want to swap. // Since we are doing byte-by-byte comparison we may not want to swap.
// GET_ARG swaps, so this is a swap back. Ugly. // GET_ARG swaps, so this is a swap back. Ugly.
const uint32_t pb32 = XESWAP32BE(pattern); const uint32_t pb32 = poly::byte_swap(pattern);
const uint8_t* pb = (uint8_t*)&pb32; const uint8_t* pb = (uint8_t*)&pb32;
uint32_t c = 0; uint32_t c = 0;
@ -138,7 +138,7 @@ void xeRtlFillMemoryUlong(uint32_t destination_ptr, uint32_t length,
// swapped arg value. // swapped arg value.
uint32_t count = length >> 2; uint32_t count = length >> 2;
uint32_t native_pattern = XESWAP32BE(pattern); uint32_t native_pattern = poly::byte_swap(pattern);
// TODO: unroll loop? // TODO: unroll loop?
@ -364,7 +364,7 @@ SHIM_CALL RtlMultiByteToUnicodeN_shim(
auto destination = (uint16_t*)SHIM_MEM_ADDR(destination_ptr); auto destination = (uint16_t*)SHIM_MEM_ADDR(destination_ptr);
for (uint32_t i = 0; i < copy_len; i++) for (uint32_t i = 0; i < copy_len; i++)
{ {
*destination++ = XESWAP16(*source++); *destination++ = poly::byte_swap(*source++);
} }
if (written_ptr != 0) if (written_ptr != 0)
@ -393,7 +393,7 @@ SHIM_CALL RtlUnicodeToMultiByteN_shim(
auto destination = (uint8_t*)SHIM_MEM_ADDR(destination_ptr); auto destination = (uint8_t*)SHIM_MEM_ADDR(destination_ptr);
for (uint32_t i = 0; i < copy_len; i++) for (uint32_t i = 0; i < copy_len; i++)
{ {
uint16_t c = XESWAP16(*source++); uint16_t c = poly::byte_swap(*source++);
*destination++ = c < 256 ? (uint8_t)c : '?'; *destination++ = c < 256 ? (uint8_t)c : '?';
} }

12
src/xenia/kernel/xboxkrnl_strings.cc
View File

@ -472,9 +472,8 @@ SHIM_CALL _vswprintf_shim(
// swap the format buffer // swap the format buffer
wchar_t* swapped_format = (wchar_t*)xe_malloc((format_length + 1) * sizeof(wchar_t)); wchar_t* swapped_format = (wchar_t*)xe_malloc((format_length + 1) * sizeof(wchar_t));
for (size_t i = 0; i < format_length; ++i) for (size_t i = 0; i < format_length; ++i) {
{ swapped_format[i] = poly::byte_swap(format[i]);
swapped_format[i] = XESWAP16(format[i]);
} }
swapped_format[format_length] = '\0'; swapped_format[format_length] = '\0';
@ -676,9 +675,8 @@ SHIM_CALL _vswprintf_shim(
const wchar_t* data = (const wchar_t*)SHIM_MEM_ADDR(value); const wchar_t* data = (const wchar_t*)SHIM_MEM_ADDR(value);
size_t data_length = wcslen(data); size_t data_length = wcslen(data);
wchar_t* swapped_data = (wchar_t*)xe_malloc((data_length + 1) * sizeof(wchar_t)); wchar_t* swapped_data = (wchar_t*)xe_malloc((data_length + 1) * sizeof(wchar_t));
for (size_t i = 0; i < data_length; ++i) for (size_t i = 0; i < data_length; ++i) {
{ swapped_data[i] = poly::byte_swap(data[i]);
swapped_data[i] = XESWAP16(data[i]);
} }
swapped_data[data_length] = '\0'; swapped_data[data_length] = '\0';
int result = wsprintf(b, local, swapped_data); int result = wsprintf(b, local, swapped_data);
@ -703,7 +701,7 @@ SHIM_CALL _vswprintf_shim(
// swap the result buffer // swap the result buffer
for (wchar_t* swap = buffer; swap != b; ++swap) for (wchar_t* swap = buffer; swap != b; ++swap)
{ {
*swap = XESWAP16(*swap); *swap = poly::byte_swap(*swap);
} }
SHIM_SET_RETURN_32((uint32_t)((b - buffer) / sizeof(wchar_t))); SHIM_SET_RETURN_32((uint32_t)((b - buffer) / sizeof(wchar_t)));

30
src/xenia/kernel/xboxkrnl_video.cc
View File

@ -117,15 +117,15 @@ void xeVdQueryVideoMode(X_VIDEO_MODE *video_mode, bool swap) {
video_mode->unknown_0x01 = 0x01; video_mode->unknown_0x01 = 0x01;
if (swap) { if (swap) {
video_mode->display_width = XESWAP32BE(video_mode->display_width); video_mode->display_width = poly::byte_swap(video_mode->display_width);
video_mode->display_height = XESWAP32BE(video_mode->display_height); video_mode->display_height = poly::byte_swap(video_mode->display_height);
video_mode->is_interlaced = XESWAP32BE(video_mode->is_interlaced); video_mode->is_interlaced = poly::byte_swap(video_mode->is_interlaced);
video_mode->is_widescreen = XESWAP32BE(video_mode->is_widescreen); video_mode->is_widescreen = poly::byte_swap(video_mode->is_widescreen);
video_mode->is_hi_def = XESWAP32BE(video_mode->is_hi_def); video_mode->is_hi_def = poly::byte_swap(video_mode->is_hi_def);
video_mode->refresh_rate = XESWAPF32BE(video_mode->refresh_rate); video_mode->refresh_rate = poly::byte_swap(video_mode->refresh_rate);
video_mode->video_standard = XESWAP32BE(video_mode->video_standard); video_mode->video_standard = poly::byte_swap(video_mode->video_standard);
video_mode->unknown_0x8a = XESWAP32BE(video_mode->unknown_0x8a); video_mode->unknown_0x8a = poly::byte_swap(video_mode->unknown_0x8a);
video_mode->unknown_0x01 = XESWAP32BE(video_mode->unknown_0x01); video_mode->unknown_0x01 = poly::byte_swap(video_mode->unknown_0x01);
} }
} }
@ -430,9 +430,9 @@ SHIM_CALL VdSwap_shim(
// use this method. // use this method.
xe_zero_struct(SHIM_MEM_ADDR(unk0), 64 * 4); xe_zero_struct(SHIM_MEM_ADDR(unk0), 64 * 4);
auto dwords = reinterpret_cast<uint32_t*>(SHIM_MEM_ADDR(unk0)); auto dwords = reinterpret_cast<uint32_t*>(SHIM_MEM_ADDR(unk0));
dwords[0] = XESWAP32((0x03 << 30) | dwords[0] = poly::byte_swap((0x03 << 30) |
((1 - 1) << 16) | ((1 - 1) << 16) |
(xenos::PM4_XE_SWAP << 8)); (xenos::PM4_XE_SWAP << 8));
SHIM_SET_RETURN_64(0); SHIM_SET_RETURN_64(0);
} }
@ -472,7 +472,7 @@ void xe::kernel::xboxkrnl::RegisterVideoExports(
export_resolver->SetVariableMapping( export_resolver->SetVariableMapping(
"xboxkrnl.exe", ordinals::VdGlobalDevice, "xboxkrnl.exe", ordinals::VdGlobalDevice,
pVdGlobalDevice); pVdGlobalDevice);
XESETUINT32BE(mem + pVdGlobalDevice, 0); poly::store_and_swap<uint32_t>(mem + pVdGlobalDevice, 0);
// VdGlobalXamDevice (4b) // VdGlobalXamDevice (4b)
// Pointer to the XAM D3D device, which we don't have. // Pointer to the XAM D3D device, which we don't have.
@ -480,7 +480,7 @@ void xe::kernel::xboxkrnl::RegisterVideoExports(
export_resolver->SetVariableMapping( export_resolver->SetVariableMapping(
"xboxkrnl.exe", ordinals::VdGlobalXamDevice, "xboxkrnl.exe", ordinals::VdGlobalXamDevice,
pVdGlobalXamDevice); pVdGlobalXamDevice);
XESETUINT32BE(mem + pVdGlobalXamDevice, 0); poly::store_and_swap<uint32_t>(mem + pVdGlobalXamDevice, 0);
// VdGpuClockInMHz (4b) // VdGpuClockInMHz (4b)
// GPU clock. Xenos is 500MHz. Hope nothing is relying on this timing... // GPU clock. Xenos is 500MHz. Hope nothing is relying on this timing...
@ -488,7 +488,7 @@ void xe::kernel::xboxkrnl::RegisterVideoExports(
export_resolver->SetVariableMapping( export_resolver->SetVariableMapping(
"xboxkrnl.exe", ordinals::VdGpuClockInMHz, "xboxkrnl.exe", ordinals::VdGpuClockInMHz,
pVdGpuClockInMHz); pVdGpuClockInMHz);
XESETUINT32BE(mem + pVdGpuClockInMHz, 500); poly::store_and_swap<uint32_t>(mem + pVdGpuClockInMHz, 500);
// VdHSIOCalibrationLock (28b) // VdHSIOCalibrationLock (28b)
// CriticalSection. // CriticalSection.

24
src/xenia/kernel/xobject.cc
View File

@ -162,18 +162,18 @@ void XObject::SetNativePointer(uint32_t native_ptr) {
DISPATCH_HEADER* header_be = DISPATCH_HEADER* header_be =
(DISPATCH_HEADER*)kernel_state_->memory()->Translate(native_ptr); (DISPATCH_HEADER*)kernel_state_->memory()->Translate(native_ptr);
DISPATCH_HEADER header; DISPATCH_HEADER header;
header.type_flags = XESWAP32(header_be->type_flags); header.type_flags = poly::byte_swap(header_be->type_flags);
header.signal_state = XESWAP32(header_be->signal_state); header.signal_state = poly::byte_swap(header_be->signal_state);
header.wait_list_flink = XESWAP32(header_be->wait_list_flink); header.wait_list_flink = poly::byte_swap(header_be->wait_list_flink);
header.wait_list_blink = XESWAP32(header_be->wait_list_blink); header.wait_list_blink = poly::byte_swap(header_be->wait_list_blink);
assert_true(!(header.wait_list_blink & 0x1)); assert_true(!(header.wait_list_blink & 0x1));
// Stash pointer in struct. // Stash pointer in struct.
uint64_t object_ptr = reinterpret_cast<uint64_t>(this); uint64_t object_ptr = reinterpret_cast<uint64_t>(this);
object_ptr |= 0x1; object_ptr |= 0x1;
header_be->wait_list_flink = XESWAP32((uint32_t)(object_ptr >> 32)); header_be->wait_list_flink = poly::byte_swap((uint32_t)(object_ptr >> 32));
header_be->wait_list_blink = XESWAP32((uint32_t)(object_ptr & 0xFFFFFFFF)); header_be->wait_list_blink = poly::byte_swap((uint32_t)(object_ptr & 0xFFFFFFFF));
XObject::UnlockType(); XObject::UnlockType();
} }
@ -193,10 +193,10 @@ XObject* XObject::GetObject(KernelState* kernel_state, void* native_ptr,
DISPATCH_HEADER* header_be = (DISPATCH_HEADER*)native_ptr; DISPATCH_HEADER* header_be = (DISPATCH_HEADER*)native_ptr;
DISPATCH_HEADER header; DISPATCH_HEADER header;
header.type_flags = XESWAP32(header_be->type_flags); header.type_flags = poly::byte_swap(header_be->type_flags);
header.signal_state = XESWAP32(header_be->signal_state); header.signal_state = poly::byte_swap(header_be->signal_state);
header.wait_list_flink = XESWAP32(header_be->wait_list_flink); header.wait_list_flink = poly::byte_swap(header_be->wait_list_flink);
header.wait_list_blink = XESWAP32(header_be->wait_list_blink); header.wait_list_blink = poly::byte_swap(header_be->wait_list_blink);
if (as_type == -1) { if (as_type == -1) {
as_type = header.type_flags & 0xFF; as_type = header.type_flags & 0xFF;
@ -260,8 +260,8 @@ XObject* XObject::GetObject(KernelState* kernel_state, void* native_ptr,
// Stash pointer in struct. // Stash pointer in struct.
uint64_t object_ptr = reinterpret_cast<uint64_t>(object); uint64_t object_ptr = reinterpret_cast<uint64_t>(object);
object_ptr |= 0x1; object_ptr |= 0x1;
header_be->wait_list_flink = XESWAP32((uint32_t)(object_ptr >> 32)); header_be->wait_list_flink = poly::byte_swap((uint32_t)(object_ptr >> 32));
header_be->wait_list_blink = XESWAP32((uint32_t)(object_ptr & 0xFFFFFFFF)); header_be->wait_list_blink = poly::byte_swap((uint32_t)(object_ptr & 0xFFFFFFFF));
XObject::UnlockType(); XObject::UnlockType();
return object; return object;

1
src/xenia/sources.gypi
View File

@ -1,7 +1,6 @@
# Copyright 2013 Ben Vanik. All Rights Reserved. # Copyright 2013 Ben Vanik. All Rights Reserved.
{ {
'sources': [ 'sources': [
'byte_order.h',
'common.h', 'common.h',
'config.h', 'config.h',
'core.h', 'core.h',

84
src/xenia/xbox.h
View File

@ -205,10 +205,10 @@ public:
Read(base, p); Read(base, p);
} }
void Read(const uint8_t* base, uint32_t p) { void Read(const uint8_t* base, uint32_t p) {
length = XEGETUINT16BE(base + p); length = poly::load_and_swap<uint16_t>(base + p);
maximum_length = XEGETUINT16BE(base + p + 2); maximum_length = poly::load_and_swap<uint16_t>(base + p + 2);
if (maximum_length) { if (maximum_length) {
buffer = (const char*)(base + XEGETUINT32BE(base + p + 4)); buffer = (const char*)(base + poly::load_and_swap<uint32_t>(base + p + 4));
} else { } else {
buffer = 0; buffer = 0;
} }
@ -242,14 +242,14 @@ public:
Read(base, p); Read(base, p);
} }
void Read(const uint8_t* base, uint32_t p) { void Read(const uint8_t* base, uint32_t p) {
root_directory = XEGETUINT32BE(base + p); root_directory = poly::load_and_swap<uint32_t>(base + p);
object_name_ptr = XEGETUINT32BE(base + p + 4); object_name_ptr = poly::load_and_swap<uint32_t>(base + p + 4);
if (object_name_ptr) { if (object_name_ptr) {
object_name.Read(base, object_name_ptr); object_name.Read(base, object_name_ptr);
} else { } else {
object_name.Zero(); object_name.Zero();
} }
attributes = XEGETUINT32BE(base + p + 8); attributes = poly::load_and_swap<uint32_t>(base + p + 8);
} }
void Zero() { void Zero() {
root_directory = 0; root_directory = 0;
@ -302,22 +302,22 @@ public:
Read(base, p); Read(base, p);
} }
void Read(const uint8_t* base, uint32_t p) { void Read(const uint8_t* base, uint32_t p) {
buttons = XEGETUINT16BE(base + p); buttons = poly::load_and_swap<uint16_t>(base + p);
left_trigger = XEGETUINT8BE(base + p + 2); left_trigger = poly::load_and_swap<uint8_t>(base + p + 2);
right_trigger = XEGETUINT8BE(base + p + 3); right_trigger = poly::load_and_swap<uint8_t>(base + p + 3);
thumb_lx = XEGETINT16BE(base + p + 4); thumb_lx = poly::load_and_swap<int16_t>(base + p + 4);
thumb_ly = XEGETINT16BE(base + p + 6); thumb_ly = poly::load_and_swap<int16_t>(base + p + 6);
thumb_rx = XEGETINT16BE(base + p + 8); thumb_rx = poly::load_and_swap<int16_t>(base + p + 8);
thumb_ry = XEGETINT16BE(base + p + 10); thumb_ry = poly::load_and_swap<int16_t>(base + p + 10);
} }
void Write(uint8_t* base, uint32_t p) { void Write(uint8_t* base, uint32_t p) {
XESETUINT16BE(base + p, buttons); poly::store_and_swap<uint16_t>(base + p, buttons);
XESETUINT8BE(base + p + 2, left_trigger); poly::store_and_swap<uint8_t>(base + p + 2, left_trigger);
XESETUINT8BE(base + p + 3, right_trigger); poly::store_and_swap<uint8_t>(base + p + 3, right_trigger);
XESETINT16BE(base + p + 4, thumb_lx); poly::store_and_swap<int16_t>(base + p + 4, thumb_lx);
XESETINT16BE(base + p + 6, thumb_ly); poly::store_and_swap<int16_t>(base + p + 6, thumb_ly);
XESETINT16BE(base + p + 8, thumb_rx); poly::store_and_swap<int16_t>(base + p + 8, thumb_rx);
XESETINT16BE(base + p + 10, thumb_ry); poly::store_and_swap<int16_t>(base + p + 10, thumb_ry);
} }
void Zero() { void Zero() {
buttons = 0; buttons = 0;
@ -337,11 +337,11 @@ public:
Read(base, p); Read(base, p);
} }
void Read(const uint8_t* base, uint32_t p) { void Read(const uint8_t* base, uint32_t p) {
packet_number = XEGETUINT32BE(base + p); packet_number = poly::load_and_swap<uint32_t>(base + p);
gamepad.Read(base, p + 4); gamepad.Read(base, p + 4);
} }
void Write(uint8_t* base, uint32_t p) { void Write(uint8_t* base, uint32_t p) {
XESETUINT32BE(base + p, packet_number); poly::store_and_swap<uint32_t>(base + p, packet_number);
gamepad.Write(base, p + 4); gamepad.Write(base, p + 4);
} }
void Zero() { void Zero() {
@ -361,12 +361,12 @@ public:
Read(base, p); Read(base, p);
} }
void Read(const uint8_t* base, uint32_t p) { void Read(const uint8_t* base, uint32_t p) {
left_motor_speed = XEGETUINT16BE(base + p); left_motor_speed = poly::load_and_swap<uint16_t>(base + p);
right_motor_speed = XEGETUINT16BE(base + p + 2); right_motor_speed = poly::load_and_swap<uint16_t>(base + p + 2);
} }
void Write(uint8_t* base, uint32_t p) { void Write(uint8_t* base, uint32_t p) {
XESETUINT16BE(base + p, left_motor_speed); poly::store_and_swap<uint16_t>(base + p, left_motor_speed);
XESETUINT16BE(base + p + 2, right_motor_speed); poly::store_and_swap<uint16_t>(base + p + 2, right_motor_speed);
} }
void Zero() { void Zero() {
left_motor_speed = right_motor_speed = 0; left_motor_speed = right_motor_speed = 0;
@ -387,16 +387,16 @@ public:
Read(base, p); Read(base, p);
} }
void Read(const uint8_t* base, uint32_t p) { void Read(const uint8_t* base, uint32_t p) {
type = XEGETUINT8BE(base + p); type = poly::load_and_swap<uint8_t>(base + p);
sub_type = XEGETUINT8BE(base + p + 1); sub_type = poly::load_and_swap<uint8_t>(base + p + 1);
flags = XEGETUINT16BE(base + p + 2); flags = poly::load_and_swap<uint16_t>(base + p + 2);
gamepad.Read(base, p + 4); gamepad.Read(base, p + 4);
vibration.Read(base, p + 4 + 12); vibration.Read(base, p + 4 + 12);
} }
void Write(uint8_t* base, uint32_t p) { void Write(uint8_t* base, uint32_t p) {
XESETUINT8BE(base + p, type); poly::store_and_swap<uint8_t>(base + p, type);
XESETUINT8BE(base + p + 1, sub_type); poly::store_and_swap<uint8_t>(base + p + 1, sub_type);
XESETUINT16BE(base + p + 2, flags); poly::store_and_swap<uint16_t>(base + p + 2, flags);
gamepad.Write(base, p + 4); gamepad.Write(base, p + 4);
vibration.Write(base, p + 4 + 12); vibration.Write(base, p + 4 + 12);
} }
@ -424,18 +424,18 @@ public:
Read(base, p); Read(base, p);
} }
void Read(const uint8_t* base, uint32_t p) { void Read(const uint8_t* base, uint32_t p) {
virtual_key = XEGETUINT16BE(base + p + 0); virtual_key = poly::load_and_swap<uint16_t>(base + p + 0);
unicode = XEGETUINT16BE(base + p + 2); unicode = poly::load_and_swap<uint16_t>(base + p + 2);
flags = XEGETUINT16BE(base + p + 4); flags = poly::load_and_swap<uint16_t>(base + p + 4);
user_index = XEGETUINT8BE(base + p + 6); user_index = poly::load_and_swap<uint8_t>(base + p + 6);
hid_code = XEGETUINT8BE(base + p + 7); hid_code = poly::load_and_swap<uint8_t>(base + p + 7);
} }
void Write(uint8_t* base, uint32_t p) { void Write(uint8_t* base, uint32_t p) {
XESETUINT16BE(base + p + 0, virtual_key); poly::store_and_swap<uint16_t>(base + p + 0, virtual_key);
XESETUINT16BE(base + p + 2, unicode); poly::store_and_swap<uint16_t>(base + p + 2, unicode);
XESETUINT16BE(base + p + 4, flags); poly::store_and_swap<uint16_t>(base + p + 4, flags);
XESETUINT8BE(base + p + 6, user_index); poly::store_and_swap<uint8_t>(base + p + 6, user_index);
XESETUINT8BE(base + p + 7, hid_code); poly::store_and_swap<uint8_t>(base + p + 7, hid_code);
} }
void Zero() { void Zero() {
virtual_key = 0; virtual_key = 0;