Start work on hacky Xbox port

.gitignore

@@ -1 +1,9 @@
 build/
+
+# nxdk garbage
+bin/
+*.obj
+*.d
+*.iso
+*.exe
+*.lib

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "tinyalloc"]
+	path = tinyalloc
+	url = https://github.com/thi-ng/tinyalloc

CMakeLists.txt

@@ -21,6 +21,8 @@ if(ENET_FOUND)
   )
 endif()
 
+message(${LIBUNICORN_INCLUDE_DIR})
+
 include_directories(SYSTEM
   ${LIBUNICORN_INCLUDE_DIR}
   ${OPENGL_INCLUDE_DIR}
@@ -34,6 +36,7 @@ add_executable(openswe1r
   emulation.c
   export.c
   shader.c
+  alloc.c
 
   dll/kernel32.c
 
@@ -76,30 +79,44 @@ target_include_directories(openswe1r PRIVATE ${CMAKE_BINARY_DIR})
 
 include(package.cmake)
 
-if(USE_VM)
-  target_compile_definitions(openswe1r PUBLIC -DUC_KVM)
+if(USE_NATIVE)
+
   target_sources(openswe1r PUBLIC
-    uc_kvm.c
+    uc_native.c
+    xbox.c
   )
+  target_compile_definitions(openswe1r PUBLIC -DUC_NATIVE -DUC_KVM)
+
+  set_target_properties(openswe1r PROPERTIES COMPILE_FLAGS "-m32 -O0" LINK_FLAGS "-m32 -static-libgcc -O0")
+
 else()
-  target_link_libraries(openswe1r
-    ${LIBUNICORN_LIBRARY}
-  )
-endif()
 
-if(ENET_FOUND)
-  target_compile_definitions(openswe1r PUBLIC -DDPLAY_ENET)
+  if(USE_VM)
+    target_compile_definitions(openswe1r PUBLIC -DUC_KVM)
+    target_sources(openswe1r PUBLIC
+      uc_kvm.c
+    )
+  else()
+    target_link_libraries(openswe1r
+      ${LIBUNICORN_LIBRARY}
+    )
+  endif()
+
+  if(ENET_FOUND)
+    target_compile_definitions(openswe1r PUBLIC -DDPLAY_ENET)
+    target_link_libraries(openswe1r
+      ${ENET_LIBRARIES}
+    )
+  endif()
+
   target_link_libraries(openswe1r
-    ${ENET_LIBRARIES}
+    ${OPENGL_LIBRARIES}
+    ${GLEW_LIBRARIES}
+    ${SDL2_LIBRARY}
+    ${OPENAL_LIBRARY}
   )
 endif()
 
-target_link_libraries(openswe1r
-  ${OPENGL_LIBRARIES}
-  ${GLEW_LIBRARIES}
-  ${SDL2_LIBRARY}
-  ${OPENAL_LIBRARY}
-)
 
 if(MSVC)
   # Silence MSVC CRT security warnings

Makefile.nxdk

@@ -0,0 +1,45 @@
+#NXDK_SDL = y
+
+XBE_TITLE = OpenSWE1R
+GEN_XISO = $(XBE_TITLE).iso
+SRCS = 
+#SHADER_OBJS = ps.inl vs.inl
+
+SRCS += $(CURDIR)/xbox.c
+
+SRCS += $(CURDIR)/main.c
+SRCS += $(CURDIR)/emulation.c
+SRCS += $(CURDIR)/export.c
+SRCS += $(CURDIR)/shader.c
+
+SRCS += $(CURDIR)/dll/kernel32.c
+
+SRCS += $(CURDIR)/com/a3d.c
+SRCS += $(CURDIR)/com/dplay.c
+
+SRCS += $(CURDIR)/uc_native.c
+
+CFLAGS += -isystem$(CURDIR)/xbox-hacks
+
+CFLAGS += -DUC_NATIVE=1 -DUC_KVM=1
+CFLAGS += -I/usr/include/unicorn
+CFLAGS += -I/usr/include/AL
+CFLAGS += -DXBOX -DAPIENTRY= -DGLAPI=
+
+SDL_DIR = $(NXDK_DIR)/lib/sdl/SDL2
+CFLAGS += -I$(SDL_DIR)/include
+
+CFLAGS += -Wno-inconsistent-dllimport
+
+#FIXME: Slow mode for pbkit! remove!
+CFLAGS += -DXBOX_GPU=1
+#CFLAGS += -DDBG=1 #FIXME: !!!
+
+# We are short on memory, so reduce binary footprint
+#CFLAGS += -Os
+#FIXME: At least one of these is bad: -fno-stack-protector -fomit-frame-pointer -ffunction-sections -fdata-sections
+#NXDK_STACKSIZE=16384
+
+SHADER_OBJS = xbox-hacks/ps.inl xbox-hacks/vs.inl
+
+include $(NXDK_DIR)/Makefile

alloc.c

@@ -0,0 +1,138 @@
+// Copyright 2019 OpenSWE1R Maintainers
+// Licensed under GPLv2 or any later version
+// Refer to the included LICENSE.txt file.
+
+// This is a temporary placeholder for a memory allocator.
+
+#include "alloc.h"
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+static unsigned int block_count = 0;
+static uint32_t block_size = 0;
+static uint8_t* block_usage = NULL;
+
+static void mark_used(unsigned int block, bool used) {
+  uint8_t mask = 1 << (block % 8);
+  if (used) {
+    block_usage[block / 8] |= mask;
+  } else {
+    block_usage[block / 8] &= ~mask;
+  }
+}
+
+static bool is_used(unsigned int block) {
+  uint8_t mask = 1 << (block % 8);
+  return block_usage[block / 8] & mask;
+}
+
+static unsigned int get_block_count(uint32_t size) {
+  return (size + block_size - 1) / block_size;
+}
+
+static unsigned int count_blocks(unsigned int block, bool used) {
+  unsigned int count = 0;
+  while(block < block_count) {
+    if (is_used(block) != used) {
+      break;
+    }
+    block++;
+    count++;
+  }
+  return count;
+}
+
+static unsigned int find_free_blocks(unsigned int needed_blocks) {
+
+  unsigned int best_count = 0;
+  unsigned int best_block = 0;
+
+  unsigned int block = 0;
+  while(block < block_count) {
+
+    bool block_used = is_used(block);
+    unsigned int available_blocks = count_blocks(block, block_used);
+
+    // Only look at unused blocks that are large enough
+    if (!block_used && (available_blocks >= needed_blocks)) {
+
+      // Check if we don't have a result yet, or if this is a better fit
+      if ((best_count == 0) || (available_blocks < best_count)) {
+
+        // Update result
+        best_block = block;
+        best_count = available_blocks;
+
+        // If we have an exact fit, use that
+        if (best_count == needed_blocks) {
+          break;
+        }
+
+      }
+    }
+
+    block += available_blocks;
+  }
+
+  // Assert that we have a result
+  assert(best_count != 0);
+
+  // Returns best block address
+  return best_block;
+}
+
+void alloc_initialize(uint32_t size, uint32_t _block_size) {
+
+  // Sanity check arguments, we expect proper alignment
+  assert((size % _block_size) == 0);
+
+  // Store settings
+  block_size = _block_size;
+  block_count = get_block_count(size);
+
+  // Allocate flags which tell us wether a block is used
+  size_t used_flag_size = (block_count + 7) / 8;
+  block_usage = malloc(used_flag_size);
+  memset(block_usage, 0x00, used_flag_size);
+
+}
+
+uint32_t alloc_allocate(uint32_t size) {
+
+  // Don't allow zero-size allocations (breaks algorithm)
+  assert(size > 0);
+
+  unsigned int needed_blocks = get_block_count(size);
+
+  //FIXME: `+ 2` is a hack, so we can recognize block splits
+  unsigned int block = find_free_blocks(needed_blocks + 2) + 1;
+
+  printf("Allocated %u blocks (0x%X / 0x%X bytes)\n", needed_blocks, needed_blocks * block_size, size);
+
+  for(unsigned int i = 0; i < needed_blocks; i++) {
+    mark_used(block + i, true);
+  }
+
+  return block * block_size;
+}
+
+void alloc_free(uint32_t offset) {
+
+  // Only free addresses that are block-aligned
+  assert(offset % block_size == 0);
+  unsigned int block = offset / block_size;
+
+  unsigned int used_blocks = count_blocks(block, true);
+
+  // Avoid double-free
+  assert(used_blocks > 0);
+
+  for(unsigned int i = 0; i < used_blocks; i++) {
+    mark_used(block + i, false);
+  }
+
+}

alloc.h

@@ -0,0 +1,5 @@
+#include <stdint.h>
+
+void alloc_initialize(uint32_t size, uint32_t _block_size);
+uint32_t alloc_allocate(uint32_t size);
+void alloc_free(uint32_t offset);

cmake/FindUnicorn.cmake

@@ -4,15 +4,15 @@
 #  LIBUNICORN_LIBRARY
 
 find_path(LIBUNICORN_INCLUDE_DIR
-          unicorn/unicorn.h
+          unicorn.h
           HINTS $ENV{UNICORNDIR}
-          PATH_SUFFIXES include)
+          PATH_SUFFIXES include/unicorn include)
 
 find_library(LIBUNICORN_LIBRARY
              NAMES unicorn
              HINTS $ENV{UNICORNDIR})
 
 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(unicorn DEFAULT_MSG
-                                  LIBUNICORN_LIBRARY LIBUNICORN_INCLUDE_DIR)
-mark_as_advanced(LIBUNICORN_INCLUDE_DIR LIBUNICORN_LIBRARY)
+
+find_package_handle_standard_args(unicorn
+                                  REQUIRED_VARS LIBUNICORN_LIBRARY LIBUNICORN_INCLUDE_DIR)

com/a3d.c

@@ -15,7 +15,7 @@
 
 
 typedef struct {
-  void* vtable;
+  API(IUnknown) iunknown;
   ALCdevice *device;
   ALCcontext *context;
 } A3d4;
@@ -32,7 +32,7 @@ typedef struct {
 } API(WAVEFORMATEX);
 
 typedef struct {
-  void* vtable;
+  API(IUnknown) iunknown;
   ALuint al_source;
   ALuint al_buffer;
   API(WAVEFORMATEX) fmt;

com/d3d.h

@@ -11,7 +11,7 @@
 #include "../windows.h"
 
 typedef struct {
-  void* vtable;
+  API(IUnknown) iunknown;
   Address surface;
   GLuint handle;
 } API(Direct3DTexture2);

com/ddraw.h

@@ -235,9 +235,10 @@ enum {
 };
 
 typedef struct {
-  void* vtable;
+  API(IUnknown) iunknown;
   Address texture; // Direct3DTexture2*
   API(DDSURFACEDESC2) desc;
+  GLuint pbo;
 } API(DirectDrawSurface4);
 
 #endif