Removing alloy::tracing, as it's unused.

src/xenia/cpu/xenon_memory.cc

@@ -11,12 +11,9 @@
 
 #include <mutex>
 
-#include <alloy/runtime/tracing.h>
-
 #include <gflags/gflags.h>
 
 using namespace alloy;
-using namespace alloy::runtime;
 using namespace xe::cpu;
 
 // TODO(benvanik): move xbox.h out
@@ -267,9 +264,6 @@ XenonMemory::~XenonMemory() {
     CloseHandle(mapping_);
     mapping_base_ = 0;
     mapping_ = 0;
-
-    alloy::tracing::WriteEvent(EventType::MemoryDeinit({
-    }));
   }
 }
 
@@ -311,9 +305,6 @@ int XenonMemory::Initialize() {
   }
   membase_ = mapping_base_;
 
-  alloy::tracing::WriteEvent(EventType::MemoryInit({
-  }));
-
   // Prepare heaps.
   virtual_heap_->Initialize(
       XENON_MEMORY_VIRTUAL_HEAP_LOW, XENON_MEMORY_VIRTUAL_HEAP_HIGH);
@@ -542,10 +533,6 @@ uint64_t XenonMemory::HeapAlloc(
       xe_zero_struct(pv, size);
     }
 
-    alloy::tracing::WriteEvent(EventType::MemoryHeapAlloc({
-      0, flags, base_address, size,
-    }));
-
     return base_address;
   }
 }
@@ -559,9 +546,6 @@ int XenonMemory::HeapFree(uint64_t address, size_t size) {
     return physical_heap_->Free(address, size) ? 0 : 1;
   } else {
     // A placed address. Decommit.
-    alloy::tracing::WriteEvent(EventType::MemoryHeapFree({
-      0, address,
-    }));
     uint8_t* p = Translate(address);
     return VirtualFree(p, size, MEM_DECOMMIT) ? 0 : 1;
   }
@@ -628,10 +612,6 @@ XenonMemoryHeap::~XenonMemoryHeap() {
 
   if (ptr_) {
     XEIGNORE(VirtualFree(ptr_, 0, MEM_RELEASE));
-
-    alloy::tracing::WriteEvent(EventType::MemoryHeapDeinit({
-      heap_id_,
-    }));
   }
 }
 
@@ -648,10 +628,6 @@ int XenonMemoryHeap::Initialize(uint64_t low, uint64_t high) {
   }
   space_ = create_mspace_with_base(ptr_, size_, 0);
 
-  alloy::tracing::WriteEvent(EventType::MemoryHeapInit({
-    heap_id_, low, high, is_physical_,
-  }));
-
   return 0;
 }
 
@@ -719,10 +695,6 @@ uint64_t XenonMemoryHeap::Alloc(
   uint64_t address =
       (uint64_t)((uintptr_t)p - (uintptr_t)memory_->mapping_base_);
 
-  alloy::tracing::WriteEvent(EventType::MemoryHeapAlloc({
-    heap_id_, flags, address, size,
-  }));
-
   return address;
 }
 
@@ -775,10 +747,6 @@ uint64_t XenonMemoryHeap::Free(uint64_t address, size_t size) {
         MEM_DECOMMIT);
   }
 
-  alloy::tracing::WriteEvent(EventType::MemoryHeapFree({
-    heap_id_, address,
-  }));
-
   return (uint64_t)real_size;
 }
 

src/xenia/cpu/xenon_runtime.cc

@@ -10,7 +10,6 @@
 #include <xenia/cpu/xenon_runtime.h>
 
 #include <alloy/frontend/ppc/ppc_frontend.h>
-#include <alloy/runtime/tracing.h>
 
 #include <xenia/cpu/xenon_thread_state.h>
 
@@ -27,10 +26,7 @@ XenonRuntime::XenonRuntime(
     export_resolver_(export_resolver) {
 }
 
-XenonRuntime::~XenonRuntime() {
-  alloy::tracing::WriteEvent(EventType::Deinit({
-  }));
-}
+XenonRuntime::~XenonRuntime() = default;
 
 int XenonRuntime::Initialize(std::unique_ptr<backend::Backend> backend) {
   std::unique_ptr<PPCFrontend> frontend(new PPCFrontend(this));
@@ -41,8 +37,5 @@ int XenonRuntime::Initialize(std::unique_ptr<backend::Backend> backend) {
     return result;
   }
 
-  alloy::tracing::WriteEvent(EventType::Init({
-  }));
-
   return result;
 }

src/xenia/cpu/xenon_thread_state.cc

@@ -9,8 +9,6 @@
 
 #include <xenia/cpu/xenon_thread_state.h>
 
-#include <alloy/runtime/tracing.h>
-
 #include <xenia/cpu/xenon_runtime.h>
 
 using namespace alloy;
@@ -19,15 +17,13 @@ using namespace alloy::frontend::ppc;
 using namespace alloy::runtime;
 using namespace xe::cpu;
 
-
-XenonThreadState::XenonThreadState(
-    XenonRuntime* runtime, uint32_t thread_id,
-    size_t stack_size, uint64_t thread_state_address) :
-    ThreadState(runtime, thread_id),
-    stack_size_(stack_size),
-    thread_state_address_(thread_state_address) {
-  stack_address_ = memory_->HeapAlloc(
-      0, stack_size, MEMORY_FLAG_ZERO);
+XenonThreadState::XenonThreadState(XenonRuntime* runtime, uint32_t thread_id,
+                                   size_t stack_size,
+                                   uint64_t thread_state_address)
+    : ThreadState(runtime, thread_id),
+      stack_size_(stack_size),
+      thread_state_address_(thread_state_address) {
+  stack_address_ = memory_->HeapAlloc(0, stack_size, MEMORY_FLAG_ZERO);
 
   // Allocate with 64b alignment.
   context_ = (PPCContext*)xe_malloc_aligned(sizeof(PPCContext));
@@ -36,12 +32,12 @@ XenonThreadState::XenonThreadState(
 
   // Stash pointers to common structures that callbacks may need.
   context_->reserve_address = memory_->reserve_address();
-  context_->membase         = memory_->membase();
-  context_->runtime         = runtime;
-  context_->thread_state    = this;
+  context_->membase = memory_->membase();
+  context_->runtime = runtime;
+  context_->thread_state = this;
 
   // Set initial registers.
-  context_->r[1]  = stack_address_ + stack_size;
+  context_->r[1] = stack_address_ + stack_size;
   context_->r[13] = thread_state_address_;
 
   // Pad out stack a bit, as some games seem to overwrite the caller by about
@@ -50,18 +46,12 @@ XenonThreadState::XenonThreadState(
 
   raw_context_ = context_;
 
-  alloy::tracing::WriteEvent(EventType::ThreadInit({
-  }));
-
   runtime_->debugger()->OnThreadCreated(this);
 }
 
 XenonThreadState::~XenonThreadState() {
   runtime_->debugger()->OnThreadDestroyed(this);
 
-  alloy::tracing::WriteEvent(EventType::ThreadDeinit({
-  }));
-
   xe_free_aligned(context_);
   memory_->HeapFree(stack_address_, stack_size_);
 }

src/xenia/cpu/xex_module.cc

@@ -9,7 +9,6 @@
 
 #include <xenia/cpu/xex_module.h>
 
-#include <alloy/runtime/tracing.h>
 #include <xenia/cpu/cpu-private.h>
 #include <xenia/cpu/xenon_runtime.h>
 #include <xenia/export_resolver.h>