diff --git a/lib/decode.c b/lib/decode.c
index 3fa3eed0..68c475f8 100644
--- a/lib/decode.c
+++ b/lib/decode.c
@@ -74,8 +74,8 @@ read_vec_count(const uint8_t **pp, const uint8_t *ep, uint32_t *resultp)
 }
 
 int
-read_vec_u32(struct mem_context *mctx, const uint8_t **pp, const uint8_t *ep, uint32_t *countp,
-             uint32_t **resultp)
+read_vec_u32(struct mem_context *mctx, const uint8_t **pp, const uint8_t *ep,
+             uint32_t *countp, uint32_t **resultp)
 {
         return read_vec(mctx, pp, ep, sizeof(uint32_t),
                         (read_elem_func_t)read_leb_u32, NULL, countp,
@@ -89,8 +89,8 @@ read_vec_u32(struct mem_context *mctx, const uint8_t **pp, const uint8_t *ep, ui
  * - the ctx pointer
  */
 int
-_read_vec_with_ctx_impl(struct mem_context *mctx, const uint8_t **pp, const uint8_t *ep,
-                        size_t elem_size,
+_read_vec_with_ctx_impl(struct mem_context *mctx, const uint8_t **pp,
+                        const uint8_t *ep, size_t elem_size,
                         int (*read_elem)(const uint8_t **pp, const uint8_t *ep,
                                          uint32_t idx, void *elem, void *),
                         void (*clear_elem)(void *elem), void *ctx,
@@ -154,13 +154,15 @@ read_elem_wrapper(const uint8_t **pp, const uint8_t *ep, uint32_t idx,
 }
 
 int
-read_vec(struct mem_context *mctx, const uint8_t **pp, const uint8_t *ep, size_t elem_size,
+read_vec(struct mem_context *mctx, const uint8_t **pp, const uint8_t *ep,
+         size_t elem_size,
          int (*read_elem)(const uint8_t **pp, const uint8_t *ep, void *elem),
          void (*clear_elem)(void *elem), uint32_t *countp, void **resultp)
 {
         struct read_vec_ctx ctx = {
                 .read_elem = read_elem,
         };
-        return _read_vec_with_ctx_impl(mctx, pp, ep, elem_size, read_elem_wrapper,
-                                       clear_elem, &ctx, countp, resultp);
+        return _read_vec_with_ctx_impl(mctx, pp, ep, elem_size,
+                                       read_elem_wrapper, clear_elem, &ctx,
+                                       countp, resultp);
 }
diff --git a/lib/decode.h b/lib/decode.h
index 4a951cbc..3155d243 100644
--- a/lib/decode.h
+++ b/lib/decode.h
@@ -11,8 +11,8 @@ int read_u32(const uint8_t **pp, const uint8_t *ep, uint32_t *resultp);
 int read_u64(const uint8_t **pp, const uint8_t *ep, uint64_t *resultp);
 
 int read_vec_count(const uint8_t **pp, const uint8_t *ep, uint32_t *resultp);
-int read_vec_u32(struct mem_context *mctx, const uint8_t **pp, const uint8_t *ep, uint32_t *countp,
-                 uint32_t **resultp);
+int read_vec_u32(struct mem_context *mctx, const uint8_t **pp,
+                 const uint8_t *ep, uint32_t *countp, uint32_t **resultp);
 
 typedef int (*read_elem_func_t)(const uint8_t **pp, const uint8_t *ep,
                                 void *elem);
@@ -20,12 +20,12 @@ typedef int (*read_elem_with_ctx_func_t)(const uint8_t **pp, const uint8_t *ep,
                                          uint32_t idx, void *elem, void *ctx);
 typedef void (*clear_elem_func_t)(void *elem);
 
-int read_vec(struct mem_context *mctx, const uint8_t **pp, const uint8_t *ep, size_t elem_size,
-             read_elem_func_t read_elem, clear_elem_func_t clear_elem,
-             uint32_t *countp, void **resultp);
+int read_vec(struct mem_context *mctx, const uint8_t **pp, const uint8_t *ep,
+             size_t elem_size, read_elem_func_t read_elem,
+             clear_elem_func_t clear_elem, uint32_t *countp, void **resultp);
 
-int _read_vec_with_ctx_impl(struct mem_context *mctx, const uint8_t **pp, const uint8_t *ep,
-                            size_t elem_size,
+int _read_vec_with_ctx_impl(struct mem_context *mctx, const uint8_t **pp,
+                            const uint8_t *ep, size_t elem_size,
                             read_elem_with_ctx_func_t read_elem,
                             clear_elem_func_t clear_elem, void *ctx,
                             uint32_t *countp, void **resultp);
@@ -44,24 +44,25 @@ int _read_vec_with_ctx_impl(struct mem_context *mctx, const uint8_t **pp, const
 
 #if defined(toywasm_typeof)
 /* a version with non-standard checks */
-#define read_vec_with_ctx(mctx, pp, ep, elem_size, read_elem, clear_elem, ctx,      \
-                          countp, resultp)                                    \
+#define read_vec_with_ctx(mctx, pp, ep, elem_size, read_elem, clear_elem,     \
+                          ctx, countp, resultp)                               \
         ({                                                                    \
                 int (*_r)(const uint8_t **, const uint8_t *, uint32_t,        \
                           toywasm_typeof(*resultp), void *) = read_elem;      \
                 void (*_c)(toywasm_typeof(*resultp)) = clear_elem;            \
                 assert(sizeof(**resultp) == elem_size);                       \
-                _read_vec_with_ctx_impl(mctx, pp, ep, elem_size,                    \
+                _read_vec_with_ctx_impl(mctx, pp, ep, elem_size,              \
                                         (read_elem_with_ctx_func_t)_r,        \
                                         (clear_elem_func_t)_c, ctx, countp,   \
                                         (void **)resultp);                    \
         })
 #else
-#define read_vec_with_ctx(mctx, pp, ep, elem_size, read_elem, clear_elem, ctx,      \
-                          countp, resultp)                                    \
-        _read_vec_with_ctx_impl(mctx,                                              \
-                pp, ep, elem_size, (read_elem_with_ctx_func_t)read_elem,      \
-                (clear_elem_func_t)clear_elem, ctx, countp, (void **)resultp)
+#define read_vec_with_ctx(mctx, pp, ep, elem_size, read_elem, clear_elem,     \
+                          ctx, countp, resultp)                               \
+        _read_vec_with_ctx_impl(mctx, pp, ep, elem_size,                      \
+                                (read_elem_with_ctx_func_t)read_elem,         \
+                                (clear_elem_func_t)clear_elem, ctx, countp,   \
+                                (void **)resultp)
 #endif
 
 struct name;
diff --git a/lib/exec.c b/lib/exec.c
index 389a1baf..dcffffbb 100644
--- a/lib/exec.c
+++ b/lib/exec.c
@@ -198,7 +198,8 @@ frame_enter(struct exec_context *ctx, struct instance *inst, uint32_t funcidx,
 #endif
         if (ei->maxlabels > 1) {
                 frame->labelidx = ctx->labels.lsize;
-                ret = VEC_PREALLOC(exec_mctx(ctx), ctx->labels, ei->maxlabels - 1);
+                ret = VEC_PREALLOC(exec_mctx(ctx), ctx->labels,
+                                   ei->maxlabels - 1);
                 if (ret != 0) {
                         return ret;
                 }
diff --git a/lib/exec_context.h b/lib/exec_context.h
index a6c69d59..f6691e9d 100644
--- a/lib/exec_context.h
+++ b/lib/exec_context.h
@@ -314,7 +314,7 @@ struct exec_context {
         void *exec_done_arg;
 #endif
 
-		struct mem_context *mctx;
+        struct mem_context *mctx;
 
         /* Options */
         struct exec_options options;
diff --git a/lib/exec_insn_subr.c b/lib/exec_insn_subr.c
index 1fea5f6f..04c946bf 100644
--- a/lib/exec_insn_subr.c
+++ b/lib/exec_insn_subr.c
@@ -104,7 +104,8 @@ memory_getptr2(struct exec_context *ctx, uint32_t memidx, uint32_t ptr,
 #endif
                 size_t need = (size_t)last_byte + 1;
                 assert(need > meminst->allocated);
-                void *np = mem_resize(meminst->mctx, meminst->data, meminst->allocated, need);
+                void *np = mem_resize(meminst->mctx, meminst->data,
+                                      meminst->allocated, need);
                 if (np == NULL) {
                         return ENOMEM;
                 }
@@ -477,16 +478,18 @@ memory_grow_impl(struct exec_context *ctx, struct meminst *mi, uint32_t sz)
                 if (new_size_in_bytes >> page_shift != new_size) {
                         ret = EOVERFLOW;
                 } else {
-                        void *np = mem_resize(mi->mctx, mi->data, mi->allocated, new_size_in_bytes);
+                        void *np =
+                                mem_resize(mi->mctx, mi->data, mi->allocated,
+                                           new_size_in_bytes);
                         if (np == NULL) {
-                            ret = ENOMEM;
+                                ret = ENOMEM;
                         } else {
-                        ret = 0;
-                            mi->data = np;
-                        assert(new_size_in_bytes > mi->allocated);
-                        memset(mi->data + mi->allocated, 0,
-                               new_size_in_bytes - mi->allocated);
-                        mi->allocated = new_size_in_bytes;
+                                ret = 0;
+                                mi->data = np;
+                                assert(new_size_in_bytes > mi->allocated);
+                                memset(mi->data + mi->allocated, 0,
+                                       new_size_in_bytes - mi->allocated);
+                                mi->allocated = new_size_in_bytes;
                         }
                 }
 #if defined(TOYWASM_ENABLE_WASM_THREADS)
diff --git a/lib/insn_impl_control.h b/lib/insn_impl_control.h
index ad0b0983..69ec500f 100644
--- a/lib/insn_impl_control.h
+++ b/lib/insn_impl_control.h
@@ -362,10 +362,10 @@ INSN_IMPL(br_table)
         struct mem_context *mctx;
         struct mem_context mctx0;
         if (VALIDATING) {
-            mctx = VCTX->mctx;
-		} else {
-            mctx = &mctx0;
-            mem_context_init(mctx);
+                mctx = VCTX->mctx;
+        } else {
+                mctx = &mctx0;
+                mem_context_init(mctx);
         }
         ret = read_vec_u32(mctx, &p, ep, &vec_count, &table);
         CHECK_RET(ret);
@@ -404,8 +404,8 @@ INSN_IMPL(br_table)
         }
         mem_free(mctx, table, vec_count * sizeof(uint32_t));
         if (!VALIDATING) {
-            mem_context_clear(mctx);
-		}
+                mem_context_clear(mctx);
+        }
         SAVE_PC;
         INSN_SUCCESS;
 fail:
diff --git a/lib/instance.c b/lib/instance.c
index 17f7cae8..8b4222cd 100644
--- a/lib/instance.c
+++ b/lib/instance.c
@@ -7,8 +7,8 @@
 #include "bitmap.h"
 #include "exec.h"
 #include "instance.h"
-#include "module.h"
 #include "mem.h"
+#include "module.h"
 #include "nbio.h"
 #include "shared_memory_impl.h"
 #include "suspend.h"
@@ -185,7 +185,8 @@ memory_instance_create(struct mem_context *mctx, struct meminst **mip,
                 if (need_in_bytes > 0) {
                         mp->data = mem_zalloc(mctx->need_in_bytes);
                         if (mp->data == NULL) {
-                                mem_free(mctx, mp->shared, sizeof(*mp->shared));
+                                mem_free(mctx, mp->shared,
+                                         sizeof(*mp->shared));
                                 mem_free(mctx, mp, sizeof(*mp));
                                 ret = ENOMEM;
                                 goto fail;
@@ -224,7 +225,8 @@ memory_instance_destroy(struct mem_context *mctx, struct meminst *mi)
 }
 
 int
-global_instance_create(struct mem_context *mctx, struct globalinst **gip, const struct globaltype *gt)
+global_instance_create(struct mem_context *mctx, struct globalinst **gip,
+                       const struct globaltype *gt)
 {
         struct globalinst *ginst;
         int ret;
@@ -249,7 +251,8 @@ global_instance_destroy(struct mem_context *mctx, struct globalinst *gi)
 
 #if defined(TOYWASM_ENABLE_WASM_EXCEPTION_HANDLING)
 int
-tag_instance_create(struct mem_context *mctx, struct taginst **tip, const struct functype *ft)
+tag_instance_create(struct mem_context *mctx, struct taginst **tip,
+                    const struct functype *ft)
 {
         struct taginst *ti;
         int ret;
@@ -273,7 +276,8 @@ tag_instance_destroy(struct mem_context *mctx, struct taginst *ti)
 #endif
 
 int
-table_instance_create(struct mem_context *mctx, struct tableinst **tip, const struct tabletype *tt)
+table_instance_create(struct mem_context *mctx, struct tableinst **tip,
+                      const struct tabletype *tt)
 {
         struct tableinst *tinst;
         int ret;
@@ -309,9 +313,9 @@ table_instance_create(struct mem_context *mctx, struct tableinst **tip, const st
 }
 
 void
-table_instance_destroy(struct mem_context *mctx ,struct tableinst *ti)
+table_instance_destroy(struct mem_context *mctx, struct tableinst *ti)
 {
-		assert(mctx == ti->mctx);
+        assert(mctx == ti->mctx);
         if (ti != NULL) {
                 uint32_t csz = valtype_cellsize(ti->type->et);
                 size_t ncells = (size_t)ti->size * csz;
@@ -324,8 +328,9 @@ table_instance_destroy(struct mem_context *mctx ,struct tableinst *ti)
  */
 
 int
-instance_create(struct mem_context *mctx, const struct module *m, struct instance **instp,
-                const struct import_object *imports, struct report *report)
+instance_create(struct mem_context *mctx, const struct module *m,
+                struct instance **instp, const struct import_object *imports,
+                struct report *report)
 {
         struct instance *inst;
         int ret;
@@ -448,7 +453,8 @@ resolve_imports(struct instance *inst, const struct import_object *imports,
 }
 
 int
-instance_create_no_init(struct mem_context *mctx, const struct module *m, struct instance **instp,
+instance_create_no_init(struct mem_context *mctx, const struct module *m,
+                        struct instance **instp,
                         const struct import_object *imports,
                         struct report *report)
 {
diff --git a/lib/instance.h b/lib/instance.h
index 88883705..85a3a7e9 100644
--- a/lib/instance.h
+++ b/lib/instance.h
@@ -19,7 +19,8 @@ __BEGIN_EXTERN_C
  * This API is inspired from js-api.
  * https://webassembly.github.io/spec/js-api/index.html#instances
  */
-int instance_create(struct mem_context *mctx, const struct module *m, struct instance **instp,
+int instance_create(struct mem_context *mctx, const struct module *m,
+                    struct instance **instp,
                     const struct import_object *imports,
                     struct report *report);
 
@@ -33,7 +34,8 @@ int instance_create(struct mem_context *mctx, const struct module *m, struct ins
  * note than instance_execute_init can return a restartable error.
  * see also: instance_execute_continue.
  */
-int instance_create_no_init(struct mem_context *mctx, const struct module *m, struct instance **instp,
+int instance_create_no_init(struct mem_context *mctx, const struct module *m,
+                            struct instance **instp,
                             const struct import_object *imports,
                             struct report *report);
 int instance_execute_init(struct exec_context *ctx);
@@ -123,7 +125,8 @@ int import_object_find_entry(
 
 struct meminst;
 struct memtype;
-int memory_instance_create(struct mem_context *mctx, struct meminst **mip, const struct memtype *mt);
+int memory_instance_create(struct mem_context *mctx, struct meminst **mip,
+                           const struct memtype *mt);
 void memory_instance_destroy(struct mem_context *mctx, struct meminst *mi);
 
 struct globalinst;
@@ -134,7 +137,8 @@ void global_instance_destroy(struct mem_context *mctx, struct globalinst *gi);
 
 struct tableinst;
 struct tabletype;
-int table_instance_create(struct mem_context *mctx, struct tableinst **tip, const struct tabletype *tt);
+int table_instance_create(struct mem_context *mctx, struct tableinst **tip,
+                          const struct tabletype *tt);
 void table_instance_destroy(struct mem_context *mctx, struct tableinst *ti);
 
 /*
@@ -146,7 +150,8 @@ void table_instance_destroy(struct mem_context *mctx, struct tableinst *ti);
  * mainly for wasi-threads, where it's host's responsibility to
  * provide the linear memory.
  */
-int create_satisfying_shared_memories(struct mem_context *mctx, const struct module *module,
+int create_satisfying_shared_memories(struct mem_context *mctx,
+                                      const struct module *module,
                                       struct import_object **imop);
 
 void instance_print_stats(const struct instance *inst);
diff --git a/lib/mem.c b/lib/mem.c
index 94439855..af9ce208 100644
--- a/lib/mem.c
+++ b/lib/mem.c
@@ -32,24 +32,23 @@ mem_alloc(struct mem_context *ctx, size_t sz)
 void *
 mem_zalloc(struct mem_context *ctx, size_t sz)
 {
-	void *p = mem_alloc(ctx, sz);
-    if (p != NULL) {
-        memset(p, 0, sz);
-    }
-    return p;
+        void *p = mem_alloc(ctx, sz);
+        if (p != NULL) {
+                memset(p, 0, sz);
+        }
+        return p;
 }
 
 void *
 mem_calloc(struct mem_context *ctx, size_t a, size_t b)
 {
-	size_t sz = a * b;
-    if (sz / a != b) {
-        return NULL;
-    }
-    return mem_zalloc(ctx, sz);
+        size_t sz = a * b;
+        if (sz / a != b) {
+                return NULL;
+        }
+        return mem_zalloc(ctx, sz);
 }
 
-
 static int
 mem_reserve(struct mem_context *ctx, size_t diff)
 {
diff --git a/lib/mem.h b/lib/mem.h
index ac001779..1a8fa3ed 100644
--- a/lib/mem.h
+++ b/lib/mem.h
@@ -9,8 +9,11 @@ struct mem_context {
 
 void mem_context_init(struct mem_context *ctx);
 void mem_context_clear(struct mem_context *ctx);
-void *__must_check mem_alloc(struct mem_context *ctx, size_t sz) __malloc_like __alloc_size(2);
-void *__must_check mem_zalloc(struct mem_context *ctx, size_t sz) __malloc_like __alloc_size(2);
+void *__must_check mem_alloc(struct mem_context *ctx, size_t sz) __malloc_like
+        __alloc_size(2);
+void *__must_check mem_zalloc(struct mem_context *ctx, size_t sz) __malloc_like
+        __alloc_size(2);
 void *__must_check mem_calloc(struct mem_context *ctx, size_t a, size_t b);
 void mem_free(struct mem_context *ctx, void *p, size_t sz);
-void *__must_check mem_resize(struct mem_context *ctx, void *p, size_t oldsz, size_t newsz) __malloc_like __alloc_size(4);
+void *__must_check mem_resize(struct mem_context *ctx, void *p, size_t oldsz,
+                              size_t newsz) __malloc_like __alloc_size(4);
diff --git a/lib/module.c b/lib/module.c
index fe57f831..c033915a 100644
--- a/lib/module.c
+++ b/lib/module.c
@@ -19,8 +19,8 @@
 #include "expr.h"
 #include "leb128.h"
 #include "load_context.h"
-#include "module.h"
 #include "mem.h"
+#include "module.h"
 #include "nbio.h"
 #include "report.h"
 #include "type.h"
@@ -820,8 +820,9 @@ read_type_section(const uint8_t **pp, const uint8_t *ep,
         const uint8_t *p = *pp;
         int ret;
 
-        ret = read_vec_with_ctx(load_mctx(ctx),&p, ep, sizeof(*m->types), read_functype,
-                                clear_functype, ctx, &m->ntypes, &m->types);
+        ret = read_vec_with_ctx(load_mctx(ctx), &p, ep, sizeof(*m->types),
+                                read_functype, clear_functype, ctx, &m->ntypes,
+                                &m->types);
         if (ret != 0) {
                 goto fail;
         }
@@ -845,8 +846,9 @@ read_import_section(const uint8_t **pp, const uint8_t *ep,
         const uint8_t *p = *pp;
         int ret;
 
-        ret = read_vec_with_ctx(load_mctx(ctx), &p, ep, sizeof(struct import), read_import,
-                                clear_import, ctx, &m->nimports, &m->imports);
+        ret = read_vec_with_ctx(load_mctx(ctx), &p, ep, sizeof(struct import),
+                                read_import, clear_import, ctx, &m->nimports,
+                                &m->imports);
         if (ret != 0) {
                 goto fail;
         }
@@ -1080,7 +1082,8 @@ read_function_section(const uint8_t **pp, const uint8_t *ep,
         const uint8_t *p = *pp;
         int ret;
 
-        ret = read_vec_u32(load_mctx(ctx), &p, ep, &m->nfuncs, &m->functypeidxes);
+        ret = read_vec_u32(load_mctx(ctx), &p, ep, &m->nfuncs,
+                           &m->functypeidxes);
         if (ret != 0) {
                 goto fail;
         }
@@ -1150,8 +1153,8 @@ read_memory_section(const uint8_t **pp, const uint8_t *ep,
         const uint8_t *p = *pp;
         int ret;
 
-        ret = read_vec_with_ctx(load_mctx(ctx), &p, ep, sizeof(*m->mems), read_memtype, NULL,
-                                ctx, &m->nmems, &m->mems);
+        ret = read_vec_with_ctx(load_mctx(ctx), &p, ep, sizeof(*m->mems),
+                                read_memtype, NULL, ctx, &m->nmems, &m->mems);
         if (ret != 0) {
                 xlog_trace("failed to load mems with %d", ret);
                 goto fail;
@@ -1206,8 +1209,9 @@ read_global_section(const uint8_t **pp, const uint8_t *ep,
         const uint8_t *p = *pp;
         int ret;
 
-        ret = read_vec_with_ctx(load_mctx(ctx), &p, ep, sizeof(*m->globals), read_global,
-                                clear_global, ctx, &m->nglobals, &m->globals);
+        ret = read_vec_with_ctx(load_mctx(ctx), &p, ep, sizeof(*m->globals),
+                                read_global, clear_global, ctx, &m->nglobals,
+                                &m->globals);
         if (ret != 0) {
                 goto fail;
         }
@@ -1233,9 +1237,9 @@ read_export_section(const uint8_t **pp, const uint8_t *ep,
         const uint8_t *p = *pp;
         int ret;
 
-        ret = read_vec_with_ctx(load_mctx(ctx), &p, ep, sizeof(struct wasm_export),
-                                read_export, clear_export, ctx, &m->nexports,
-                                &m->exports);
+        ret = read_vec_with_ctx(load_mctx(ctx), &p, ep,
+                                sizeof(struct wasm_export), read_export,
+                                clear_export, ctx, &m->nexports, &m->exports);
         if (ret != 0) {
                 goto fail;
         }
@@ -1432,7 +1436,8 @@ read_element(const uint8_t **pp, const uint8_t *ep, uint32_t idx,
                  * vec(funcidx)
                  */
                 assert(elem->type == TYPE_FUNCREF);
-                ret = read_vec_u32(load_mctx(ctx), &p, ep, &elem->init_size, &elem->funcs);
+                ret = read_vec_u32(load_mctx(ctx), &p, ep, &elem->init_size,
+                                   &elem->funcs);
                 if (ret != 0) {
                         goto fail;
                 }
@@ -1452,10 +1457,10 @@ read_element(const uint8_t **pp, const uint8_t *ep, uint32_t idx,
                 /*
                  * vec(expr)
                  */
-                ret = read_vec_with_ctx(load_mctx(ctx), &p, ep, sizeof(*elem->init_exprs),
-                                        read_element_init_expr, clear_expr,
-                                        &init_expr_ctx, &elem->init_size,
-                                        &elem->init_exprs);
+                ret = read_vec_with_ctx(
+                        load_mctx(ctx), &p, ep, sizeof(*elem->init_exprs),
+                        read_element_init_expr, clear_expr, &init_expr_ctx,
+                        &elem->init_size, &elem->init_exprs);
                 if (ret != 0) {
                         goto fail;
                 }
@@ -1499,8 +1504,9 @@ read_element_section(const uint8_t **pp, const uint8_t *ep,
         const uint8_t *p = *pp;
         int ret;
 
-        ret = read_vec_with_ctx(load_mctx(ctx), &p, ep, sizeof(*m->elems), read_element,
-                                clear_element, ctx, &m->nelems, &m->elems);
+        ret = read_vec_with_ctx(load_mctx(ctx), &p, ep, sizeof(*m->elems),
+                                read_element, clear_element, ctx, &m->nelems,
+                                &m->elems);
         if (ret != 0) {
                 goto fail;
         }
@@ -1526,8 +1532,9 @@ read_code_section(const uint8_t **pp, const uint8_t *ep,
 
         assert(m->funcs == NULL);
         uint32_t nfuncs_in_code = 0;
-        ret = read_vec_with_ctx(load_mctx(ctx), &p, ep, sizeof(*m->funcs), read_func,
-                                clear_func, ctx, &nfuncs_in_code, &m->funcs);
+        ret = read_vec_with_ctx(load_mctx(ctx), &p, ep, sizeof(*m->funcs),
+                                read_func, clear_func, ctx, &nfuncs_in_code,
+                                &m->funcs);
         if (ret != 0) {
                 assert(nfuncs_in_code == 0);
                 goto fail;
@@ -1638,8 +1645,9 @@ read_data_section(const uint8_t **pp, const uint8_t *ep,
         const uint8_t *p = *pp;
         int ret;
 
-        ret = read_vec_with_ctx(load_mctx(ctx), &p, ep, sizeof(*m->datas), read_data,
-                                clear_data, ctx, &m->ndatas, &m->datas);
+        ret = read_vec_with_ctx(load_mctx(ctx), &p, ep, sizeof(*m->datas),
+                                read_data, clear_data, ctx, &m->ndatas,
+                                &m->datas);
         if (ret != 0) {
                 goto fail;
         }
@@ -2227,8 +2235,8 @@ module_create0(struct mem_context *mctx, struct module **mp)
 }
 
 int
-module_create(struct mem_context *mctx, struct module **mp, const uint8_t *p, const uint8_t *ep,
-              struct load_context *ctx)
+module_create(struct mem_context *mctx, struct module **mp, const uint8_t *p,
+              const uint8_t *ep, struct load_context *ctx)
 {
         struct module *m;
         int ret = module_create0(mctx, &m);
@@ -2260,7 +2268,8 @@ module_unload(struct mem_context *mctx, struct module *m)
                 }
                 mem_free(mctx, m->funcs, m->nfuncs * sizeof(*m->funcs));
         }
-        mem_free(mctx, m->functypeidxes, m->nfuncs * sizeof(*m->functypeidxes));
+        mem_free(mctx, m->functypeidxes,
+                 m->nfuncs * sizeof(*m->functypeidxes));
 
         mem_free(mctx, m->tables, m->ntables * sizeof(*m->tables));
         mem_free(mctx, m->mems, m->nmems * sizeof(*m->mems));
diff --git a/lib/module.h b/lib/module.h
index c2dbd676..a1abbfe3 100644
--- a/lib/module.h
+++ b/lib/module.h
@@ -9,7 +9,8 @@ struct mem_context;
 
 __BEGIN_EXTERN_C
 
-int module_create(struct mem_context *mctx, struct module **mp, const uint8_t *p, const uint8_t *ep,
+int module_create(struct mem_context *mctx, struct module **mp,
+                  const uint8_t *p, const uint8_t *ep,
                   struct load_context *ctx);
 void module_destroy(struct mem_context *mctx, struct module *m);
 int module_find_export(const struct module *m, const struct name *name,
diff --git a/lib/name.c b/lib/name.c
index ad9cbd43..4ac61f4d 100644
--- a/lib/name.c
+++ b/lib/name.c
@@ -93,17 +93,17 @@ clear_naming(struct naming *ft)
 /* https://github.com/WebAssembly/design/blob/main/BinaryEncoding.md#name-map
  */
 static int
-parse_namemap(struct nametable *table, struct namemap *map, const struct module *m, const uint8_t *p,
-              const uint8_t *ep)
+parse_namemap(struct nametable *table, struct namemap *map,
+              const struct module *m, const uint8_t *p, const uint8_t *ep)
 {
         struct read_naming_context ctx;
         int ret;
 
         ctx.module = m;
         map->entries = NULL;
-        ret = read_vec_with_ctx(&table->mctx, &p, ep, sizeof(struct naming), read_naming,
-                                clear_naming, &ctx, &map->nentries,
-                                &map->entries);
+        ret = read_vec_with_ctx(&table->mctx, &p, ep, sizeof(struct naming),
+                                read_naming, clear_naming, &ctx,
+                                &map->nentries, &map->entries);
         if (ret != 0) {
                 goto fail;
         }
@@ -203,7 +203,8 @@ namemap_init(struct namemap *map)
 static void
 namemap_clear(struct nametable *table, struct namemap *map)
 {
-        mem_free(&table->mctx, map->entries, map->nentries * sizeof(*map->entries));
+        mem_free(&table->mctx, map->entries,
+                 map->nentries * sizeof(*map->entries));
         map->nentries = 0;
         map->entries = NULL;
 }
diff --git a/lib/shared_memory.c b/lib/shared_memory.c
index 656a3210..6fef6587 100644
--- a/lib/shared_memory.c
+++ b/lib/shared_memory.c
@@ -17,7 +17,8 @@ _dtor(struct import_object *imo)
 }
 
 int
-create_satisfying_shared_memories(struct mem_context *mctx, const struct module *m,
+create_satisfying_shared_memories(struct mem_context *mctx,
+                                  const struct module *m,
                                   struct import_object **imop)
 {
         struct import_object *imo = NULL;
diff --git a/lib/type.h b/lib/type.h
index c7a6ec06..342d5869 100644
--- a/lib/type.h
+++ b/lib/type.h
@@ -578,7 +578,7 @@ struct meminst {
          */
         struct shared_meminst *shared;
 #endif
-		struct mem_context *mctx;
+        struct mem_context *mctx;
 };
 
 struct globalinst {
diff --git a/lib/util.h b/lib/util.h
index 8319155c..2d3d60d3 100644
--- a/lib/util.h
+++ b/lib/util.h
@@ -8,10 +8,12 @@
 void *__must_check xzalloc(size_t sz) __malloc_like __alloc_size(1);
 
 struct mem_context;
-int __must_check resize_array(struct mem_context *ctx, void **p, size_t elem_size,
-                              uint32_t old_elem_count, uint32_t new_elem_count);
+int __must_check resize_array(struct mem_context *ctx, void **p,
+                              size_t elem_size, uint32_t old_elem_count,
+                              uint32_t new_elem_count);
 
-#define ARRAY_RESIZE(ctx, a, osz, sz) resize_array((ctx), (void **)&(a), sizeof(*a), osz, sz)
+#define ARRAY_RESIZE(ctx, a, osz, sz)                                         \
+        resize_array((ctx), (void **)&(a), sizeof(*a), osz, sz)
 #define ARRAY_FOREACH(p, a, sz) for (p = a; p < a + sz; p++)
 
 #define ZERO(p) memset(p, 0, sizeof(*p))
diff --git a/lib/vec.h b/lib/vec.h
index 989818b7..a2659443 100644
--- a/lib/vec.h
+++ b/lib/vec.h
@@ -17,9 +17,10 @@ struct mem_context;
 
 __BEGIN_EXTERN_C
 
-int __must_check _vec_resize(struct mem_context *ctx, void *vec, size_t elem_size,
-                             uint32_t new_elem_count);
-int __must_check _vec_prealloc(struct mem_context *ctx, void *vec, size_t elem_size, uint32_t count);
+int __must_check _vec_resize(struct mem_context *ctx, void *vec,
+                             size_t elem_size, uint32_t new_elem_count);
+int __must_check _vec_prealloc(struct mem_context *ctx, void *vec,
+                               size_t elem_size, uint32_t count);
 void _vec_free(struct mem_context *ctx, void *vec);
 
 __END_EXTERN_C
@@ -36,7 +37,8 @@ __END_EXTERN_C
  * given number of elements. that is, psize >= lsize + needed.
  * it doesn't initialize newly allocated elements.
  */
-#define VEC_PREALLOC(ctx, v, needed) _vec_prealloc(ctx, &v, sizeof(*v.p), needed);
+#define VEC_PREALLOC(ctx, v, needed)                                          \
+        _vec_prealloc(ctx, &v, sizeof(*v.p), needed);
 #define VEC_FREE(ctx, v) _vec_free(ctx, &v)
 #define VEC_FOREACH(it, v) ARRAY_FOREACH(it, v.p, v.lsize)
 #define VEC_FOREACH_IDX(i, it, v) for (i = 0, it = v.p; i < v.lsize; i++, it++)