Refactoring of function types. Also fixes some library import bugs.

src/alloy/runtime/function.cc

@@ -17,8 +17,9 @@ using namespace alloy;
 using namespace alloy::runtime;
 
 
-Function::Function(Type type, uint64_t address) :
-    type_(type), address_(address), debug_info_(0) {
+Function::Function(FunctionInfo* symbol_info) :
+    address_(symbol_info->address()),
+    symbol_info_(symbol_info), debug_info_(0) {
   // TODO(benvanik): create on demand?
   lock_ = AllocMutex();
 }
@@ -77,43 +78,27 @@ int Function::Call(ThreadState* thread_state) {
   if (original_thread_state != thread_state) {
     ThreadState::Bind(thread_state);
   }
-  int result = CallImpl(thread_state);
+
+  int result = 0;
+  
+  if (symbol_info_->behavior() == FunctionInfo::BEHAVIOR_EXTERN) {
+    auto handler = symbol_info_->extern_handler();
+    if (handler) {
+      handler(thread_state->raw_context(),
+              symbol_info_->extern_arg0(),
+              symbol_info_->extern_arg1());
+    } else {
+      XELOGW("undefined extern call to %.8X %s",
+             symbol_info_->address(),
+             symbol_info_->name());
+      result = 1;
+    }
+  } else {
+    CallImpl(thread_state);
+  }
+
   if (original_thread_state != thread_state) {
     ThreadState::Bind(original_thread_state);
   }
   return result;
 }
-
-ExternFunction::ExternFunction(
-    uint64_t address, Handler handler, void* arg0, void* arg1) :
-    name_(0),
-    handler_(handler), arg0_(arg0), arg1_(arg1),
-    Function(Function::EXTERN_FUNCTION, address) {
-}
-
-ExternFunction::~ExternFunction() {
-  if (name_) {
-    xe_free(name_);
-  }
-}
-
-void ExternFunction::set_name(const char* name) {
-  name_ = xestrdupa(name);
-}
-
-int ExternFunction::CallImpl(ThreadState* thread_state) {
-  if (!handler_) {
-    XELOGW("undefined extern call to %.8X %s", address(), name());
-    return 0;
-  }
-  handler_(thread_state->raw_context(), arg0_, arg1_);
-  return 0;
-}
-
-GuestFunction::GuestFunction(FunctionInfo* symbol_info) :
-    symbol_info_(symbol_info),
-    Function(Function::USER_FUNCTION, symbol_info->address()) {
-}
-
-GuestFunction::~GuestFunction() {
-}

src/alloy/runtime/function.h

@@ -24,17 +24,11 @@ class ThreadState;
 
 class Function {
 public:
-  enum Type {
-    UNKNOWN_FUNCTION = 0,
-    EXTERN_FUNCTION,
-    USER_FUNCTION,
-  };
-public:
-  Function(Type type, uint64_t address);
+  Function(FunctionInfo* symbol_info);
   virtual ~Function();
 
-  Type type() const { return type_; }
   uint64_t address() const { return address_; }
+  FunctionInfo* symbol_info() const { return symbol_info_; }
 
   DebugInfo* debug_info() const { return debug_info_; }
   void set_debug_info(DebugInfo* debug_info) { debug_info_ = debug_info; }
@@ -51,8 +45,8 @@ protected:
   virtual int CallImpl(ThreadState* thread_state) = 0;
 
 protected:
-  Type        type_;
   uint64_t    address_;
+  FunctionInfo* symbol_info_;
   DebugInfo*  debug_info_;
 
   // TODO(benvanik): move elsewhere? DebugData?
@@ -61,43 +55,6 @@ protected:
 };
 
 
-class ExternFunction : public Function {
-public:
-  typedef void(*Handler)(void* context, void* arg0, void* arg1);
-public:
-  ExternFunction(uint64_t address, Handler handler, void* arg0, void* arg1);
-  virtual ~ExternFunction();
-
-  const char* name() const { return name_; }
-  void set_name(const char* name);
-
-  Handler handler() const { return handler_; }
-  void* arg0() const { return arg0_; }
-  void* arg1() const { return arg1_; }
-
-protected:
-  virtual int CallImpl(ThreadState* thread_state);
-
-protected:
-  char* name_;
-  Handler handler_;
-  void* arg0_;
-  void* arg1_;
-};
-
-
-class GuestFunction : public Function {
-public:
-  GuestFunction(FunctionInfo* symbol_info);
-  virtual ~GuestFunction();
-
-  FunctionInfo* symbol_info() const { return symbol_info_; }
-
-protected:
-  FunctionInfo* symbol_info_;
-};
-
-
 }  // namespace runtime
 }  // namespace alloy
 

src/alloy/runtime/symbol_info.cc

@@ -34,11 +34,19 @@ void SymbolInfo::set_name(const char* name) {
 FunctionInfo::FunctionInfo(Module* module, uint64_t address) :
     end_address_(0), behavior_(BEHAVIOR_DEFAULT), function_(0),
     SymbolInfo(SymbolInfo::TYPE_FUNCTION, module, address) {
+  xe_zero_struct(&extern_info_, sizeof(extern_info_));
 }
 
 FunctionInfo::~FunctionInfo() {
 }
 
+void FunctionInfo::SetupExtern(ExternHandler handler, void* arg0, void* arg1) {
+  behavior_ = BEHAVIOR_EXTERN;
+  extern_info_.handler = handler;
+  extern_info_.arg0 = arg0;
+  extern_info_.arg1 = arg1;
+}
+
 VariableInfo::VariableInfo(Module* module, uint64_t address) :
     SymbolInfo(SymbolInfo::TYPE_VARIABLE, module, address) {
 }

src/alloy/runtime/symbol_info.h

@@ -63,6 +63,7 @@ public:
     BEHAVIOR_PROLOG,
     BEHAVIOR_EPILOG,
     BEHAVIOR_EPILOG_RETURN,
+    BEHAVIOR_EXTERN,
   };
 
 public:
@@ -79,10 +80,21 @@ public:
   Function* function() const { return function_; }
   void set_function(Function* value) { function_ = value; }
 
+  typedef void(*ExternHandler)(void* context, void* arg0, void* arg1);
+  void SetupExtern(ExternHandler handler, void* arg0, void* arg1);
+  ExternHandler extern_handler() const { return extern_info_.handler; }
+  void* extern_arg0() const { return extern_info_.arg0; }
+  void* extern_arg1() const { return extern_info_.arg1; }
+
 private:
   uint64_t  end_address_;
   Behavior  behavior_;
   Function* function_;
+  struct {
+    ExternHandler handler;
+    void* arg0;
+    void* arg1;
+  } extern_info_;
 };
 
 class VariableInfo : public SymbolInfo {