[D3D12] Switch from gflags to cvars

src/xenia/cpu/backend/x64/premake5.lua

@@ -27,6 +27,5 @@ project("xenia-cpu-backend-x64")
 
   includedirs({
     project_root.."/third_party/capstone/include",
-    project_root.."/third_party/gflags/src",
   })
   local_platform_files()

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

@@ -28,7 +28,8 @@
 
 DEFINE_bool(
     enable_haswell_instructions, true,
-    "Uses the AVX2/FMA/etc instructions on Haswell processors, if available.");
+    "Uses the AVX2/FMA/etc instructions on Haswell processors, if available.",
+    "CPU");
 
 namespace xe {
 namespace cpu {
@@ -83,7 +84,7 @@ bool X64Backend::Initialize(Processor* processor) {
   }
 
   // Need movbe to do advanced LOAD/STORE tricks.
-  if (FLAGS_enable_haswell_instructions) {
+  if (cvars::enable_haswell_instructions) {
     machine_info_.supports_extended_load_store =
         cpu.has(Xbyak::util::Cpu::tMOVBE);
   } else {

src/xenia/cpu/backend/x64/x64_backend.h

@@ -10,10 +10,9 @@
 #ifndef XENIA_CPU_BACKEND_X64_X64_BACKEND_H_
 #define XENIA_CPU_BACKEND_X64_X64_BACKEND_H_
 
-#include <gflags/gflags.h>
-
 #include <memory>
 
+#include "xenia/base/cvar.h"
 #include "xenia/cpu/backend/backend.h"
 
 DECLARE_bool(enable_haswell_instructions);

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

@@ -9,8 +9,6 @@
 
 #include "xenia/cpu/backend/x64/x64_emitter.h"
 
-#include <gflags/gflags.h>
-
 #include <stddef.h>
 #include <climits>
 #include <cstring>
@@ -36,11 +34,12 @@
 #include "xenia/cpu/thread_state.h"
 
 DEFINE_bool(enable_debugprint_log, false,
-            "Log debugprint traps to the active debugger");
+            "Log debugprint traps to the active debugger", "CPU");
 DEFINE_bool(ignore_undefined_externs, true,
-            "Don't exit when an undefined extern is called.");
+            "Don't exit when an undefined extern is called.", "CPU");
 DEFINE_bool(emit_source_annotations, false,
-            "Add extra movs and nops to make disassembly easier to read.");
+            "Add extra movs and nops to make disassembly easier to read.",
+            "CPU");
 
 namespace xe {
 namespace cpu {
@@ -71,7 +70,7 @@ X64Emitter::X64Emitter(X64Backend* backend, XbyakAllocator* allocator)
       backend_(backend),
       code_cache_(backend->code_cache()),
       allocator_(allocator) {
-  if (FLAGS_enable_haswell_instructions) {
+  if (cvars::enable_haswell_instructions) {
     feature_flags_ |= cpu_.has(Xbyak::util::Cpu::tAVX2) ? kX64EmitAVX2 : 0;
     feature_flags_ |= cpu_.has(Xbyak::util::Cpu::tFMA) ? kX64EmitFMA : 0;
     feature_flags_ |= cpu_.has(Xbyak::util::Cpu::tLZCNT) ? kX64EmitLZCNT : 0;
@@ -245,7 +244,7 @@ bool X64Emitter::Emit(HIRBuilder* builder, size_t* out_stack_size) {
   add(rsp, (uint32_t)stack_size);
   ret();
 
-  if (FLAGS_emit_source_annotations) {
+  if (cvars::emit_source_annotations) {
     nop();
     nop();
     nop();
@@ -262,7 +261,7 @@ void X64Emitter::MarkSourceOffset(const Instr* i) {
   entry->hir_offset = uint32_t(i->block->ordinal << 16) | i->ordinal;
   entry->code_offset = static_cast<uint32_t>(getSize());
 
-  if (FLAGS_emit_source_annotations) {
+  if (cvars::emit_source_annotations) {
     nop();
     nop();
     mov(eax, entry->guest_address);
@@ -299,7 +298,7 @@ uint64_t TrapDebugPrint(void* raw_context, uint64_t address) {
   // TODO(benvanik): truncate to length?
   XELOGD("(DebugPrint) %s", str);
 
-  if (FLAGS_enable_debugprint_log) {
+  if (cvars::enable_debugprint_log) {
     debugging::DebugPrint("(DebugPrint) %s", str);
   }
 
@@ -309,7 +308,7 @@ uint64_t TrapDebugPrint(void* raw_context, uint64_t address) {
 uint64_t TrapDebugBreak(void* raw_context, uint64_t address) {
   auto thread_state = *reinterpret_cast<ThreadState**>(raw_context);
   XELOGE("tw/td forced trap hit! This should be a crash!");
-  if (FLAGS_break_on_debugbreak) {
+  if (cvars::break_on_debugbreak) {
     xe::debugging::Break();
   }
   return 0;
@@ -446,7 +445,7 @@ void X64Emitter::CallIndirect(const hir::Instr* instr,
 
 uint64_t UndefinedCallExtern(void* raw_context, uint64_t function_ptr) {
   auto function = reinterpret_cast<Function*>(function_ptr);
-  if (!FLAGS_ignore_undefined_externs) {
+  if (!cvars::ignore_undefined_externs) {
     xe::FatalError("undefined extern call to %.8X %s", function->address(),
                    function->name().c_str());
   } else {

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

@@ -9,8 +9,6 @@
 
 #include "xenia/cpu/compiler/passes/conditional_group_pass.h"
 
-#include <gflags/gflags.h>
-
 #include "xenia/base/profiling.h"
 #include "xenia/cpu/compiler/compiler.h"
 #include "xenia/cpu/ppc/ppc_context.h"

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

@@ -9,15 +9,16 @@
 
 #include "xenia/cpu/compiler/passes/constant_propagation_pass.h"
 
-#include <gflags/gflags.h>
 #include <cmath>
 
 #include "xenia/base/assert.h"
+#include "xenia/base/cvar.h"
 #include "xenia/base/profiling.h"
 #include "xenia/cpu/function.h"
 #include "xenia/cpu/processor.h"
 
-DEFINE_bool(inline_mmio_access, true, "Inline constant MMIO loads and stores.");
+DEFINE_bool(inline_mmio_access, true, "Inline constant MMIO loads and stores.",
+            "CPU");
 
 namespace xe {
 namespace cpu {
@@ -221,7 +222,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder, bool& result) {
 
             auto mmio_range =
                 processor_->memory()->LookupVirtualMappedRange(address);
-            if (FLAGS_inline_mmio_access && mmio_range) {
+            if (cvars::inline_mmio_access && mmio_range) {
               i->Replace(&OPCODE_LOAD_MMIO_info, 0);
               i->src1.offset = reinterpret_cast<uint64_t>(mmio_range);
               i->src2.offset = address;
@@ -273,7 +274,7 @@ bool ConstantPropagationPass::Run(HIRBuilder* builder, bool& result) {
           break;
         case OPCODE_STORE:
         case OPCODE_STORE_OFFSET:
-          if (FLAGS_inline_mmio_access && i->src1.value->IsConstant()) {
+          if (cvars::inline_mmio_access && i->src1.value->IsConstant()) {
             auto address = i->src1.value->constant.i32;
             if (i->opcode->num == OPCODE_STORE_OFFSET) {
               address += i->src2.value->constant.i32;

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

@@ -9,8 +9,8 @@
 
 #include "xenia/cpu/compiler/passes/context_promotion_pass.h"
 
-#include <gflags/gflags.h>
-
+#include "xenia/apu/apu_flags.h"
+#include "xenia/base/cvar.h"
 #include "xenia/base/profiling.h"
 #include "xenia/cpu/compiler/compiler.h"
 #include "xenia/cpu/ppc/ppc_context.h"
@@ -19,7 +19,7 @@
 DECLARE_bool(debug);
 
 DEFINE_bool(store_all_context_values, false,
-            "Don't strip dead context stores to aid in debugging.");
+            "Don't strip dead context stores to aid in debugging.", "CPU");
 
 namespace xe {
 namespace cpu {
@@ -77,7 +77,7 @@ bool ContextPromotionPass::Run(HIRBuilder* builder) {
   // Remove all dead stores.
   // This will break debugging as we can't recover this information when
   // trying to extract stack traces/register values, so we don't do that.
-  if (!FLAGS_debug && !FLAGS_store_all_context_values) {
+  if (!cvars::debug && !cvars::store_all_context_values) {
     block = builder->first_block();
     while (block) {
       RemoveDeadStoresBlock(block);

src/xenia/cpu/cpu_flags.cc

@@ -9,38 +9,42 @@
 
 #include "xenia/cpu/cpu_flags.h"
 
-DEFINE_string(cpu, "any", "CPU backend [any, x64].");
+DEFINE_string(cpu, "any", "CPU backend [any, x64].", "CPU");
 
 DEFINE_string(
     load_module_map, "",
     "Loads a .map for symbol names and to diff with the generated symbol "
-    "database.");
+    "database.",
+    "CPU");
 
 DEFINE_bool(disassemble_functions, false,
-            "Disassemble functions during generation.");
+            "Disassemble functions during generation.", "CPU");
 
-DEFINE_bool(trace_functions, false,
-            "Generate tracing for function statistics.");
+DEFINE_bool(trace_functions, false, "Generate tracing for function statistics.",
+            "CPU");
 DEFINE_bool(trace_function_coverage, false,
-            "Generate tracing for function instruction coverage statistics.");
+            "Generate tracing for function instruction coverage statistics.",
+            "CPU");
 DEFINE_bool(trace_function_references, false,
-            "Generate tracing for function address references.");
+            "Generate tracing for function address references.", "CPU");
 DEFINE_bool(trace_function_data, false,
-            "Generate tracing for function result data.");
+            "Generate tracing for function result data.", "CPU");
 
 DEFINE_bool(
     disable_global_lock, false,
-    "Disables global lock usage in guest code. Does not affect host code.");
+    "Disables global lock usage in guest code. Does not affect host code.",
+    "CPU");
 
 DEFINE_bool(validate_hir, false,
-            "Perform validation checks on the HIR during compilation.");
+            "Perform validation checks on the HIR during compilation.", "CPU");
 
 // Breakpoints:
 DEFINE_uint64(break_on_instruction, 0,
-              "int3 before the given guest address is executed.");
-DEFINE_int32(break_condition_gpr, -1, "GPR compared to");
-DEFINE_uint64(break_condition_value, 0, "value compared against");
-DEFINE_string(break_condition_op, "eq", "comparison operator");
-DEFINE_bool(break_condition_truncate, true, "truncate value to 32-bits");
+              "int3 before the given guest address is executed.", "CPU");
+DEFINE_int32(break_condition_gpr, -1, "GPR compared to", "CPU");
+DEFINE_uint64(break_condition_value, 0, "value compared against", "CPU");
+DEFINE_string(break_condition_op, "eq", "comparison operator", "CPU");
+DEFINE_bool(break_condition_truncate, true, "truncate value to 32-bits", "CPU");
 
-DEFINE_bool(break_on_debugbreak, true, "int3 on JITed __debugbreak requests.");
+DEFINE_bool(break_on_debugbreak, true, "int3 on JITed __debugbreak requests.",
+            "CPU");

src/xenia/cpu/cpu_flags.h

@@ -9,8 +9,7 @@
 
 #ifndef XENIA_CPU_CPU_FLAGS_H_
 #define XENIA_CPU_CPU_FLAGS_H_
-
-#include <gflags/gflags.h>
+#include "xenia/base/cvar.h"
 
 DECLARE_string(cpu);
 

src/xenia/cpu/ppc/ppc_emit_control.cc

@@ -728,12 +728,12 @@ int InstrEmit_mtmsr(PPCHIRBuilder& f, const InstrData& i) {
         f.ZeroExtend(f.ZeroExtend(f.LoadGPR(i.X.RT), INT64_TYPE), INT64_TYPE));
     if (i.X.RT == 13) {
       // iff storing from r13 we are taking a lock (disable interrupts).
-      if (!FLAGS_disable_global_lock) {
+      if (!cvars::disable_global_lock) {
         f.CallExtern(f.builtins()->enter_global_lock);
       }
     } else {
       // Otherwise we are restoring interrupts (probably).
-      if (!FLAGS_disable_global_lock) {
+      if (!cvars::disable_global_lock) {
         f.CallExtern(f.builtins()->leave_global_lock);
       }
     }
@@ -753,12 +753,12 @@ int InstrEmit_mtmsrd(PPCHIRBuilder& f, const InstrData& i) {
                    f.ZeroExtend(f.LoadGPR(i.X.RT), INT64_TYPE));
     if (i.X.RT == 13) {
       // iff storing from r13 we are taking a lock (disable interrupts).
-      if (!FLAGS_disable_global_lock) {
+      if (!cvars::disable_global_lock) {
         f.CallExtern(f.builtins()->enter_global_lock);
       }
     } else {
       // Otherwise we are restoring interrupts (probably).
-      if (!FLAGS_disable_global_lock) {
+      if (!cvars::disable_global_lock) {
         f.CallExtern(f.builtins()->leave_global_lock);
       }
     }

src/xenia/cpu/ppc/ppc_hir_builder.cc

@@ -182,25 +182,25 @@ bool PPCHIRBuilder::Emit(GuestFunction* function, uint32_t flags) {
 }
 
 void PPCHIRBuilder::MaybeBreakOnInstruction(uint32_t address) {
-  if (address != FLAGS_break_on_instruction) {
+  if (address != cvars::break_on_instruction) {
     return;
   }
 
   Comment("--break-on-instruction target");
 
-  if (FLAGS_break_condition_gpr < 0) {
+  if (cvars::break_condition_gpr < 0) {
     DebugBreak();
     return;
   }
 
-  auto left = LoadGPR(FLAGS_break_condition_gpr);
-  auto right = LoadConstantUint64(FLAGS_break_condition_value);
-  if (FLAGS_break_condition_truncate) {
+  auto left = LoadGPR(cvars::break_condition_gpr);
+  auto right = LoadConstantUint64(cvars::break_condition_value);
+  if (cvars::break_condition_truncate) {
     left = Truncate(left, INT32_TYPE);
     right = Truncate(right, INT32_TYPE);
   }
 
-  auto op = FLAGS_break_condition_op.c_str();
+  auto op = cvars::break_condition_op.c_str();
   // TODO(rick): table?
   if (strcasecmp(op, "eq") == 0) {
     TrapTrue(CompareEQ(left, right));

src/xenia/cpu/ppc/ppc_translator.cc

@@ -9,8 +9,6 @@
 
 #include "xenia/cpu/ppc/ppc_translator.h"
 
-#include <gflags/gflags.h>
-
 #include "xenia/base/assert.h"
 #include "xenia/base/byte_order.h"
 #include "xenia/base/memory.h"
@@ -41,7 +39,7 @@ PPCTranslator::PPCTranslator(PPCFrontend* frontend) : frontend_(frontend) {
   assembler_ = backend->CreateAssembler();
   assembler_->Initialize();
 
-  bool validate = FLAGS_validate_hir;
+  bool validate = cvars::validate_hir;
 
   // Merge blocks early. This will let us use more context in other passes.
   // The CFG is required for simplification and dirtied by it.
@@ -108,19 +106,19 @@ bool PPCTranslator::Translate(GuestFunction* function,
   xe::make_reset_scope(&string_buffer_);
 
   // NOTE: we only want to do this when required, as it's expensive to build.
-  if (FLAGS_disassemble_functions) {
+  if (cvars::disassemble_functions) {
     debug_info_flags |= DebugInfoFlags::kDebugInfoAllDisasm;
   }
-  if (FLAGS_trace_functions) {
+  if (cvars::trace_functions) {
     debug_info_flags |= DebugInfoFlags::kDebugInfoTraceFunctions;
   }
-  if (FLAGS_trace_function_coverage) {
+  if (cvars::trace_function_coverage) {
     debug_info_flags |= DebugInfoFlags::kDebugInfoTraceFunctionCoverage;
   }
-  if (FLAGS_trace_function_references) {
+  if (cvars::trace_function_references) {
     debug_info_flags |= DebugInfoFlags::kDebugInfoTraceFunctionReferences;
   }
-  if (FLAGS_trace_function_data) {
+  if (cvars::trace_function_data) {
     debug_info_flags |= DebugInfoFlags::kDebugInfoTraceFunctionData;
   }
   std::unique_ptr<FunctionDebugInfo> debug_info;

src/xenia/cpu/ppc/testing/ppc_testing_main.cc

@@ -7,8 +7,6 @@
  ******************************************************************************
  */
 
-#include <gflags/gflags.h>
-
 #include "xenia/base/filesystem.h"
 #include "xenia/base/logging.h"
 #include "xenia/base/main.h"
@@ -26,9 +24,9 @@
 #endif  // XE_COMPILER_MSVC
 
 DEFINE_string(test_path, "src/xenia/cpu/ppc/testing/",
-              "Directory scanned for test files.");
+              "Directory scanned for test files.", "Other");
 DEFINE_string(test_bin_path, "src/xenia/cpu/ppc/testing/bin/",
-              "Directory with binary outputs of the test files.");
+              "Directory with binary outputs of the test files.", "Other");
 
 namespace xe {
 namespace cpu {
@@ -54,8 +52,8 @@ class TestSuite {
     name = src_file_path.substr(src_file_path.find_last_of(xe::kPathSeparator) +
                                 1);
     name = ReplaceExtension(name, L"");
-    map_file_path = xe::to_wstring(FLAGS_test_bin_path) + name + L".map";
-    bin_file_path = xe::to_wstring(FLAGS_test_bin_path) + name + L".bin";
+    map_file_path = xe::to_wstring(cvars::test_bin_path) + name + L".map";
+    bin_file_path = xe::to_wstring(cvars::test_bin_path) + name + L".bin";
   }
 
   bool Load() {
@@ -192,11 +190,11 @@ class TestRunner {
     std::unique_ptr<xe::cpu::backend::Backend> backend;
     if (!backend) {
 #if defined(XENIA_HAS_X64_BACKEND) && XENIA_HAS_X64_BACKEND
-      if (FLAGS_cpu == "x64") {
+      if (cvars::cpu == "x64") {
         backend.reset(new xe::cpu::backend::x64::X64Backend());
       }
 #endif  // XENIA_HAS_X64_BACKEND
-      if (FLAGS_cpu == "any") {
+      if (cvars::cpu == "any") {
 #if defined(XENIA_HAS_X64_BACKEND) && XENIA_HAS_X64_BACKEND
         if (!backend) {
           backend.reset(new xe::cpu::backend::x64::X64Backend());
@@ -408,7 +406,7 @@ bool RunTests(const std::wstring& test_name) {
   int passed_count = 0;
 
   auto test_path_root =
-      xe::fix_path_separators(xe::to_wstring(FLAGS_test_path));
+      xe::fix_path_separators(xe::to_wstring(cvars::test_path));
   std::vector<std::wstring> test_files;
   if (!DiscoverTests(test_path_root, test_files)) {
     return false;

src/xenia/cpu/ppc/testing/ppc_testing_native_main.cc

@@ -7,8 +7,6 @@
  ******************************************************************************
  */
 
-#include <gflags/gflags.h>
-
 #include "xenia/base/filesystem.h"
 #include "xenia/base/logging.h"
 #include "xenia/base/main.h"
@@ -58,8 +56,8 @@ class TestSuite {
     name = src_file_path.substr(src_file_path.find_last_of(xe::kPathSeparator) +
                                 1);
     name = ReplaceExtension(name, L"");
-    map_file_path = xe::to_wstring(FLAGS_test_bin_path) + name + L".map";
-    bin_file_path = xe::to_wstring(FLAGS_test_bin_path) + name + L".bin";
+    map_file_path = xe::to_wstring(cvars::test_bin_path) + name + L".map";
+    bin_file_path = xe::to_wstring(cvars::test_bin_path) + name + L".bin";
   }
 
   bool Load() {
@@ -454,7 +452,7 @@ bool RunTests(const std::wstring& test_name) {
   int passed_count = 0;
 
   auto test_path_root =
-      xe::fix_path_separators(xe::to_wstring(FLAGS_test_path));
+      xe::fix_path_separators(xe::to_wstring(cvars::test_path));
   std::vector<std::wstring> test_files;
   if (!DiscoverTests(test_path_root, test_files)) {
     return false;

src/xenia/cpu/ppc/testing/premake5.lua

@@ -11,7 +11,6 @@ project("xenia-cpu-ppc-tests")
     "xenia-cpu-backend-x64",
     "xenia-cpu",
     "xenia-base",
-    "gflags",
     "capstone", -- cpu-backend-x64
     "mspack",
   })
@@ -22,15 +21,11 @@ project("xenia-cpu-ppc-tests")
   files({
     "*.s",
   })
-  includedirs({
-    project_root.."/third_party/gflags/src",
-  })
   filter("files:*.s")
     flags({"ExcludeFromBuild"})
   filter("platforms:Windows")
     debugdir(project_root)
     debugargs({
-      "--flagfile=scratch/flags.txt",
       "2>&1",
       "1>scratch/stdout-testing.txt",
     })
@@ -46,7 +41,6 @@ project("xenia-cpu-ppc-nativetests")
   language("C++")
   links({
     "xenia-base",
-    "gflags",
   })
   files({
     "ppc_testing_native_main.cc",
@@ -59,9 +53,6 @@ project("xenia-cpu-ppc-nativetests")
   filter("files:instr_*.s", "files:seq_*.s")
     flags({"ExcludeFromBuild"})
   filter({})
-  includedirs({
-    project_root.."/third_party/gflags/src",
-  })
   buildoptions({
     "-Wa,-mregnames",  -- Tell GAS to accept register names.
   })

src/xenia/cpu/premake5.lua

@@ -12,7 +12,6 @@ project("xenia-cpu")
   })
   includedirs({
     project_root.."/third_party/llvm/include",
-    project_root.."/third_party/gflags/src",
   })
   local_platform_files()
   local_platform_files("backend")

src/xenia/cpu/processor.cc

@@ -9,12 +9,11 @@
 
 #include "xenia/cpu/processor.h"
 
-#include <gflags/gflags.h>
-
 #include "xenia/base/assert.h"
 #include "xenia/base/atomic.h"
 #include "xenia/base/byte_order.h"
 #include "xenia/base/byte_stream.h"
+#include "xenia/base/cvar.h"
 #include "xenia/base/debugging.h"
 #include "xenia/base/exception_handler.h"
 #include "xenia/base/logging.h"
@@ -42,9 +41,11 @@
 #endif
 
 DEFINE_bool(debug, DEFAULT_DEBUG_FLAG,
-            "Allow debugging and retain debug information.");
-DEFINE_string(trace_function_data_path, "", "File to write trace data to.");
-DEFINE_bool(break_on_start, false, "Break into the debugger on startup.");
+            "Allow debugging and retain debug information.", "General");
+DEFINE_string(trace_function_data_path, "", "File to write trace data to.",
+              "CPU");
+DEFINE_bool(break_on_start, false, "Break into the debugger on startup.",
+            "CPU");
 
 namespace xe {
 namespace kernel {
@@ -132,14 +133,14 @@ bool Processor::Setup(std::unique_ptr<backend::Backend> backend) {
   stack_walker_ = StackWalker::Create(backend_->code_cache());
   if (!stack_walker_) {
     // TODO(benvanik): disable features.
-    if (FLAGS_debug) {
+    if (cvars::debug) {
       XELOGW("Disabling --debug due to lack of stack walker");
-      FLAGS_debug = false;
+      cvars::debug = false;
     }
   }
 
   // Open the trace data path, if requested.
-  functions_trace_path_ = xe::to_wstring(FLAGS_trace_function_data_path);
+  functions_trace_path_ = xe::to_wstring(cvars::trace_function_data_path);
   if (!functions_trace_path_.empty()) {
     functions_trace_file_ = ChunkedMappedMemoryWriter::Open(
         functions_trace_path_, 32 * 1024 * 1024, true);
@@ -149,7 +150,7 @@ bool Processor::Setup(std::unique_ptr<backend::Backend> backend) {
 }
 
 void Processor::PreLaunch() {
-  if (FLAGS_break_on_start) {
+  if (cvars::break_on_start) {
     // Start paused.
     XELOGI("Breaking into debugger because of --break_on_start...");
     execution_state_ = ExecutionState::kRunning;
@@ -629,9 +630,9 @@ bool Processor::OnThreadBreakpointHit(Exception* ex) {
     SuspendAllBreakpoints();
   }
 
-  // Update all thread states with their latest values, using the context we got
-  // from the exception instead of a sampled value (as it would just show the
-  // exception handler).
+  // Update all thread states with their latest values, using the context we
+  // got from the exception instead of a sampled value (as it would just show
+  // the exception handler).
   UpdateThreadExecutionStates(thread_info->thread_id, ex->thread_context());
 
   // Walk the captured thread stack and look for breakpoints at any address in

src/xenia/cpu/processor.h

@@ -10,13 +10,12 @@
 #ifndef XENIA_CPU_PROCESSOR_H_
 #define XENIA_CPU_PROCESSOR_H_
 
-#include <gflags/gflags.h>
-
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
+#include "xenia/base/cvar.h"
 #include "xenia/base/mapped_memory.h"
 #include "xenia/base/mutex.h"
 #include "xenia/cpu/backend/backend.h"

src/xenia/cpu/stack_walker_win.cc

@@ -9,8 +9,6 @@
 
 #include "xenia/cpu/stack_walker.h"
 
-#include <gflags/gflags.h>
-
 #include <mutex>
 
 #include "xenia/base/logging.h"
@@ -20,7 +18,7 @@
 #include "xenia/cpu/processor.h"
 
 DEFINE_bool(debug_symbol_loader, false,
-            "Enable dbghelp debug logging and validation.");
+            "Enable dbghelp debug logging and validation.", "CPU");
 
 // Must be included after platform_win.h:
 #pragma warning(push)
@@ -98,7 +96,7 @@ bool InitializeStackWalker() {
 
   // Initialize the symbol lookup services.
   DWORD options = sym_get_options_();
-  if (FLAGS_debug_symbol_loader) {
+  if (cvars::debug_symbol_loader) {
     options |= SYMOPT_DEBUG;
   }
   options |= SYMOPT_DEFERRED_LOADS;

src/xenia/cpu/testing/premake5.lua

@@ -2,9 +2,6 @@ project_root = "../../../.."
 include(project_root.."/tools/build")
 
 test_suite("xenia-cpu-tests", project_root, ".", {
-  includedirs = {
-    project_root.."/third_party/gflags/src",
-  },
   links = {
     "capstone",
     "xenia-base",

src/xenia/cpu/testing/sandbox_main.cc

@@ -14,8 +14,6 @@
 #include "xenia/cpu/ppc/ppc_frontend.h"
 #include "xenia/cpu/raw_module.h"
 
-#include <gflags/gflags.h>
-
 namespace xe {
 namespace cpu {
 namespace sandbox {

src/xenia/cpu/xex_module.cc

@@ -1008,8 +1008,8 @@ bool XexModule::LoadContinue() {
   }
 
   // Load a specified module map and diff.
-  if (FLAGS_load_module_map.size()) {
-    if (!ReadMap(FLAGS_load_module_map.c_str())) {
+  if (cvars::load_module_map.size()) {
+    if (!ReadMap(cvars::load_module_map.c_str())) {
       return false;
     }
   }