[PATCH experiment 15/16] port QemuCoLockable to C++ coroutines

[Paolo Bonzini]

Convert "T coroutine_fn" annotations to the new type CoroutineFn<T>,
and add co_await as needed.

_Generic is replaced by an overloaded constructor.  C++ also does
not like & on a temporary, so that is replaced by a function
qemu_make_co_lockable_nonnull that hides it from the compiler.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
---
 include/qemu/co-lockable.h | 111 ++++++++++++++++++-------------------
 1 file changed, 53 insertions(+), 58 deletions(-)

diff --git a/include/qemu/co-lockable.h b/include/qemu/co-lockable.h
index 09f4620017..13e3cc7a69 100644
--- a/include/qemu/co-lockable.h
+++ b/include/qemu/co-lockable.h
@@ -16,83 +16,78 @@
 #include "qemu/coroutine.h"
 #include "qemu/thread.h"
 
-typedef void coroutine_fn QemuCoLockUnlockFunc(void *);
+typedef CoroutineFn<void> QemuCoLockUnlockFunc(void *);
+
+extern CoroutineFn<void> qemu_mutex_co_lock(QemuMutex *m);
+extern CoroutineFn<void> qemu_mutex_co_unlock(QemuMutex *m);
 
 struct QemuCoLockable {
     void *object;
     QemuCoLockUnlockFunc *lock;
     QemuCoLockUnlockFunc *unlock;
+
+    QemuCoLockable() :
+        object{NULL},
+        lock{(QemuCoLockUnlockFunc *) NULL},
+        unlock{(QemuCoLockUnlockFunc *) NULL} {}
+    QemuCoLockable(QemuMutex *x) :
+        object{x},
+        lock{(QemuCoLockUnlockFunc *) qemu_mutex_co_lock},
+        unlock{(QemuCoLockUnlockFunc *) qemu_mutex_co_unlock} {}
+    QemuCoLockable(CoMutex *x) :
+        object{x},
+        lock{(QemuCoLockUnlockFunc *) qemu_co_mutex_lock},
+        unlock{(QemuCoLockUnlockFunc *) qemu_co_mutex_unlock} {}
 };
 
-static inline __attribute__((__always_inline__)) QemuCoLockable *
-qemu_make_co_lockable(void *x, QemuCoLockable *lockable)
+template<typename T>
+static inline QemuCoLockable qcml_obj_nonnull_(T *x)
 {
-    /*
-     * We cannot test this in a macro, otherwise we get compiler
-     * warnings like "the address of 'm' will always evaluate as 'true'".
-     */
-    return x ? lockable : NULL;
+    return QemuCoLockable{x};
 }
 
-static inline __attribute__((__always_inline__)) QemuCoLockable *
-qemu_null_co_lockable(void *x)
+static inline QemuCoLockable const 
*qemu_make_co_lockable_nonnull(QemuCoLockable const &x)
 {
+    return &x;
+}
+
+template<typename T>
+static inline QemuCoLockable qcml_obj_(T *x)
+{
+    return QemuCoLockable{x};
+}
+extern void build_not_reached();
+
+template<> inline
+QemuCoLockable qcml_obj_(void *x)
+{
+#ifdef __OPTIMIZE__
     if (x != NULL) {
-        qemu_build_not_reached();
+        build_not_reached();
     }
-    return NULL;
+#endif
+    return QemuCoLockable{};
 }
 
-/*
- * In C, compound literals have the lifetime of an automatic variable.
- * In C++ it would be different, but then C++ wouldn't need QemuCoLockable
- * either...
- */
-#define QMCL_OBJ_(x, name) (&(QemuCoLockable) {                         \
-        .object = (x),                                                  \
-        .lock = (QemuCoLockUnlockFunc *) qemu_ ## name ## _lock,        \
-        .unlock = (QemuCoLockUnlockFunc *) qemu_ ## name ## _unlock     \
-    })
-
-/**
- * QEMU_MAKE_CO_LOCKABLE - Make a polymorphic QemuCoLockable
- *
- * @x: a lock object (currently one of QemuMutex, CoMutex).
- *
- * Returns a QemuCoLockable object that can be passed around
- * to a function that can operate with locks of any kind, or
- * NULL if @x is %NULL.
- *
- * Note the speci case for void *, so that we may pass "NULL".
- */
-#define QEMU_MAKE_CO_LOCKABLE(x)                                            \
-    _Generic((x), QemuCoLockable *: (x),                                    \
-             void *: qemu_null_co_lockable(x),                              \
-             QemuMutex *: qemu_make_co_lockable(x, QMCL_OBJ_(x, mutex)),    \
-             CoMutex *: qemu_make_co_lockable(x, QMCL_OBJ_(x, co_mutex)))   \
-
-/**
- * QEMU_MAKE_CO_LOCKABLE_NONNULL - Make a polymorphic QemuCoLockable
- *
- * @x: a lock object (currently one of QemuMutex, QemuRecMutex,
- *     CoMutex, QemuSpin).
- *
- * Returns a QemuCoLockable object that can be passed around
- * to a function that can operate with locks of any kind.
- */
-#define QEMU_MAKE_CO_LOCKABLE_NONNULL(x)                        \
-    _Generic((x), QemuCoLockable *: (x),                        \
-                  QemuMutex *: QMCL_OBJ_(x, mutex),             \
-                  CoMutex *: QMCL_OBJ_(x, co_mutex))
-
-static inline void coroutine_fn qemu_co_lockable_lock(QemuCoLockable *x)
+static inline QemuCoLockable const *qemu_make_co_lockable(QemuCoLockable const 
&x)
 {
-    x->lock(x->object);
+    if (x.object)
+        return &x;
+    else
+        return NULL;
 }
 
-static inline void coroutine_fn qemu_co_lockable_unlock(QemuCoLockable *x)
+#define QEMU_MAKE_CO_LOCKABLE_NONNULL(x) 
qemu_make_co_lockable_nonnull(qcml_obj_nonnull_(x))
+#define QEMU_MAKE_CO_LOCKABLE(x)         qemu_make_co_lockable(qcml_obj_(x))
+
+static inline CoroutineFn<void> qemu_co_lockable_lock(const QemuCoLockable *x)
 {
-    x->unlock(x->object);
+    co_await x->lock(x->object);
+}
+
+static inline CoroutineFn<void> qemu_co_lockable_unlock(const QemuCoLockable 
*x)
+{
+    co_await x->unlock(x->object);
 }
 
 #endif
-- 
2.35.1