extract list manipulation logic from waitlist.c

the api is inspired from bsd queue.h

Author: yamt

.clang-format

@@ -8,5 +8,5 @@ ConstructorInitializerIndentWidth: 8
 AlwaysBreakAfterReturnType: TopLevelDefinitions
 BreakBeforeBraces: Linux
 IndentGotoLabels: false
-ForEachMacros: ["ARRAY_FOREACH", "VEC_FOREACH", "VEC_FOREACH_IDX"]
+ForEachMacros: ["ARRAY_FOREACH", "LIST_FOREACH", "VEC_FOREACH", "VEC_FOREACH_IDX"]
 SpaceBeforeParens: ControlStatementsExceptControlMacros

CMakeLists.txt

@@ -187,6 +187,7 @@ set(lib_sources
 	"lib/insn.c"
 	"lib/instance.c"
 	"lib/leb128.c"
+	"lib/list.c"
 	"lib/module.c"
 	"lib/nbio.c"
 	"lib/report.c"

lib/list.c

@@ -0,0 +1,45 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "list.h"
+
+void
+list_remove(struct list_head *h, void *elem, struct list_entry *e)
+{
+        assert(h->first != NULL);
+        assert(*h->tailnextp == NULL);
+        assert(*e->prevnextp == elem);
+        *e->prevnextp = e->next;
+        if (e->next == NULL) {
+                assert(h->tailnextp == &e->next);
+                h->tailnextp = e->prevnextp;
+        } else {
+                uintptr_t offset = (uintptr_t)e - (uintptr_t)elem;
+                struct list_entry *nextentry =
+                        (void *)((uintptr_t)e->next + offset);
+                assert(nextentry->prevnextp == &e->next);
+                nextentry->prevnextp = e->prevnextp;
+        }
+        assert(*h->tailnextp == NULL);
+}
+
+void
+list_insert_tail(struct list_head *h, void *elem, struct list_entry *e)
+{
+        assert(*h->tailnextp == NULL);
+        e->prevnextp = h->tailnextp;
+        *h->tailnextp = elem;
+        h->tailnextp = &e->next;
+        e->next = NULL;
+        assert(h->first != NULL);
+        assert(*h->tailnextp == NULL);
+        assert(*e->prevnextp == elem);
+}
+
+void
+list_head_init(struct list_head *h)
+{
+        h->first = NULL;
+        h->tailnextp = &h->first;
+}

lib/list.h

@@ -0,0 +1,68 @@
+#include "platform.h"
+
+struct list_elem;
+
+struct list_entry {
+        struct list_elem *next;
+        struct list_elem **prevnextp;
+};
+
+struct list_head {
+        struct list_elem *first;
+        struct list_elem **tailnextp;
+};
+
+void list_head_init(struct list_head *h);
+void list_remove(struct list_head *h, void *elem, struct list_entry *e);
+void list_insert_tail(struct list_head *h, void *elem, struct list_entry *e);
+
+#define LIST_ENTRY(TYPE)                                                      \
+        struct {                                                              \
+                TYPE *next;                                                   \
+                TYPE **prevnextp;                                             \
+        }
+
+#define LIST_HEAD(TYPE)                                                       \
+        struct {                                                              \
+                TYPE *first;                                                  \
+                TYPE **tailnextp;                                             \
+        }
+
+#define LIST_FOREACH(VAR, HEAD, NAME)                                         \
+        for (VAR = (HEAD)->first; VAR != NULL; VAR = (VAR)->NAME.next)
+
+#if defined(__clang__)
+#define CHECK_TYPE(a, b)                                                      \
+        do {                                                                  \
+                __attribute__((__unused__)) __typeof__(a) __dummy = b;        \
+        } while (0)
+#else
+#define CHECK_TYPE(a, b)
+#endif
+
+#define LIST_FIRST(HEAD) (HEAD)->first
+
+#define LIST_EMPTY(HEAD) (LIST_FIRST(HEAD) == NULL)
+
+#define LIST_REMOVE(HEAD, ELEM, NAME)                                         \
+        CHECK_TYPE(&(HEAD)->first, (HEAD)->tailnextp);                        \
+        CHECK_TYPE((HEAD)->first, (ELEM)->NAME.next);                         \
+        CHECK_TYPE(&(ELEM)->NAME.next, (ELEM)->NAME.prevnextp);               \
+        ctassert(sizeof(*(HEAD)) == sizeof(struct list_head));                \
+        ctassert(sizeof((ELEM)->NAME) == sizeof(struct list_entry));          \
+        list_remove((struct list_head *)(HEAD), (ELEM),                       \
+                    (struct list_entry *)&(ELEM)->NAME)
+
+#define LIST_INSERT_TAIL(HEAD, ELEM, NAME)                                    \
+        CHECK_TYPE(&(HEAD)->first, (HEAD)->tailnextp);                        \
+        CHECK_TYPE((HEAD)->first, (ELEM)->NAME.next);                         \
+        CHECK_TYPE(&(ELEM)->NAME.next, (ELEM)->NAME.prevnextp);               \
+        ctassert(sizeof(*(HEAD)) == sizeof(struct list_head));                \
+        ctassert(sizeof((ELEM)->NAME) == sizeof(struct list_entry));          \
+        list_insert_tail((struct list_head *)(HEAD), (ELEM),                  \
+                         (struct list_entry *)&(ELEM)->NAME)
+
+#define LIST_HEAD_INIT(HEAD)                                                  \
+        CHECK_TYPE(&(HEAD)->first, (HEAD)->tailnextp);                        \
+        ctassert(sizeof(*(HEAD)) == sizeof(struct list_head));                \
+        list_head_init((struct list_head *)(HEAD))