Experimenting with instrument API. Not quite right.

src/alloy/runtime/instrument.h

@@ -0,0 +1,149 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2014 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#ifndef ALLOY_RUNTIME_INSTRUMENT_H_
+#define ALLOY_RUNTIME_INSTRUMENT_H_
+
+#include <alloy/core.h>
+
+XEDECLARECLASS1(alloy, Memory);
+
+
+namespace alloy {
+namespace runtime {
+
+class Function;
+class Runtime;
+class ThreadState;
+
+
+class Instrument {
+public:
+  Instrument(Runtime* runtime);
+  virtual ~Instrument();
+
+  Runtime* runtime() const { return runtime_; }
+  Memory* memory() const { return memory_; }
+  bool is_attached() const { return is_attached_; }
+
+  virtual bool Attach();
+  virtual bool Detach();
+
+private:
+  Runtime*  runtime_;
+  Memory*   memory_;
+  bool      is_attached_;
+};
+
+
+class FunctionInstrument : public Instrument {
+public:
+  FunctionInstrument(Runtime* runtime, Function* function);
+  virtual ~FunctionInstrument() {}
+
+  Function* target() const { return target_; }
+
+  virtual bool Attach();
+  virtual bool Detach();
+
+public:
+  void Enter(ThreadState* thread_state);
+  void Exit(ThreadState* thread_state);
+
+protected:
+  class Instance {
+  public:
+    Instance(FunctionInstrument* instrument) : instrument_(instrument) {}
+    virtual ~Instance() {}
+
+    FunctionInstrument* instrument() const { return instrument_; }
+
+    virtual void OnEnter(ThreadState* thread_state) = 0;
+    virtual void OnExit(ThreadState* thread_state) = 0;
+
+    // TODO(benvanik): utilities:
+    //     Log(...)
+    //     DebugBreak(type)
+    //     GetArg(N)/GetReturn()/SetReturn(V) ?
+    //     CallSelf()
+    //     Call(target_fn/address)
+    //     Return(opt_value)
+
+  private:
+    FunctionInstrument* instrument_;
+  };
+
+private:
+  Function* target_;
+};
+
+
+class MemoryInstrument : public Instrument {
+public:
+  MemoryInstrument(Runtime* runtime, uint64_t address, uint64_t end_address);
+  virtual ~MemoryInstrument() {}
+
+  uint64_t address() const { return address_; }
+  uint64_t end_address() const { return end_address_; }
+
+  virtual bool Attach();
+  virtual bool Detach();
+
+public:
+  enum AccessType {
+    ACCESS_READ = (1 << 1),
+    ACCESS_WRITE = (1 << 2),
+  };
+  void Access(ThreadState* thread_state, uint64_t address, AccessType type);
+
+protected:
+  class Instance {
+  public:
+    Instance(MemoryInstrument* instrument) : instrument_(instrument) {}
+    virtual ~Instance() {}
+
+    MemoryInstrument* instrument() const { return instrument_; }
+
+    virtual void OnAccess(
+        ThreadState* thread_state, uint64_t address, AccessType type) = 0;
+
+  private:
+    MemoryInstrument* instrument_;
+  };
+
+private:
+  uint64_t address_;
+  uint64_t end_address_;
+};
+
+
+// ThreadInstrument
+//   (v Detach())
+//   ThreadInstrumentInstance:
+//     instrument()
+//     v OnCreate(context, state_ptr)
+//     v OnStart(context, state_ptr)
+//     v OnResume(context, state_ptr)
+//     v OnSuspend(context, state_ptr)
+//     v OnExit(context, state_ptr)
+
+// ModuleInstrument
+//   (v Detach())
+//   ModuleInstrumentInstance:
+//     instrument()
+//     v OnLoad(context)
+//     v OnUnload(context)
+//     // get proc address?
+
+
+}  // namespace runtime
+}  // namespace alloy
+
+
+#endif  // ALLOY_RUNTIME_INSTRUMENT_H_