base: Add 'construct_at' utility

This utility allows for the manual placement of objects without the need
to have a global placement new operation nor the need for type-specific
new operators.

Issue #989

base/include/util/construct_at.h

@@ -0,0 +1,84 @@
+/*
+ * \brief  Utility for the manual placement of objects
+ * \author Norman Feske
+ * \date   2014-02-07
+ */
+
+/*
+ * Copyright (C) 2014 Genode Labs GmbH
+ *
+ * This file is part of the Genode OS framework, which is distributed
+ * under the terms of the GNU General Public License version 2.
+ */
+
+#ifndef _INCLUDE__UTIL__CONSTRUCT_AT_H_
+#define _INCLUDE__UTIL__CONSTRUCT_AT_H_
+
+#include <base/stdint.h>
+#include <base/printf.h>
+
+namespace Genode {
+	template <typename T, typename... ARGS>
+	static inline T *construct_at(void *, ARGS &&...);
+}
+
+
+/**
+ * Construct object of given type at a specific location
+ *
+ * \param T     object type
+ * \param at    desired object location
+ * \param args  list of arguments for the object constructor
+ *
+ * \return  typed object pointer
+ *
+ * We use move semantics (ARGS &&) because otherwise the compiler would create
+ * a temporary copy of all arguments that have a reference type and use a
+ * reference to this copy instead of the original within this function.
+ *
+ * There is a slight difference between the object that is constructed by this
+ * function and a common object of the given type. If the destructor of the
+ * given type or of any base of the given type is virtual, the vtable of the
+ * returned object references an empty delete(void *) operator for that
+ * destructor. However, this shouldn't be a problem as an object constructed by
+ * this function should never get destructed implicitely or through a delete
+ * expression.
+ */
+template <typename T, typename... ARGS>
+static inline T * Genode::construct_at(void *at, ARGS &&... args)
+{
+	/**
+	 * Utility to equip an existing type 'T' with a placement new operator
+	 */
+	struct Placeable : T
+	{
+		Placeable(ARGS &&... args) : T(args...) { }
+
+		void * operator new (size_t, void *ptr) { return ptr; }
+		void   operator delete (void *, void *) { }
+
+		/**
+		 * Standard delete operator
+		 *
+		 * As we explicitely define one version of the delete operator, the
+		 * compiler won't implicitely define any delete version for this class.
+		 * But if type T has a virtual destructor, the compiler implicitely
+		 * defines a 'virtual ~Placeable()' which needs the following operator.
+		 */
+		void  operator delete (void *)
+		{
+			PERR("cxx: Placeable::operator delete (void *) not supported.");
+		}
+	};
+
+	/*
+	 * If the args input to this function contains rvalues, the compiler would
+	 * use the according rvalue references as lvalues at the following call if
+	 * we don't cast them back to rvalue references explicitely. We can not use
+	 * lvalues here because the compiler can not bind them to rvalue references
+	 * as expected by Placeable.
+	 */
+	return new (at) Placeable(static_cast<ARGS &&>(args)...);
+}
+
+#endif /* _INCLUDE__UTIL__CONSTRUCT_AT_H_ */