Now running up to the first required kernel call.

If memory address validation is turned off it runs a lot further.

src/kernel/export.cc

@@ -14,23 +14,6 @@ using namespace xe;
 using namespace xe::kernel;
 
 
-bool KernelExport::IsImplemented() {
-  switch (type) {
-  case Function:
-    if (function_data.impl) {
-      return true;
-    }
-    break;
-  case Variable:
-    if (variable_data) {
-      return true;
-    }
-    break;
-  }
-  return false;
-}
-
-
 ExportResolver::ExportResolver() {
 }
 
@@ -44,6 +27,13 @@ void ExportResolver::RegisterTable(
   table.exports = exports;
   table.count = count;
   tables_.push_back(table);
+
+  for (size_t n = 0; n < count; n++) {
+    exports[n].is_implemented = false;
+    exports[n].variable_ptr = 0;
+    exports[n].function_data.shim = NULL;
+    exports[n].function_data.impl = NULL;
+  }
 }
 
 KernelExport* ExportResolver::GetExportByOrdinal(const char* library_name,
@@ -69,3 +59,23 @@ KernelExport* ExportResolver::GetExportByName(const char* library_name,
   XEASSERTALWAYS();
   return NULL;
 }
+
+void ExportResolver::SetVariableMapping(const char* library_name,
+                                        const uint32_t ordinal,
+                                        uint32_t value) {
+  KernelExport* kernel_export = GetExportByOrdinal(library_name, ordinal);
+  XEASSERTNOTNULL(kernel_export);
+  kernel_export->is_implemented = true;
+  kernel_export->variable_ptr = value;
+}
+
+void ExportResolver::SetFunctionMapping(const char* library_name,
+                                        const uint32_t ordinal,
+                                        xe_kernel_export_shim_fn shim,
+                                        xe_kernel_export_impl_fn impl) {
+  KernelExport* kernel_export = GetExportByOrdinal(library_name, ordinal);
+  XEASSERTNOTNULL(kernel_export);
+  kernel_export->is_implemented = true;
+  kernel_export->function_data.shim = shim;
+  kernel_export->function_data.impl = impl;
+}

src/kernel/modules/xboxkrnl/xboxkrnl_module.cc

@@ -17,11 +17,55 @@ using namespace xe::kernel;
 using namespace xe::kernel::xboxkrnl;
 
 
+namespace {
+
+  // bit 27 = something?
+  typedef struct {
+    uint32_t    flags;
+    uint8_t     processor_count;
+    uint8_t     unknown0;
+    uint8_t     unknown1;
+    uint8_t     unknown2;
+    uint32_t    unknown4;
+    uint16_t    unknown5;
+    uint16_t    unknown6;
+  } XboxHardwareInfo_t;
+  // XboxHardwareInfo_t XboxHardwareInfo = {
+  //   0x00000000, 3, 0, 0, 0, 0, 0, 0,
+  // };
+
+  // This should remain zero for now.
+  // The pointer returned should have a 4b value at 0x58 that is the first
+  // argument to RtlImageXexHeaderField (header base?)
+  //uint32_t XexExecutableModuleHandle = 0x00000000;
+
+}
+
+
 XboxkrnlModule::XboxkrnlModule(xe_pal_ref pal, xe_memory_ref memory,
                                shared_ptr<ExportResolver> resolver) :
     KernelModule(pal, memory, resolver) {
   resolver->RegisterTable(
       "xboxkrnl.exe", xboxkrnl_export_table, XECOUNT(xboxkrnl_export_table));
+
+  // TODO(benvanik): alloc heap memory somewhere in user space
+  // TODO(benvanik): tools for reading/writing to heap memory
+
+  // HACK: register some dummy globals for now.
+  // KeDebugMonitorData
+  resolver->SetVariableMapping(
+      "xboxkrnl.exe", 0x00000059,
+      0);
+  // XboxHardwareInfo
+  resolver->SetVariableMapping(
+      "xboxkrnl.exe", 0x00000156,
+      0);
+  // XexExecutableModuleHandle
+  resolver->SetVariableMapping(
+      "xboxkrnl.exe", 0x00000193,
+      0);
+
+  // 0x0000012B, RtlImageXexHeaderField
 }
 
 XboxkrnlModule::~XboxkrnlModule() {

src/kernel/user_module.cc

@@ -369,7 +369,7 @@ void UserModule::Dump(ExportResolver* export_resolver) {
             export_resolver->GetExportByOrdinal(library->name, info->ordinal);
         if (kernel_export) {
           known_count++;
-          if (kernel_export->IsImplemented()) {
+          if (kernel_export->is_implemented) {
             impl_count++;
           }
         } else {
@@ -395,7 +395,7 @@ void UserModule::Dump(ExportResolver* export_resolver) {
         bool implemented = false;
         if (kernel_export) {
           name = kernel_export->name;
-          implemented = kernel_export->IsImplemented();
+          implemented = kernel_export->is_implemented;
         }
         if (info->thunk_address) {
           printf("   F %.8X %.8X %.3X (%3d) %s %s\n",