Refactoring to allow for raw binary loading.

include/xenia/cpu/codegen/module_generator.h

@@ -35,7 +35,8 @@ class ModuleGenerator {
 public:
   ModuleGenerator(
       xe_memory_ref memory, kernel::ExportResolver* export_resolver,
-      kernel::UserModule* module, sdb::SymbolDatabase* sdb,
+      const char* module_name, const char* module_path,
+      sdb::SymbolDatabase* sdb,
       llvm::LLVMContext* context, llvm::Module* gen_module);
   ~ModuleGenerator();
 
@@ -61,7 +62,8 @@ private:
 
   xe_memory_ref memory_;
   kernel::ExportResolver* export_resolver_;
-  kernel::UserModule* module_;
+  char* module_name_;
+  char* module_path_;
   sdb::SymbolDatabase* sdb_;
 
   llvm::LLVMContext*  context_;

include/xenia/cpu/exec_module.h

@@ -41,22 +41,25 @@ class ExecModule {
 public:
   ExecModule(
       xe_memory_ref memory, shared_ptr<kernel::ExportResolver> export_resolver,
-      kernel::UserModule* user_module,
+      const char* module_name, const char* module_path,
       shared_ptr<llvm::ExecutionEngine>& engine);
   ~ExecModule();
 
-  int Prepare();
+  int PrepareUserModule(kernel::UserModule* user_module);
+  int PrepareRawBinary(uint32_t start_address, uint32_t end_address);
 
   void Dump();
 
 private:
+  int Prepare();
   int InjectGlobals();
   int Init();
   int Uninit();
 
   xe_memory_ref                       memory_;
   shared_ptr<kernel::ExportResolver>  export_resolver_;
-  kernel::UserModule*                 module_;
+  char*                               module_name_;
+  char*                               module_path_;
   shared_ptr<llvm::ExecutionEngine>   engine_;
   shared_ptr<sdb::SymbolDatabase>     sdb_;
   shared_ptr<llvm::LLVMContext>       context_;

include/xenia/cpu/processor.h

@@ -38,6 +38,9 @@ public:
 
   int Setup();
 
+  int PrepareModule(const char* module_name, const char* module_path,
+                    uint32_t start_address, uint32_t end_address,
+                    shared_ptr<kernel::ExportResolver> export_resolver);
   int PrepareModule(kernel::UserModule* user_module,
                     shared_ptr<kernel::ExportResolver> export_resolver);
 

include/xenia/cpu/sdb.h

@@ -142,11 +142,10 @@ public:
 
 class SymbolDatabase {
 public:
-  SymbolDatabase(xe_memory_ref memory, kernel::ExportResolver* export_resolver,
-                 kernel::UserModule* module);
-  ~SymbolDatabase();
+  SymbolDatabase(xe_memory_ref memory, kernel::ExportResolver* export_resolver);
+  virtual ~SymbolDatabase();
 
-  int Analyze();
+  virtual int Analyze();
 
   ExceptionEntrySymbol* GetOrInsertExceptionEntry(uint32_t address);
   FunctionSymbol* GetOrInsertFunction(uint32_t address);
@@ -161,24 +160,21 @@ public:
   void Dump();
   void DumpFunctionBlocks(FunctionSymbol* fn);
 
-private:
+protected:
   typedef std::map<uint32_t, Symbol*> SymbolMap;
   typedef std::list<FunctionSymbol*> FunctionList;
 
-  int FindGplr();
-  int AddImports(const xe_xex2_import_library_t *library);
-  int AddMethodHints();
   int AnalyzeFunction(FunctionSymbol* fn);
   int CompleteFunctionGraph(FunctionSymbol* fn);
   bool FillHoles();
   int FlushQueue();
 
-  bool IsValueInTextRange(uint32_t value);
   bool IsRestGprLr(uint32_t addr);
+  virtual uint32_t GetEntryPoint() = 0;
+  virtual bool IsValueInTextRange(uint32_t value) = 0;
 
   xe_memory_ref   memory_;
   kernel::ExportResolver* export_resolver_;
-  kernel::UserModule* module_;
   size_t          function_count_;
   size_t          variable_count_;
   SymbolMap       symbols_;
@@ -186,6 +182,43 @@ private:
 };
 
 
+class RawSymbolDatabase : public SymbolDatabase {
+public:
+  RawSymbolDatabase(xe_memory_ref memory,
+                    kernel::ExportResolver* export_resolver,
+                    uint32_t start_address, uint32_t end_address);
+  virtual ~RawSymbolDatabase();
+
+private:
+  virtual uint32_t GetEntryPoint();
+  virtual bool IsValueInTextRange(uint32_t value);
+
+  uint32_t start_address_;
+  uint32_t end_address_;
+};
+
+
+class XexSymbolDatabase : public SymbolDatabase {
+public:
+  XexSymbolDatabase(xe_memory_ref memory,
+                    kernel::ExportResolver* export_resolver,
+                    kernel::UserModule* module);
+  virtual ~XexSymbolDatabase();
+
+  virtual int Analyze();
+
+private:
+  int FindGplr();
+  int AddImports(const xe_xex2_import_library_t *library);
+  int AddMethodHints();
+
+  virtual uint32_t GetEntryPoint();
+  virtual bool IsValueInTextRange(uint32_t value);
+
+  kernel::UserModule* module_;
+};
+
+
 }  // namespace sdb
 }  // namespace cpu
 }  // namespace xe

include/xenia/kernel/runtime.h

@@ -44,6 +44,8 @@ public:
   shared_ptr<ExportResolver> export_resolver();
   const xechar_t* command_line();
 
+  int LoadBinaryModule(const xechar_t* path, uint32_t start_address);
+
   int LoadModule(const xechar_t* path);
   void LaunchModule(UserModule* user_module);
   UserModule* GetModule(const xechar_t* path);