first steps towards a QEMU target backend

- This commit only enables linking against QEMU.  The abstraction layer is
  completely dysfunctional at this time.
- QEMU's build system needs to be patched in order to create a static
  library.  This patch is currently not included in the Fail* repository.
- QEMU's JIT compilation may complicate or even preclude the implementation
  of some of Fail*'s backend abstractions.  Only a minimal subset (serial
  I/O, memory, memory writes, save/restore) is planned for the first phase.

git-svn-id: https://www4.informatik.uni-erlangen.de/i4svn/danceos/trunk/devel/fail@1615 8c4709b5-6ec9-48aa-a5cd-a96041d1645a

src/core/sal/qemu/QEMUConfig.hpp

@@ -0,0 +1,20 @@
+/**
+ * \brief Type definitions and configuration settings for the
+ * qemu-system-x86_64 target backend.
+ */
+
+#ifndef __QEMU_CONFIG_HPP__
+  #define __QEMU_CONFIG_HPP__
+
+// FIXME: qemu/targphys.h defines address types (but relies on a global preprocessor macro)
+
+namespace fail {
+
+typedef uint64_t guest_address_t; //!< the guest memory address type
+typedef unsigned char* host_address_t;  //!< the host memory address type
+typedef uint64_t register_data_t; //!< register data type (64 bit)
+typedef int timer_t;         //!< type of timer IDs
+
+} // end-of-namespace: fail
+
+#endif // __QEMU_CONFIG_HPP__

src/core/sal/qemu/QEMUController.cc

@@ -0,0 +1,23 @@
+#include <sstream>
+
+#include "QEMUController.hpp"
+#include "QEMUMemory.hpp"
+#include "QEMURegister.hpp"
+#include "../Register.hpp"
+#include "../SALInst.hpp"
+
+namespace fail {
+
+QEMUController::QEMUController()
+	: SimulatorController(new QEMURegisterManager(), new QEMUMemoryManager())
+{
+	// TODO: probably do additional RegisterManager initializations
+}
+
+QEMUController::~QEMUController()
+{
+	delete m_Regs;
+	delete m_Mem;
+}
+
+} // end-of-namespace: fail

src/core/sal/qemu/QEMUController.hpp

@@ -0,0 +1,59 @@
+#ifndef __QEMU_CONTROLLER_HPP__
+  #define __QEMU_CONTROLLER_HPP__
+
+#include <string>
+#include <cassert>
+#include <iostream>
+#include <iomanip>
+#include <string.h>
+
+#include "../SimulatorController.hpp"
+#include "../Listener.hpp"
+
+namespace fail {
+
+class ExperimentFlow;
+
+/**
+ * \class QEMUController
+ * Very rudimentary, QEMU-specific implementation of a SimulatorController.
+ */
+class QEMUController : public SimulatorController {
+private:
+public:
+	// Initialize the controller.
+	QEMUController();
+	~QEMUController();
+	/**
+	 * I/O port communication handler. This method is called from QEMU.  TODO.
+	 * @param data the data transmitted
+	 * @param port the port it was transmitted on
+	 * @param out true if the I/O traffic has been outbound, false otherwise
+	 */
+	void onIOPort(unsigned char data, unsigned port, bool out) {}
+	/**
+	 * Static internal handler for TimerListeners.  TODO.
+	 */
+	static void onTimerTrigger(void *thisPtr) {}
+	/* ********************************************************************
+	 * Simulator Controller & Access API:
+	 * ********************************************************************/
+	/**
+	 * Save simulator state.  TODO.
+	 * @param path Location to store state information
+	 */
+	void save(const std::string& path) {}
+	/**
+	 * Restore simulator state. Clears all Listeners.  TODO.
+	 * @param path Location to previously saved state information
+	 */
+	void restore(const std::string& path) {}
+	/**
+	 * Reboot simulator. Clears all Listeners.  TODO.
+	 */
+	void reboot() {}
+};
+
+} // end-of-namespace: fail
+
+#endif // __QEMU_CONTROLLER_HPP__

