Merging Runtime into Processor.

src/xenia/cpu/processor.h

@@ -13,7 +13,14 @@
 #include <mutex>
 #include <vector>
 
+#include "xenia/cpu/backend/backend.h"
+#include "xenia/cpu/debugger.h"
+#include "xenia/cpu/entry_table.h"
 #include "xenia/cpu/export_resolver.h"
+#include "xenia/cpu/frontend/ppc_frontend.h"
+#include "xenia/cpu/function.h"
+#include "xenia/cpu/module.h"
+#include "xenia/cpu/thread_state.h"
 #include "xenia/memory.h"
 
 namespace xe {
@@ -35,12 +42,31 @@ class Processor {
   Processor(Memory* memory, ExportResolver* export_resolver);
   ~Processor();
 
-  ExportResolver* export_resolver() const { return export_resolver_; }
-  Runtime* runtime() const { return runtime_; }
   Memory* memory() const { return memory_; }
+  Debugger* debugger() const { return debugger_.get(); }
+  frontend::PPCFrontend* frontend() const { return frontend_.get(); }
+  backend::Backend* backend() const { return backend_.get(); }
+  ExportResolver* export_resolver() const { return export_resolver_; }
 
   int Setup();
 
+  int AddModule(std::unique_ptr<Module> module);
+  Module* GetModule(const char* name);
+  Module* GetModule(const std::string& name) { return GetModule(name.c_str()); }
+  std::vector<Module*> GetModules();
+
+  Module* builtin_module() const { return builtin_module_; }
+  FunctionInfo* DefineBuiltin(const std::string& name,
+                              FunctionInfo::ExternHandler handler, void* arg0,
+                              void* arg1);
+
+  std::vector<Function*> FindFunctionsWithAddress(uint32_t address);
+
+  int LookupFunctionInfo(uint32_t address, FunctionInfo** out_symbol_info);
+  int LookupFunctionInfo(Module* module, uint32_t address,
+                         FunctionInfo** out_symbol_info);
+  int ResolveFunction(uint32_t address, Function** out_function);
+
   int Execute(ThreadState* thread_state, uint32_t address);
   uint64_t Execute(ThreadState* thread_state, uint32_t address, uint64_t args[],
                    size_t arg_count);
@@ -52,10 +78,24 @@ class Processor {
                             size_t arg_count);
 
  private:
+  int DemandFunction(FunctionInfo* symbol_info, Function** out_function);
+
+  Memory* memory_;
+
+  uint32_t debug_info_flags_;
+  uint32_t trace_flags_;
+
+  std::unique_ptr<Debugger> debugger_;
+
+  std::unique_ptr<frontend::PPCFrontend> frontend_;
+  std::unique_ptr<backend::Backend> backend_;
   ExportResolver* export_resolver_;
 
-  Runtime* runtime_;
-  Memory* memory_;
+  EntryTable entry_table_;
+  std::mutex modules_lock_;
+  std::vector<std::unique_ptr<Module>> modules_;
+  Module* builtin_module_;
+  uint32_t next_builtin_address_;
 
   Irql irql_;
   std::mutex interrupt_thread_lock_;