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

Linux tweaks.

This commit is contained in:
Ben Vanik 2015-08-18 14:18:00 -07:00
parent 19299fad4b
commit 8b0d4fb51c
37 changed files with 200 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
build_tools

@ -1 +1 @@
Subproject commit c004e383e1621d6bbdbdb9b2cb1d8eb9369aed6e
Subproject commit 7c9845040311ae8a1964f6d4f6a4eef3530bb3d7

11
docs/building.md
View File

@ -28,6 +28,17 @@ the file to run in the 'Command Arguments' field (or use `--flagfile=flags.txt`)
To redirect output, use the following command flags:
`--flagfile=$(SolutionDir)scratch\flags.txt 2>&1 1>$(SolutionDir)scratch\stdout.txt`
### Linux
Linux support is extremely experimental and incomplete.
Only tested with GCC 4.9 on Ubuntu 14. [CodeLite](http://codelite.org) is the
IDE of choice and `xb premake` will spit out files for that. Make also works via
`xb build`.
Currently building requires that CC == CXX == g++. If you know a way around this
(to force .c files to be built with g++) let me know.
## Running
To make life easier you can use `--flagfile=myflags.txt` to specify all

12
premake5.lua
View File

@ -36,7 +36,7 @@ filter("configurations:Checked")
})
flags({"Symbols"})
runtime("Debug")
filter("configurations:Checked", "platforms:Windows")
filter({"configurations:Checked", "platforms:Windows"})
buildoptions({
"/RTCsu", -- Full Run-Time Checks.
})
@ -69,6 +69,7 @@ filter("platforms:Linux")
toolset("clang")
buildoptions({
"-std=c++14",
"-mlzcnt", -- Assume lzcnt supported.
})
filter("platforms:Windows")
@ -151,7 +152,6 @@ solution("xenia")
include("src/xenia/app")
include("src/xenia/apu")
include("src/xenia/apu/nop")
include("src/xenia/apu/xaudio2")
include("src/xenia/base")
include("src/xenia/cpu")
include("src/xenia/cpu/backend/x64")
@ -161,13 +161,17 @@ solution("xenia")
include("src/xenia/gpu/gl4")
include("src/xenia/hid")
include("src/xenia/hid/nop")
include("src/xenia/hid/winkey")
include("src/xenia/hid/xinput")
include("src/xenia/kernel")
include("src/xenia/ui")
include("src/xenia/ui/gl")
include("src/xenia/vfs")
if os.is("windows") then
include("src/xenia/apu/xaudio2")
include("src/xenia/hid/winkey")
include("src/xenia/hid/xinput")
end
include("third_party/capstone.lua")
include("third_party/elemental-forms")
include("third_party/glew.lua")

9
src/xenia/app/premake5.lua
View File