src/core/sal/qemu/QEMUListener.cc

@@ -0,0 +1,8 @@
+#include "QEMUListener.hpp"
+#include "../SALInst.hpp"
+
+namespace fail {
+
+// TODO
+
+} // end-of-namespace: fail

src/core/sal/qemu/QEMUListener.hpp

@@ -0,0 +1,24 @@
+#ifndef __QEMU_LISTENER_HPP__
+  #define __QEMU_LISTENER_HPP__
+
+#include "../Listener.hpp"
+
+namespace fail {
+
+typedef GenericBPSingleListener BPSingleListener;
+
+/**
+ * \class TimerListener
+ * Concrete TimerListener implementation of GenericTimerListener for QEMU.
+ */
+class TimerListener : public GenericTimerListener {
+private:
+public:
+	// TODO
+};
+
+// TODO: MemWriteListener
+
+} // end-of-namespace: fail
+
+#endif // __QEMU_LISTENER_HPP__

src/core/sal/qemu/QEMUMemory.hpp

@@ -0,0 +1,41 @@
+#ifndef __QEMU_MEMORY_HPP__
+  #define __QEMU_MEMORY_HPP__
+
+#include "../Memory.hpp"
+
+namespace fail {
+
+/**
+ * \class QEMUMemoryManager
+ * Represents a concrete implemenation of the abstract
+ * MemoryManager to provide access to QEMU's memory pool.
+ */
+class QEMUMemoryManager : public MemoryManager {
+public:
+	size_t getPoolSize() const { return 0; /* TODO */ }
+	host_address_t getStartAddr() const { return 0; }
+	byte_t getByte(guest_address_t addr)
+	{
+		return static_cast<byte_t>(0); /* TODO */
+	}
+	void getBytes(guest_address_t addr, size_t cnt, void *dest)
+	{
+		char *d = static_cast<char *>(dest);
+		for (size_t i = 0; i < cnt; ++i)
+			d[i] = getByte(addr + i);
+	}
+	void setByte(guest_address_t addr, byte_t data)
+	{
+		/* TODO */
+	}
+	void setBytes(guest_address_t addr, size_t cnt, void const *src)
+	{
+		char const *s = static_cast<char const *>(src);
+		for (size_t i = 0; i < cnt; ++i)
+			setByte(addr + i, s[i]);
+	}
+};
+
+} // end-of-namespace: fail
+
+#endif // __QEMU_MEMORY_HPP__

src/core/sal/qemu/QEMURegister.hpp

@@ -0,0 +1,45 @@
+#ifndef __QEMU_REGISTER_HPP__
+  #define __QEMU_REGISTER_HPP__
+
+#include "../Register.hpp"
+
+#include <iostream>
+#include <cassert>
+
+namespace fail {
+
+/**
+ * \class QEMURegister
+ * QEMU-specific implementation of x86 registers.  TODO.
+ */
+class QEMURegister : public Register {
+public:
+	QEMURegister(unsigned int id, regwidth_t width, regdata_t* link, RegisterType t)
+		: Register(id, t, width) { }
+	regdata_t getData() { return 0; /* TODO */ }
+	void setData(regdata_t data) { /* TODO */ }
+};
+
+/**
+ * \class QEMURegisterManager
+ * QEMU-specific implementation of the RegisterManager.  TODO.
+ */
+class QEMURegisterManager : public RegisterManager {
+public:
+	address_t getInstructionPointer()
+	{
+		return static_cast<address_t>(0); /* TODO */
+	}
+	address_t getStackPointer()
+	{
+		return static_cast<address_t>(0); /* TODO */
+	}
+	address_t getBasePointer()
+	{
+		return static_cast<address_t>(0); /* TODO */
+	}
+};
+
+} // end-of-namespace: fail
+
+#endif // __QEMU_REGISTER_HPP__

src/core/sal/qemu/lol.h

@@ -0,0 +1 @@
+#error YO DAWG