Clang fixes.

src/xenia/cpu/backend/x64/x64_emitter.cc

@@ -48,10 +48,10 @@ using namespace Xbyak;
 using xe::cpu::hir::HIRBuilder;
 using xe::cpu::hir::Instr;
 
-static const size_t MAX_CODE_SIZE = 1 * 1024 * 1024;
+static const size_t kMaxCodeSize = 1 * 1024 * 1024;
 
-static const size_t STASH_OFFSET = 32;
-static const size_t STASH_OFFSET_HIGH = 32 + 32;
+static const size_t kStashOffset = 32;
+// static const size_t kStashOffsetHigh = 32 + 32;
 
 const uint32_t X64Emitter::gpr_reg_map_[X64Emitter::GPR_COUNT] = {
     Operand::RBX, Operand::R12, Operand::R13, Operand::R14, Operand::R15,
@@ -62,7 +62,7 @@ const uint32_t X64Emitter::xmm_reg_map_[X64Emitter::XMM_COUNT] = {
 };
 
 X64Emitter::X64Emitter(X64Backend* backend, XbyakAllocator* allocator)
-    : CodeGenerator(MAX_CODE_SIZE, AutoGrow, allocator),
+    : CodeGenerator(kMaxCodeSize, AutoGrow, allocator),
       processor_(backend->processor()),
       backend_(backend),
       code_cache_(backend->code_cache()),
@@ -292,7 +292,7 @@ void X64Emitter::DebugBreak() {
 uint64_t TrapDebugPrint(void* raw_context, uint64_t address) {
   auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
   uint32_t str_ptr = uint32_t(thread_state->context()->r[3]);
-  uint16_t str_len = uint16_t(thread_state->context()->r[4]);
+  // uint16_t str_len = uint16_t(thread_state->context()->r[4]);
   auto str = thread_state->memory()->TranslateVirtual<const char*>(str_ptr);
   // TODO(benvanik): truncate to length?
   XELOGD("(DebugPrint) %s", str);
@@ -663,9 +663,9 @@ void X64Emitter::LoadConstantXmm(Xbyak::Xmm dest, const vec128_t& v) {
   } else {
     // TODO(benvanik): see what other common values are.
     // TODO(benvanik): build constant table - 99% are reused.
-    MovMem64(rsp + STASH_OFFSET, v.low);
-    MovMem64(rsp + STASH_OFFSET + 8, v.high);
-    vmovdqa(dest, ptr[rsp + STASH_OFFSET]);
+    MovMem64(rsp + kStashOffset, v.low);
+    MovMem64(rsp + kStashOffset + 8, v.high);
+    vmovdqa(dest, ptr[rsp + kStashOffset]);
   }
 }
 
@@ -708,7 +708,7 @@ void X64Emitter::LoadConstantXmm(Xbyak::Xmm dest, double v) {
 }
 
 Address X64Emitter::StashXmm(int index, const Xmm& r) {
-  auto addr = ptr[rsp + STASH_OFFSET + (index * 16)];
+  auto addr = ptr[rsp + kStashOffset + (index * 16)];
   vmovups(addr, r);
   return addr;
 }

src/xenia/cpu/export_resolver.cc

@@ -15,9 +15,9 @@
 namespace xe {
 namespace cpu {
 
-ExportResolver::ExportResolver() {}
+ExportResolver::ExportResolver() = default;
 
-ExportResolver::~ExportResolver() {}
+ExportResolver::~ExportResolver() = default;
 
 void ExportResolver::RegisterTable(
     const std::string& library_name,
@@ -40,28 +40,28 @@ Export* ExportResolver::GetExportByOrdinal(const std::string& library_name,
 
 void ExportResolver::SetVariableMapping(const std::string& library_name,
                                         uint16_t ordinal, uint32_t value) {
-  auto export = GetExportByOrdinal(library_name, ordinal);
-  assert_not_null(export);
-  export->tags |= ExportTag::kImplemented;
-  export->variable_ptr = value;
+  auto export_entry = GetExportByOrdinal(library_name, ordinal);
+  assert_not_null(export_entry);
+  export_entry->tags |= ExportTag::kImplemented;
+  export_entry->variable_ptr = value;
 }
 
 void ExportResolver::SetFunctionMapping(const std::string& library_name,
                                         uint16_t ordinal,
                                         xe_kernel_export_shim_fn shim) {
-  auto export = GetExportByOrdinal(library_name, ordinal);
-  assert_not_null(export);
-  export->tags |= ExportTag::kImplemented;
-  export->function_data.shim = shim;
+  auto export_entry = GetExportByOrdinal(library_name, ordinal);
+  assert_not_null(export_entry);
+  export_entry->tags |= ExportTag::kImplemented;
+  export_entry->function_data.shim = shim;
 }
 
 void ExportResolver::SetFunctionMapping(const std::string& library_name,
                                         uint16_t ordinal,
                                         ExportTrampoline trampoline) {
-  auto export = GetExportByOrdinal(library_name, ordinal);
-  assert_not_null(export);
-  export->tags |= ExportTag::kImplemented;
-  export->function_data.trampoline = trampoline;
+  auto export_entry = GetExportByOrdinal(library_name, ordinal);
+  assert_not_null(export_entry);
+  export_entry->tags |= ExportTag::kImplemented;
+  export_entry->function_data.trampoline = trampoline;
 }
 
 }  // namespace cpu

src/xenia/cpu/frontend/ppc_emit_fpu.cc

@@ -475,8 +475,8 @@ XEEMITTER(mtfsfx, 0xFC00058E, XFL)(PPCHIRBuilder& f, InstrData& i) {
   } else {
     // Directly store.
     // TODO(benvanik): use w/field mask to select bits.
-    i.XFL.W;
-    i.XFL.FM;
+    // i.XFL.W;
+    // i.XFL.FM;
     f.StoreFPSCR(f.Cast(f.LoadFPR(i.XFL.RB), INT64_TYPE));
   }
   return 0;

src/xenia/cpu/frontend/ppc_instr.cc

@@ -32,7 +32,7 @@ void DumpAllInstrCounts() {
                       instr_type->name);
     }
   }
-  fprintf(stdout, sb.GetString());
+  fprintf(stdout, "%s", sb.GetString());
   fflush(stdout);
 }
 

src/xenia/cpu/frontend/ppc_translator.cc

@@ -46,7 +46,7 @@ PPCTranslator::PPCTranslator(PPCFrontend* frontend) : frontend_(frontend) {
   scanner_.reset(new PPCScanner(frontend));
   builder_.reset(new PPCHIRBuilder(frontend));
   compiler_.reset(new Compiler(frontend->processor()));
-  assembler_ = std::move(backend->CreateAssembler());
+  assembler_ = backend->CreateAssembler();
   assembler_->Initialize();
 
   bool validate = FLAGS_validate_hir;

src/xenia/cpu/xex_module.cc

@@ -35,14 +35,7 @@ void UndefinedImport(PPCContext* ppc_context, KernelState* kernel_state) {
 }
 
 XexModule::XexModule(Processor* processor, KernelState* kernel_state)
-    : Module(processor),
-      processor_(processor),
-      kernel_state_(kernel_state),
-      xex_(nullptr),
-      base_address_(0),
-      low_address_(0),
-      high_address_(0),
-      loaded_(false) {}
+    : Module(processor), processor_(processor), kernel_state_(kernel_state) {}
 
 XexModule::~XexModule() { xe_xex2_dealloc(xex_); }
 
@@ -150,8 +143,6 @@ uint32_t XexModule::GetProcAddress(const char* name) const {
   // Table of ordinals (by name)
   uint16_t* ordinal_table = (uint16_t*)((uint64_t)e + e->AddressOfNameOrdinals);
 
-  const char* mod_name = (const char*)((uint64_t)e + e->Name);
-
   for (uint32_t i = 0; i < e->NumberOfNames; i++) {
     const char* fn_name = (const char*)((uint64_t)e + name_table[i]);
     uint16_t ordinal = ordinal_table[i];
@@ -210,7 +201,6 @@ bool XexModule::Load(const std::string& name, const std::string& path,
   loaded_ = true;
   xex_ = xex;
 
-  auto header = xex_header();
   auto old_header = xe_xex2_get_header(xex_);
 
   // Setup debug info.

src/xenia/cpu/xex_module.h

@@ -83,17 +83,17 @@ class XexModule : public xe::cpu::Module {
   bool FindSaveRest();
 
  private:
-  Processor* processor_;
-  kernel::KernelState* kernel_state_;
+  Processor* processor_ = nullptr;
+  kernel::KernelState* kernel_state_ = nullptr;
   std::string name_;
   std::string path_;
-  xe_xex2_ref xex_;
+  xe_xex2_ref xex_ = nullptr;
   std::vector<uint8_t> xex_header_mem_;  // Holds the xex header
-  bool loaded_;                          // Loaded into memory?
+  bool loaded_ = false;                  // Loaded into memory?
 
-  uint32_t base_address_;
-  uint32_t low_address_;
-  uint32_t high_address_;
+  uint32_t base_address_ = 0;
+  uint32_t low_address_ = 0;
+  uint32_t high_address_ = 0;
 };
 
 }  // namespace cpu