@ -12,7 +12,6 @@ project("xenia-app")
"gflags",
"xenia-apu",
"xenia-apu-nop",
"xenia-apu-xaudio2",
"xenia-base",
"xenia-core",
"xenia-cpu",
@ -21,8 +20,6 @@ project("xenia-app")
"xenia-gpu",
"xenia-gpu-gl4",
"xenia-hid-nop",
"xenia-hid-winkey",
"xenia-hid-xinput",
"xenia-kernel",
"xenia-ui",
"xenia-ui-gl",
@ -49,6 +46,12 @@ project("xenia-app")
project_root.."/third_party/elemental-forms",
})
filter("platforms:Windows")
links({
"xenia-apu-xaudio2",
"xenia-hid-winkey",
"xenia-hid-xinput",
})
filter("configurations:Checked")
local libav_root = "../third_party/libav-xma-bin/lib/Debug"
linkoptions({

8
src/xenia/base/atomic.h
View File

@ -102,17 +102,17 @@ inline int32_t atomic_dec(volatile int32_t* value) {
}
inline int32_t atomic_exchange(int32_t new_value, volatile int32_t* value) {
return __sync_val_compare_and_swap(*value, value, new_value);
return __sync_val_compare_and_swap(value, *value, new_value);
}
inline int64_t atomic_exchange(int64_t new_value, volatile int64_t* value) {
return __sync_val_compare_and_swap(*value, value, new_value);
return __sync_val_compare_and_swap(value, *value, new_value);
}
inline int32_t atomic_exchange_add(int32_t amount, volatile int32_t* value) {
return __sync_fetch_and_add(amount, value);
return __sync_fetch_and_add(value, amount);
}
inline int64_t atomic_exchange_add(int64_t amount, volatile int64_t* value) {
return __sync_fetch_and_add(amount, value);
return __sync_fetch_and_add(value, amount);
}
inline bool atomic_cas(int32_t old_value, int32_t new_value,

10
src/xenia/base/logging.h
View File

@ -31,15 +31,7 @@ namespace xe {
do { \
} while (false)
#if XE_COMPILER_GNUC
#define XE_LOG_LINE_ATTRIBUTE __attribute__((format(printf, 5, 6)))
#else
#define XE_LOG_LINE_ATTRIBUTE
#endif // XE_COMPILER_GNUC
void log_line(const char level_char, const char* fmt,
...) XE_LOG_LINE_ATTRIBUTE;
#undef XE_LOG_LINE_ATTRIBUTE
void log_line(const char level_char, const char* fmt, ...);
void handle_fatal(const char* fmt, ...);
#if XE_OPTION_ENABLE_LOGGING

4
src/xenia/base/mapped_memory_posix.cc
View File

@ -39,11 +39,11 @@ std::unique_ptr<MappedMemory> MappedMemory::Open(const std::wstring& path,
const char* mode_str;
int prot;
switch (mode) {
case Mode::READ:
case Mode::kRead:
mode_str = "rb";
prot = PROT_READ;
break;
case Mode::READ_WRITE:
case Mode::kReadWrite:
mode_str = "r+b";
prot = PROT_READ | PROT_WRITE;
break;

18
src/xenia/base/string.cc
View File

@ -9,20 +9,34 @@
#include "xenia/base/string.h"
// TODO(benvanik): when GCC finally gets codecvt, use that.
#if XE_PLATFORM_LINUX
#define NO_CODECVT 1
#else
#include <codecvt>
#endif // XE_PLATFORM_LINUX
#include <cstring>
#include <locale>
namespace xe {
std::string to_string(const std::wstring& source) {
static std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
#if NO_CODECVT
return std::string(source.begin(), source.end());
#else
static std::wstring_convert<std::codecvt_utf8_utf16<wchar_t> > converter;
return converter.to_bytes(source);
#endif // XE_PLATFORM_LINUX
}
std::wstring to_wstring(const std::string& source) {
static std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
#if NO_CODECVT
return std::wstring(source.begin(), source.end());
#else
static std::wstring_convert<std::codecvt_utf8_utf16<wchar_t> > converter;
return converter.from_bytes(source);
#endif // XE_PLATFORM_LINUX
}
std::string::size_type find_first_of_case(const std::string& target,

21
src/xenia/base/threading_linux.cc Normal file
View File

@ -0,0 +1,21 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2015 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include "xenia/base/threading.h"
#include <pthread.h>
#include <time.h>
namespace xe {
namespace threading {
void MaybeYield() { pthread_yield(); }
} // namespace threading
} // namespace xe

2
src/xenia/base/threading_posix.cc
View File

@ -30,8 +30,6 @@ void set_name(std::thread::native_handle_type handle, const std::string& name) {
pthread_setname_np(pthread_self(), name.c_str());
}
void MaybeYield() { pthread_yield_np(); }
void Sleep(std::chrono::microseconds duration) {
timespec rqtp = {duration.count() / 1000000, duration.count() % 1000};
nanosleep(&rqtp, nullptr);

2
src/xenia/cpu/backend/x64/x64_assembler.cc
View File

@ -9,6 +9,8 @@
#include "xenia/cpu/backend/x64/x64_assembler.h"
#include <climits>
#include "third_party/capstone/include/capstone.h"
#include "third_party/capstone/include/x86.h"
#include "xenia/base/reset_scope.h"

4
src/xenia/cpu/backend/x64/x64_backend.cc
View File

@ -61,10 +61,10 @@ bool X64Backend::Initialize() {
machine_info_.supports_extended_load_store = false;
}
machine_info_.register_sets[0] = {
machine_info_.register_sets[0] = (MachineInfo::RegisterSet){
0, "gpr", MachineInfo::RegisterSet::INT_TYPES, X64Emitter::GPR_COUNT,
};
machine_info_.register_sets[1] = {
machine_info_.register_sets[1] = (MachineInfo::RegisterSet){
1, "xmm", MachineInfo::RegisterSet::FLOAT_TYPES |
MachineInfo::RegisterSet::VEC_TYPES,
X64Emitter::XMM_COUNT,

12
src/xenia/cpu/backend/x64/x64_sequences.cc
View File

@ -2019,7 +2019,7 @@ struct LOAD_MMIO_I32
auto read_address = uint32_t(i.src2.value);
e.mov(e.r8, uint64_t(mmio_range->callback_context));
e.mov(e.r9d, read_address);
e.CallNativeSafe(mmio_range->read);
e.CallNativeSafe(reinterpret_cast<void*>(mmio_range->read));
e.bswap(e.eax);
e.mov(i.dest, e.eax);
if (IsTracingData()) {
@ -2050,7 +2050,7 @@ struct STORE_MMIO_I32
e.mov(e.r10d, i.src3);
e.bswap(e.r10d);
}
e.CallNativeSafe(mmio_range->write);
e.CallNativeSafe(reinterpret_cast<void*>(mmio_range->write));
if (IsTracingData()) {
if (i.src3.is_constant) {
e.mov(e.r8d, i.src3.constant());
@ -6461,7 +6461,7 @@ struct PACK : Sequence<PACK, I<OPCODE_PACK, V128Op, V128Op, V128Op>> {
e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMPackFLOAT16_2));
} else {
e.lea(e.r8, e.StashXmm(0, i.src1));
e.CallNativeSafe(EmulateFLOAT16_2);
e.CallNativeSafe(reinterpret_cast<void*>(EmulateFLOAT16_2));
e.vmovaps(i.dest, e.xmm0);
}
}
@ -6488,7 +6488,7 @@ struct PACK : Sequence<PACK, I<OPCODE_PACK, V128Op, V128Op, V128Op>> {
e.vpshufb(i.dest, i.dest, e.GetXmmConstPtr(XMMPackFLOAT16_4));
} else {
e.lea(e.r8, e.StashXmm(0, i.src1));
e.CallNativeSafe(EmulateFLOAT16_4);
e.CallNativeSafe(reinterpret_cast<void*>(EmulateFLOAT16_4));
e.vmovaps(i.dest, e.xmm0);
}
}
@ -6787,7 +6787,7 @@ struct UNPACK : Sequence<UNPACK, I<OPCODE_UNPACK, V128Op, V128Op>> {
e.vpor(i.dest, e.GetXmmConstPtr(XMM0001));
} else {
e.lea(e.r8, e.StashXmm(0, i.src1));
e.CallNativeSafe(EmulateFLOAT16_2);
e.CallNativeSafe(reinterpret_cast<void*>(EmulateFLOAT16_2));
e.vmovaps(i.dest, e.xmm0);
}
}
@ -6821,7 +6821,7 @@ struct UNPACK : Sequence<UNPACK, I<OPCODE_UNPACK, V128Op, V128Op>> {
e.vcvtph2ps(i.dest, i.dest);
} else {
e.lea(e.r8, e.StashXmm(0, i.src1));
e.CallNativeSafe(EmulateFLOAT16_4);
e.CallNativeSafe(reinterpret_cast<void*>(EmulateFLOAT16_4));
e.vmovaps(i.dest, e.xmm0);
}
}

55
src/xenia/cpu/backend/x64/x64_tracers.cc
View File

@ -9,6 +9,8 @@
#include "xenia/cpu/backend/x64/x64_tracers.h"
#include <cinttypes>
#include "xenia/base/vec128.h"
#include "xenia/cpu/backend/x64/x64_emitter.h"
#include "xenia/cpu/processor.h"
@ -61,35 +63,36 @@ void TraceString(void* raw_context, const char* str) {
void TraceContextLoadI8(void* raw_context, uint64_t offset, uint8_t value) {
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
DPRINT("%d (%X) = ctx i8 +%llu\n", (int8_t)value, value, offset);
DPRINT("%d (%X) = ctx i8 +%" PRIu64 "\n", (int8_t)value, value, offset);
}
void TraceContextLoadI16(void* raw_context, uint64_t offset, uint16_t value) {
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
DPRINT("%d (%X) = ctx i16 +%llu\n", (int16_t)value, value, offset);
DPRINT("%d (%X) = ctx i16 +%" PRIu64 "\n", (int16_t)value, value, offset);
}
void TraceContextLoadI32(void* raw_context, uint64_t offset, uint32_t value) {
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
DPRINT("%d (%X) = ctx i32 +%llu\n", (int32_t)value, value, offset);
DPRINT("%d (%X) = ctx i32 +%" PRIu64 "\n", (int32_t)value, value, offset);
}
void TraceContextLoadI64(void* raw_context, uint64_t offset, uint64_t value) {
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
DPRINT("%lld (%llX) = ctx i64 +%llu\n", (int64_t)value, value, offset);
DPRINT("%" PRId64 " (%" PRIX64 ") = ctx i64 +%" PRIu64 "\n", (int64_t)value,
value, offset);
}
void TraceContextLoadF32(void* raw_context, uint64_t offset, __m128 value) {
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
DPRINT("%e (%X) = ctx f32 +%llu\n", xe::m128_f32<0>(value),
DPRINT("%e (%X) = ctx f32 +%" PRIu64 "\n", xe::m128_f32<0>(value),
xe::m128_i32<0>(value), offset);
}
void TraceContextLoadF64(void* raw_context, uint64_t offset,
const double* value) {
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
auto v = _mm_loadu_pd(value);
DPRINT("%le (%llX) = ctx f64 +%llu\n", xe::m128_f64<0>(v), xe::m128_i64<0>(v),
offset);
DPRINT("%le (%" PRIX64 ") = ctx f64 +%" PRIu64 "\n", xe::m128_f64<0>(v),
xe::m128_i64<0>(v), offset);
}
void TraceContextLoadV128(void* raw_context, uint64_t offset, __m128 value) {
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
DPRINT("[%e, %e, %e, %e] [%.8X, %.8X, %.8X, %.8X] = ctx v128 +%llu\n",
DPRINT("[%e, %e, %e, %e] [%.8X, %.8X, %.8X, %.8X] = ctx v128 +%" PRIu64 "\n",
xe::m128_f32<0>(value), xe::m128_f32<1>(value), xe::m128_f32<2>(value),
xe::m128_f32<3>(value), xe::m128_i32<0>(value), xe::m128_i32<1>(value),
xe::m128_i32<2>(value), xe::m128_i32<3>(value), offset);
@ -97,38 +100,40 @@ void TraceContextLoadV128(void* raw_context, uint64_t offset, __m128 value) {
void TraceContextStoreI8(void* raw_context, uint64_t offset, uint8_t value) {
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
DPRINT("ctx i8 +%llu = %d (%X)\n", offset, (int8_t)value, value);
DPRINT("ctx i8 +%" PRIu64 " = %d (%X)\n", offset, (int8_t)value, value);
}
void TraceContextStoreI16(void* raw_context, uint64_t offset, uint16_t value) {
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
DPRINT("ctx i16 +%llu = %d (%X)\n", offset, (int16_t)value, value);
DPRINT("ctx i16 +%" PRIu64 " = %d (%X)\n", offset, (int16_t)value, value);
}
void TraceContextStoreI32(void* raw_context, uint64_t offset, uint32_t value) {
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
DPRINT("ctx i32 +%llu = %d (%X)\n", offset, (int32_t)value, value);
DPRINT("ctx i32 +%" PRIu64 " = %d (%X)\n", offset, (int32_t)value, value);
}
void TraceContextStoreI64(void* raw_context, uint64_t offset, uint64_t value) {
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
DPRINT("ctx i64 +%llu = %lld (%llX)\n", offset, (int64_t)value, value);
DPRINT("ctx i64 +%" PRIu64 " = %" PRId64 " (%" PRIX64 ")\n", offset,
(int64_t)value, value);
}
void TraceContextStoreF32(void* raw_context, uint64_t offset, __m128 value) {
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
DPRINT("ctx f32 +%llu = %e (%X)\n", offset, xe::m128_f32<0>(value),
DPRINT("ctx f32 +%" PRIu64 " = %e (%X)\n", offset, xe::m128_f32<0>(value),
xe::m128_i32<0>(value));
}
void TraceContextStoreF64(void* raw_context, uint64_t offset,
const double* value) {
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
auto v = _mm_loadu_pd(value);
DPRINT("ctx f64 +%llu = %le (%llX)\n", offset, xe::m128_f64<0>(v),
xe::m128_i64<0>(v));
DPRINT("ctx f64 +%" PRIu64 " = %le (%" PRIX64 ")\n", offset,
xe::m128_f64<0>(v), xe::m128_i64<0>(v));
}
void TraceContextStoreV128(void* raw_context, uint64_t offset, __m128 value) {
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
DPRINT("ctx v128 +%llu = [%e, %e, %e, %e] [%.8X, %.8X, %.8X, %.8X]\n", offset,
xe::m128_f32<0>(value), xe::m128_f32<1>(value), xe::m128_f32<2>(value),
xe::m128_f32<3>(value), xe::m128_i32<0>(value), xe::m128_i32<1>(value),
xe::m128_i32<2>(value), xe::m128_i32<3>(value));
DPRINT("ctx v128 +%" PRIu64 " = [%e, %e, %e, %e] [%.8X, %.8X, %.8X, %.8X]\n",
offset, xe::m128_f32<0>(value), xe::m128_f32<1>(value),
xe::m128_f32<2>(value), xe::m128_f32<3>(value), xe::m128_i32<0>(value),
xe::m128_i32<1>(value), xe::m128_i32<2>(value),
xe::m128_i32<3>(value));
}
void TraceMemoryLoadI8(void* raw_context, uint32_t address, uint8_t value) {
@ -145,7 +150,8 @@ void TraceMemoryLoadI32(void* raw_context, uint32_t address, uint32_t value) {
}
void TraceMemoryLoadI64(void* raw_context, uint32_t address, uint64_t value) {
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
DPRINT("%lld (%llX) = load.i64 %.8X\n", (int64_t)value, value, address);
DPRINT("%" PRId64 " (%" PRIX64 ") = load.i64 %.8X\n", (int64_t)value, value,
address);
}
void TraceMemoryLoadF32(void* raw_context, uint32_t address, __m128 value) {
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
@ -154,7 +160,7 @@ void TraceMemoryLoadF32(void* raw_context, uint32_t address, __m128 value) {
}
void TraceMemoryLoadF64(void* raw_context, uint32_t address, __m128 value) {
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
DPRINT("%le (%llX) = load.f64 %.8X\n", xe::m128_f64<0>(value),
DPRINT("%le (%" PRIX64 ") = load.f64 %.8X\n", xe::m128_f64<0>(value),
xe::m128_i64<0>(value), address);
}
void TraceMemoryLoadV128(void* raw_context, uint32_t address, __m128 value) {
@ -179,7 +185,8 @@ void TraceMemoryStoreI32(void* raw_context, uint32_t address, uint32_t value) {
}
void TraceMemoryStoreI64(void* raw_context, uint32_t address, uint64_t value) {
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
DPRINT("store.i64 %.8X = %lld (%llX)\n", address, (int64_t)value, value);
DPRINT("store.i64 %.8X = %" PRId64 " (%" PRIX64 ")\n", address,
(int64_t)value, value);
}
void TraceMemoryStoreF32(void* raw_context, uint32_t address, __m128 value) {
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
@ -188,8 +195,8 @@ void TraceMemoryStoreF32(void* raw_context, uint32_t address, __m128 value) {
}
void TraceMemoryStoreF64(void* raw_context, uint32_t address, __m128 value) {
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
DPRINT("store.f64 %.8X = %le (%llX)\n", address, xe::m128_f64<0>(value),
xe::m128_i64<0>(value));
DPRINT("store.f64 %.8X = %le (%" PRIX64 ")\n", address,
xe::m128_f64<0>(value), xe::m128_i64<0>(value));
}
void TraceMemoryStoreV128(void* raw_context, uint32_t address, __m128 value) {
auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);

6
src/xenia/cpu/elf_module.cc
View File

@ -79,7 +79,7 @@ bool ElfModule::Load(const std::string& name, const std::string& path,
XELOGE(
"ELF: Could not load ELF because target machine is not PPC! (target: "
"%d)",
hdr->e_machine);
uint32_t(hdr->e_machine));
return false;
}
@ -108,8 +108,8 @@ bool ElfModule::Load(const std::string& name, const std::string& path,
// Allocate and copy into memory.
// Base address @ 0x80000000
uint32_t virtual_addr = phdr[i].p_vaddr < 0x80000000
? phdr[i].p_vaddr + 0x80000000
: phdr[i].p_vaddr;
? uint32_t(phdr[i].p_vaddr) + 0x80000000
: uint32_t(phdr[i].p_vaddr);
if (!memory()
->LookupHeap(virtual_addr)
->AllocFixed(

3
src/xenia/cpu/frontend/ppc_context.cc
View File

@ -9,6 +9,7 @@
#include "xenia/cpu/frontend/ppc_context.h"
#include <cinttypes>
#include <cstdlib>
namespace xe {
@ -64,7 +65,7 @@ bool PPCContext::CompareRegWithString(const char* name, const char* value,
if (sscanf(name, "r%d", &n) == 1) {
uint64_t expected = ParseInt64(value);
if (this->r[n] != expected) {
snprintf(out_value, out_value_size, "%016llX", this->r[n]);
snprintf(out_value, out_value_size, "%016" PRIX64, this->r[n]);
return false;
}
return true;

5
src/xenia/cpu/frontend/ppc_instr.cc
View File

@ -9,6 +9,7 @@
#include "xenia/cpu/frontend/ppc_instr.h"
#include <cinttypes>
#include <sstream>
#include <vector>
@ -98,9 +99,9 @@ void InstrOperand::Dump(std::string& out_str) {
break;
case 8:
if (imm.is_signed) {
snprintf(buffer, max_count, "%lld", (int64_t)imm.value);
snprintf(buffer, max_count, "%" PRId64, (int64_t)imm.value);
} else {
snprintf(buffer, max_count, "0x%.16llX", imm.value);
snprintf(buffer, max_count, "0x%.16" PRIX64, imm.value);
}
break;
}

3
src/xenia/cpu/hir/hir_builder.cc
View File

@ -9,6 +9,7 @@
#include "xenia/cpu/hir/hir_builder.h"
#include <cinttypes>
#include <cstdarg>
#include <cstring>
@ -118,7 +119,7 @@ void HIRBuilder::DumpValue(StringBuffer* str, Value* value) {
str->AppendFormat("%X", value->constant.i32);
break;
case INT64_TYPE:
str->AppendFormat("%llX", value->constant.i64);
str->AppendFormat("%" PRIX64, value->constant.i64);
break;
case FLOAT32_TYPE:
str->AppendFormat("%F", value->constant.f32);

16
src/xenia/cpu/hir/value.cc
View File

@ -322,11 +322,23 @@ void Value::MulHi(Value* other, bool is_unsigned) {
}
break;
case INT64_TYPE:
#if XE_COMPILER_MSVC
if (is_unsigned) {
constant.i64 = __umulh(constant.i64, other->constant.i64);
} else {
constant.i64 = __mulh(constant.i64, other->constant.i64);
}
#else
if (is_unsigned) {
constant.i64 = static_cast<uint64_t>(
static_cast<unsigned __int128>(constant.i64) *
static_cast<unsigned __int128>(other->constant.i64));
} else {
constant.i64 =
static_cast<uint64_t>(static_cast<__int128>(constant.i64) *
static_cast<__int128>(other->constant.i64));
}
#endif // XE_COMPILER_MSVC
break;
default:
assert_unhandled_case(type);
@ -440,7 +452,7 @@ void Value::Abs() {
break;
case VEC128_TYPE:
for (int i = 0; i < 4; ++i) {
constant.v128.f32[i] = std::fabsf(constant.v128.f32[i]);
constant.v128.f32[i] = std::abs(constant.v128.f32[i]);
}
break;
default:
@ -452,7 +464,7 @@ void Value::Abs() {
void Value::Sqrt() {
switch (type) {
case FLOAT32_TYPE:
constant.f32 = 1.0f / std::sqrtf(constant.f32);
constant.f32 = 1.0f / std::sqrt(constant.f32);
break;
case FLOAT64_TYPE:
constant.f64 = 1.0 / std::sqrt(constant.f64);

5
src/xenia/cpu/thread_state.cc
View File

@ -9,6 +9,7 @@
#include "xenia/cpu/thread_state.h"
#include <cstdlib>
#include <cstring>
#include "xenia/base/assert.h"
@ -85,7 +86,7 @@ ThreadState::ThreadState(Processor* processor, uint32_t thread_id,
// Allocate with 64b alignment.
context_ =
reinterpret_cast<PPCContext*>(_aligned_malloc(sizeof(PPCContext), 64));
reinterpret_cast<PPCContext*>(aligned_alloc(64, sizeof(PPCContext)));
assert_true(((uint64_t)context_ & 0x3F) == 0);
std::memset(context_, 0, sizeof(PPCContext));
@ -110,7 +111,7 @@ ThreadState::~ThreadState() {
thread_state_ = nullptr;
}
_aligned_free(context_);
free(context_);
if (stack_allocated_) {
memory()->LookupHeap(stack_address_)->Decommit(stack_address_, stack_size_);
}

1
src/xenia/gpu/register_file.h
View File

@ -11,6 +11,7 @@
#define XENIA_GPU_REGISTER_FILE_H_
#include <cstdint>
#include <cstdlib>
namespace xe {
namespace gpu {

1
src/xenia/gpu/sampler_info.cc
View File

@ -9,6 +9,7 @@
#include "xenia/gpu/sampler_info.h"
#include <cstring>
#include <memory>
#include "third_party/xxhash/xxhash.h"

8
src/xenia/gpu/texture_info.cc
View File

@ -187,8 +187,8 @@ void TextureInfo::CalculateTextureSizes2D(const xe_gpu_texture_fetch_t& fetch) {
format_info->block_height;
// Tiles are 32x32 blocks. All textures must be multiples of tile dimensions.
uint32_t tile_width = uint32_t(std::ceilf(block_width / 32.0f));
uint32_t tile_height = uint32_t(std::ceilf(block_height / 32.0f));
uint32_t tile_width = uint32_t(std::ceil(block_width / 32.0f));
uint32_t tile_height = uint32_t(std::ceil(block_height / 32.0f));
size_2d.block_width = tile_width * 32;
size_2d.block_height = tile_height * 32;
@ -229,8 +229,8 @@ void TextureInfo::CalculateTextureSizesCube(
format_info->block_height;
// Tiles are 32x32 blocks. All textures must be multiples of tile dimensions.
uint32_t tile_width = uint32_t(std::ceilf(block_width / 32.0f));
uint32_t tile_height = uint32_t(std::ceilf(block_height / 32.0f));
uint32_t tile_width = uint32_t(std::ceil(block_width / 32.0f));
uint32_t tile_height = uint32_t(std::ceil(block_height / 32.0f));
size_cube.block_width = tile_width * 32;
size_cube.block_height = tile_height * 32;

1
src/xenia/gpu/texture_info.h
View File

@ -10,6 +10,7 @@
#ifndef XENIA_GPU_TEXTURE_INFO_H_
#define XENIA_GPU_TEXTURE_INFO_H_
#include <cstring>
#include <memory>
#include "xenia/base/assert.h"

12
src/xenia/kernel/objects/xmodule.h
View File

@ -44,15 +44,9 @@ struct X_LDR_DATA_TABLE_ENTRY {
xe::be<uint32_t> time_date_stamp; // 0x50
xe::be<uint32_t> loaded_imports; // 0x54
xe::be<uint32_t> xex_header_base; // 0x58
union {
X_ANSI_STRING load_file_name; // 0x5C
struct {
xe::be<uint32_t> closure_root; // 0x5C
xe::be<uint32_t> traversal_parent; // 0x60
};
};
// X_ANSI_STRING load_file_name; // 0x5C
xe::be<uint32_t> closure_root; // 0x5C
xe::be<uint32_t> traversal_parent; // 0x60
};
class XModule : public XObject {

2
src/xenia/kernel/objects/xthread.h
View File

@ -189,7 +189,7 @@ class XThread : public XObject {
int32_t priority_ = 0;
uint32_t affinity_ = 0;
std::atomic<uint32_t> irql_ = 0;
std::atomic<uint32_t> irql_ = {0};
xe::mutex apc_lock_;
NativeList* apc_list_ = nullptr;
};

2
src/xenia/kernel/util/xex2_info.h
View File

@ -405,7 +405,7 @@ struct xe_xex2_loader_info_t {
xe_xex2_media_flags media_flags;
};
enum xe_xex2_section_type : uint32_t {
enum xe_xex2_section_type {
XEX_SECTION_CODE = 1,
XEX_SECTION_DATA = 2,
XEX_SECTION_READONLY_DATA = 3,

29
src/xenia/kernel/xobject.h
View File

@ -12,6 +12,7 @@
#include <algorithm>
#include <atomic>
#include <cstddef>
#include <string>
#include "xenia/base/threading.h"
@ -162,10 +163,7 @@ class XObject {
int32_t as_type = -1);
template <typename T>
static object_ref<T> GetNativeObject(KernelState* kernel_state,
void* native_ptr, int32_t as_type = -1) {
return object_ref<T>(reinterpret_cast<T*>(
GetNativeObject(kernel_state, native_ptr, as_type).release()));
}
void* native_ptr, int32_t as_type = -1);
virtual xe::threading::WaitHandle* GetWaitHandle() { return nullptr; }
@ -208,9 +206,9 @@ template <typename T>
class object_ref {
public:
object_ref() noexcept : value_(nullptr) {}
object_ref(nullptr_t) noexcept // NOLINT(runtime/explicit)
object_ref(std::nullptr_t) noexcept // NOLINT(runtime/explicit)
: value_(nullptr) {}
object_ref& operator=(nullptr_t) noexcept {
object_ref& operator=(std::nullptr_t) noexcept {
reset();
return (*this);
}
@ -250,9 +248,7 @@ class object_ref {
return (*this);
}
void swap(object_ref& right) noexcept {
std::_Swap_adl(value_, right.value_);
}
void swap(object_ref& right) noexcept { std::swap(value_, right.value_); }
~object_ref() noexcept {
if (value_) {
@ -298,22 +294,22 @@ class object_ref {
};
template <class _Ty>
bool operator==(const object_ref<_Ty>& _Left, nullptr_t) noexcept {
bool operator==(const object_ref<_Ty>& _Left, std::nullptr_t) noexcept {
return (_Left.get() == reinterpret_cast<_Ty*>(0));
}
template <class _Ty>
bool operator==(nullptr_t, const object_ref<_Ty>& _Right) noexcept {
bool operator==(std::nullptr_t, const object_ref<_Ty>& _Right) noexcept {
return (reinterpret_cast<_Ty*>(0) == _Right.get());
}
template <class _Ty>
bool operator!=(const object_ref<_Ty>& _Left, nullptr_t _Right) noexcept {
bool operator!=(const object_ref<_Ty>& _Left, std::nullptr_t _Right) noexcept {
return (!(_Left == _Right));
}
template <class _Ty>
bool operator!=(nullptr_t _Left, const object_ref<_Ty>& _Right) noexcept {
bool operator!=(std::nullptr_t _Left, const object_ref<_Ty>& _Right) noexcept {
return (!(_Left == _Right));
}
@ -323,6 +319,13 @@ object_ref<T> retain_object(T* ptr) {
return object_ref<T>(ptr);
}
template <typename T>
object_ref<T> XObject::GetNativeObject(KernelState* kernel_state,
void* native_ptr, int32_t as_type) {
return object_ref<T>(reinterpret_cast<T*>(
GetNativeObject(kernel_state, native_ptr, as_type).release()));
}
} // namespace kernel
} // namespace xe

10
src/xenia/profiling.cc
View File

@ -24,16 +24,16 @@
#define MICROPROFILE_USE_THREAD_NAME_CALLBACK 1
#define MICROPROFILE_WEBSERVER_MAXFRAMES 3
#define MICROPROFILE_PRINTF XELOGI
#define MICROPROFILE_WEBSERVER 1
#define MICROPROFILE_WEBSERVER 0
#define MICROPROFILE_DEBUG 0
#if MICROPROFILE_WEBSERVER
#include <winsock.h> // NOLINT(build/include_order)
#endif // MICROPROFILE_WEBSERVER
#include "third_party/microprofile/microprofile.h"
#include "third_party/microprofile/microprofileui.h"
#include "xenia/profiling.h"
#if XE_OPTION_PROFILING
#include "third_party/microprofile/microprofileui.h"
#endif // XE_OPTION_PROFILING
DEFINE_bool(show_profiler, false, "Show profiling UI by default.");
namespace xe {

6
src/xenia/profiling.h
View File

@ -14,9 +14,11 @@
#include "xenia/base/string.h"
#define XE_OPTION_PROFILING 1
#if XE_PLATFORM_WIN32
#define XE_OPTION_PROFILING 1
#define XE_OPTION_PROFILING_UI 1
#else
#define XE_OPTION_PROFILING 0
#endif // XE_PLATFORM_WIN32
#if XE_OPTION_PROFILING
@ -115,8 +117,10 @@ namespace xe {
do { \
} while (false)
#ifndef MICROPROFILE_TEXT_WIDTH
#define MICROPROFILE_TEXT_WIDTH 1
#define MICROPROFILE_TEXT_HEIGHT 1
#endif // !MICROPROFILE_TEXT_WIDTH
#endif // XE_OPTION_PROFILING

1
src/xenia/ui/gl/gl4_elemental_renderer.cc
View File

@ -9,6 +9,7 @@
#include "xenia/ui/gl/gl4_elemental_renderer.h"
#include <cstring>
#include <memory>
#include <string>

1
src/xenia/ui/gl/gl_profiler_display.cc
View File

@ -12,6 +12,7 @@
#include <algorithm>
#include <string>
#include "third_party/microprofile/microprofile.h"
#include "third_party/microprofile/microprofileui.h"
#include "xenia/base/assert.h"

3
src/xenia/vfs/devices/stfs_container_device.cc
View File

@ -198,7 +198,8 @@ StfsContainerDevice::Error StfsContainerDevice::ReadAllEntries(
size_t remaining_size = file_size;
uint32_t info = 0x80;
while (remaining_size && block_index && info >= 0x80) {
size_t block_size = std::min(0x1000ull, remaining_size);
size_t block_size =
std::min(static_cast<size_t>(0x1000), remaining_size);
size_t offset = BlockToOffset(ComputeBlockNumber(block_index));
entry->block_list_.push_back({offset, block_size});
remaining_size -= block_size;

3
third_party/GL/glew.c vendored
View File

@ -10116,7 +10116,8 @@ GLenum GLEWAPIENTRY glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST)
}
/* query opengl extensions string */
extStart = glewExperimental ? "" : glGetString(GL_EXTENSIONS);
extStart = glewExperimental ? (const GLubyte*)""
: (const GLubyte*)glGetString(GL_EXTENSIONS);
if (extStart == 0)
extStart = (const GLubyte*)"";
extEnd = extStart + _glewStrLen(extStart);

9
third_party/capstone.lua vendored
View File

@ -41,3 +41,12 @@ project("capstone")
"capstone/arch/X86/*.inc",
})
force_compile_as_cc({"capstone/**.c"})
filter("platforms:Linux")
-- Capstone code is... not fantastic.
buildoptions({
"-Wno-error=write-strings",
"-Wno-write-string",
"-Wno-deprecated",
"-w",
})

2
third_party/elemental-forms vendored

@ -1 +1 @@
Subproject commit 4fdbd5fe789da92fd5e23240c63ed5aa2cba5ed2
Subproject commit 0b0d51fa4afcf00f67770cf52fc4db7abb6a8cbb

12
xenia-build
View File

@ -476,11 +476,15 @@ class BaseBuildCommand(Command):
self.parser.add_argument(
'--force', action='store_true',
help='Forces a full rebuild.')
self.parser.add_argument(
'--no-premake', action='store_true',
help='Skips running premake before building.')
def execute(self, args, pass_args, cwd):
print('- running premake...')
run_platform_premake()
print('')
if not args['no_premake']:
print('- running premake...')
run_platform_premake()
print('')
print('- building (%s):%s...' % (
'all' if not len(args['target']) else ' '.join(args['target']),
@ -500,7 +504,7 @@ class BaseBuildCommand(Command):
else:
# TODO(benvanik): allow gcc?
os.environ['CXX'] = 'clang++-3.8'
os.environ['CC'] = 'clang-3.8'
os.environ['CC'] = 'clang++-3.8'
result = shell_call([
'make',
'-Cbuild/',