Consistency in memset calls.

src/xenia/apu/audio_system.cc

@@ -60,7 +60,7 @@ AudioSystem::AudioSystem(Emulator* emulator)
       memory_(emulator->memory()),
       worker_running_(false),
       decoder_running_(false) {
-  memset(clients_, 0, sizeof(clients_));
+  std::memset(clients_, 0, sizeof(clients_));
   for (size_t i = 0; i < maximum_client_count_; ++i) {
     unused_clients_.push(i);
   }

src/xenia/cpu/backend/backend.cc

@@ -14,7 +14,7 @@ namespace cpu {
 namespace backend {
 
 Backend::Backend(Processor* processor) : processor_(processor) {
-  memset(&machine_info_, 0, sizeof(machine_info_));
+  std::memset(&machine_info_, 0, sizeof(machine_info_));
 }
 
 Backend::~Backend() = default;

src/xenia/cpu/compiler/passes/register_allocation_pass.cc

@@ -39,7 +39,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;
-  memset(&usage_sets_, 0, sizeof(usage_sets_));
+  std::memset(&usage_sets_, 0, sizeof(usage_sets_));
   uint32_t n = 0;
   while (mi_sets[n].count) {
     auto& mi_set = mi_sets[n];

src/xenia/cpu/frontend/ppc_hir_builder.cc

@@ -70,8 +70,8 @@ bool 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);
-  memset(instr_offset_list_, 0, list_size);
-  memset(label_list_, 0, list_size);
+  std::memset(instr_offset_list_, 0, list_size);
+  std::memset(label_list_, 0, list_size);
 
   // Always mark entry with label.
   label_list_[0] = NewLabel();

src/xenia/cpu/symbol_info.cc

@@ -26,7 +26,7 @@ FunctionInfo::FunctionInfo(Module* module, uint32_t address)
       end_address_(0),
       behavior_(BEHAVIOR_DEFAULT),
       function_(0) {
-  memset(&extern_info_, 0, sizeof(extern_info_));
+  std::memset(&extern_info_, 0, sizeof(extern_info_));
 }
 
 FunctionInfo::~FunctionInfo() = default;

src/xenia/gpu/register_file.cc

@@ -14,7 +14,7 @@
 namespace xe {
 namespace gpu {
 
-RegisterFile::RegisterFile() { memset(values, 0, sizeof(values)); }
+RegisterFile::RegisterFile() { std::memset(values, 0, sizeof(values)); }
 
 const RegisterInfo* RegisterFile::GetRegisterInfo(uint32_t index) {
   switch (index) {

src/xenia/kernel/object_table.cc

@@ -68,7 +68,7 @@ X_STATUS ObjectTable::FindFreeSlot(uint32_t* out_slot) {
   }
   // Zero out new memory.
   if (new_table_size > old_table_size) {
-    memset(reinterpret_cast<uint8_t*>(new_table) + old_table_size, 0,
+    std::memset(reinterpret_cast<uint8_t*>(new_table) + old_table_size, 0,
            new_table_size - old_table_size);
   }
   last_free_entry_ = table_capacity_;

src/xenia/kernel/xam_net.cc

@@ -39,7 +39,7 @@ void LoadSockaddr(const uint8_t* ptr, sockaddr* out_addr) {
 void StoreSockaddr(const sockaddr& addr, uint8_t* ptr) {
   switch (addr.sa_family) {
     case AF_UNSPEC:
-      memset(ptr, 0, sizeof(addr));
+      std::memset(ptr, 0, sizeof(addr));
       break;
     case AF_INET: {
       auto& in_addr = reinterpret_cast<const sockaddr_in&>(addr);
@@ -98,7 +98,7 @@ SHIM_CALL NetDll_XNetRandom_shim(PPCContext* ppc_state, KernelState* state) {
 
   // For now, constant values.
   // This makes replicating things easier.
-  memset(SHIM_MEM_ADDR(buffer_ptr), 0xBB, length);
+  std::memset(SHIM_MEM_ADDR(buffer_ptr), 0xBB, length);
 
   SHIM_SET_RETURN_32(0);
 }
@@ -316,7 +316,7 @@ SHIM_CALL NetDll_accept_shim(PPCContext* ppc_state, KernelState* state) {
   SOCKET ret_socket = accept(socket_handle, &addr, &addrlen);
 
   if (ret_socket == INVALID_SOCKET) {
-    memset(SHIM_MEM_ADDR(addr_ptr), 0, sizeof(addr));
+    std::memset(SHIM_MEM_ADDR(addr_ptr), 0, sizeof(addr));
     SHIM_SET_MEM_32(addrlen_ptr, sizeof(addr));
     SHIM_SET_RETURN_32(-1);
   } else {
@@ -427,7 +427,7 @@ SHIM_CALL NetDll_recvfrom_shim(PPCContext* ppc_state, KernelState* state) {
       recvfrom(socket_handle, reinterpret_cast<char*>(SHIM_MEM_ADDR(buf_ptr)),
                len, flags, &from, &fromlen);
   if (ret == -1) {
-    memset(SHIM_MEM_ADDR(from_ptr), 0, sizeof(from));
+    std::memset(SHIM_MEM_ADDR(from_ptr), 0, sizeof(from));
     SHIM_SET_MEM_32(fromlen_ptr, sizeof(from));
   } else {
     StoreSockaddr(from, SHIM_MEM_ADDR(from_ptr));

src/xenia/kernel/xam_user.cc

@@ -209,7 +209,7 @@ SHIM_CALL XamUserReadProfileSettings_shim(PPCContext* ppc_state,
       buffer_offset = setting->Append(SHIM_MEM_ADDR(user_data_ptr + 24),
                                       SHIM_MEM_ADDR(buffer_ptr), buffer_offset);
     } else {
-      memset(SHIM_MEM_ADDR(user_data_ptr + 24), 0, 16);
+      std::memset(SHIM_MEM_ADDR(user_data_ptr + 24), 0, 16);
     }
     user_data_ptr += kSettingSize;
   }

src/xenia/kernel/xboxkrnl_memory.cc

@@ -383,7 +383,7 @@ SHIM_CALL MmQueryStatistics_shim(PPCContext* ppc_state, KernelState* state) {
   X_STATUS result = X_STATUS_SUCCESS;
 
   // Zero out the struct.
-  memset(SHIM_MEM_ADDR(stats_ptr), 0, 104);
+  std::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.

src/xenia/kernel/xboxkrnl_video.cc

@@ -277,7 +277,7 @@ SHIM_CALL VdGetSystemCommandBuffer_shim(PPCContext* ppc_state,
 
   XELOGD("VdGetSystemCommandBuffer(%.8X, %.8X)", p0_ptr, p1_ptr);
 
-  memset(SHIM_MEM_ADDR(p0_ptr), 0, 0x94);
+  std::memset(SHIM_MEM_ADDR(p0_ptr), 0, 0x94);
   SHIM_SET_MEM_32(p0_ptr, 0xBEEF0000);
   SHIM_SET_MEM_32(p1_ptr, 0xBEEF0001);
 }
@@ -430,7 +430,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.
-  memset(SHIM_MEM_ADDR(unk0), 0, 64 * 4);
+  std::memset(SHIM_MEM_ADDR(unk0), 0, 64 * 4);
   auto dwords = reinterpret_cast<uint32_t*>(SHIM_MEM_ADDR(unk0));
   dwords[0] = xe::byte_swap((0x3 << 30) | ((63 - 1) << 16) |
                             (xe::gpu::xenos::PM4_XE_SWAP << 8));

src/xenia/memory.cc

@@ -604,7 +604,7 @@ bool BaseHeap::AllocFixed(uint32_t base_address, uint32_t size,
     }
 
     if (FLAGS_scribble_heap && protect & kMemoryProtectWrite) {
-      memset(result, 0xCD, page_count * page_size_);
+      std::memset(result, 0xCD, page_count * page_size_);
     }
   }
 

src/xenia/ui/win32/win32_window.cc

@@ -112,7 +112,7 @@ void Win32Window::EnableMMCSS() {
                                                "DwmSetPresentParameters");
   if (pDwmSetPresentParameters) {
     DWM_PRESENT_PARAMETERS pp;
-    memset(&pp, 0, sizeof(DWM_PRESENT_PARAMETERS));
+    std::memset(&pp, 0, sizeof(DWM_PRESENT_PARAMETERS));
     pp.cbSize = sizeof(DWM_PRESENT_PARAMETERS);
     pp.fQueue = FALSE;
     pp.cBuffer = 2;