From cecf83b7b754bc48dee63722cb11feb5eb3d9457 Mon Sep 17 00:00:00 2001 From: Ben Vanik Date: Wed, 20 Aug 2014 22:22:47 -0700 Subject: [PATCH] Removing xenia/malloc.* Using standard memory functions now. --- src/alloy/arena.cc | 8 +- src/alloy/backend/ivm/ivm_function.cc | 8 +- src/alloy/backend/ivm/ivm_stack.cc | 4 +- src/alloy/backend/x64/x64_assembler.cc | 3 +- src/alloy/backend/x64/x64_code_cache_posix.cc | 2 +- .../passes/register_allocation_pass.cc | 2 +- src/alloy/core.h | 1 - src/alloy/frontend/ppc/ppc_hir_builder.cc | 6 +- src/alloy/frontend/ppc/ppc_instr_tables.h | 4 +- src/alloy/hir/hir_builder.cc | 2 +- src/alloy/runtime/debug_info.cc | 10 +- src/xenia/common.h | 1 - src/xenia/core/ref.cc | 11 +- src/xenia/core/socket_posix.cc | 65 ++++--- src/xenia/cpu/xenon_thread_state.cc | 5 +- src/xenia/gpu/register_file.cc | 9 +- src/xenia/gpu/shader_resource.cc | 163 +++++++++--------- .../kernel/fs/devices/disc_image_file.cc | 5 +- .../kernel/fs/devices/stfs_container_file.cc | 2 +- src/xenia/kernel/fs/gdfx.cc | 11 +- src/xenia/kernel/fs/stfs.cc | 16 +- src/xenia/kernel/object_table.cc | 16 +- src/xenia/kernel/objects/xfile.h | 9 +- src/xenia/kernel/objects/xuser_module.cc | 7 +- src/xenia/kernel/util/xex2.cc | 125 ++++++-------- src/xenia/kernel/xboxkrnl_io.cc | 42 ++--- src/xenia/kernel/xboxkrnl_memory.cc | 2 +- src/xenia/kernel/xboxkrnl_module.cc | 4 +- src/xenia/kernel/xboxkrnl_strings.cc | 8 +- src/xenia/kernel/xboxkrnl_video.cc | 10 +- src/xenia/malloc.cc | 137 --------------- src/xenia/malloc.h | 36 ---- src/xenia/memory.cc | 4 +- src/xenia/sources.gypi | 2 - src/xenia/xbox.h | 2 +- tools/alloy-sandbox/alloy-sandbox.cc | 5 +- 36 files changed, 266 insertions(+), 481 deletions(-) delete mode 100644 src/xenia/malloc.cc delete mode 100644 src/xenia/malloc.h diff --git a/src/alloy/arena.cc b/src/alloy/arena.cc index 66632e57d..081467e72 100644 --- a/src/alloy/arena.cc +++ b/src/alloy/arena.cc @@ -73,11 +73,11 @@ void* Arena::CloneContents() { } chunk = chunk->next; } - void* result = xe_malloc(total_length); + void* result = malloc(total_length); uint8_t* p = (uint8_t*)result; chunk = head_chunk_; while (chunk) { - xe_copy_struct(p, chunk->buffer, chunk->offset); + memcpy(p, chunk->buffer, chunk->offset); p += chunk->offset; if (chunk == active_chunk_) { break; @@ -89,12 +89,12 @@ void* Arena::CloneContents() { Arena::Chunk::Chunk(size_t chunk_size) : next(nullptr), capacity(chunk_size), buffer(0), offset(0) { - buffer = (uint8_t*)xe_malloc(capacity); + buffer = reinterpret_cast(malloc(capacity)); } Arena::Chunk::~Chunk() { if (buffer) { - xe_free(buffer); + free(buffer); } } diff --git a/src/alloy/backend/ivm/ivm_function.cc b/src/alloy/backend/ivm/ivm_function.cc index 2dba04264..aab30ce7b 100644 --- a/src/alloy/backend/ivm/ivm_function.cc +++ b/src/alloy/backend/ivm/ivm_function.cc @@ -25,13 +25,13 @@ IVMFunction::IVMFunction(FunctionInfo* symbol_info) : Function(symbol_info), register_count_(0), intcode_count_(0), - intcodes_(0), + intcodes_(nullptr), source_map_count_(0), - source_map_(0) {} + source_map_(nullptr) {} IVMFunction::~IVMFunction() { - xe_free(intcodes_); - xe_free(source_map_); + free(intcodes_); + free(source_map_); } void IVMFunction::Setup(TranslationContext& ctx) { diff --git a/src/alloy/backend/ivm/ivm_stack.cc b/src/alloy/backend/ivm/ivm_stack.cc index 5177ed351..1e80e4073 100644 --- a/src/alloy/backend/ivm/ivm_stack.cc +++ b/src/alloy/backend/ivm/ivm_stack.cc @@ -65,12 +65,12 @@ void IVMStack::Free(size_t register_count) { IVMStack::Chunk::Chunk(size_t chunk_size) : prev(NULL), next(NULL), capacity(chunk_size), buffer(0), offset(0) { - buffer = (uint8_t*)xe_malloc(capacity); + buffer = reinterpret_cast(malloc(capacity)); } IVMStack::Chunk::~Chunk() { if (buffer) { - xe_free(buffer); + free(buffer); } } diff --git a/src/alloy/backend/x64/x64_assembler.cc b/src/alloy/backend/x64/x64_assembler.cc index 34b8928b2..2b4075df2 100644 --- a/src/alloy/backend/x64/x64_assembler.cc +++ b/src/alloy/backend/x64/x64_assembler.cc @@ -93,8 +93,7 @@ int X64Assembler::Assemble(FunctionInfo* symbol_info, HIRBuilder* builder, void X64Assembler::DumpMachineCode(DebugInfo* debug_info, void* machine_code, size_t code_size, StringBuffer* str) { - BE::DISASM disasm; - xe_zero_struct(&disasm, sizeof(disasm)); + BE::DISASM disasm = {0}; disasm.Archi = 64; disasm.Options = BE::Tabulation + BE::MasmSyntax + BE::PrefixedNumeral; disasm.EIP = (BE::UIntPtr)machine_code; diff --git a/src/alloy/backend/x64/x64_code_cache_posix.cc b/src/alloy/backend/x64/x64_code_cache_posix.cc index 63a44e709..0fa023ab5 100644 --- a/src/alloy/backend/x64/x64_code_cache_posix.cc +++ b/src/alloy/backend/x64/x64_code_cache_posix.cc @@ -76,7 +76,7 @@ void* X64CodeCache::PlaceCode(void* machine_code, size_t code_size, lock_.unlock(); // Copy code. - xe_copy_struct(final_address, machine_code, code_size); + memcpy(final_address, machine_code, code_size); return final_address; } diff --git a/src/alloy/compiler/passes/register_allocation_pass.cc b/src/alloy/compiler/passes/register_allocation_pass.cc index cdfe910ad..2e4f6fc21 100644 --- a/src/alloy/compiler/passes/register_allocation_pass.cc +++ b/src/alloy/compiler/passes/register_allocation_pass.cc @@ -33,7 +33,7 @@ RegisterAllocationPass::RegisterAllocationPass(const MachineInfo* machine_info) // Initialize register sets. // TODO(benvanik): rewrite in a way that makes sense - this is terrible. auto mi_sets = machine_info->register_sets; - xe_zero_struct(&usage_sets_, sizeof(usage_sets_)); + memset(&usage_sets_, 0, sizeof(usage_sets_)); uint32_t n = 0; while (mi_sets[n].count) { auto& mi_set = mi_sets[n]; diff --git a/src/alloy/core.h b/src/alloy/core.h index e8a2c6637..08c6e2645 100644 --- a/src/alloy/core.h +++ b/src/alloy/core.h @@ -12,7 +12,6 @@ // TODO(benvanik): move the common stuff into here? #include -#include #include #endif // ALLOY_CORE_H_ diff --git a/src/alloy/frontend/ppc/ppc_hir_builder.cc b/src/alloy/frontend/ppc/ppc_hir_builder.cc index 627c4cac8..9078bfa3f 100644 --- a/src/alloy/frontend/ppc/ppc_hir_builder.cc +++ b/src/alloy/frontend/ppc/ppc_hir_builder.cc @@ -69,8 +69,8 @@ int PPCHIRBuilder::Emit(FunctionInfo* symbol_info, uint32_t flags) { size_t list_size = instr_count_ * sizeof(void*); instr_offset_list_ = (Instr**)arena_->Alloc(list_size); label_list_ = (Label**)arena_->Alloc(list_size); - xe_zero_struct(instr_offset_list_, list_size); - xe_zero_struct(label_list_, list_size); + memset(instr_offset_list_, 0, list_size); + memset(label_list_, 0, list_size); // Always mark entry with label. label_list_[0] = NewLabel(); @@ -171,7 +171,7 @@ void PPCHIRBuilder::AnnotateLabel(uint64_t address, Label* label) { snprintf(name_buffer, poly::countof(name_buffer), "loc_%.8X", (uint32_t)address); label->name = (char*)arena_->Alloc(sizeof(name_buffer)); - xe_copy_struct(label->name, name_buffer, sizeof(name_buffer)); + memcpy(label->name, name_buffer, sizeof(name_buffer)); } FunctionInfo* PPCHIRBuilder::LookupFunction(uint64_t address) { diff --git a/src/alloy/frontend/ppc/ppc_instr_tables.h b/src/alloy/frontend/ppc/ppc_instr_tables.h index ccab23c49..bab5e48f1 100644 --- a/src/alloy/frontend/ppc/ppc_instr_tables.h +++ b/src/alloy/frontend/ppc/ppc_instr_tables.h @@ -95,7 +95,7 @@ namespace tables { static InstrType** instr_table_prep(InstrType* unprep, size_t unprep_count, int a, int b) { int prep_count = (int)pow(2.0, b - a + 1); - InstrType** prep = (InstrType**)xe_calloc(prep_count * sizeof(void*)); + InstrType** prep = (InstrType**)calloc(prep_count, sizeof(void*)); for (int n = 0; n < unprep_count; n++) { int ordinal = select_bits(unprep[n].opcode, a, b); prep[ordinal] = &unprep[n]; @@ -107,7 +107,7 @@ static InstrType** instr_table_prep_63(InstrType* unprep, size_t unprep_count, int a, int b) { // Special handling for A format instructions. int prep_count = (int)pow(2.0, b - a + 1); - InstrType** prep = (InstrType**)xe_calloc(prep_count * sizeof(void*)); + InstrType** prep = (InstrType**)calloc(prep_count, sizeof(void*)); for (int n = 0; n < unprep_count; n++) { int ordinal = select_bits(unprep[n].opcode, a, b); if (unprep[n].format == kXEPPCInstrFormatA) { diff --git a/src/alloy/hir/hir_builder.cc b/src/alloy/hir/hir_builder.cc index 2a0bec6f3..72871413f 100644 --- a/src/alloy/hir/hir_builder.cc +++ b/src/alloy/hir/hir_builder.cc @@ -632,7 +632,7 @@ void HIRBuilder::Comment(const char* format, ...) { return; } void* p = arena_->Alloc(len + 1); - xe_copy_struct(p, buffer, len + 1); + memcpy(p, buffer, len + 1); Instr* i = AppendInstr(OPCODE_COMMENT_info, 0); i->src1.offset = (uint64_t)p; i->src2.value = i->src3.value = NULL; diff --git a/src/alloy/runtime/debug_info.cc b/src/alloy/runtime/debug_info.cc index 64022868c..0eac0b795 100644 --- a/src/alloy/runtime/debug_info.cc +++ b/src/alloy/runtime/debug_info.cc @@ -21,11 +21,11 @@ DebugInfo::DebugInfo() source_map_(nullptr) {} DebugInfo::~DebugInfo() { - xe_free(source_map_); - xe_free(source_disasm_); - xe_free(raw_hir_disasm_); - xe_free(hir_disasm_); - xe_free(machine_code_disasm_); + free(source_map_); + free(source_disasm_); + free(raw_hir_disasm_); + free(hir_disasm_); + free(machine_code_disasm_); } void DebugInfo::InitializeSourceMap(size_t source_map_count, diff --git a/src/xenia/common.h b/src/xenia/common.h index 3b911ea0f..821b83cc7 100644 --- a/src/xenia/common.h +++ b/src/xenia/common.h @@ -17,7 +17,6 @@ #include #include -#include #include #include diff --git a/src/xenia/core/ref.cc b/src/xenia/core/ref.cc index c09c613eb..de0347ca5 100644 --- a/src/xenia/core/ref.cc +++ b/src/xenia/core/ref.cc @@ -9,14 +9,9 @@ #include +void xe_ref_init(xe_ref_t* ref) { ref->count = 1; } -void xe_ref_init(xe_ref_t* ref) { - ref->count = 1; -} - -void xe_ref_retain(xe_ref_t* ref) { - poly::atomic_inc(&ref->count); -} +void xe_ref_retain(xe_ref_t* ref) { poly::atomic_inc(&ref->count); } void xe_ref_release(xe_ref_t* ref, xe_ref_dealloc_t dealloc) { if (!ref) { @@ -26,6 +21,6 @@ void xe_ref_release(xe_ref_t* ref, xe_ref_dealloc_t dealloc) { if (dealloc) { dealloc(ref); } - xe_free(ref); + free(ref); } } diff --git a/src/xenia/core/socket_posix.cc b/src/xenia/core/socket_posix.cc index 1d9acbf5d..5b815e1c2 100644 --- a/src/xenia/core/socket_posix.cc +++ b/src/xenia/core/socket_posix.cc @@ -15,7 +15,6 @@ #include #include - void xe_socket_init() { // No-op. } @@ -35,31 +34,30 @@ void xe_socket_close(socket_t socket) { void xe_socket_set_keepalive(socket_t socket, bool value) { int opt_value = value ? 1 : 0; - setsockopt(socket, SOL_SOCKET, SO_KEEPALIVE, - &opt_value, sizeof(opt_value)); + setsockopt(socket, SOL_SOCKET, SO_KEEPALIVE, &opt_value, sizeof(opt_value)); } void xe_socket_set_reuseaddr(socket_t socket, bool value) { int opt_value = value ? 1 : 0; - setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, - &opt_value, sizeof(opt_value)); + setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, &opt_value, sizeof(opt_value)); } void xe_socket_set_nodelay(socket_t socket, bool value) { int opt_value = value ? 1 : 0; - setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, - &opt_value, sizeof(opt_value)); + setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, &opt_value, sizeof(opt_value)); } void xe_socket_set_nonblock(socket_t socket, bool value) { int flags; - while ((flags = fcntl(socket, F_GETFL, 0)) == -1 && errno == EINTR); + while ((flags = fcntl(socket, F_GETFL, 0)) == -1 && errno == EINTR) + ; if (flags == -1) { return; } int r; while ((r = fcntl(socket, F_SETFL, flags | O_NONBLOCK)) == -1 && - errno == EINTR); + errno == EINTR) + ; if (r == -1) { return; } @@ -67,9 +65,9 @@ void xe_socket_set_nonblock(socket_t socket, bool value) { int xe_socket_bind(socket_t socket, uint32_t port) { struct sockaddr_in socket_addr; - socket_addr.sin_family = AF_INET; + socket_addr.sin_family = AF_INET; socket_addr.sin_addr.s_addr = htonl(INADDR_ANY); - socket_addr.sin_port = htons(port); + socket_addr.sin_port = htons(port); int r = bind(socket, (struct sockaddr*)&socket_addr, sizeof(socket_addr)); if (r < 0) { return 1; @@ -79,9 +77,9 @@ int xe_socket_bind(socket_t socket, uint32_t port) { int xe_socket_bind_loopback(socket_t socket) { struct sockaddr_in socket_addr; - socket_addr.sin_family = AF_INET; + socket_addr.sin_family = AF_INET; socket_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); - socket_addr.sin_port = htons(0); + socket_addr.sin_port = htons(0); int r = bind(socket, (struct sockaddr*)&socket_addr, sizeof(socket_addr)); if (r == SOCKET_ERROR) { return 1; @@ -100,8 +98,8 @@ int xe_socket_listen(socket_t socket) { int xe_socket_accept(socket_t socket, xe_socket_connection_t* out_client_info) { struct sockaddr_in client_addr; socklen_t client_count = sizeof(client_addr); - socket_t client_socket_id = accept( - socket, (struct sockaddr*)&client_addr, &client_count); + socket_t client_socket_id = + accept(socket, (struct sockaddr*)&client_addr, &client_count); if (client_socket_id < 0) { return 1; } @@ -109,8 +107,8 @@ int xe_socket_accept(socket_t socket, xe_socket_connection_t* out_client_info) { out_client_info->socket = client_socket_id; int client_ip = client_addr.sin_addr.s_addr; - inet_ntop(AF_INET, &client_ip, - out_client_info->addr, XECOUNT(out_client_info->addr)); + inet_ntop(AF_INET, &client_ip, out_client_info->addr, + XECOUNT(out_client_info->addr)); return 0; } @@ -130,21 +128,21 @@ int64_t xe_socket_recv(socket_t socket, uint8_t* data, size_t length, int flags, } struct xe_socket_loop { - socket_t socket; + socket_t socket; - int notify_rd_id; - int notify_wr_id; + int notify_rd_id; + int notify_wr_id; struct pollfd events[2]; - bool pending_queued_write; - bool pending_recv; - bool pending_send; + bool pending_queued_write; + bool pending_recv; + bool pending_send; }; xe_socket_loop_t* xe_socket_loop_create(socket_t socket) { - xe_socket_loop_t* loop = (xe_socket_loop_t*)xe_calloc( - sizeof(xe_socket_loop_t)); + xe_socket_loop_t* loop = + (xe_socket_loop_t*)calloc(1, sizeof(xe_socket_loop_t)); loop->socket = socket; @@ -153,10 +151,10 @@ xe_socket_loop_t* xe_socket_loop_create(socket_t socket) { loop->notify_rd_id = notify_ids[0]; loop->notify_wr_id = notify_ids[1]; - loop->events[0].fd = socket; - loop->events[0].events = POLLIN; - loop->events[1].fd = loop->notify_rd_id; - loop->events[1].events = POLLIN; + loop->events[0].fd = socket; + loop->events[0].events = POLLIN; + loop->events[1].fd = loop->notify_rd_id; + loop->events[1].events = POLLIN; return loop; } @@ -164,11 +162,11 @@ xe_socket_loop_t* xe_socket_loop_create(socket_t socket) { void xe_socket_loop_destroy(xe_socket_loop_t* loop) { close(loop->notify_rd_id); close(loop->notify_wr_id); - xe_free(loop); + free(loop); } -int xe_socket_loop_poll(xe_socket_loop_t* loop, - bool check_read, bool check_write) { +int xe_socket_loop_poll(xe_socket_loop_t* loop, bool check_read, + bool check_write) { // Prep events object. if (check_read) { loop->events[0].events |= POLLIN; @@ -180,7 +178,8 @@ int xe_socket_loop_poll(xe_socket_loop_t* loop, // Poll. int r; while ((r = poll(loop->events, XECOUNT(loop->events), -1)) == -1 && - errno == EINTR); + errno == EINTR) + ; if (r == -1) { return 1; } diff --git a/src/xenia/cpu/xenon_thread_state.cc b/src/xenia/cpu/xenon_thread_state.cc index e2abd64a1..0cdf90b38 100644 --- a/src/xenia/cpu/xenon_thread_state.cc +++ b/src/xenia/cpu/xenon_thread_state.cc @@ -28,9 +28,8 @@ XenonThreadState::XenonThreadState(XenonRuntime* runtime, uint32_t thread_id, assert_not_zero(stack_address_); // Allocate with 64b alignment. - context_ = (PPCContext*)xe_malloc_aligned(sizeof(PPCContext)); + context_ = (PPCContext*)calloc(1, sizeof(PPCContext)); assert_true(((uint64_t)context_ & 0xF) == 0); - xe_zero_struct(context_, sizeof(PPCContext)); // Stash pointers to common structures that callbacks may need. context_->reserve_address = memory_->reserve_address(); @@ -55,7 +54,7 @@ XenonThreadState::XenonThreadState(XenonRuntime* runtime, uint32_t thread_id, XenonThreadState::~XenonThreadState() { runtime_->debugger()->OnThreadDestroyed(this); - xe_free_aligned(context_); + free(context_); xenon_memory()->HeapFree(stack_address_, stack_size_); } diff --git a/src/xenia/gpu/register_file.cc b/src/xenia/gpu/register_file.cc index 288881d58..a2eec25fe 100644 --- a/src/xenia/gpu/register_file.cc +++ b/src/xenia/gpu/register_file.cc @@ -9,19 +9,16 @@ #include - using namespace xe; using namespace xe::gpu; - -RegisterFile::RegisterFile() { - xe_zero_struct(values, sizeof(values)); -} +RegisterFile::RegisterFile() { memset(values, 0, sizeof(values)); } const char* RegisterFile::GetRegisterName(uint32_t index) { switch (index) { #define XE_GPU_REGISTER(index, type, name) \ - case index: return #name; + case index: \ + return #name; #include #undef XE_GPU_REGISTER default: diff --git a/src/xenia/gpu/shader_resource.cc b/src/xenia/gpu/shader_resource.cc index 42986bf74..0d7447168 100644 --- a/src/xenia/gpu/shader_resource.cc +++ b/src/xenia/gpu/shader_resource.cc @@ -12,21 +12,21 @@ #include #include - using namespace std; using namespace xe; using namespace xe::gpu; using namespace xe::gpu::xenos; - ShaderResource::ShaderResource(const MemoryRange& memory_range, - const Info& info, - xenos::XE_GPU_SHADER_TYPE type) + const Info& info, xenos::XE_GPU_SHADER_TYPE type) : HashedResource(memory_range), - info_(info), type_(type), is_prepared_(false), disasm_src_(nullptr) { - xe_zero_struct(&alloc_counts_, sizeof(alloc_counts_)); - xe_zero_struct(&buffer_inputs_, sizeof(buffer_inputs_)); - xe_zero_struct(&sampler_inputs_, sizeof(sampler_inputs_)); + info_(info), + type_(type), + is_prepared_(false), + disasm_src_(nullptr) { + memset(&alloc_counts_, 0, sizeof(alloc_counts_)); + memset(&buffer_inputs_, 0, sizeof(buffer_inputs_)); + memset(&sampler_inputs_, 0, sizeof(sampler_inputs_)); // Verify. dword_count_ = memory_range.length / 4; @@ -34,7 +34,7 @@ ShaderResource::ShaderResource(const MemoryRange& memory_range, // Copy bytes and swap. size_t byte_size = dword_count_ * sizeof(uint32_t); - dwords_ = (uint32_t*)xe_malloc(byte_size); + dwords_ = (uint32_t*)malloc(byte_size); for (uint32_t n = 0; n < dword_count_; n++) { dwords_[n] = poly::load_and_swap(memory_range.host_base + n * 4); } @@ -47,8 +47,8 @@ ShaderResource::ShaderResource(const MemoryRange& memory_range, } ShaderResource::~ShaderResource() { - xe_free(disasm_src_); - xe_free(dwords_); + free(disasm_src_); + free(dwords_); } void ShaderResource::GatherIO() { @@ -83,18 +83,18 @@ void ShaderResource::GatherAlloc(const instr_cf_alloc_t* cf) { allocs_.push_back(*cf); switch (cf->buffer_select) { - case SQ_POSITION: - // Position (SV_POSITION). - alloc_counts_.positions += cf->size + 1; - break; - case SQ_PARAMETER_PIXEL: - // Output to PS (if VS), or frag output (if PS). - alloc_counts_.params += cf->size + 1; - break; - case SQ_MEMORY: - // MEMEXPORT? - alloc_counts_.memories += cf->size + 1; - break; + case SQ_POSITION: + // Position (SV_POSITION). + alloc_counts_.positions += cf->size + 1; + break; + case SQ_PARAMETER_PIXEL: + // Output to PS (if VS), or frag output (if PS). + alloc_counts_.params += cf->size + 1; + break; + case SQ_MEMORY: + // MEMEXPORT? + alloc_counts_.memories += cf->size + 1; + break; } } @@ -109,27 +109,26 @@ void ShaderResource::GatherExec(const instr_cf_exec_t* cf) { const instr_fetch_t* fetch = (const instr_fetch_t*)(dwords_ + alu_off * 3); switch (fetch->opc) { - case VTX_FETCH: - GatherVertexFetch(&fetch->vtx); - break; - case TEX_FETCH: - GatherTextureFetch(&fetch->tex); - break; - case TEX_GET_BORDER_COLOR_FRAC: - case TEX_GET_COMP_TEX_LOD: - case TEX_GET_GRADIENTS: - case TEX_GET_WEIGHTS: - case TEX_SET_TEX_LOD: - case TEX_SET_GRADIENTS_H: - case TEX_SET_GRADIENTS_V: - default: - assert_always(); - break; + case VTX_FETCH: + GatherVertexFetch(&fetch->vtx); + break; + case TEX_FETCH: + GatherTextureFetch(&fetch->tex); + break; + case TEX_GET_BORDER_COLOR_FRAC: + case TEX_GET_COMP_TEX_LOD: + case TEX_GET_GRADIENTS: + case TEX_GET_WEIGHTS: + case TEX_SET_TEX_LOD: + case TEX_SET_GRADIENTS_H: + case TEX_SET_GRADIENTS_V: + default: + assert_always(); + break; } } else { // TODO(benvanik): gather registers used, predicate bits used, etc. - const instr_alu_t* alu = - (const instr_alu_t*)(dwords_ + alu_off * 3); + const instr_alu_t* alu = (const instr_alu_t*)(dwords_ + alu_off * 3); if (alu->vector_write_mask) { if (alu->export_data && alu->vector_dest == 63) { alloc_counts_.point_size = true; @@ -213,39 +212,39 @@ void ShaderResource::GatherVertexFetch(const instr_fetch_vtx_t* vtx) { el->offset_words = vtx->offset; el->size_words = 0; switch (el->format) { - case FMT_8_8_8_8: - case FMT_2_10_10_10: - case FMT_10_11_11: - case FMT_11_11_10: - el->size_words = 1; - break; - case FMT_16_16: - case FMT_16_16_FLOAT: - el->size_words = 1; - break; - case FMT_16_16_16_16: - case FMT_16_16_16_16_FLOAT: - el->size_words = 2; - break; - case FMT_32: - case FMT_32_FLOAT: - el->size_words = 1; - break; - case FMT_32_32: - case FMT_32_32_FLOAT: - el->size_words = 2; - break; - case FMT_32_32_32_FLOAT: - el->size_words = 3; - break; - case FMT_32_32_32_32: - case FMT_32_32_32_32_FLOAT: - el->size_words = 4; - break; - default: - XELOGE("Unknown vertex format: %d", el->format); - assert_always(); - break; + case FMT_8_8_8_8: + case FMT_2_10_10_10: + case FMT_10_11_11: + case FMT_11_11_10: + el->size_words = 1; + break; + case FMT_16_16: + case FMT_16_16_FLOAT: + el->size_words = 1; + break; + case FMT_16_16_16_16: + case FMT_16_16_16_16_FLOAT: + el->size_words = 2; + break; + case FMT_32: + case FMT_32_FLOAT: + el->size_words = 1; + break; + case FMT_32_32: + case FMT_32_32_FLOAT: + el->size_words = 2; + break; + case FMT_32_32_32_FLOAT: + el->size_words = 3; + break; + case FMT_32_32_32_32: + case FMT_32_32_32_32_FLOAT: + el->size_words = 4; + break; + default: + XELOGE("Unknown vertex format: %d", el->format); + assert_always(); + break; } } @@ -255,22 +254,20 @@ void ShaderResource::GatherTextureFetch(const xenos::instr_fetch_tex_t* tex) { assert_true(sampler_inputs_.count + 1 < poly::countof(sampler_inputs_.descs)); auto& input = sampler_inputs_.descs[sampler_inputs_.count++]; input.input_index = sampler_inputs_.count - 1; - input.fetch_slot = tex->const_idx & 0xF; // ? + input.fetch_slot = tex->const_idx & 0xF; // ? input.tex_fetch = *tex; // Format mangling, size estimation, etc. } -VertexShaderResource::VertexShaderResource( - const MemoryRange& memory_range, const Info& info) - : ShaderResource(memory_range, info, XE_GPU_SHADER_TYPE_VERTEX) { -} +VertexShaderResource::VertexShaderResource(const MemoryRange& memory_range, + const Info& info) + : ShaderResource(memory_range, info, XE_GPU_SHADER_TYPE_VERTEX) {} VertexShaderResource::~VertexShaderResource() = default; -PixelShaderResource::PixelShaderResource( - const MemoryRange& memory_range, const Info& info) - : ShaderResource(memory_range, info, XE_GPU_SHADER_TYPE_PIXEL) { -} +PixelShaderResource::PixelShaderResource(const MemoryRange& memory_range, + const Info& info) + : ShaderResource(memory_range, info, XE_GPU_SHADER_TYPE_PIXEL) {} PixelShaderResource::~PixelShaderResource() = default; diff --git a/src/xenia/kernel/fs/devices/disc_image_file.cc b/src/xenia/kernel/fs/devices/disc_image_file.cc index 45db575f0..82afb41f1 100644 --- a/src/xenia/kernel/fs/devices/disc_image_file.cc +++ b/src/xenia/kernel/fs/devices/disc_image_file.cc @@ -21,7 +21,7 @@ namespace fs { DiscImageFile::DiscImageFile(KernelState* kernel_state, Mode mode, DiscImageEntry* entry) - : entry_(entry), XFile(kernel_state, mode) {} + : XFile(kernel_state, mode), entry_(entry) {} DiscImageFile::~DiscImageFile() {} @@ -59,8 +59,7 @@ X_STATUS DiscImageFile::ReadSync(void* buffer, size_t buffer_length, } size_t real_offset = gdfx_entry->offset + byte_offset; size_t real_length = std::min(buffer_length, gdfx_entry->size - byte_offset); - xe_copy_memory(buffer, buffer_length, entry_->mmap()->data() + real_offset, - real_length); + memcpy(buffer, entry_->mmap()->data() + real_offset, real_length); *out_bytes_read = real_length; return X_STATUS_SUCCESS; } diff --git a/src/xenia/kernel/fs/devices/stfs_container_file.cc b/src/xenia/kernel/fs/devices/stfs_container_file.cc index 32529fd95..fa7750c57 100644 --- a/src/xenia/kernel/fs/devices/stfs_container_file.cc +++ b/src/xenia/kernel/fs/devices/stfs_container_file.cc @@ -78,7 +78,7 @@ X_STATUS STFSContainerFile::ReadSync(void* buffer, size_t buffer_length, offset += byte_offset % 4096; read_length = std::min(read_length, record.length - (byte_offset % 4096)); } - xe_copy_struct(dest_ptr, entry_->mmap()->data() + offset, read_length); + memcpy(dest_ptr, entry_->mmap()->data() + offset, read_length); dest_ptr += read_length; remaining_length -= read_length; } diff --git a/src/xenia/kernel/fs/gdfx.cc b/src/xenia/kernel/fs/gdfx.cc index 1b722ad46..7eb8b43b2 100644 --- a/src/xenia/kernel/fs/gdfx.cc +++ b/src/xenia/kernel/fs/gdfx.cc @@ -50,19 +50,14 @@ void GDFXEntry::Dump(int indent) { } } -GDFX::GDFX(poly::MappedMemory* mmap) : mmap_(mmap) { - root_entry_ = nullptr; -} +GDFX::GDFX(poly::MappedMemory* mmap) : mmap_(mmap) { root_entry_ = nullptr; } -GDFX::~GDFX() { - delete root_entry_; -} +GDFX::~GDFX() { delete root_entry_; } GDFXEntry* GDFX::root_entry() { return root_entry_; } GDFX::Error GDFX::Load() { - ParseState state; - xe_zero_struct(&state, sizeof(state)); + ParseState state = {0}; state.ptr = mmap_->data(); state.size = mmap_->size(); diff --git a/src/xenia/kernel/fs/stfs.cc b/src/xenia/kernel/fs/stfs.cc index bf6ec0617..bc0483bff 100644 --- a/src/xenia/kernel/fs/stfs.cc +++ b/src/xenia/kernel/fs/stfs.cc @@ -37,15 +37,15 @@ bool STFSVolumeDescriptor::Read(const uint8_t* p) { block_separation = poly::load_and_swap(p + 0x02); file_table_block_count = poly::load_and_swap(p + 0x03); file_table_block_number = XEGETUINT24BE(p + 0x05); - xe_copy_struct(top_hash_table_hash, p + 0x08, 0x14); + memcpy(top_hash_table_hash, p + 0x08, 0x14); total_allocated_block_count = poly::load_and_swap(p + 0x1C); total_unallocated_block_count = poly::load_and_swap(p + 0x20); return true; }; bool STFSHeader::Read(const uint8_t* p) { - xe_copy_struct(license_entries, p + 0x22C, 0x100); - xe_copy_struct(header_hash, p + 0x32C, 0x14); + memcpy(license_entries, p + 0x22C, 0x100); + memcpy(header_hash, p + 0x32C, 0x14); header_size = poly::load_and_swap(p + 0x340); content_type = (STFSContentType)poly::load_and_swap(p + 0x344); metadata_version = poly::load_and_swap(p + 0x348); @@ -64,8 +64,8 @@ bool STFSHeader::Read(const uint8_t* p) { disc_number = poly::load_and_swap(p + 0x366); disc_in_set = poly::load_and_swap(p + 0x367); save_game_id = poly::load_and_swap(p + 0x368); - xe_copy_struct(console_id, p + 0x36C, 0x5); - xe_copy_struct(profile_id, p + 0x371, 0x8); + memcpy(console_id, p + 0x36C, 0x5); + memcpy(profile_id, p + 0x371, 0x8); data_file_count = poly::load_and_swap(p + 0x39D); data_file_combined_size = poly::load_and_swap(p + 0x3A1); descriptor_type = (STFSDescriptorType)poly::load_and_swap(p + 0x3A9); @@ -76,7 +76,7 @@ bool STFSHeader::Read(const uint8_t* p) { if (!volume_descriptor.Read(p + 0x379)) { return false; } - xe_copy_struct(device_id, p + 0x3FD, 0x14); + memcpy(device_id, p + 0x3FD, 0x14); for (size_t n = 0; n < 0x900 / 2; n++) { display_names[n] = poly::load_and_swap(p + 0x411 + n * 2); display_descs[n] = poly::load_and_swap(p + 0xD11 + n * 2); @@ -88,8 +88,8 @@ bool STFSHeader::Read(const uint8_t* p) { transfer_flags = poly::load_and_swap(p + 0x1711); thumbnail_image_size = poly::load_and_swap(p + 0x1712); title_thumbnail_image_size = poly::load_and_swap(p + 0x1716); - xe_copy_struct(thumbnail_image, p + 0x171A, 0x4000); - xe_copy_struct(title_thumbnail_image, p + 0x571A, 0x4000); + memcpy(thumbnail_image, p + 0x171A, 0x4000); + memcpy(title_thumbnail_image, p + 0x571A, 0x4000); return true; } diff --git a/src/xenia/kernel/object_table.cc b/src/xenia/kernel/object_table.cc index 2b2541daf..8745a3814 100644 --- a/src/xenia/kernel/object_table.cc +++ b/src/xenia/kernel/object_table.cc @@ -18,7 +18,7 @@ namespace xe { namespace kernel { ObjectTable::ObjectTable() - : table_capacity_(0), table_(NULL), last_free_entry_(0) {} + : table_capacity_(0), table_(nullptr), last_free_entry_(0) {} ObjectTable::~ObjectTable() { std::lock_guard lock(table_mutex_); @@ -34,7 +34,7 @@ ObjectTable::~ObjectTable() { table_capacity_ = 0; last_free_entry_ = 0; - xe_free(table_); + free(table_); table_ = NULL; } @@ -59,12 +59,18 @@ X_STATUS ObjectTable::FindFreeSlot(uint32_t* out_slot) { // Table out of slots, expand. uint32_t new_table_capacity = std::max(16 * 1024u, table_capacity_ * 2); - ObjectTableEntry* new_table = (ObjectTableEntry*)xe_recalloc( - table_, table_capacity_ * sizeof(ObjectTableEntry), - new_table_capacity * sizeof(ObjectTableEntry)); + size_t new_table_size = new_table_capacity * sizeof(ObjectTableEntry); + size_t old_table_size = table_capacity_ * sizeof(ObjectTableEntry); + ObjectTableEntry* new_table = + (ObjectTableEntry*)realloc(table_, new_table_size); if (!new_table) { return X_STATUS_NO_MEMORY; } + // Zero out new memory. + if (new_table_size > old_table_size) { + memset(reinterpret_cast(new_table) + old_table_size, 0, + new_table_size - old_table_size); + } last_free_entry_ = table_capacity_; table_capacity_ = new_table_capacity; table_ = new_table; diff --git a/src/xenia/kernel/objects/xfile.h b/src/xenia/kernel/objects/xfile.h index dfb2d7fe5..42057447a 100644 --- a/src/xenia/kernel/objects/xfile.h +++ b/src/xenia/kernel/objects/xfile.h @@ -74,8 +74,7 @@ class XDirectoryInfo { poly::store_and_swap(dst + 48, info->allocation_size); poly::store_and_swap(dst + 56, info->attributes); poly::store_and_swap(dst + 60, info->file_name_length); - xe_copy_memory(dst + 64, info->file_name_length, info->file_name, - info->file_name_length); + memcpy(dst + 64, info->file_name, info->file_name_length); dst += info->next_entry_offset; src += info->next_entry_offset; } while (info->next_entry_offset != 0); @@ -99,8 +98,7 @@ class XVolumeInfo { poly::store_and_swap(dst + 8, this->serial_number); poly::store_and_swap(dst + 12, this->label_length); poly::store_and_swap(dst + 16, this->supports_objects); - xe_copy_memory(dst + 20, this->label_length, this->label, - this->label_length); + memcpy(dst + 20, this->label, this->label_length); } }; static_assert_size(XVolumeInfo, 24); @@ -120,8 +118,7 @@ class XFileSystemAttributeInfo { poly::store_and_swap(dst + 4, this->maximum_component_name_length); poly::store_and_swap(dst + 8, this->fs_name_length); - xe_copy_memory(dst + 12, this->fs_name_length, this->fs_name, - this->fs_name_length); + memcpy(dst + 12, this->fs_name, this->fs_name_length); } }; static_assert_size(XFileSystemAttributeInfo, 16); diff --git a/src/xenia/kernel/objects/xuser_module.cc b/src/xenia/kernel/objects/xuser_module.cc index 65e82337c..634da5530 100644 --- a/src/xenia/kernel/objects/xuser_module.cc +++ b/src/xenia/kernel/objects/xuser_module.cc @@ -67,7 +67,7 @@ X_STATUS XUserModule::LoadFromFile(const char* path) { XEEXPECTZERO(result); size_t buffer_length = file_info.file_length; - buffer = (uint8_t*)xe_malloc(buffer_length); + buffer = (uint8_t*)malloc(buffer_length); // Open file for reading. result = fs_entry->Open(kernel_state(), fs::Mode::READ, false, &file); @@ -85,7 +85,7 @@ X_STATUS XUserModule::LoadFromFile(const char* path) { XECLEANUP: if (buffer) { - xe_free(buffer); + free(buffer); } if (file) { file->Release(); @@ -99,8 +99,7 @@ X_STATUS XUserModule::LoadFromMemory(const void* addr, const size_t length) { XenonRuntime* runtime = processor->runtime(); // Load the XEX into memory and decrypt. - xe_xex2_options_t xex_options; - xe_zero_struct(&xex_options, sizeof(xex_options)); + xe_xex2_options_t xex_options = {0}; xex_ = xe_xex2_load(kernel_state()->memory(), addr, length, xex_options); if (!xex_) { return X_STATUS_UNSUCCESSFUL; diff --git a/src/xenia/kernel/util/xex2.cc b/src/xenia/kernel/util/xex2.cc index 1a7b48f41..b0a2526db 100644 --- a/src/xenia/kernel/util/xex2.cc +++ b/src/xenia/kernel/util/xex2.cc @@ -51,7 +51,7 @@ int xe_xex2_find_import_infos(xe_xex2_ref xex, xe_xex2_ref xe_xex2_load(xe::Memory *memory, const void *addr, const size_t length, xe_xex2_options_t options) { - xe_xex2_ref xex = (xe_xex2_ref)xe_calloc(sizeof(xe_xex2)); + xe_xex2_ref xex = (xe_xex2_ref)calloc(1, sizeof(xe_xex2)); xe_ref_init((xe_ref)xex); xex->memory = memory; @@ -85,14 +85,14 @@ void xe_xex2_dealloc(xe_xex2_ref xex) { } xe_xex2_header_t *header = &xex->header; - xe_free(header->sections); - xe_free(header->resource_infos); + free(header->sections); + free(header->resource_infos); if (header->file_format_info.compression_type == XEX_COMPRESSION_BASIC) { - xe_free(header->file_format_info.compression_info.basic.blocks); + free(header->file_format_info.compression_info.basic.blocks); } for (size_t n = 0; n < header->import_library_count; n++) { xe_xex2_import_library_t *library = &header->import_libraries[n]; - xe_free(library->records); + free(library->records); } xex->memory = NULL; @@ -162,13 +162,12 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length, break; case XEX_HEADER_RESOURCE_INFO: { header->resource_info_count = (opt_header->length - 4) / 16; - header->resource_infos = (xe_xex2_resource_info_t *)xe_calloc( - sizeof(xe_xex2_resource_info_t) * header->resource_info_count); + header->resource_infos = (xe_xex2_resource_info_t *)calloc( + header->resource_info_count, sizeof(xe_xex2_resource_info_t)); const uint8_t *ph = pp + 0x04; for (size_t n = 0; n < header->resource_info_count; n++) { auto &res = header->resource_infos[n]; - XEEXPECTZERO( - xe_copy_memory(res.name, sizeof(res.name), ph + 0x00, 8)); + memcpy(res.name, ph + 0x00, 8); res.address = poly::load_and_swap(ph + 0x08); res.size = poly::load_and_swap(ph + 0x0C); ph += 16; @@ -254,8 +253,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length, pp += 12 + string_table_size; for (size_t m = 0; m < count; m++) { xe_xex2_import_library_t *library = &header->import_libraries[m]; - XEEXPECTZERO(xe_copy_memory(library->digest, sizeof(library->digest), - pp + 0x04, 20)); + memcpy(library->digest, pp + 0x04, 20); library->import_id = poly::load_and_swap(pp + 0x18); library->version.value = poly::load_and_swap(pp + 0x1C); library->min_version.value = poly::load_and_swap(pp + 0x20); @@ -282,7 +280,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length, library->record_count = poly::load_and_swap(pp + 0x26); library->records = - (uint32_t *)xe_calloc(library->record_count * sizeof(uint32_t)); + (uint32_t *)calloc(library->record_count, sizeof(uint32_t)); XEEXPECTNOTNULL(library->records); pp += 0x28; for (size_t i = 0; i < library->record_count; i++) { @@ -304,8 +302,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length, pp += 4; for (size_t m = 0; m < count; m++) { xe_xex2_static_library_t *library = &header->static_libraries[m]; - XEEXPECTZERO(xe_copy_memory(library->name, sizeof(library->name), - pp + 0x00, 8)); + memcpy(library->name, pp + 0x00, 8); library->name[8] = 0; library->major = poly::load_and_swap(pp + 0x08); library->minor = poly::load_and_swap(pp + 0x0A); @@ -333,8 +330,8 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length, uint32_t info_size = poly::load_and_swap(pp + 0x00); comp_info->block_count = (info_size - 8) / 8; comp_info->blocks = - (xe_xex2_file_basic_compression_block_t *)xe_calloc( - comp_info->block_count * + (xe_xex2_file_basic_compression_block_t *)calloc( + comp_info->block_count, sizeof(xe_xex2_file_basic_compression_block_t)); XEEXPECTNOTNULL(comp_info->blocks); for (size_t m = 0; m < comp_info->block_count; m++) { @@ -360,9 +357,7 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length, comp_info->window_size = poly::load_and_swap(pp + 0x08); comp_info->window_bits = window_bits; comp_info->block_size = poly::load_and_swap(pp + 0x0C); - XEEXPECTZERO(xe_copy_memory(comp_info->block_hash, - sizeof(comp_info->block_hash), - pp + 0x10, 20)); + memcpy(comp_info->block_hash, pp + 0x10, 20); } break; case XEX_COMPRESSION_DELTA: // TODO: XEX_COMPRESSION_DELTA @@ -378,25 +373,18 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length, ldr = &header->loader_info; ldr->header_size = poly::load_and_swap(pc + 0x000); ldr->image_size = poly::load_and_swap(pc + 0x004); - XEEXPECTZERO(xe_copy_memory(ldr->rsa_signature, sizeof(ldr->rsa_signature), - pc + 0x008, 256)); + memcpy(ldr->rsa_signature, pc + 0x008, 256); ldr->unklength = poly::load_and_swap(pc + 0x108); ldr->image_flags = (xe_xex2_image_flags)poly::load_and_swap(pc + 0x10C); ldr->load_address = poly::load_and_swap(pc + 0x110); - XEEXPECTZERO(xe_copy_memory(ldr->section_digest, sizeof(ldr->section_digest), - pc + 0x114, 20)); + memcpy(ldr->section_digest, pc + 0x114, 20); ldr->import_table_count = poly::load_and_swap(pc + 0x128); - XEEXPECTZERO(xe_copy_memory(ldr->import_table_digest, - sizeof(ldr->import_table_digest), pc + 0x12C, - 20)); - XEEXPECTZERO( - xe_copy_memory(ldr->media_id, sizeof(ldr->media_id), pc + 0x140, 16)); - XEEXPECTZERO( - xe_copy_memory(ldr->file_key, sizeof(ldr->file_key), pc + 0x150, 16)); + memcpy(ldr->import_table_digest, pc + 0x12C, 20); + memcpy(ldr->media_id, pc + 0x140, 16); + memcpy(ldr->file_key, pc + 0x150, 16); ldr->export_table = poly::load_and_swap(pc + 0x160); - XEEXPECTZERO(xe_copy_memory(ldr->header_digest, sizeof(ldr->header_digest), - pc + 0x164, 20)); + memcpy(ldr->header_digest, pc + 0x164, 20); ldr->game_regions = (xe_xex2_region_flags)poly::load_and_swap(pc + 0x178); ldr->media_flags = @@ -406,15 +394,14 @@ int xe_xex2_read_header(const uint8_t *addr, const size_t length, ps = p + header->certificate_offset + 0x180; header->section_count = poly::load_and_swap(ps + 0x000); ps += 4; - header->sections = (xe_xex2_section_t *)xe_calloc(header->section_count * - sizeof(xe_xex2_section_t)); + header->sections = (xe_xex2_section_t *)calloc(header->section_count, + sizeof(xe_xex2_section_t)); XEEXPECTNOTNULL(header->sections); for (size_t n = 0; n < header->section_count; n++) { xe_xex2_section_t *section = &header->sections[n]; section->info.value = poly::load_and_swap(ps); ps += 4; - XEEXPECTZERO(xe_copy_memory(section->digest, sizeof(section->digest), ps, - sizeof(section->digest))); + memcpy(section->digest, ps, sizeof(section->digest)); ps += sizeof(section->digest); } @@ -462,7 +449,7 @@ mspack_memory_file *mspack_memory_open(struct mspack_system *sys, void *buffer, return NULL; } mspack_memory_file *memfile = - (mspack_memory_file *)xe_calloc(sizeof(mspack_memory_file)); + (mspack_memory_file *)calloc(1, sizeof(mspack_memory_file)); if (!memfile) { return NULL; } @@ -473,16 +460,13 @@ mspack_memory_file *mspack_memory_open(struct mspack_system *sys, void *buffer, } void mspack_memory_close(mspack_memory_file *file) { mspack_memory_file *memfile = (mspack_memory_file *)file; - xe_free(memfile); + free(memfile); } int mspack_memory_read(struct mspack_file *file, void *buffer, int chars) { mspack_memory_file *memfile = (mspack_memory_file *)file; const off_t remaining = memfile->buffer_size - memfile->offset; const off_t total = std::min(static_cast(chars), remaining); - if (xe_copy_memory(buffer, total, - (uint8_t *)memfile->buffer + memfile->offset, total)) { - return -1; - } + memcpy(buffer, (uint8_t *)memfile->buffer + memfile->offset, total); memfile->offset += total; return (int)total; } @@ -490,23 +474,20 @@ int mspack_memory_write(struct mspack_file *file, void *buffer, int chars) { mspack_memory_file *memfile = (mspack_memory_file *)file; const off_t remaining = memfile->buffer_size - memfile->offset; const off_t total = std::min(static_cast(chars), remaining); - if (xe_copy_memory((uint8_t *)memfile->buffer + memfile->offset, - memfile->buffer_size - memfile->offset, buffer, total)) { - return -1; - } + memcpy((uint8_t *)memfile->buffer + memfile->offset, buffer, total); memfile->offset += total; return (int)total; } void *mspack_memory_alloc(struct mspack_system *sys, size_t chars) { - return xe_calloc(chars); + return calloc(chars, 1); } -void mspack_memory_free(void *ptr) { xe_free(ptr); } +void mspack_memory_free(void *ptr) { free(ptr); } void mspack_memory_copy(void *src, void *dest, size_t chars) { - xe_copy_memory(dest, chars, src, chars); + memcpy(dest, src, chars); } struct mspack_system *mspack_memory_sys_create() { struct mspack_system *sys = - (struct mspack_system *)xe_calloc(sizeof(struct mspack_system)); + (struct mspack_system *)calloc(1, sizeof(struct mspack_system)); if (!sys) { return NULL; } @@ -517,7 +498,7 @@ struct mspack_system *mspack_memory_sys_create() { sys->copy = mspack_memory_copy; return sys; } -void mspack_memory_sys_destroy(struct mspack_system *sys) { xe_free(sys); } +void mspack_memory_sys_destroy(struct mspack_system *sys) { free(sys); } void xe_xex2_decrypt_buffer(const uint8_t *session_key, const uint8_t *input_buffer, @@ -560,7 +541,11 @@ int xe_xex2_read_image_uncompressed(const xe_xex2_header_t *header, switch (header->file_format_info.encryption_type) { case XEX_ENCRYPTION_NONE: - return xe_copy_memory(buffer, uncompressed_size, p, exe_length); + if (exe_length > uncompressed_size) { + return 1; + } + memcpy(buffer, p, exe_length); + return 0; case XEX_ENCRYPTION_NORMAL: xe_xex2_decrypt_buffer(header->session_key, p, exe_length, buffer, uncompressed_size); @@ -597,7 +582,7 @@ int xe_xex2_read_image_basic_compressed(const xe_xex2_header_t *header, if (!alloc_result) { XELOGE("Unable to allocate XEX memory at %.8X-%.8X.", header->exe_address, uncompressed_size); - XEFAIL(); + return 1; } uint8_t *buffer = memory->Translate(header->exe_address); uint8_t *d = buffer; @@ -612,8 +597,12 @@ int xe_xex2_read_image_basic_compressed(const xe_xex2_header_t *header, switch (header->file_format_info.encryption_type) { case XEX_ENCRYPTION_NONE: - XEEXPECTZERO(xe_copy_memory(d, uncompressed_size - (d - buffer), p, - exe_length - (p - source_buffer))); + if (exe_length - (p - source_buffer) > + uncompressed_size - (d - buffer)) { + // Overflow. + return 1; + } + memcpy(d, p, exe_length - (p - source_buffer)); break; case XEX_ENCRYPTION_NORMAL: { const uint8_t *ct = p; @@ -639,9 +628,6 @@ int xe_xex2_read_image_basic_compressed(const xe_xex2_header_t *header, } return 0; - -XECLEANUP: - return 1; } int xe_xex2_read_image_compressed(const xe_xex2_header_t *header, @@ -682,7 +668,7 @@ int xe_xex2_read_image_compressed(const xe_xex2_header_t *header, case XEX_ENCRYPTION_NORMAL: // TODO: a way to do without a copy/alloc? free_input = true; - input_buffer = (const uint8_t *)xe_calloc(input_size); + input_buffer = (const uint8_t *)calloc(1, input_size); XEEXPECTNOTNULL(input_buffer); xe_xex2_decrypt_buffer(header->session_key, exe_buffer, exe_length, (uint8_t *)input_buffer, input_size); @@ -692,14 +678,14 @@ int xe_xex2_read_image_compressed(const xe_xex2_header_t *header, return false; } - compress_buffer = (uint8_t *)xe_calloc(exe_length); + compress_buffer = (uint8_t *)calloc(1, exe_length); XEEXPECTNOTNULL(compress_buffer); p = input_buffer; d = compress_buffer; // De-block. - deblock_buffer = (uint8_t *)xe_calloc(input_size); + deblock_buffer = (uint8_t *)calloc(1, input_size); XEEXPECTNOTNULL(deblock_buffer); block_size = header->file_format_info.compression_info.normal.block_size; while (block_size) { @@ -714,7 +700,7 @@ int xe_xex2_read_image_compressed(const xe_xex2_header_t *header, if (!chunk_size) { break; } - xe_copy_memory(d, exe_length - (d - compress_buffer), p, chunk_size); + memcpy(d, p, chunk_size); p += chunk_size; d += chunk_size; @@ -770,10 +756,10 @@ XECLEANUP: mspack_memory_sys_destroy(sys); sys = NULL; } - xe_free(compress_buffer); - xe_free(deblock_buffer); + free(compress_buffer); + free(deblock_buffer); if (free_input) { - xe_free((void *)input_buffer); + free((void *)input_buffer); } return result_code; } @@ -865,9 +851,8 @@ int xe_xex2_load_pe(xe_xex2_ref xex) { // Setup/load sections. sechdr = IMAGE_FIRST_SECTION(nthdr); for (size_t n = 0; n < filehdr->NumberOfSections; n++, sechdr++) { - PESection *section = (PESection *)xe_calloc(sizeof(PESection)); - xe_copy_memory(section->name, sizeof(section->name), sechdr->Name, - sizeof(sechdr->Name)); + PESection *section = (PESection *)calloc(1, sizeof(PESection)); + memcpy(section->name, sechdr->Name, sizeof(sechdr->Name)); section->name[8] = 0; section->raw_address = sechdr->PointerToRawData; section->raw_size = sechdr->SizeOfRawData; @@ -928,8 +913,8 @@ int xe_xex2_find_import_infos(xe_xex2_ref xex, } // Allocate storage. - xe_xex2_import_info_t *infos = (xe_xex2_import_info_t *)xe_calloc( - info_count * sizeof(xe_xex2_import_info_t)); + xe_xex2_import_info_t *infos = (xe_xex2_import_info_t *)calloc( + info_count, sizeof(xe_xex2_import_info_t)); assert_not_null(infos); assert_not_zero(info_count); diff --git a/src/xenia/kernel/xboxkrnl_io.cc b/src/xenia/kernel/xboxkrnl_io.cc index 11a32e000..06da957b9 100644 --- a/src/xenia/kernel/xboxkrnl_io.cc +++ b/src/xenia/kernel/xboxkrnl_io.cc @@ -24,27 +24,23 @@ namespace kernel { using namespace xe::kernel::fs; class X_OBJECT_ATTRIBUTES { -public: - uint32_t root_directory; - uint32_t object_name_ptr; + public: + uint32_t root_directory; + uint32_t object_name_ptr; X_ANSI_STRING object_name; - uint32_t attributes; + uint32_t attributes; - X_OBJECT_ATTRIBUTES() { - Zero(); - } - X_OBJECT_ATTRIBUTES(const uint8_t* base, uint32_t p) { - Read(base, p); - } + X_OBJECT_ATTRIBUTES() { Zero(); } + X_OBJECT_ATTRIBUTES(const uint8_t* base, uint32_t p) { Read(base, p); } void Read(const uint8_t* base, uint32_t p) { - root_directory = poly::load_and_swap(base + p); + root_directory = poly::load_and_swap(base + p); object_name_ptr = poly::load_and_swap(base + p + 4); if (object_name_ptr) { object_name.Read(base, object_name_ptr); } else { object_name.Zero(); } - attributes = poly::load_and_swap(base + p + 8); + attributes = poly::load_and_swap(base + p + 8); } void Zero() { root_directory = 0; @@ -135,7 +131,7 @@ SHIM_CALL NtCreateFile_shim(PPCContext* ppc_state, KernelState* state) { } } - xe_free(object_name); + free(object_name); SHIM_SET_RETURN_32(result); } @@ -203,7 +199,7 @@ SHIM_CALL NtOpenFile_shim(PPCContext* ppc_state, KernelState* state) { } } - xe_free(object_name); + free(object_name); SHIM_SET_RETURN_32(result); } @@ -494,7 +490,7 @@ SHIM_CALL NtQueryFullAttributesFile_shim(PPCContext* ppc_state, } } - xe_free(object_name); + free(object_name); SHIM_SET_RETURN_32(result); } @@ -520,23 +516,23 @@ SHIM_CALL NtQueryVolumeInformationFile_shim(PPCContext* ppc_state, result = X_STATUS_SUCCESS; switch (fs_info_class) { case 1: { // FileFsVolumeInformation - auto volume_info = (XVolumeInfo*)xe_calloc(length); + auto volume_info = (XVolumeInfo*)calloc(length, 1); result = file->QueryVolume(volume_info, length); if (XSUCCEEDED(result)) { volume_info->Write(SHIM_MEM_BASE, fs_info_ptr); info = length; } - xe_free(volume_info); + free(volume_info); break; } case 5: { // FileFsAttributeInformation - auto fs_attribute_info = (XFileSystemAttributeInfo*)xe_calloc(length); + auto fs_attribute_info = (XFileSystemAttributeInfo*)calloc(length, 1); result = file->QueryFileSystemAttributes(fs_attribute_info, length); if (XSUCCEEDED(result)) { fs_attribute_info->Write(SHIM_MEM_BASE, fs_info_ptr); info = length; } - xe_free(fs_attribute_info); + free(fs_attribute_info); break; } default: @@ -589,7 +585,7 @@ SHIM_CALL NtQueryDirectoryFile_shim(PPCContext* ppc_state, KernelState* state) { if (length < 72) { SHIM_SET_RETURN_32(X_STATUS_INFO_LENGTH_MISMATCH); - xe_free(file_name); + free(file_name); return; } @@ -599,14 +595,14 @@ SHIM_CALL NtQueryDirectoryFile_shim(PPCContext* ppc_state, KernelState* state) { XFile* file = NULL; result = state->object_table()->GetObject(file_handle, (XObject**)&file); if (XSUCCEEDED(result)) { - XDirectoryInfo* dir_info = (XDirectoryInfo*)xe_calloc(length); + XDirectoryInfo* dir_info = (XDirectoryInfo*)calloc(length, 1); result = file->QueryDirectory(dir_info, length, file_name, restart_scan != 0); if (XSUCCEEDED(result)) { dir_info->Write(SHIM_MEM_BASE, file_info_ptr); info = length; } - xe_free(dir_info); + free(dir_info); } if (XFAILED(result)) { @@ -621,7 +617,7 @@ SHIM_CALL NtQueryDirectoryFile_shim(PPCContext* ppc_state, KernelState* state) { file->Release(); } - xe_free(file_name); + free(file_name); SHIM_SET_RETURN_32(result); } diff --git a/src/xenia/kernel/xboxkrnl_memory.cc b/src/xenia/kernel/xboxkrnl_memory.cc index b6a7124e0..7cb6266dc 100644 --- a/src/xenia/kernel/xboxkrnl_memory.cc +++ b/src/xenia/kernel/xboxkrnl_memory.cc @@ -319,7 +319,7 @@ SHIM_CALL MmQueryStatistics_shim(PPCContext* ppc_state, KernelState* state) { X_STATUS result = X_STATUS_SUCCESS; // Zero out the struct. - xe_zero_struct(SHIM_MEM_ADDR(stats_ptr), 104); + memset(SHIM_MEM_ADDR(stats_ptr), 0, 104); SHIM_SET_MEM_32(stats_ptr + 0, 104); // Set the constants the game is likely asking for. diff --git a/src/xenia/kernel/xboxkrnl_module.cc b/src/xenia/kernel/xboxkrnl_module.cc index 04149eaf9..08be07e73 100644 --- a/src/xenia/kernel/xboxkrnl_module.cc +++ b/src/xenia/kernel/xboxkrnl_module.cc @@ -108,8 +108,8 @@ XboxkrnlModule::XboxkrnlModule(Emulator* emulator, KernelState* kernel_state) export_resolver_->SetVariableMapping( "xboxkrnl.exe", ordinals::ExLoadedCommandLine, pExLoadedCommandLine); char command_line[] = "\"default.xex\""; - xe_copy_memory(mem + pExLoadedCommandLine, 1024, command_line, - poly::countof(command_line) + 1); + memcpy(mem + pExLoadedCommandLine, command_line, + poly::countof(command_line) + 1); // XboxKrnlVersion (8b) // Kernel version, looks like 2b.2b.2b.2b. diff --git a/src/xenia/kernel/xboxkrnl_strings.cc b/src/xenia/kernel/xboxkrnl_strings.cc index 986b2c741..1498deb43 100644 --- a/src/xenia/kernel/xboxkrnl_strings.cc +++ b/src/xenia/kernel/xboxkrnl_strings.cc @@ -408,7 +408,7 @@ SHIM_CALL _vswprintf_shim(PPCContext* ppc_state, KernelState* state) { // swap the format buffer wchar_t* swapped_format = - (wchar_t*)xe_malloc((format_length + 1) * sizeof(wchar_t)); + (wchar_t*)malloc((format_length + 1) * sizeof(wchar_t)); for (size_t i = 0; i < format_length; ++i) { swapped_format[i] = poly::byte_swap(format[i]); } @@ -587,13 +587,13 @@ SHIM_CALL _vswprintf_shim(PPCContext* ppc_state, KernelState* state) { const wchar_t* data = (const wchar_t*)SHIM_MEM_ADDR(value); size_t data_length = wcslen(data); wchar_t* swapped_data = - (wchar_t*)xe_malloc((data_length + 1) * sizeof(wchar_t)); + (wchar_t*)malloc((data_length + 1) * sizeof(wchar_t)); for (size_t i = 0; i < data_length; ++i) { swapped_data[i] = poly::byte_swap(data[i]); } swapped_data[data_length] = '\0'; int result = wsprintf(b, local, swapped_data); - xe_free(swapped_data); + free(swapped_data); b += result; arg_index++; } else { @@ -607,7 +607,7 @@ SHIM_CALL _vswprintf_shim(PPCContext* ppc_state, KernelState* state) { } *b = '\0'; - xe_free(swapped_format); + free(swapped_format); // swap the result buffer for (wchar_t* swap = buffer; swap != b; ++swap) { diff --git a/src/xenia/kernel/xboxkrnl_video.cc b/src/xenia/kernel/xboxkrnl_video.cc index 419393a70..5a7f72de7 100644 --- a/src/xenia/kernel/xboxkrnl_video.cc +++ b/src/xenia/kernel/xboxkrnl_video.cc @@ -202,15 +202,15 @@ SHIM_CALL VdEnableRingBufferRPtrWriteBack_shim(PPCContext* ppc_state, //(1:17:38 AM) Rick: .text:8201B348 lwz r11, 0x2B10(r31) //(1:17:38 AM) Rick: .text:8201B34C addi r11, r11, 0x3C //(1:17:38 AM) Rick: .text:8201B350 srwi r10, r11, 20 # - //r10 = r11 >> 20 + // r10 = r11 >> 20 //(1:17:38 AM) Rick: .text:8201B354 clrlwi r11, r11, 3 # - //r11 = r11 & 0x1FFFFFFF + // r11 = r11 & 0x1FFFFFFF //(1:17:38 AM) Rick: .text:8201B358 addi r10, r10, 0x200 //(1:17:39 AM) Rick: .text:8201B35C rlwinm r10, r10, - //0,19,19 # r10 = r10 & 0x1000 + // 0,19,19 # r10 = r10 & 0x1000 //(1:17:39 AM) Rick: .text:8201B360 add r3, r10, r11 //(1:17:39 AM) Rick: .text:8201B364 bl - //VdEnableRingBufferRPtrWriteBack + // VdEnableRingBufferRPtrWriteBack // TODO(benvanik): something? } @@ -300,7 +300,7 @@ SHIM_CALL VdSwap_shim(PPCContext* ppc_state, KernelState* state) { // token value. It'd be nice to figure out what this is really doing so // that we could simulate it, though due to TCR I bet all games need to // use this method. - xe_zero_struct(SHIM_MEM_ADDR(unk0), 64 * 4); + memset(SHIM_MEM_ADDR(unk0), 0, 64 * 4); auto dwords = reinterpret_cast(SHIM_MEM_ADDR(unk0)); dwords[0] = poly::byte_swap((0x03 << 30) | ((1 - 1) << 16) | (xe::gpu::xenos::PM4_XE_SWAP << 8)); diff --git a/src/xenia/malloc.cc b/src/xenia/malloc.cc deleted file mode 100644 index 1c827d46f..000000000 --- a/src/xenia/malloc.cc +++ /dev/null @@ -1,137 +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. * - ****************************************************************************** - */ - -#include - -#include - - -void *xe_malloc(const size_t size) { - // Some platforms return NULL from malloc with size zero. - if (!size) { - return malloc(1); - } - return malloc(size); -} - -void *xe_calloc(const size_t size) { - // Some platforms return NULL from malloc with size zero. - if (!size) { - return calloc(1, 1); - } - return calloc(1, size); -} - -void* xe_realloc(void *ptr, const size_t old_size, const size_t new_size) { - if (!ptr) { - // Support realloc as malloc. - return malloc(new_size); - } - if (old_size == new_size) { - // No-op. - return ptr; - } - if (!new_size) { - // Zero-size realloc, return a dummy buffer for platforms that don't support - // zero-size allocs. - void *dummy = malloc(1); - if (!dummy) { - return NULL; - } - xe_free(ptr); - return dummy; - } - - return realloc(ptr, new_size); -} - -void* xe_recalloc(void *ptr, const size_t old_size, const size_t new_size) { - if (!ptr) { - // Support realloc as malloc. - return calloc(1, new_size); - } - if (old_size == new_size) { - // No-op. - return ptr; - } - if (!new_size) { - // Zero-size realloc, return a dummy buffer for platforms that don't support - // zero-size allocs. - void *dummy = calloc(1, 1); - if (!dummy) { - return NULL; - } - xe_free(ptr); - return dummy; - } - - void *result = realloc(ptr, new_size); - if (!result) { - return NULL; - } - - // Zero out new memory. - if (new_size > old_size) { - xe_zero_memory(result, new_size, old_size, new_size - old_size); - } - - return result; -} - -void xe_free(void *ptr) { - if (ptr) { - free(ptr); - } -} - -xe_aligned_void_t *xe_malloc_aligned(const size_t size) { - // TODO(benvanik): validate every platform is aligned to XE_ALIGNMENT. - return xe_malloc(size); -} - -void xe_free_aligned(xe_aligned_void_t *ptr) { - xe_free((void*)ptr); -} - -int xe_zero_struct(void *ptr, const size_t size) { - return xe_zero_memory(ptr, size, 0, size); -} - -int xe_zero_memory(void *ptr, const size_t size, const size_t offset, - const size_t length) { - // TODO(benvanik): validate sizing/clamp. - if (!ptr || !length) { - return 0; - } - if (offset + length > size) { - return 1; - } - memset((uint8_t*)ptr + offset, 0, length); - return 0; -} - -int xe_copy_struct(void *dest, const void *source, const size_t size) { - return xe_copy_memory(dest, size, source, size); -} - -int xe_copy_memory(void *dest, const size_t dest_size, const void *source, - const size_t source_size) { - // TODO(benvanik): validate sizing. - if (!source_size) { - return 0; - } - if (!dest || !source) { - return 1; - } - if (dest_size < source_size) { - return 1; - } - memcpy(dest, source, source_size); - return 0; -} diff --git a/src/xenia/malloc.h b/src/xenia/malloc.h deleted file mode 100644 index cfe6304e5..000000000 --- a/src/xenia/malloc.h +++ /dev/null @@ -1,36 +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_MALLOC_H_ -#define XENIA_MALLOC_H_ - -#include - - -#define xe_alloca(size) alloca(size) - -void *xe_malloc(const size_t size); -void *xe_calloc(const size_t size); -void *xe_realloc(void *ptr, const size_t old_size, const size_t new_size); -void *xe_recalloc(void *ptr, const size_t old_size, const size_t new_size); -void xe_free(void *ptr); - -typedef __declspec(align(16)) volatile void xe_aligned_void_t; -xe_aligned_void_t *xe_malloc_aligned(const size_t size); -void xe_free_aligned(xe_aligned_void_t *ptr); - -int xe_zero_struct(void *ptr, const size_t size); -int xe_zero_memory(void *ptr, const size_t size, const size_t offset, - const size_t length); -int xe_copy_struct(void *dest, const void *source, const size_t size); -int xe_copy_memory(void *dest, const size_t dest_size, const void *source, - const size_t source_size); - - -#endif // XENIA_MALLOC_H_ diff --git a/src/xenia/memory.cc b/src/xenia/memory.cc index 596812317..4ee269353 100644 --- a/src/xenia/memory.cc +++ b/src/xenia/memory.cc @@ -348,7 +348,7 @@ uint64_t Memory::HeapAlloc(uint64_t base_address, size_t size, uint32_t flags, } if (result) { if (flags & MEMORY_FLAG_ZERO) { - xe_zero_struct(Translate(result), size); + memset(Translate(result), 0, size); } } return result; @@ -377,7 +377,7 @@ uint64_t Memory::HeapAlloc(uint64_t base_address, size_t size, uint32_t flags, } if (flags & MEMORY_FLAG_ZERO) { - xe_zero_struct(pv, size); + memset(pv, 0, size); } return base_address; diff --git a/src/xenia/sources.gypi b/src/xenia/sources.gypi index 26c0a909d..23345750f 100644 --- a/src/xenia/sources.gypi +++ b/src/xenia/sources.gypi @@ -11,8 +11,6 @@ 'export_resolver.h', 'logging.cc', 'logging.h', - 'malloc.cc', - 'malloc.h', 'memory.cc', 'memory.h', 'profiling.cc', diff --git a/src/xenia/xbox.h b/src/xenia/xbox.h index fb0431eaa..ce056362e 100644 --- a/src/xenia/xbox.h +++ b/src/xenia/xbox.h @@ -266,7 +266,7 @@ public: if (buffer == NULL || length == 0) { return NULL; } - auto copy = (char*)xe_calloc(length + 1); + auto copy = (char*)calloc(length + 1, sizeof(char)); std::strncpy(copy, buffer, length); return copy; } diff --git a/tools/alloy-sandbox/alloy-sandbox.cc b/tools/alloy-sandbox/alloy-sandbox.cc index 393a1c6ac..8ed74a8ac 100644 --- a/tools/alloy-sandbox/alloy-sandbox.cc +++ b/tools/alloy-sandbox/alloy-sandbox.cc @@ -35,9 +35,8 @@ class ThreadState : public alloy::runtime::ThreadState { memset(memory_->Translate(stack_address_), 0, stack_size_); // Allocate with 64b alignment. - context_ = (PPCContext*)xe_malloc_aligned(sizeof(PPCContext)); + context_ = (PPCContext*)calloc(1, sizeof(PPCContext)); assert_true((reinterpret_cast(context_) & 0xF) == 0); - memset(&context_, 0, sizeof(PPCContext)); // Stash pointers to common structures that callbacks may need. context_->reserve_address = memory_->reserve_address(); @@ -59,7 +58,7 @@ class ThreadState : public alloy::runtime::ThreadState { } ~ThreadState() override { runtime_->debugger()->OnThreadDestroyed(this); - xe_free_aligned(context_); + free(context_); } PPCContext* context() const { return context_; }