diff --git a/doc/guides/rom-method-table.md b/doc/guides/rom-method-table.md
index 6bf2366ad..6d9cd71cd 100644
--- a/doc/guides/rom-method-table.md
+++ b/doc/guides/rom-method-table.md
@@ -45,18 +45,19 @@ After String.define_method(:foo):
 
 ### Memory Layout
 
-Each `mrb_mt_tbl` stores method entries as parallel arrays in a single
-contiguous block:
+Each `mrb_mt_tbl` stores method entries as an array of `mrb_mt_entry`
+structs, each combining a function pointer and an encoded key:
 
 ```
-ptr -> [ vals[0] vals[1] ... vals[N-1] | keys[0] keys[1] ... keys[N-1] ]
-       |<--- union mrb_mt_ptr array ------>|<--- mrb_sym (encoded) array -->|
+ptr -> [ entry[0] | entry[1] | ... | entry[N-1] ]
+       |<--- mrb_mt_entry: { val, key } each ---->|
 ```
 
-Values are `union mrb_mt_ptr` (function pointer or proc pointer). Keys are
-`mrb_sym` with flags packed into the lower bits using `MRB_MT_KEY()`.
+Values are `union mrb_mt_ptr` (function pointer or proc pointer). Keys
+are `mrb_sym` with flags packed into the lower bits using
+`MRB_MT_KEY()`.
 
-Keys must be sorted by symbol ID for binary search. The
+Entries must be sorted by symbol ID for binary search. The
 `mrb_mt_init_rom()` function handles sorting at startup, so the
 source code order does not matter.
 
@@ -64,33 +65,20 @@ source code order does not matter.
 
 ### Step 1: Define the Static Data
 
-Include `<mruby/internal.h>` (which provides `mrb_mt_tbl`, `union mrb_mt_ptr`,
-`MRB_MT_KEY()`, and flag constants) and define the ROM data structure:
+Include `<mruby/internal.h>` (which provides `mrb_mt_entry`,
+`mrb_mt_tbl`, `MRB_MT_ENTRY()`, `MRB_MT_ROM_TAB()`, and flag
+constants) and define the ROM entries:
 
 ```c
 #include <mruby/internal.h>
 #include <mruby/presym.h>
 
-#define MY_ROM_MT_SIZE 3
-static struct {
-  union mrb_mt_ptr vals[MY_ROM_MT_SIZE];
-  mrb_sym keys[MY_ROM_MT_SIZE];
-} my_rom_data = {
-  .vals = {
-    { .func = my_method_a },
-    { .func = my_method_b },
-    { .func = my_method_c },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(method_a), MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(method_b), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(eq),     MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl my_rom_mt = {
-  MY_ROM_MT_SIZE, MY_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&my_rom_data, NULL
+static mrb_mt_entry my_rom_entries[] = {
+  MRB_MT_ENTRY(my_method_a, MRB_SYM(method_a), MRB_MT_FUNC),
+  MRB_MT_ENTRY(my_method_b, MRB_SYM(method_b), MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(my_method_eq, MRB_OPSYM(eq),    MRB_MT_FUNC),
 };
+static mrb_mt_tbl my_rom_mt = MRB_MT_ROM_TAB(my_rom_entries);
 ```
 
 ### Step 2: Register in the Init Function
@@ -107,7 +95,7 @@ mrb_mruby_mygem_gem_init(mrb_state *mrb)
 }
 ```
 
-`mrb_mt_init_rom()` sorts the keys by symbol ID, sets the readonly
+`mrb_mt_init_rom()` sorts the entries by symbol ID, sets the readonly
 flag, and pushes the ROM layer onto the class's method table chain.
 
 ### Step 3: Verify
@@ -127,14 +115,33 @@ union mrb_mt_ptr {
   mrb_func_t func;
 };
 
+typedef struct mrb_mt_entry {
+  union mrb_mt_ptr val;
+  mrb_sym key;
+} mrb_mt_entry;
+
 typedef struct mrb_mt_tbl {
   int             size;
-  int             alloc;    /* bit 30: MRB_MT_READONLY_BIT */
-  union mrb_mt_ptr   *ptr;
-  struct mrb_mt_tbl  *next;     /* next (lower-priority) layer, or NULL */
+  int             alloc;       /* bit 30: MRB_MT_READONLY_BIT */
+  mrb_mt_entry   *ptr;
+  struct mrb_mt_tbl  *next;    /* next (lower-priority) layer, or NULL */
 } mrb_mt_tbl;
 ```
 
+### Macros
+
+```c
+/* ROM table entry: bundles function pointer with encoded key */
+#define MRB_MT_ENTRY(fn, sym, flags) \
+  { { .func = (fn) }, MRB_MT_KEY((sym), (flags)) }
+
+/* ROM table initializer (auto-computes size from entries array) */
+#define MRB_MT_ROM_TAB(entries) { \
+  (int)(sizeof(entries)/sizeof(entries[0])), \
+  (int)(sizeof(entries)/sizeof(entries[0])), \
+  (entries), NULL }
+```
+
 ### Key Encoding
 
 ```c
@@ -150,7 +157,8 @@ typedef struct mrb_mt_tbl {
 | `MRB_MT_PUBLIC`  | 0     | Public visibility                             |
 | `MRB_MT_PRIVATE` | 1     | Private visibility                            |
 
-Most ROM entries use `MRB_MT_FUNC|MRB_MT_PUBLIC` or `MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC`.
+Most ROM entries use `MRB_MT_FUNC` or `MRB_MT_FUNC|MRB_MT_NOARG`.
+Since `MRB_MT_PUBLIC` is 0, it can be omitted.
 
 **How to choose flags:**
 
@@ -158,8 +166,7 @@ Most ROM entries use `MRB_MT_FUNC|MRB_MT_PUBLIC` or `MRB_MT_FUNC|MRB_MT_NOARG|MR
   RProc-based methods (rare in ROM tables).
 - **`MRB_MT_NOARG`**: Set when the original `mrb_define_method_id()` used
   `MRB_ARGS_NONE()`. This enables an optimized call path in the VM.
-- **`MRB_MT_PUBLIC` / `MRB_MT_PRIVATE`**: Match the intended visibility. Almost
-  all methods are public.
+- **`MRB_MT_PRIVATE`**: Set for private methods (e.g., `initialize`).
 
 ### Symbol Macros
 
@@ -189,26 +196,21 @@ Sorts the ROM table, sets the readonly flag, and pushes it onto the
 class's method table chain. Multiple calls push additional layers,
 which is how extension gems add methods to core classes.
 
-## Vals and Keys Correspondence
+## Entry Correspondence
 
-Each `vals[i]` corresponds to `keys[i]`. The function pointer in
-`vals[i]` is the C implementation of the method identified by
-`keys[i]`. Their order in the source code does not matter (they are
-sorted at init time), but keeping them in the same order improves
-readability.
+Each `MRB_MT_ENTRY()` bundles a function pointer with its method name
+and flags in a single line. Their order in the source code does not
+matter (they are sorted at init time), but keeping related methods
+together improves readability.
 
 **Method aliases** (two names for the same function) are expressed as
 separate entries sharing the same function pointer:
 
 ```c
-.vals = {
-  { .func = mrb_str_size },   /* size */
-  { .func = mrb_str_size },   /* length (alias) */
-},
-.keys = {
-  MRB_MT_KEY(MRB_SYM(size),   MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  MRB_MT_KEY(MRB_SYM(length), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-}
+static mrb_mt_entry str_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_str_size, MRB_SYM(size),   MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_size, MRB_SYM(length), MRB_MT_FUNC|MRB_MT_NOARG),
+};
 ```
 
 ## Conditional Methods
@@ -221,9 +223,8 @@ blocks):
 
 ```c
 #ifndef MRB_NO_FLOAT
-#define FLOAT_ROM_MT_SIZE 29
-static struct { ... } float_rom_data = { ... };
-static mrb_mt_tbl float_rom_mt = { ... };
+static mrb_mt_entry float_rom_entries[] = { ... };
+static mrb_mt_tbl float_rom_mt = MRB_MT_ROM_TAB(float_rom_entries);
 #endif
 
 void mrb_init_numeric(mrb_state *mrb) {
@@ -259,9 +260,8 @@ ROM layer in front of the core ROM layer:
 ```c
 /* mrbgems/mruby-string-ext/src/string.c */
 
-#define STRING_EXT_ROM_MT_SIZE 53
-static struct { ... } string_ext_rom_data = { ... };
-static mrb_mt_tbl string_ext_rom_mt = { ... };
+static mrb_mt_entry string_ext_rom_entries[] = { ... };
+static mrb_mt_tbl string_ext_rom_mt = MRB_MT_ROM_TAB(string_ext_rom_entries);
 
 void mrb_mruby_string_ext_gem_init(mrb_state *mrb)
 {
@@ -360,21 +360,25 @@ To convert existing `mrb_define_method_id()` calls to a ROM table:
 
 1. **Count** the number of method definitions that can be converted.
 
-2. **Create** the ROM data structure with `#define MY_ROM_MT_SIZE N`.
+2. **Create** the ROM entries array using `MRB_MT_ENTRY()`.
 
-3. **Move** each `mrb_define_method_id()` call into the ROM table:
-   - The second-to-last argument (function pointer) goes into `.vals`.
-   - The third argument (symbol) goes into `.keys` via `MRB_MT_KEY()`.
-   - Map the `MRB_ARGS_*` macro to flags:
-     - `MRB_ARGS_NONE()` -> `MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC`
-     - Anything else -> `MRB_MT_FUNC|MRB_MT_PUBLIC`
+3. **Move** each `mrb_define_method_id()` call into the entries:
+   - `MRB_MT_ENTRY(func, sym, flags)` where:
+     - `func` is the function pointer
+     - `sym` is the symbol macro (e.g., `MRB_SYM(name)`)
+     - `flags` are:
+       - `MRB_ARGS_NONE()` -> `MRB_MT_FUNC|MRB_MT_NOARG`
+       - Anything else -> `MRB_MT_FUNC`
+       - Add `MRB_MT_PRIVATE` for private methods
 
-4. **Replace** the calls with `mrb_mt_init_rom(c, &my_rom_mt)`.
+4. **Create** the table with `MRB_MT_ROM_TAB(entries)`.
 
-5. **Keep** any methods that cannot be converted (see above) as
+5. **Replace** the calls with `mrb_mt_init_rom(c, &my_rom_mt)`.
+
+6. **Keep** any methods that cannot be converted (see above) as
    individual `mrb_define_method_id()` calls after the ROM init.
 
-6. **Build and test**: `rake CONFIG=host-debug -j24 all test:run:serial`
+7. **Build and test**: `rake CONFIG=host-debug -j24 all test:run:serial`
 
 ### Before
 
@@ -390,26 +394,12 @@ void mrb_mruby_foo_gem_init(mrb_state *mrb) {
 ### After
 
 ```c
-#define FOO_ROM_MT_SIZE 3
-static struct {
-  union mrb_mt_ptr vals[FOO_ROM_MT_SIZE];
-  mrb_sym keys[FOO_ROM_MT_SIZE];
-} foo_rom_data = {
-  .vals = {
-    { .func = foo_bar },
-    { .func = foo_baz },
-    { .func = foo_eq },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(bar),   MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(baz),   MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(eq),  MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl foo_rom_mt = {
-  FOO_ROM_MT_SIZE, FOO_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&foo_rom_data, NULL
+static mrb_mt_entry foo_rom_entries[] = {
+  MRB_MT_ENTRY(foo_bar, MRB_SYM(bar),  MRB_MT_FUNC),
+  MRB_MT_ENTRY(foo_baz, MRB_SYM(baz),  MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(foo_eq,  MRB_OPSYM(eq), MRB_MT_FUNC),
 };
+static mrb_mt_tbl foo_rom_mt = MRB_MT_ROM_TAB(foo_rom_entries);
 
 void mrb_mruby_foo_gem_init(mrb_state *mrb) {
   struct RClass *foo = mrb_define_class_id(mrb, MRB_SYM(Foo), mrb->object_class);
diff --git a/include/mruby/internal.h b/include/mruby/internal.h
index ece832238..ce31e0baa 100644
--- a/include/mruby/internal.h
+++ b/include/mruby/internal.h
@@ -34,10 +34,16 @@ union mrb_mt_ptr {
   mrb_func_t func;
 };
 
+/* entry combining function pointer and key */
+typedef struct mrb_mt_entry {
+  union mrb_mt_ptr val;
+  mrb_sym key;
+} mrb_mt_entry;
+
 typedef struct mrb_mt_tbl {
   int               size;
   int               alloc;  /* bit 30: MRB_MT_READONLY_BIT, bit 29: MRB_MT_FROZEN_BIT */
-  union mrb_mt_ptr *ptr;
+  mrb_mt_entry     *ptr;
   struct mrb_mt_tbl *next;
 } mrb_mt_tbl;
 
@@ -50,12 +56,22 @@ typedef struct mrb_mt_tbl {
 #define MRB_MT_PUBLIC  0    /* MRB_METHOD_PUBLIC_FL */
 #define MRB_MT_PRIVATE 1    /* MRB_METHOD_PRIVATE_FL */
 
+/* ROM table entry: { {.func=fn}, MRB_MT_KEY(sym, flags) } */
+#define MRB_MT_ENTRY(fn, sym, flags) \
+  { { .func = (fn) }, MRB_MT_KEY((sym), (flags)) }
+
+/* ROM table initializer from entries array (auto-computes size) */
+#define MRB_MT_ROM_TAB(entries) { \
+  (int)(sizeof(entries)/sizeof(entries[0])), \
+  (int)(sizeof(entries)/sizeof(entries[0])), \
+  (entries), NULL }
+
 /* "removed" tombstone: MRB_MT_FUNC flag set with NULL function pointer.
    This combination never occurs naturally (C functions are never NULL).
    Unlike undef (proc=NULL without MRB_MT_FUNC), a removed marker makes
    mt_get() return 0 ("not found"), blocking ROM chain walk while
    allowing superclass lookup. */
-#define MRB_MT_REMOVED_P(key, val) (((key)&MRB_MT_FUNC) && (val).func==NULL)
+#define MRB_MT_REMOVED_P(e) (((e).key&MRB_MT_FUNC) && (e).val.func==NULL)
 
 void mrb_mt_init_rom(struct RClass *c, mrb_mt_tbl *rom);
 #endif
diff --git a/mrbgems/mruby-array-ext/src/array.c b/mrbgems/mruby-array-ext/src/array.c
index e155f3a19..eb00bea65 100644
--- a/mrbgems/mruby-array-ext/src/array.c
+++ b/mrbgems/mruby-array-ext/src/array.c
@@ -1537,78 +1537,38 @@ ary_combination_next(mrb_state *mrb, mrb_value self)
 }
 
 /* ---------------------------*/
-#define ARRAY_EXT_ROM_MT_SIZE 29
-static struct {
-  union mrb_mt_ptr vals[ARRAY_EXT_ROM_MT_SIZE];
-  mrb_sym keys[ARRAY_EXT_ROM_MT_SIZE];
-} array_ext_rom_data = {
-  .vals = {
-    { .func = ary_assoc },
-    { .func = ary_at },
-    { .func = ary_rassoc },
-    { .func = ary_values_at },
-    { .func = ary_slice_bang },
-    { .func = ary_compact },
-    { .func = ary_compact_bang },
-    { .func = ary_rotate },
-    { .func = ary_rotate_bang },
-    { .func = ary_sub },
-    { .func = ary_difference },
-    { .func = ary_union },
-    { .func = ary_union_multi },
-    { .func = ary_intersection },
-    { .func = ary_intersection_multi },
-    { .func = ary_intersect_p },
-    { .func = ary_fill_parse_arg },
-    { .func = ary_fill_exec },
-    { .func = ary_uniq },
-    { .func = ary_uniq_bang },
-    { .func = ary_flatten },
-    { .func = ary_flatten_bang },
-    { .func = ary_normalize_index },
-    { .func = ary_fetch },
-    { .func = ary_insert },
-    { .func = ary_deconstruct },
-    { .func = ary_product_group },
-    { .func = ary_combination_init },
-    { .func = ary_combination_next },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(assoc),              MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(at),                 MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(rassoc),             MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(values_at),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(slice),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(compact),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(compact),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(rotate),             MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(rotate),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(sub),              MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(difference),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(or),               MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(union),              MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(and),              MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(intersection),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(intersect),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__fill_parse_arg),   MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__fill_exec),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__uniq),             MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(__uniq),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(flatten),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(flatten),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__normalize_index),  MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__fetch),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(insert),             MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(deconstruct),        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__product_group),    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__combination_init), MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__combination_next), MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl array_ext_rom_mt = {
-  ARRAY_EXT_ROM_MT_SIZE, ARRAY_EXT_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&array_ext_rom_data, NULL
+static mrb_mt_entry array_ext_rom_entries[] = {
+  MRB_MT_ENTRY(ary_assoc,             MRB_SYM(assoc),              MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_at,                MRB_SYM(at),                 MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_rassoc,            MRB_SYM(rassoc),             MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_values_at,         MRB_SYM(values_at),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_slice_bang,        MRB_SYM_B(slice),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_compact,           MRB_SYM(compact),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(ary_compact_bang,      MRB_SYM_B(compact),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(ary_rotate,            MRB_SYM(rotate),             MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_rotate_bang,       MRB_SYM_B(rotate),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_sub,               MRB_OPSYM(sub),              MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_difference,        MRB_SYM(difference),         MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_union,             MRB_OPSYM(or),               MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_union_multi,       MRB_SYM(union),              MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_intersection,      MRB_OPSYM(and),              MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_intersection_multi, MRB_SYM(intersection),      MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_intersect_p,       MRB_SYM_Q(intersect),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_fill_parse_arg,    MRB_SYM(__fill_parse_arg),   MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_fill_exec,         MRB_SYM(__fill_exec),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_uniq,              MRB_SYM(__uniq),             MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(ary_uniq_bang,         MRB_SYM_B(__uniq),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(ary_flatten,           MRB_SYM(flatten),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_flatten_bang,      MRB_SYM_B(flatten),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_normalize_index,   MRB_SYM(__normalize_index),  MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_fetch,             MRB_SYM(__fetch),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_insert,            MRB_SYM(insert),             MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_deconstruct,       MRB_SYM(deconstruct),        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(ary_product_group,     MRB_SYM(__product_group),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_combination_init,  MRB_SYM(__combination_init), MRB_MT_FUNC),
+  MRB_MT_ENTRY(ary_combination_next,  MRB_SYM(__combination_next), MRB_MT_FUNC),
 };
+static mrb_mt_tbl array_ext_rom_mt = MRB_MT_ROM_TAB(array_ext_rom_entries);
 
 void
 mrb_mruby_array_ext_gem_init(mrb_state* mrb)
diff --git a/mrbgems/mruby-class-ext/src/class.c b/mrbgems/mruby-class-ext/src/class.c
index d9a7eaf09..990e2f3ad 100644
--- a/mrbgems/mruby-class-ext/src/class.c
+++ b/mrbgems/mruby-class-ext/src/class.c
@@ -335,57 +335,24 @@ mrb_mod_cmp(mrb_state *mrb, mrb_value self)
 }
 
 /* ---------------------------*/
-#define MOD_EXT_ROM_MT_SIZE 9
-static struct {
-  union mrb_mt_ptr vals[MOD_EXT_ROM_MT_SIZE];
-  mrb_sym keys[MOD_EXT_ROM_MT_SIZE];
-} mod_ext_rom_data = {
-  .vals = {
-    { .func = mrb_mod_lt },
-    { .func = mrb_mod_le },
-    { .func = mrb_mod_cmp },
-    { .func = mrb_mod_gt },
-    { .func = mrb_mod_ge },
-    { .func = mod_module_exec },
-    { .func = mod_module_exec },
-    { .func = mod_name },
-    { .func = mod_singleton_class_p },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_OPSYM(lt),              MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(le),              MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(cmp),             MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(gt),              MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(ge),              MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(class_exec),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(module_exec),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(name),             MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(singleton_class), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl mod_ext_rom_mt = {
-  MOD_EXT_ROM_MT_SIZE, MOD_EXT_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&mod_ext_rom_data, NULL
+static mrb_mt_entry mod_ext_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_mod_lt,            MRB_OPSYM(lt),              MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_le,            MRB_OPSYM(le),              MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_cmp,           MRB_OPSYM(cmp),             MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_gt,            MRB_OPSYM(gt),              MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_ge,            MRB_OPSYM(ge),              MRB_MT_FUNC),
+  MRB_MT_ENTRY(mod_module_exec,       MRB_SYM(class_exec),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(mod_module_exec,       MRB_SYM(module_exec),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(mod_name,              MRB_SYM(name),              MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mod_singleton_class_p, MRB_SYM_Q(singleton_class), MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl mod_ext_rom_mt = MRB_MT_ROM_TAB(mod_ext_rom_entries);
 
-#define CLS_EXT_ROM_MT_SIZE 2
-static struct {
-  union mrb_mt_ptr vals[CLS_EXT_ROM_MT_SIZE];
-  mrb_sym keys[CLS_EXT_ROM_MT_SIZE];
-} cls_ext_rom_data = {
-  .vals = {
-    { .func = class_attached_object },
-    { .func = class_subclasses },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(attached_object), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(subclasses),      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl cls_ext_rom_mt = {
-  CLS_EXT_ROM_MT_SIZE, CLS_EXT_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&cls_ext_rom_data, NULL
+static mrb_mt_entry cls_ext_rom_entries[] = {
+  MRB_MT_ENTRY(class_attached_object, MRB_SYM(attached_object), MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(class_subclasses,      MRB_SYM(subclasses),      MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl cls_ext_rom_mt = MRB_MT_ROM_TAB(cls_ext_rom_entries);
 
 /*
  * Initialize the mruby-class-ext gem.
diff --git a/mrbgems/mruby-complex/src/complex.c b/mrbgems/mruby-complex/src/complex.c
index 081811ffb..cac74a1be 100644
--- a/mrbgems/mruby-complex/src/complex.c
+++ b/mrbgems/mruby-complex/src/complex.c
@@ -558,80 +558,32 @@ complex_pow(mrb_state *mrb, mrb_value self)
 }
 
 /* ---------------------------*/
-#define COMPLEX_ROM_MT_SIZE 13
-static struct {
-  union mrb_mt_ptr vals[COMPLEX_ROM_MT_SIZE];
-  mrb_sym keys[COMPLEX_ROM_MT_SIZE];
-} complex_rom_data = {
-  .vals = {
-    { .func = complex_real },
-    { .func = complex_imaginary },
-    { .func = mrb_complex_to_f },
-    { .func = mrb_complex_to_i },
-    { .func = mrb_obj_itself },
-    { .func = complex_add },
-    { .func = complex_sub },
-    { .func = complex_mul },
-    { .func = complex_div },
-    { .func = complex_div },
-    { .func = complex_eq },
-    { .func = complex_hash },
-    { .func = complex_pow },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(real),      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(imaginary), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_f),      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_i),      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_c),      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(add),     MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(sub),     MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(mul),     MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(div),     MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(quo),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(eq),      MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(hash),      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(pow),     MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl complex_rom_mt = {
-  COMPLEX_ROM_MT_SIZE, COMPLEX_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&complex_rom_data, NULL
+static mrb_mt_entry complex_rom_entries[] = {
+  MRB_MT_ENTRY(complex_real,      MRB_SYM(real),      MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(complex_imaginary, MRB_SYM(imaginary), MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_complex_to_f,  MRB_SYM(to_f),      MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_complex_to_i,  MRB_SYM(to_i),      MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_obj_itself,    MRB_SYM(to_c),      MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(complex_add,       MRB_OPSYM(add),     MRB_MT_FUNC),
+  MRB_MT_ENTRY(complex_sub,       MRB_OPSYM(sub),     MRB_MT_FUNC),
+  MRB_MT_ENTRY(complex_mul,       MRB_OPSYM(mul),     MRB_MT_FUNC),
+  MRB_MT_ENTRY(complex_div,       MRB_OPSYM(div),     MRB_MT_FUNC),
+  MRB_MT_ENTRY(complex_div,       MRB_SYM(quo),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(complex_eq,        MRB_OPSYM(eq),      MRB_MT_FUNC),
+  MRB_MT_ENTRY(complex_hash,      MRB_SYM(hash),      MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(complex_pow,       MRB_OPSYM(pow),     MRB_MT_FUNC),
 };
+static mrb_mt_tbl complex_rom_mt = MRB_MT_ROM_TAB(complex_rom_entries);
 
-#define NIL_TO_C_ROM_MT_SIZE 1
-static struct {
-  union mrb_mt_ptr vals[NIL_TO_C_ROM_MT_SIZE];
-  mrb_sym keys[NIL_TO_C_ROM_MT_SIZE];
-} nil_to_c_rom_data = {
-  .vals = {
-    { .func = nil_to_c },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(to_c), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl nil_to_c_rom_mt = {
-  NIL_TO_C_ROM_MT_SIZE, NIL_TO_C_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&nil_to_c_rom_data, NULL
+static mrb_mt_entry nil_to_c_rom_entries[] = {
+  MRB_MT_ENTRY(nil_to_c, MRB_SYM(to_c), MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl nil_to_c_rom_mt = MRB_MT_ROM_TAB(nil_to_c_rom_entries);
 
-#define KERNEL_COMPLEX_ROM_MT_SIZE 1
-static struct {
-  union mrb_mt_ptr vals[KERNEL_COMPLEX_ROM_MT_SIZE];
-  mrb_sym keys[KERNEL_COMPLEX_ROM_MT_SIZE];
-} kernel_complex_rom_data = {
-  .vals = {
-    { .func = complex_s_rect },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(Complex), MRB_MT_FUNC|MRB_MT_PRIVATE),
-  }
-};
-static mrb_mt_tbl kernel_complex_rom_mt = {
-  KERNEL_COMPLEX_ROM_MT_SIZE, KERNEL_COMPLEX_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&kernel_complex_rom_data, NULL
+static mrb_mt_entry kernel_complex_rom_entries[] = {
+  MRB_MT_ENTRY(complex_s_rect, MRB_SYM(Complex), MRB_MT_FUNC|MRB_MT_PRIVATE),
 };
+static mrb_mt_tbl kernel_complex_rom_mt = MRB_MT_ROM_TAB(kernel_complex_rom_entries);
 
 void mrb_mruby_complex_gem_init(mrb_state *mrb)
 {
diff --git a/mrbgems/mruby-hash-ext/src/hash_ext.c b/mrbgems/mruby-hash-ext/src/hash_ext.c
index 8340738a7..db35bc351 100644
--- a/mrbgems/mruby-hash-ext/src/hash_ext.c
+++ b/mrbgems/mruby-hash-ext/src/hash_ext.c
@@ -367,32 +367,15 @@ hash_merge(mrb_state *mrb, mrb_value hash)
   return hash;
 }
 
-#define HASH_EXT_ROM_MT_SIZE 6
-static struct {
-  union mrb_mt_ptr vals[HASH_EXT_ROM_MT_SIZE];
-  mrb_sym keys[HASH_EXT_ROM_MT_SIZE];
-} hash_ext_rom_data = {
-  .vals = {
-    { .func = hash_values_at },
-    { .func = hash_slice },
-    { .func = hash_slice_bang },
-    { .func = hash_except },
-    { .func = hash_key },
-    { .func = hash_merge },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(values_at), MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(slice),     MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(slice),   MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(except),    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(key),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__merge),   MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl hash_ext_rom_mt = {
-  HASH_EXT_ROM_MT_SIZE, HASH_EXT_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&hash_ext_rom_data, NULL
+static mrb_mt_entry hash_ext_rom_entries[] = {
+  MRB_MT_ENTRY(hash_values_at, MRB_SYM(values_at), MRB_MT_FUNC),
+  MRB_MT_ENTRY(hash_slice,     MRB_SYM(slice),     MRB_MT_FUNC),
+  MRB_MT_ENTRY(hash_slice_bang, MRB_SYM_B(slice),  MRB_MT_FUNC),
+  MRB_MT_ENTRY(hash_except,    MRB_SYM(except),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(hash_key,       MRB_SYM(key),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(hash_merge,     MRB_SYM(__merge),   MRB_MT_FUNC),
 };
+static mrb_mt_tbl hash_ext_rom_mt = MRB_MT_ROM_TAB(hash_ext_rom_entries);
 
 void
 mrb_mruby_hash_ext_gem_init(mrb_state *mrb)
diff --git a/mrbgems/mruby-io/src/file.c b/mrbgems/mruby-io/src/file.c
index 2d8962bf9..70f9dbe2a 100644
--- a/mrbgems/mruby-io/src/file.c
+++ b/mrbgems/mruby-io/src/file.c
@@ -1122,32 +1122,15 @@ mrb_file_join(mrb_state *mrb, mrb_value klass)
 }
 
 /* ---------------------------*/
-#define FILE_ROM_MT_SIZE 6
-static struct {
-  union mrb_mt_ptr vals[FILE_ROM_MT_SIZE];
-  mrb_sym keys[FILE_ROM_MT_SIZE];
-} file_rom_data = {
-  .vals = {
-    { .func = mrb_file_flock },
-    { .func = mrb_file_atime },
-    { .func = mrb_file_ctime },
-    { .func = mrb_file_mtime },
-    { .func = mrb_file_size },
-    { .func = mrb_file_truncate },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(flock),    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(_atime),   MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(_ctime),   MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(_mtime),   MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(size),     MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(truncate), MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl file_rom_mt = {
-  FILE_ROM_MT_SIZE, FILE_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&file_rom_data, NULL
+static mrb_mt_entry file_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_file_flock,    MRB_SYM(flock),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_file_atime,    MRB_SYM(_atime),   MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_file_ctime,    MRB_SYM(_ctime),   MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_file_mtime,    MRB_SYM(_mtime),   MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_file_size,     MRB_SYM(size),     MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_file_truncate, MRB_SYM(truncate), MRB_MT_FUNC),
 };
+static mrb_mt_tbl file_rom_mt = MRB_MT_ROM_TAB(file_rom_entries);
 
 void
 mrb_init_file(mrb_state *mrb)
diff --git a/mrbgems/mruby-io/src/io.c b/mrbgems/mruby-io/src/io.c
index aee6db8cb..a5477ed64 100644
--- a/mrbgems/mruby-io/src/io.c
+++ b/mrbgems/mruby-io/src/io.c
@@ -2197,92 +2197,45 @@ io_flush(mrb_state *mrb, mrb_value io)
 }
 
 /* ---------------------------*/
-#define IO_ROM_MT_SIZE 36
-static struct {
-  union mrb_mt_ptr vals[IO_ROM_MT_SIZE];
-  mrb_sym keys[IO_ROM_MT_SIZE];
-} io_rom_data = {
-  .vals = {
-    { .func = io_init },
-    { .func = io_init_copy },
-    { .func = io_isatty },
-    { .func = io_eof },
-    { .func = io_getc },
-    { .func = io_gets },
-    { .func = io_read },
-    { .func = io_readchar },
-    { .func = io_readline },
-    { .func = io_readlines },
-    { .func = io_sync },
-    { .func = io_set_sync },
-    { .func = io_sysread },
-    { .func = io_sysseek },
-    { .func = io_syswrite },
-    { .func = io_seek },
-    { .func = io_close },
-    { .func = io_close_write },
-    { .func = io_set_close_on_exec },
-    { .func = io_close_on_exec_p },
-    { .func = io_closed },
-    { .func = io_flush },
-    { .func = io_ungetc },
-    { .func = io_ungetbyte },
-    { .func = io_pos },
-    { .func = io_pid },
-    { .func = io_fileno },
-    { .func = io_write },
-    { .func = io_puts },
-    { .func = io_print },
-    { .func = io_putc },
-    { .func = io_lshift },
-    { .func = io_pread },
-    { .func = io_pwrite },
-    { .func = io_getbyte },
-    { .func = io_readbyte },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(initialize),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(initialize_copy),  MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(isatty),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(eof),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(getc),             MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(gets),             MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(read),             MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(readchar),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(readline),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(readlines),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(sync),             MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_E(sync),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(sysread),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(sysseek),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(syswrite),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(seek),             MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(close),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(close_write),      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_E(close_on_exec),  MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(close_on_exec),  MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(closed),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(flush),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(ungetc),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(ungetbyte),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(pos),              MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(pid),              MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(fileno),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(write),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(puts),             MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(print),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(putc),             MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(lshift),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(pread),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(pwrite),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(getbyte),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(readbyte),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl io_rom_mt = {
-  IO_ROM_MT_SIZE, IO_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&io_rom_data, NULL
+static mrb_mt_entry io_rom_entries[] = {
+  MRB_MT_ENTRY(io_init,              MRB_SYM(initialize),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(io_init_copy,         MRB_SYM(initialize_copy),  MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(io_isatty,            MRB_SYM(isatty),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(io_eof,               MRB_SYM_Q(eof),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(io_getc,              MRB_SYM(getc),             MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(io_gets,              MRB_SYM(gets),             MRB_MT_FUNC),
+  MRB_MT_ENTRY(io_read,              MRB_SYM(read),             MRB_MT_FUNC),
+  MRB_MT_ENTRY(io_readchar,          MRB_SYM(readchar),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(io_readline,          MRB_SYM(readline),         MRB_MT_FUNC),
+  MRB_MT_ENTRY(io_readlines,         MRB_SYM(readlines),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(io_sync,              MRB_SYM(sync),             MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(io_set_sync,          MRB_SYM_E(sync),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(io_sysread,           MRB_SYM(sysread),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(io_sysseek,           MRB_SYM(sysseek),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(io_syswrite,          MRB_SYM(syswrite),         MRB_MT_FUNC),
+  MRB_MT_ENTRY(io_seek,              MRB_SYM(seek),             MRB_MT_FUNC),
+  MRB_MT_ENTRY(io_close,             MRB_SYM(close),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(io_close_write,       MRB_SYM(close_write),      MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(io_set_close_on_exec, MRB_SYM_E(close_on_exec),  MRB_MT_FUNC),
+  MRB_MT_ENTRY(io_close_on_exec_p,   MRB_SYM_Q(close_on_exec),  MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(io_closed,            MRB_SYM_Q(closed),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(io_flush,             MRB_SYM(flush),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(io_ungetc,            MRB_SYM(ungetc),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(io_ungetbyte,         MRB_SYM(ungetbyte),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(io_pos,               MRB_SYM(pos),              MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(io_pid,               MRB_SYM(pid),              MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(io_fileno,            MRB_SYM(fileno),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(io_write,             MRB_SYM(write),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(io_puts,              MRB_SYM(puts),             MRB_MT_FUNC),
+  MRB_MT_ENTRY(io_print,             MRB_SYM(print),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(io_putc,              MRB_SYM(putc),             MRB_MT_FUNC),
+  MRB_MT_ENTRY(io_lshift,            MRB_OPSYM(lshift),         MRB_MT_FUNC),
+  MRB_MT_ENTRY(io_pread,             MRB_SYM(pread),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(io_pwrite,            MRB_SYM(pwrite),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(io_getbyte,           MRB_SYM(getbyte),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(io_readbyte,          MRB_SYM(readbyte),         MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl io_rom_mt = MRB_MT_ROM_TAB(io_rom_entries);
 
 void
 mrb_init_io(mrb_state *mrb)
diff --git a/mrbgems/mruby-kernel-ext/src/kernel.c b/mrbgems/mruby-kernel-ext/src/kernel.c
index 46036aeed..7b39f7772 100644
--- a/mrbgems/mruby-kernel-ext/src/kernel.c
+++ b/mrbgems/mruby-kernel-ext/src/kernel.c
@@ -288,34 +288,16 @@ mrb_f_hash(mrb_state *mrb, mrb_value self)
   return arg;
 }
 
-#define KERNEL_EXT_ROM_MT_SIZE 7
-static struct {
-  union mrb_mt_ptr vals[KERNEL_EXT_ROM_MT_SIZE];
-  mrb_sym keys[KERNEL_EXT_ROM_MT_SIZE];
-} kernel_ext_rom_data = {
-  .vals = {
-    { .func = mrb_f_raise },
-    { .func = mrb_f_caller },
-    { .func = mrb_f_method },
-    { .func = mrb_f_callee },
-    { .func = mrb_f_integer },
-    { .func = mrb_f_string },
-    { .func = mrb_f_array },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(fail),       MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(caller),     MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(__method__), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(__callee__), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(Integer),    MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(String),     MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(Array),      MRB_MT_FUNC|MRB_MT_PRIVATE),
-  }
-};
-static mrb_mt_tbl kernel_ext_rom_mt = {
-  KERNEL_EXT_ROM_MT_SIZE, KERNEL_EXT_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&kernel_ext_rom_data, NULL
+static mrb_mt_entry kernel_ext_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_f_raise,   MRB_SYM(fail),       MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_f_caller,  MRB_SYM(caller),     MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_f_method,  MRB_SYM(__method__), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_f_callee,  MRB_SYM(__callee__), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_f_integer, MRB_SYM(Integer),    MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_f_string,  MRB_SYM(String),     MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_f_array,   MRB_SYM(Array),      MRB_MT_FUNC|MRB_MT_PRIVATE),
 };
+static mrb_mt_tbl kernel_ext_rom_mt = MRB_MT_ROM_TAB(kernel_ext_rom_entries);
 
 void
 mrb_mruby_kernel_ext_gem_init(mrb_state *mrb)
diff --git a/mrbgems/mruby-metaprog/src/metaprog.c b/mrbgems/mruby-metaprog/src/metaprog.c
index f50c2e243..82bf23859 100644
--- a/mrbgems/mruby-metaprog/src/metaprog.c
+++ b/mrbgems/mruby-metaprog/src/metaprog.c
@@ -690,93 +690,42 @@ mrb_mod_s_nesting(mrb_state *mrb, mrb_value mod)
 }
 
 /* ---------------------------*/
-#define METAPROG_KRN_ROM_MT_SIZE 15
-static struct {
-  union mrb_mt_ptr vals[METAPROG_KRN_ROM_MT_SIZE];
-  mrb_sym keys[METAPROG_KRN_ROM_MT_SIZE];
-} metaprog_krn_rom_data = {
-  .vals = {
-    { .func = mrb_f_global_variables },
-    { .func = mrb_local_variables },
-    { .func = mrb_singleton_class },
-    { .func = mrb_obj_ivar_defined },
-    { .func = mrb_obj_ivar_get },
-    { .func = mrb_obj_ivar_set },
-    { .func = mrb_obj_instance_variables },
-    { .func = mrb_obj_methods_m },
-    { .func = mrb_obj_private_methods },
-    { .func = mrb_obj_protected_methods },
-    { .func = mrb_obj_public_methods },
-    { .func = mrb_obj_singleton_methods_m },
-    { .func = mod_define_singleton_method },
-    { .func = mrb_f_send },
-    { .func = mrb_f_public_send },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(global_variables),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(local_variables),             MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(singleton_class),             MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(instance_variable_defined), MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(instance_variable_get),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(instance_variable_set),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(instance_variables),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(methods),                     MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(private_methods),             MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(protected_methods),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(public_methods),              MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(singleton_methods),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(define_singleton_method),     MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(send),                        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(public_send),                 MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl metaprog_krn_rom_mt = {
-  METAPROG_KRN_ROM_MT_SIZE, METAPROG_KRN_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&metaprog_krn_rom_data, NULL
+static mrb_mt_entry metaprog_krn_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_f_global_variables,    MRB_SYM(global_variables),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_local_variables,       MRB_SYM(local_variables),             MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_singleton_class,       MRB_SYM(singleton_class),             MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_obj_ivar_defined,      MRB_SYM_Q(instance_variable_defined), MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_obj_ivar_get,          MRB_SYM(instance_variable_get),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_obj_ivar_set,          MRB_SYM(instance_variable_set),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_obj_instance_variables, MRB_SYM(instance_variables),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_obj_methods_m,         MRB_SYM(methods),                     MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_obj_private_methods,   MRB_SYM(private_methods),             MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_obj_protected_methods, MRB_SYM(protected_methods),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_obj_public_methods,    MRB_SYM(public_methods),              MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_obj_singleton_methods_m, MRB_SYM(singleton_methods),         MRB_MT_FUNC),
+  MRB_MT_ENTRY(mod_define_singleton_method, MRB_SYM(define_singleton_method),   MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_f_send,               MRB_SYM(send),                        MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_f_public_send,        MRB_SYM(public_send),                 MRB_MT_FUNC),
 };
+static mrb_mt_tbl metaprog_krn_rom_mt = MRB_MT_ROM_TAB(metaprog_krn_rom_entries);
 
-#define METAPROG_MOD_ROM_MT_SIZE 14
-static struct {
-  union mrb_mt_ptr vals[METAPROG_MOD_ROM_MT_SIZE];
-  mrb_sym keys[METAPROG_MOD_ROM_MT_SIZE];
-} metaprog_mod_rom_data = {
-  .vals = {
-    { .func = mrb_mod_class_variables },
-    { .func = mrb_mod_remove_cvar },
-    { .func = mrb_mod_cvar_defined },
-    { .func = mrb_mod_cvar_get },
-    { .func = mrb_mod_cvar_set },
-    { .func = mrb_mod_included_modules },
-    { .func = mrb_mod_instance_methods },
-    { .func = mrb_mod_public_instance_methods },
-    { .func = mrb_mod_private_instance_methods },
-    { .func = mrb_mod_protected_instance_methods },
-    { .func = mrb_mod_undefined_methods },
-    { .func = mrb_mod_remove_method },
-    { .func = mrb_f_nil },
-    { .func = mrb_mod_constants },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(class_variables),             MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(remove_class_variable),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(class_variable_defined),    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(class_variable_get),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(class_variable_set),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(included_modules),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(instance_methods),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(public_instance_methods),     MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(private_instance_methods),    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(protected_instance_methods),  MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(undefined_instance_methods),  MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(remove_method),               MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(method_removed),              MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(constants),                   MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl metaprog_mod_rom_mt = {
-  METAPROG_MOD_ROM_MT_SIZE, METAPROG_MOD_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&metaprog_mod_rom_data, NULL
+static mrb_mt_entry metaprog_mod_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_mod_class_variables,          MRB_SYM(class_variables),             MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_remove_cvar,              MRB_SYM(remove_class_variable),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_cvar_defined,             MRB_SYM_Q(class_variable_defined),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_cvar_get,                 MRB_SYM(class_variable_get),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_cvar_set,                 MRB_SYM(class_variable_set),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_included_modules,         MRB_SYM(included_modules),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_mod_instance_methods,         MRB_SYM(instance_methods),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_public_instance_methods,  MRB_SYM(public_instance_methods),     MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_private_instance_methods, MRB_SYM(private_instance_methods),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_protected_instance_methods, MRB_SYM(protected_instance_methods), MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_undefined_methods,        MRB_SYM(undefined_instance_methods),  MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_mod_remove_method,            MRB_SYM(remove_method),               MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_f_nil,                        MRB_SYM(method_removed),              MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_constants,                MRB_SYM(constants),                   MRB_MT_FUNC),
 };
+static mrb_mt_tbl metaprog_mod_rom_mt = MRB_MT_ROM_TAB(metaprog_mod_rom_entries);
 
 void
 mrb_mruby_metaprog_gem_init(mrb_state* mrb)
diff --git a/mrbgems/mruby-method/src/method.c b/mrbgems/mruby-method/src/method.c
index 89bca0198..f07d92e82 100644
--- a/mrbgems/mruby-method/src/method.c
+++ b/mrbgems/mruby-method/src/method.c
@@ -832,123 +832,50 @@ method_name(mrb_state *mrb, mrb_value self)
 }
 
 /* ---------------------------*/
-#define METHOD_UBM_ROM_MT_SIZE 12
-static struct {
-  union mrb_mt_ptr vals[METHOD_UBM_ROM_MT_SIZE];
-  mrb_sym keys[METHOD_UBM_ROM_MT_SIZE];
-} method_ubm_rom_data = {
-  .vals = {
-    { .func = unbound_method_bind },
-    { .func = method_super_method },
-    { .func = method_eql },
-    { .func = method_eql },
-    { .func = method_to_s },
-    { .func = method_to_s },
-    { .func = method_arity },
-    { .func = method_source_location },
-    { .func = method_parameters },
-    { .func = method_bcall },
-    { .func = method_owner },
-    { .func = method_name },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(bind),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(super_method),    MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(eq),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(eql),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_s),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(inspect),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(arity),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(source_location), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(parameters),      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(bind_call),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(owner),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(name),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl method_ubm_rom_mt = {
-  METHOD_UBM_ROM_MT_SIZE, METHOD_UBM_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&method_ubm_rom_data, NULL
+static mrb_mt_entry method_ubm_rom_entries[] = {
+  MRB_MT_ENTRY(unbound_method_bind,  MRB_SYM(bind),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(method_super_method,  MRB_SYM(super_method),    MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(method_eql,           MRB_OPSYM(eq),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(method_eql,           MRB_SYM_Q(eql),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(method_to_s,          MRB_SYM(to_s),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(method_to_s,          MRB_SYM(inspect),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(method_arity,         MRB_SYM(arity),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(method_source_location, MRB_SYM(source_location), MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(method_parameters,    MRB_SYM(parameters),      MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(method_bcall,         MRB_SYM(bind_call),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(method_owner,         MRB_SYM(owner),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(method_name,          MRB_SYM(name),            MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl method_ubm_rom_mt = MRB_MT_ROM_TAB(method_ubm_rom_entries);
 
-#define METHOD_MTD_ROM_MT_SIZE 14
-static struct {
-  union mrb_mt_ptr vals[METHOD_MTD_ROM_MT_SIZE];
-  mrb_sym keys[METHOD_MTD_ROM_MT_SIZE];
-} method_mtd_rom_data = {
-  .vals = {
-    { .func = method_eql },
-    { .func = method_eql },
-    { .func = method_to_s },
-    { .func = method_to_s },
-    { .func = method_call },
-    { .func = method_call },
-    { .func = method_unbind },
-    { .func = method_super_method },
-    { .func = method_arity },
-    { .func = method_source_location },
-    { .func = method_parameters },
-    { .func = method_owner },
-    { .func = method_receiver },
-    { .func = method_name },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_OPSYM(eq),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(eql),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_s),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(inspect),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(call),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(aref),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(unbind),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(super_method),    MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(arity),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(source_location), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(parameters),      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(owner),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(receiver),        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(name),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl method_mtd_rom_mt = {
-  METHOD_MTD_ROM_MT_SIZE, METHOD_MTD_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&method_mtd_rom_data, NULL
+static mrb_mt_entry method_mtd_rom_entries[] = {
+  MRB_MT_ENTRY(method_eql,            MRB_OPSYM(eq),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(method_eql,            MRB_SYM_Q(eql),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(method_to_s,           MRB_SYM(to_s),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(method_to_s,           MRB_SYM(inspect),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(method_call,           MRB_SYM(call),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(method_call,           MRB_OPSYM(aref),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(method_unbind,         MRB_SYM(unbind),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(method_super_method,   MRB_SYM(super_method),    MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(method_arity,          MRB_SYM(arity),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(method_source_location, MRB_SYM(source_location), MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(method_parameters,     MRB_SYM(parameters),      MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(method_owner,          MRB_SYM(owner),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(method_receiver,       MRB_SYM(receiver),        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(method_name,           MRB_SYM(name),            MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl method_mtd_rom_mt = MRB_MT_ROM_TAB(method_mtd_rom_entries);
 
-#define METHOD_KRN_ROM_MT_SIZE 2
-static struct {
-  union mrb_mt_ptr vals[METHOD_KRN_ROM_MT_SIZE];
-  mrb_sym keys[METHOD_KRN_ROM_MT_SIZE];
-} method_krn_rom_data = {
-  .vals = {
-    { .func = mrb_kernel_method },
-    { .func = mrb_kernel_singleton_method },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(method),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(singleton_method), MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl method_krn_rom_mt = {
-  METHOD_KRN_ROM_MT_SIZE, METHOD_KRN_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&method_krn_rom_data, NULL
+static mrb_mt_entry method_krn_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_kernel_method,           MRB_SYM(method),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_kernel_singleton_method, MRB_SYM(singleton_method), MRB_MT_FUNC),
 };
+static mrb_mt_tbl method_krn_rom_mt = MRB_MT_ROM_TAB(method_krn_rom_entries);
 
-#define METHOD_MOD_ROM_MT_SIZE 1
-static struct {
-  union mrb_mt_ptr vals[METHOD_MOD_ROM_MT_SIZE];
-  mrb_sym keys[METHOD_MOD_ROM_MT_SIZE];
-} method_mod_rom_data = {
-  .vals = {
-    { .func = mrb_module_instance_method },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(instance_method), MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl method_mod_rom_mt = {
-  METHOD_MOD_ROM_MT_SIZE, METHOD_MOD_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&method_mod_rom_data, NULL
+static mrb_mt_entry method_mod_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_module_instance_method, MRB_SYM(instance_method), MRB_MT_FUNC),
 };
+static mrb_mt_tbl method_mod_rom_mt = MRB_MT_ROM_TAB(method_mod_rom_entries);
 
 void
 mrb_mruby_method_gem_init(mrb_state* mrb)
diff --git a/mrbgems/mruby-numeric-ext/src/numeric_ext.c b/mrbgems/mruby-numeric-ext/src/numeric_ext.c
index d88a04f56..c88e01641 100644
--- a/mrbgems/mruby-numeric-ext/src/numeric_ext.c
+++ b/mrbgems/mruby-numeric-ext/src/numeric_ext.c
@@ -480,38 +480,18 @@ int_sqrt(mrb_state *mrb, mrb_value self)
   }
 }
 
-#define INTEGER_EXT_ROM_MT_SIZE 9
-static struct {
-  union mrb_mt_ptr vals[INTEGER_EXT_ROM_MT_SIZE];
-  mrb_sym keys[INTEGER_EXT_ROM_MT_SIZE];
-} integer_ext_rom_data = {
-  .vals = {
-    { .func = int_remainder },
-    { .func = int_powm },
-    { .func = int_digits },
-    { .func = int_size },
-    { .func = int_bit_length },
-    { .func = int_odd },
-    { .func = int_even },
-    { .func = int_gcd },
-    { .func = int_lcm },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(remainder),  MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(pow),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(digits),     MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(size),       MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(bit_length), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(odd),      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(even),     MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(gcd),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(lcm),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl integer_ext_rom_mt = {
-  INTEGER_EXT_ROM_MT_SIZE, INTEGER_EXT_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&integer_ext_rom_data, NULL
+static mrb_mt_entry integer_ext_rom_entries[] = {
+  MRB_MT_ENTRY(int_remainder,  MRB_SYM(remainder),  MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_powm,       MRB_SYM(pow),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_digits,     MRB_SYM(digits),     MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_size,       MRB_SYM(size),       MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(int_bit_length, MRB_SYM(bit_length), MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(int_odd,        MRB_SYM_Q(odd),      MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(int_even,       MRB_SYM_Q(even),     MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(int_gcd,        MRB_SYM(gcd),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_lcm,        MRB_SYM(lcm),        MRB_MT_FUNC),
 };
+static mrb_mt_tbl integer_ext_rom_mt = MRB_MT_ROM_TAB(integer_ext_rom_entries);
 
 void
 mrb_mruby_numeric_ext_gem_init(mrb_state* mrb)
diff --git a/mrbgems/mruby-object-ext/src/object.c b/mrbgems/mruby-object-ext/src/object.c
index 6ecd79ed3..f99c41968 100644
--- a/mrbgems/mruby-object-ext/src/object.c
+++ b/mrbgems/mruby-object-ext/src/object.c
@@ -97,60 +97,22 @@ obj_instance_exec(mrb_state *mrb, mrb_value self)
   return mrb_object_exec(mrb, self, mrb_singleton_class_ptr(mrb, self));
 }
 
-#define NIL_EXT_ROM_MT_SIZE 3
-static struct {
-  union mrb_mt_ptr vals[NIL_EXT_ROM_MT_SIZE];
-  mrb_sym keys[NIL_EXT_ROM_MT_SIZE];
-} nil_ext_rom_data = {
-  .vals = {
-    { .func = nil_to_a },
-    { .func = nil_to_h },
-    { .func = nil_to_i },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(to_a), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_h), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_i), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl nil_ext_rom_mt = {
-  NIL_EXT_ROM_MT_SIZE, NIL_EXT_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&nil_ext_rom_data, NULL
+static mrb_mt_entry nil_ext_rom_entries[] = {
+  MRB_MT_ENTRY(nil_to_a, MRB_SYM(to_a), MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(nil_to_h, MRB_SYM(to_h), MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(nil_to_i, MRB_SYM(to_i), MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl nil_ext_rom_mt = MRB_MT_ROM_TAB(nil_ext_rom_entries);
 
-#define KERNEL_EXT_ROM_MT_SIZE 1
-static struct {
-  union mrb_mt_ptr vals[KERNEL_EXT_ROM_MT_SIZE];
-  mrb_sym keys[KERNEL_EXT_ROM_MT_SIZE];
-} kernel_ext_rom_data = {
-  .vals = {
-    { .func = mrb_obj_itself },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(itself), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl kernel_ext_rom_mt = {
-  KERNEL_EXT_ROM_MT_SIZE, KERNEL_EXT_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&kernel_ext_rom_data, NULL
+static mrb_mt_entry kernel_ext_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_obj_itself, MRB_SYM(itself), MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl kernel_ext_rom_mt = MRB_MT_ROM_TAB(kernel_ext_rom_entries);
 
-#define BOB_EXT_ROM_MT_SIZE 1
-static struct {
-  union mrb_mt_ptr vals[BOB_EXT_ROM_MT_SIZE];
-  mrb_sym keys[BOB_EXT_ROM_MT_SIZE];
-} bob_ext_rom_data = {
-  .vals = {
-    { .func = obj_instance_exec },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(instance_exec), MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl bob_ext_rom_mt = {
-  BOB_EXT_ROM_MT_SIZE, BOB_EXT_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&bob_ext_rom_data, NULL
+static mrb_mt_entry bob_ext_rom_entries[] = {
+  MRB_MT_ENTRY(obj_instance_exec, MRB_SYM(instance_exec), MRB_MT_FUNC),
 };
+static mrb_mt_tbl bob_ext_rom_mt = MRB_MT_ROM_TAB(bob_ext_rom_entries);
 
 void
 mrb_mruby_object_ext_gem_init(mrb_state* mrb)
diff --git a/mrbgems/mruby-proc-ext/src/proc.c b/mrbgems/mruby-proc-ext/src/proc.c
index 2a0ad2e2d..4c4fc82a1 100644
--- a/mrbgems/mruby-proc-ext/src/proc.c
+++ b/mrbgems/mruby-proc-ext/src/proc.c
@@ -244,47 +244,19 @@ mrb_proc_parameters(mrb_state *mrb, mrb_value self)
 }
 
 /* ---------------------------*/
-#define PROC_EXT_ROM_MT_SIZE 5
-static struct {
-  union mrb_mt_ptr vals[PROC_EXT_ROM_MT_SIZE];
-  mrb_sym keys[PROC_EXT_ROM_MT_SIZE];
-} proc_ext_rom_data = {
-  .vals = {
-    { .func = proc_inspect },
-    { .func = proc_lambda_p },
-    { .func = mrb_proc_parameters },
-    { .func = proc_source_location },
-    { .func = proc_inspect },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(inspect),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(lambda),        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(parameters),      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(source_location), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_s),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl proc_ext_rom_mt = {
-  PROC_EXT_ROM_MT_SIZE, PROC_EXT_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&proc_ext_rom_data, NULL
+static mrb_mt_entry proc_ext_rom_entries[] = {
+  MRB_MT_ENTRY(proc_inspect,         MRB_SYM(inspect),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(proc_lambda_p,        MRB_SYM_Q(lambda),        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_proc_parameters,  MRB_SYM(parameters),      MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(proc_source_location, MRB_SYM(source_location), MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(proc_inspect,         MRB_SYM(to_s),            MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl proc_ext_rom_mt = MRB_MT_ROM_TAB(proc_ext_rom_entries);
 
-#define KERNEL_EXT_ROM_MT_SIZE 1
-static struct {
-  union mrb_mt_ptr vals[KERNEL_EXT_ROM_MT_SIZE];
-  mrb_sym keys[KERNEL_EXT_ROM_MT_SIZE];
-} kernel_ext_rom_data = {
-  .vals = {
-    { .func = kernel_proc },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(proc), MRB_MT_FUNC|MRB_MT_PRIVATE),
-  }
-};
-static mrb_mt_tbl kernel_ext_rom_mt = {
-  KERNEL_EXT_ROM_MT_SIZE, KERNEL_EXT_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&kernel_ext_rom_data, NULL
+static mrb_mt_entry kernel_ext_rom_entries[] = {
+  MRB_MT_ENTRY(kernel_proc, MRB_SYM(proc), MRB_MT_FUNC|MRB_MT_PRIVATE),
 };
+static mrb_mt_tbl kernel_ext_rom_mt = MRB_MT_ROM_TAB(kernel_ext_rom_entries);
 
 void
 mrb_mruby_proc_ext_gem_init(mrb_state* mrb)
diff --git a/mrbgems/mruby-random/src/random.c b/mrbgems/mruby-random/src/random.c
index e542b8b4b..d7008d559 100644
--- a/mrbgems/mruby-random/src/random.c
+++ b/mrbgems/mruby-random/src/random.c
@@ -568,68 +568,26 @@ random_f_bytes(mrb_state *mrb, mrb_value self)
 }
 
 
-#define KERNEL_RAND_ROM_MT_SIZE 2
-static struct {
-  union mrb_mt_ptr vals[KERNEL_RAND_ROM_MT_SIZE];
-  mrb_sym keys[KERNEL_RAND_ROM_MT_SIZE];
-} kernel_rand_rom_data = {
-  .vals = {
-    { .func = random_f_rand },
-    { .func = random_f_srand },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(rand),  MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(srand), MRB_MT_FUNC|MRB_MT_PRIVATE),
-  }
-};
-static mrb_mt_tbl kernel_rand_rom_mt = {
-  KERNEL_RAND_ROM_MT_SIZE, KERNEL_RAND_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&kernel_rand_rom_data, NULL
+static mrb_mt_entry kernel_rand_rom_entries[] = {
+  MRB_MT_ENTRY(random_f_rand,  MRB_SYM(rand),  MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(random_f_srand, MRB_SYM(srand), MRB_MT_FUNC|MRB_MT_PRIVATE),
 };
+static mrb_mt_tbl kernel_rand_rom_mt = MRB_MT_ROM_TAB(kernel_rand_rom_entries);
 
-#define RANDOM_ROM_MT_SIZE 4
-static struct {
-  union mrb_mt_ptr vals[RANDOM_ROM_MT_SIZE];
-  mrb_sym keys[RANDOM_ROM_MT_SIZE];
-} random_rom_data = {
-  .vals = {
-    { .func = random_m_init },
-    { .func = random_m_rand },
-    { .func = random_m_srand },
-    { .func = random_m_bytes },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(rand),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(srand),      MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(bytes),      MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl random_rom_mt = {
-  RANDOM_ROM_MT_SIZE, RANDOM_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&random_rom_data, NULL
+static mrb_mt_entry random_rom_entries[] = {
+  MRB_MT_ENTRY(random_m_init,  MRB_SYM(initialize), MRB_MT_FUNC),
+  MRB_MT_ENTRY(random_m_rand,  MRB_SYM(rand),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(random_m_srand, MRB_SYM(srand),      MRB_MT_FUNC),
+  MRB_MT_ENTRY(random_m_bytes, MRB_SYM(bytes),      MRB_MT_FUNC),
 };
+static mrb_mt_tbl random_rom_mt = MRB_MT_ROM_TAB(random_rom_entries);
 
-#define ARRAY_RAND_ROM_MT_SIZE 3
-static struct {
-  union mrb_mt_ptr vals[ARRAY_RAND_ROM_MT_SIZE];
-  mrb_sym keys[ARRAY_RAND_ROM_MT_SIZE];
-} array_rand_rom_data = {
-  .vals = {
-    { .func = mrb_ary_shuffle },
-    { .func = mrb_ary_shuffle_bang },
-    { .func = mrb_ary_sample },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(shuffle),    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(shuffle),  MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(sample),     MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl array_rand_rom_mt = {
-  ARRAY_RAND_ROM_MT_SIZE, ARRAY_RAND_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&array_rand_rom_data, NULL
+static mrb_mt_entry array_rand_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_ary_shuffle,      MRB_SYM(shuffle),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_shuffle_bang, MRB_SYM_B(shuffle),  MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_sample,      MRB_SYM(sample),     MRB_MT_FUNC),
 };
+static mrb_mt_tbl array_rand_rom_mt = MRB_MT_ROM_TAB(array_rand_rom_entries);
 
 void mrb_mruby_random_gem_init(mrb_state *mrb)
 {
diff --git a/mrbgems/mruby-range-ext/src/range.c b/mrbgems/mruby-range-ext/src/range.c
index 07e3f8f30..408633e13 100644
--- a/mrbgems/mruby-range-ext/src/range.c
+++ b/mrbgems/mruby-range-ext/src/range.c
@@ -216,26 +216,12 @@ range_empty_p(mrb_state *mrb, mrb_value range)
   return mrb_bool_value(comp == -2 || comp > 0 || (comp == 0 && excl));
 }
 
-#define RANGE_EXT_ROM_MT_SIZE 3
-static struct {
-  union mrb_mt_ptr vals[RANGE_EXT_ROM_MT_SIZE];
-  mrb_sym keys[RANGE_EXT_ROM_MT_SIZE];
-} range_ext_rom_data = {
-  .vals = {
-    { .func = range_cover },
-    { .func = range_size },
-    { .func = range_empty_p },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM_Q(cover),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(size),             MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(__empty_range),  MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl range_ext_rom_mt = {
-  RANGE_EXT_ROM_MT_SIZE, RANGE_EXT_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&range_ext_rom_data, NULL
+static mrb_mt_entry range_ext_rom_entries[] = {
+  MRB_MT_ENTRY(range_cover,   MRB_SYM_Q(cover),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(range_size,    MRB_SYM(size),             MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(range_empty_p, MRB_SYM_Q(__empty_range),  MRB_MT_FUNC),
 };
+static mrb_mt_tbl range_ext_rom_mt = MRB_MT_ROM_TAB(range_ext_rom_entries);
 
 void
 mrb_mruby_range_ext_gem_init(mrb_state* mrb)
diff --git a/mrbgems/mruby-rational/src/rational.c b/mrbgems/mruby-rational/src/rational.c
index 9a849a74b..d81c48748 100644
--- a/mrbgems/mruby-rational/src/rational.c
+++ b/mrbgems/mruby-rational/src/rational.c
@@ -1228,99 +1228,38 @@ rational_hash(mrb_state *mrb, mrb_value rat)
 }
 
 /* ---------------------------*/
-#define RATIONAL_ROM_MT_SIZE 14
-static struct {
-  union mrb_mt_ptr vals[RATIONAL_ROM_MT_SIZE];
-  mrb_sym keys[RATIONAL_ROM_MT_SIZE];
-} rational_rom_data = {
-  .vals = {
-    { .func = rational_numerator },
-    { .func = rational_denominator },
-    { .func = mrb_rational_to_i },
-    { .func = mrb_obj_itself },
-    { .func = rational_negative_p },
-    { .func = rational_eq },
-    { .func = rational_minus },
-    { .func = rational_add },
-    { .func = rational_sub },
-    { .func = rational_mul },
-    { .func = rational_div },
-    { .func = rational_div },
-    { .func = rational_pow },
-    { .func = rational_hash },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(numerator),   MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(denominator), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_i),        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_r),        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(negative),  MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(eq),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(minus),     MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(add),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(sub),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(mul),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(div),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(quo),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(pow),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(hash),        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl rational_rom_mt = {
-  RATIONAL_ROM_MT_SIZE, RATIONAL_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&rational_rom_data, NULL
+static mrb_mt_entry rational_rom_entries[] = {
+  MRB_MT_ENTRY(rational_numerator,   MRB_SYM(numerator),   MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(rational_denominator, MRB_SYM(denominator), MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_rational_to_i,    MRB_SYM(to_i),        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_obj_itself,       MRB_SYM(to_r),        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(rational_negative_p,  MRB_SYM_Q(negative),  MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(rational_eq,          MRB_OPSYM(eq),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(rational_minus,       MRB_OPSYM(minus),     MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(rational_add,         MRB_OPSYM(add),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(rational_sub,         MRB_OPSYM(sub),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(rational_mul,         MRB_OPSYM(mul),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(rational_div,         MRB_OPSYM(div),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(rational_div,         MRB_SYM(quo),         MRB_MT_FUNC),
+  MRB_MT_ENTRY(rational_pow,         MRB_OPSYM(pow),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(rational_hash,        MRB_SYM(hash),        MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl rational_rom_mt = MRB_MT_ROM_TAB(rational_rom_entries);
 
-#define INTEGER_TO_R_ROM_MT_SIZE 1
-static struct {
-  union mrb_mt_ptr vals[INTEGER_TO_R_ROM_MT_SIZE];
-  mrb_sym keys[INTEGER_TO_R_ROM_MT_SIZE];
-} integer_to_r_rom_data = {
-  .vals = {
-    { .func = int_to_r },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(to_r), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl integer_to_r_rom_mt = {
-  INTEGER_TO_R_ROM_MT_SIZE, INTEGER_TO_R_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&integer_to_r_rom_data, NULL
+static mrb_mt_entry integer_to_r_rom_entries[] = {
+  MRB_MT_ENTRY(int_to_r, MRB_SYM(to_r), MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl integer_to_r_rom_mt = MRB_MT_ROM_TAB(integer_to_r_rom_entries);
 
-#define NIL_TO_R_ROM_MT_SIZE 1
-static struct {
-  union mrb_mt_ptr vals[NIL_TO_R_ROM_MT_SIZE];
-  mrb_sym keys[NIL_TO_R_ROM_MT_SIZE];
-} nil_to_r_rom_data = {
-  .vals = {
-    { .func = nil_to_r },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(to_r), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl nil_to_r_rom_mt = {
-  NIL_TO_R_ROM_MT_SIZE, NIL_TO_R_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&nil_to_r_rom_data, NULL
+static mrb_mt_entry nil_to_r_rom_entries[] = {
+  MRB_MT_ENTRY(nil_to_r, MRB_SYM(to_r), MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl nil_to_r_rom_mt = MRB_MT_ROM_TAB(nil_to_r_rom_entries);
 
-#define KERNEL_RATIONAL_ROM_MT_SIZE 1
-static struct {
-  union mrb_mt_ptr vals[KERNEL_RATIONAL_ROM_MT_SIZE];
-  mrb_sym keys[KERNEL_RATIONAL_ROM_MT_SIZE];
-} kernel_rational_rom_data = {
-  .vals = {
-    { .func = rational_m },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(Rational), MRB_MT_FUNC|MRB_MT_PRIVATE),
-  }
-};
-static mrb_mt_tbl kernel_rational_rom_mt = {
-  KERNEL_RATIONAL_ROM_MT_SIZE, KERNEL_RATIONAL_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&kernel_rational_rom_data, NULL
+static mrb_mt_entry kernel_rational_rom_entries[] = {
+  MRB_MT_ENTRY(rational_m, MRB_SYM(Rational), MRB_MT_FUNC|MRB_MT_PRIVATE),
 };
+static mrb_mt_tbl kernel_rational_rom_mt = MRB_MT_ROM_TAB(kernel_rational_rom_entries);
 
 void mrb_mruby_rational_gem_init(mrb_state *mrb)
 {
diff --git a/mrbgems/mruby-set/src/set.c b/mrbgems/mruby-set/src/set.c
index 8ac1a8867..998782e18 100644
--- a/mrbgems/mruby-set/src/set.c
+++ b/mrbgems/mruby-set/src/set.c
@@ -1464,106 +1464,52 @@ set_s_create(mrb_state *mrb, mrb_value klass)
   return set;
 }
 
-#define SET_ROM_MT_SIZE 43
-static struct {
-  union mrb_mt_ptr vals[SET_ROM_MT_SIZE];
-  mrb_sym keys[SET_ROM_MT_SIZE];
-} set_rom_data = {
-  .vals = {
-    { .func = set_size },
-    { .func = set_size },
-    { .func = set_empty_p },
-    { .func = set_clear },
-    { .func = set_to_a },
-    { .func = set_include_p },
-    { .func = set_include_p },
-    { .func = set_include_p },
-    { .func = set_add },
-    { .func = set_add },
-    { .func = set_add_p },
-    { .func = set_delete },
-    { .func = set_delete_p },
-    { .func = set_init },
-    { .func = set_core_merge },
-    { .func = set_core_subtract },
-    { .func = set_core_union },
-    { .func = set_core_difference },
-    { .func = set_core_intersection },
-    { .func = set_core_xor },
-    { .func = set_equal },
-    { .func = set_hash_m },
-    { .func = set_join },
-    { .func = set_inspect },
-    { .func = set_inspect },
-    { .func = set_reset },
-    { .func = set_add_all },
-    { .func = set_delete_all },
-    { .func = set_include_all_p },
-    { .func = set_include_any_p },
-    { .func = set_superset_p },
-    { .func = set_superset_p },
-    { .func = set_proper_superset_p },
-    { .func = set_proper_superset_p },
-    { .func = set_subset_p },
-    { .func = set_subset_p },
-    { .func = set_proper_subset_p },
-    { .func = set_proper_subset_p },
-    { .func = set_intersect_p },
-    { .func = set_disjoint_p },
-    { .func = set_cmp },
-    { .func = set_flatten },
-    { .func = set_flatten_bang },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(size),              MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(length),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(empty),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(clear),             MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_a),              MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(include),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(member),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(eqq),             MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(add),               MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(lshift),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(add),             MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(delete),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(delete),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__init),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__merge),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__subtract),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__union),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__difference),      MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__intersection),    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__xor),             MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(eq),              MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(hash),              MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(join),              MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(inspect),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_s),              MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(reset),             MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(add_all),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(delete_all),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(include_all),     MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(include_any),     MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(superset),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(ge),              MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(proper_superset), MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(gt),              MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(subset),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(le),              MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(proper_subset),   MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(lt),              MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(intersect),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(disjoint),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(cmp),             MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(flatten),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(flatten),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl set_rom_mt = {
-  SET_ROM_MT_SIZE, SET_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&set_rom_data, NULL
+static mrb_mt_entry set_rom_entries[] = {
+  MRB_MT_ENTRY(set_size,              MRB_SYM(size),              MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(set_size,              MRB_SYM(length),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(set_empty_p,           MRB_SYM_Q(empty),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(set_clear,             MRB_SYM(clear),             MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(set_to_a,              MRB_SYM(to_a),              MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(set_include_p,         MRB_SYM_Q(include),         MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_include_p,         MRB_SYM_Q(member),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_include_p,         MRB_OPSYM(eqq),             MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_add,               MRB_SYM(add),               MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_add,               MRB_OPSYM(lshift),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_add_p,             MRB_SYM_Q(add),             MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_delete,            MRB_SYM(delete),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_delete_p,          MRB_SYM_Q(delete),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_init,              MRB_SYM(__init),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(set_core_merge,        MRB_SYM(__merge),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_core_subtract,     MRB_SYM(__subtract),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_core_union,        MRB_SYM(__union),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_core_difference,   MRB_SYM(__difference),      MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_core_intersection, MRB_SYM(__intersection),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_core_xor,          MRB_SYM(__xor),             MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_equal,             MRB_OPSYM(eq),              MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_hash_m,            MRB_SYM(hash),              MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(set_join,              MRB_SYM(join),              MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_inspect,           MRB_SYM(inspect),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(set_inspect,           MRB_SYM(to_s),              MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(set_reset,             MRB_SYM(reset),             MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(set_add_all,           MRB_SYM(add_all),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_delete_all,        MRB_SYM(delete_all),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_include_all_p,     MRB_SYM_Q(include_all),     MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_include_any_p,     MRB_SYM_Q(include_any),     MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_superset_p,        MRB_SYM_Q(superset),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_superset_p,        MRB_OPSYM(ge),              MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_proper_superset_p, MRB_SYM_Q(proper_superset), MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_proper_superset_p, MRB_OPSYM(gt),              MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_subset_p,          MRB_SYM_Q(subset),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_subset_p,          MRB_OPSYM(le),              MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_proper_subset_p,   MRB_SYM_Q(proper_subset),   MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_proper_subset_p,   MRB_OPSYM(lt),              MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_intersect_p,       MRB_SYM_Q(intersect),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_disjoint_p,        MRB_SYM_Q(disjoint),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_cmp,               MRB_OPSYM(cmp),             MRB_MT_FUNC),
+  MRB_MT_ENTRY(set_flatten,           MRB_SYM(flatten),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(set_flatten_bang,      MRB_SYM_B(flatten),         MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl set_rom_mt = MRB_MT_ROM_TAB(set_rom_entries);
 
 void
 mrb_mruby_set_gem_init(mrb_state *mrb)
diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c
index 700e0aee6..60154fce1 100644
--- a/mrbgems/mruby-socket/src/socket.c
+++ b/mrbgems/mruby-socket/src/socket.c
@@ -1271,113 +1271,45 @@ mrb_win32_basicsocket_syswrite(mrb_state *mrb, mrb_value self)
 #endif
 
 /* ---------------------------*/
-#define ADDRINFO_ROM_MT_SIZE 2
-static struct {
-  union mrb_mt_ptr vals[ADDRINFO_ROM_MT_SIZE];
-  mrb_sym keys[ADDRINFO_ROM_MT_SIZE];
-} addrinfo_rom_data = {
-  .vals = {
-    { .func = mrb_addrinfo_getnameinfo },
-    { .func = mrb_addrinfo_unix_path },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(getnameinfo), MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(unix_path),   MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl addrinfo_rom_mt = {
-  ADDRINFO_ROM_MT_SIZE, ADDRINFO_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&addrinfo_rom_data, NULL
+static mrb_mt_entry addrinfo_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_addrinfo_getnameinfo, MRB_SYM(getnameinfo), MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_addrinfo_unix_path,   MRB_SYM(unix_path),   MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl addrinfo_rom_mt = MRB_MT_ROM_TAB(addrinfo_rom_entries);
 
-#define BASICSOCKET_ROM_MT_SIZE 11
-static struct {
-  union mrb_mt_ptr vals[BASICSOCKET_ROM_MT_SIZE];
-  mrb_sym keys[BASICSOCKET_ROM_MT_SIZE];
-} basicsocket_rom_data = {
-  .vals = {
-    { .func = mrb_basicsocket_recvfrom },
-    { .func = mrb_basicsocket_setnonblock },
-    { .func = mrb_basicsocket_getpeereid },
-    { .func = mrb_basicsocket_getpeername },
-    { .func = mrb_basicsocket_getsockname },
-    { .func = mrb_basicsocket_getsockopt },
-    { .func = mrb_basicsocket_recv },
-    { .func = mrb_basicsocket_send },
-    { .func = mrb_basicsocket_setsockopt },
-    { .func = mrb_basicsocket_shutdown },
-    { .func = mrb_basicsocket_set_is_socket },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(_recvfrom),     MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(_setnonblock),  MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(getpeereid),    MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(getpeername),   MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(getsockname),   MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(getsockopt),    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(recv),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(send),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(setsockopt),    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(shutdown),      MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_E(_is_socket),  MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl basicsocket_rom_mt = {
-  BASICSOCKET_ROM_MT_SIZE, BASICSOCKET_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&basicsocket_rom_data, NULL
+static mrb_mt_entry basicsocket_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_basicsocket_recvfrom,      MRB_SYM(_recvfrom),     MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_basicsocket_setnonblock,   MRB_SYM(_setnonblock),  MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_basicsocket_getpeereid,    MRB_SYM(getpeereid),    MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_basicsocket_getpeername,   MRB_SYM(getpeername),   MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_basicsocket_getsockname,   MRB_SYM(getsockname),   MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_basicsocket_getsockopt,    MRB_SYM(getsockopt),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_basicsocket_recv,          MRB_SYM(recv),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_basicsocket_send,          MRB_SYM(send),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_basicsocket_setsockopt,    MRB_SYM(setsockopt),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_basicsocket_shutdown,      MRB_SYM(shutdown),      MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_basicsocket_set_is_socket, MRB_SYM_E(_is_socket),  MRB_MT_FUNC),
 };
+static mrb_mt_tbl basicsocket_rom_mt = MRB_MT_ROM_TAB(basicsocket_rom_entries);
 
-#define IPSOCKET_ROM_MT_SIZE 1
-static struct {
-  union mrb_mt_ptr vals[IPSOCKET_ROM_MT_SIZE];
-  mrb_sym keys[IPSOCKET_ROM_MT_SIZE];
-} ipsocket_rom_data = {
-  .vals = {
-    { .func = mrb_ipsocket_recvfrom },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(recvfrom), MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl ipsocket_rom_mt = {
-  IPSOCKET_ROM_MT_SIZE, IPSOCKET_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&ipsocket_rom_data, NULL
+static mrb_mt_entry ipsocket_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_ipsocket_recvfrom, MRB_SYM(recvfrom), MRB_MT_FUNC),
 };
+static mrb_mt_tbl ipsocket_rom_mt = MRB_MT_ROM_TAB(ipsocket_rom_entries);
 
-#define SOCKET_OPTION_ROM_MT_SIZE 10
-static struct {
-  union mrb_mt_ptr vals[SOCKET_OPTION_ROM_MT_SIZE];
-  mrb_sym keys[SOCKET_OPTION_ROM_MT_SIZE];
-} socket_option_rom_data = {
-  .vals = {
-    { .func = socket_option_init },
-    { .func = socket_option_inspect },
-    { .func = socket_option_family },
-    { .func = socket_option_level },
-    { .func = socket_option_optname },
-    { .func = socket_option_data },
-    { .func = socket_option_bool },
-    { .func = socket_option_int },
-    { .func = socket_option_notimp },
-    { .func = socket_option_notimp },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(inspect),    MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(family),     MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(level),      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(optname),    MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(data),       MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(bool),       MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(int),        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(linger),     MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(unpack),     MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl socket_option_rom_mt = {
-  SOCKET_OPTION_ROM_MT_SIZE, SOCKET_OPTION_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&socket_option_rom_data, NULL
+static mrb_mt_entry socket_option_rom_entries[] = {
+  MRB_MT_ENTRY(socket_option_init,    MRB_SYM(initialize), MRB_MT_FUNC),
+  MRB_MT_ENTRY(socket_option_inspect, MRB_SYM(inspect),    MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(socket_option_family,  MRB_SYM(family),     MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(socket_option_level,   MRB_SYM(level),      MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(socket_option_optname, MRB_SYM(optname),    MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(socket_option_data,    MRB_SYM(data),       MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(socket_option_bool,    MRB_SYM(bool),       MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(socket_option_int,     MRB_SYM(int),        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(socket_option_notimp,  MRB_SYM(linger),     MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(socket_option_notimp,  MRB_SYM(unpack),     MRB_MT_FUNC),
 };
+static mrb_mt_tbl socket_option_rom_mt = MRB_MT_ROM_TAB(socket_option_rom_entries);
 
 void
 mrb_mruby_socket_gem_init(mrb_state* mrb)
diff --git a/mrbgems/mruby-string-ext/src/string.c b/mrbgems/mruby-string-ext/src/string.c
index 0ede53f25..74a219e14 100644
--- a/mrbgems/mruby-string-ext/src/string.c
+++ b/mrbgems/mruby-string-ext/src/string.c
@@ -2219,143 +2219,67 @@ str_prepend(mrb_state *mrb, mrb_value self)
 }
 
 /* ---------------------------*/
-#define STRING_EXT_ROM_MT_SIZE 53
-static struct {
-  union mrb_mt_ptr vals[STRING_EXT_ROM_MT_SIZE];
-  mrb_sym keys[STRING_EXT_ROM_MT_SIZE];
-} string_ext_rom_data = {
-  .vals = {
-    { .func = mrb_str_dump },
-    { .func = str_swapcase_bang },
-    { .func = mrb_str_slice_bang },
-    { .func = str_swapcase },
-    { .func = str_clear },
-    { .func = str_concat_m },
-    { .func = str_concat_m },
-    { .func = str_append_as_bytes },
-    { .func = str_count },
-    { .func = str_tr_m },
-    { .func = str_partition },
-    { .func = str_rpartition },
-    { .func = str_insert },
-    { .func = str_prepend },
-    { .func = str_tr_bang },
-    { .func = str_tr_s },
-    { .func = str_tr_s_bang },
-    { .func = str_squeeze_m },
-    { .func = str_squeeze_bang },
-    { .func = str_delete_m },
-    { .func = str_delete_bang },
-    { .func = str_start_with },
-    { .func = str_end_with },
-    { .func = str_hex },
-    { .func = str_oct },
-    { .func = str_chr },
-    { .func = str_succ },
-    { .func = str_succ_bang },
-    { .func = str_succ },
-    { .func = str_succ_bang },
-    { .func = str_ord },
-    { .func = str_del_prefix_bang },
-    { .func = str_del_prefix },
-    { .func = str_del_suffix_bang },
-    { .func = str_del_suffix },
-    { .func = str_casecmp },
-    { .func = str_casecmp_p },
-    { .func = str_uplus },
-    { .func = str_uminus },
-    { .func = str_ascii_only_p },
-    { .func = str_b },
-    { .func = str_lines },
-    { .func = str_codepoints },
-    { .func = str_lstrip },
-    { .func = str_rstrip },
-    { .func = str_strip },
-    { .func = str_lstrip_bang },
-    { .func = str_rstrip_bang },
-    { .func = str_strip_bang },
-    { .func = str_chars_ary },
-    { .func = str_ljust_core },
-    { .func = str_rjust_core },
-    { .func = str_center_core },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(dump),             MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(swapcase),       MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(slice),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(swapcase),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(clear),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(lshift),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(concat),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(append_as_bytes),  MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(count),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(tr),               MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(partition),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(rpartition),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(insert),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(prepend),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(tr),             MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(tr_s),             MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(tr_s),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(squeeze),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(squeeze),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(delete),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(delete),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(start_with),     MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(end_with),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(hex),              MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(oct),              MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(chr),              MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(succ),             MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(succ),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(next),             MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(next),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(ord),              MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(delete_prefix),  MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(delete_prefix),    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(delete_suffix),  MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(delete_suffix),    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(casecmp),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(casecmp),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(plus),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(minus),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(ascii_only),     MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(b),                MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__lines),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__codepoints),     MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(lstrip),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(rstrip),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(strip),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(lstrip),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(rstrip),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(strip),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__chars),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(ljust),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(rjust),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(center),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl string_ext_rom_mt = {
-  STRING_EXT_ROM_MT_SIZE, STRING_EXT_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&string_ext_rom_data, NULL
+static mrb_mt_entry string_ext_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_str_dump,        MRB_SYM(dump),             MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_swapcase_bang,   MRB_SYM_B(swapcase),       MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_slice_bang,  MRB_SYM_B(slice),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_swapcase,        MRB_SYM(swapcase),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_clear,           MRB_SYM(clear),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_concat_m,        MRB_OPSYM(lshift),         MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_concat_m,        MRB_SYM(concat),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_append_as_bytes, MRB_SYM(append_as_bytes),  MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_count,           MRB_SYM(count),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_tr_m,            MRB_SYM(tr),               MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_partition,       MRB_SYM(partition),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_rpartition,      MRB_SYM(rpartition),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_insert,          MRB_SYM(insert),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_prepend,         MRB_SYM(prepend),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_tr_bang,         MRB_SYM_B(tr),             MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_tr_s,            MRB_SYM(tr_s),             MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_tr_s_bang,       MRB_SYM_B(tr_s),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_squeeze_m,       MRB_SYM(squeeze),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_squeeze_bang,    MRB_SYM_B(squeeze),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_delete_m,        MRB_SYM(delete),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_delete_bang,     MRB_SYM_B(delete),         MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_start_with,      MRB_SYM_Q(start_with),     MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_end_with,        MRB_SYM_Q(end_with),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_hex,             MRB_SYM(hex),              MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_oct,             MRB_SYM(oct),              MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_chr,             MRB_SYM(chr),              MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_succ,            MRB_SYM(succ),             MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_succ_bang,       MRB_SYM_B(succ),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_succ,            MRB_SYM(next),             MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_succ_bang,       MRB_SYM_B(next),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_ord,             MRB_SYM(ord),              MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_del_prefix_bang, MRB_SYM_B(delete_prefix),  MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_del_prefix,      MRB_SYM(delete_prefix),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_del_suffix_bang, MRB_SYM_B(delete_suffix),  MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_del_suffix,      MRB_SYM(delete_suffix),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_casecmp,         MRB_SYM(casecmp),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_casecmp_p,       MRB_SYM_Q(casecmp),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_uplus,           MRB_OPSYM(plus),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_uminus,          MRB_OPSYM(minus),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_ascii_only_p,    MRB_SYM_Q(ascii_only),     MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_b,               MRB_SYM(b),                MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_lines,           MRB_SYM(__lines),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_codepoints,      MRB_SYM(__codepoints),     MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_lstrip,          MRB_SYM(lstrip),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_rstrip,          MRB_SYM(rstrip),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_strip,           MRB_SYM(strip),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_lstrip_bang,     MRB_SYM_B(lstrip),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_rstrip_bang,     MRB_SYM_B(rstrip),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_strip_bang,      MRB_SYM_B(strip),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_chars_ary,       MRB_SYM(__chars),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(str_ljust_core,      MRB_SYM(ljust),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_rjust_core,      MRB_SYM(rjust),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(str_center_core,     MRB_SYM(center),           MRB_MT_FUNC),
 };
+static mrb_mt_tbl string_ext_rom_mt = MRB_MT_ROM_TAB(string_ext_rom_entries);
 
-#define INTEGER_CHR_ROM_MT_SIZE 1
-static struct {
-  union mrb_mt_ptr vals[INTEGER_CHR_ROM_MT_SIZE];
-  mrb_sym keys[INTEGER_CHR_ROM_MT_SIZE];
-} integer_chr_rom_data = {
-  .vals = {
-    { .func = int_chr },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(chr), MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl integer_chr_rom_mt = {
-  INTEGER_CHR_ROM_MT_SIZE, INTEGER_CHR_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&integer_chr_rom_data, NULL
+static mrb_mt_entry integer_chr_rom_entries[] = {
+  MRB_MT_ENTRY(int_chr, MRB_SYM(chr), MRB_MT_FUNC),
 };
+static mrb_mt_tbl integer_chr_rom_mt = MRB_MT_ROM_TAB(integer_chr_rom_entries);
 
 void
 mrb_mruby_string_ext_gem_init(mrb_state* mrb)
diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c
index b0bcd88c9..e2a0229ba 100644
--- a/mrbgems/mruby-struct/src/struct.c
+++ b/mrbgems/mruby-struct/src/struct.c
@@ -776,50 +776,24 @@ mrb_struct_to_s(mrb_state *mrb, mrb_value self)
  *  `Symbol` (such as `:name`).
  */
 /* ---------------------------*/
-#define STRUCT_ROM_MT_SIZE 15
-static struct {
-  union mrb_mt_ptr vals[STRUCT_ROM_MT_SIZE];
-  mrb_sym keys[STRUCT_ROM_MT_SIZE];
-} struct_rom_data = {
-  .vals = {
-    { .func = mrb_struct_equal },
-    { .func = mrb_struct_aref },
-    { .func = mrb_struct_aset },
-    { .func = mrb_struct_members },
-    { .func = mrb_struct_initialize },
-    { .func = mrb_struct_init_copy },
-    { .func = mrb_struct_eql },
-    { .func = mrb_struct_to_s },
-    { .func = mrb_struct_to_s },
-    { .func = mrb_struct_len },
-    { .func = mrb_struct_len },
-    { .func = mrb_struct_to_a },
-    { .func = mrb_struct_to_a },
-    { .func = mrb_struct_to_h },
-    { .func = mrb_struct_values_at },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_OPSYM(eq),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(aref),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(aset),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(members),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(initialize),      MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM_Q(eql),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_s),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(inspect),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(size),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(length),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_a),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(values),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_h),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(values_at),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl struct_rom_mt = {
-  STRUCT_ROM_MT_SIZE, STRUCT_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&struct_rom_data, NULL
+static mrb_mt_entry struct_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_struct_equal,      MRB_OPSYM(eq),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_struct_aref,       MRB_OPSYM(aref),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_struct_aset,       MRB_OPSYM(aset),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_struct_members,    MRB_SYM(members),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_struct_initialize, MRB_SYM(initialize),      MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_struct_init_copy,  MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_struct_eql,        MRB_SYM_Q(eql),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_struct_to_s,       MRB_SYM(to_s),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_struct_to_s,       MRB_SYM(inspect),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_struct_len,        MRB_SYM(size),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_struct_len,        MRB_SYM(length),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_struct_to_a,       MRB_SYM(to_a),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_struct_to_a,       MRB_SYM(values),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_struct_to_h,       MRB_SYM(to_h),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_struct_values_at,  MRB_SYM(values_at),       MRB_MT_FUNC),
 };
+static mrb_mt_tbl struct_rom_mt = MRB_MT_ROM_TAB(struct_rom_entries);
 
 void
 mrb_mruby_struct_gem_init(mrb_state* mrb)
diff --git a/mrbgems/mruby-symbol-ext/src/symbol.c b/mrbgems/mruby-symbol-ext/src/symbol.c
index 3b30a2c4c..cb37e5fd0 100644
--- a/mrbgems/mruby-symbol-ext/src/symbol.c
+++ b/mrbgems/mruby-symbol-ext/src/symbol.c
@@ -58,24 +58,11 @@ mrb_sym_length(mrb_state *mrb, mrb_value self)
   return mrb_fixnum_value(len);
 }
 
-#define SYMBOL_EXT_ROM_MT_SIZE 2
-static struct {
-  union mrb_mt_ptr vals[SYMBOL_EXT_ROM_MT_SIZE];
-  mrb_sym keys[SYMBOL_EXT_ROM_MT_SIZE];
-} symbol_ext_rom_data = {
-  .vals = {
-    { .func = mrb_sym_length },
-    { .func = mrb_sym_length },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(length), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(size),   MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl symbol_ext_rom_mt = {
-  SYMBOL_EXT_ROM_MT_SIZE, SYMBOL_EXT_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&symbol_ext_rom_data, NULL
+static mrb_mt_entry symbol_ext_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_sym_length, MRB_SYM(length), MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_sym_length, MRB_SYM(size),   MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl symbol_ext_rom_mt = MRB_MT_ROM_TAB(symbol_ext_rom_entries);
 
 void
 mrb_mruby_symbol_ext_gem_init(mrb_state* mrb)
diff --git a/mrbgems/mruby-time/src/time.c b/mrbgems/mruby-time/src/time.c
index 48ff7af8d..daacf360a 100644
--- a/mrbgems/mruby-time/src/time.c
+++ b/mrbgems/mruby-time/src/time.c
@@ -1664,112 +1664,55 @@ time_utc_offset(mrb_state *mrb, mrb_value self)
 }
 
 /* ---------------------------*/
-#define TIME_ROM_MT_SIZE 46
-static struct {
-  union mrb_mt_ptr vals[TIME_ROM_MT_SIZE];
-  mrb_sym keys[TIME_ROM_MT_SIZE];
-} time_rom_data = {
-  .vals = {
-    { .func = time_hash },
-    { .func = time_eq },
-    { .func = time_eq },
-    { .func = time_cmp },
-    { .func = time_plus },
-    { .func = time_minus },
-    { .func = time_to_s },
-    { .func = time_to_s },
-    { .func = time_asctime },
-    { .func = time_asctime },
-    { .func = time_day },
-    { .func = time_dst_p },
-    { .func = time_getutc },
-    { .func = time_getlocal },
-    { .func = time_getutc },
-    { .func = time_utc_p },
-    { .func = time_utc },
-    { .func = time_hour },
-    { .func = time_localtime },
-    { .func = time_day },
-    { .func = time_min },
-    { .func = time_mon },
-    { .func = time_mon },
-    { .func = time_sec },
-    { .func = time_to_i },
-    { .func = time_usec },
-    { .func = time_nsec },
-    { .func = time_nsec },
-    { .func = time_utc },
-    { .func = time_utc_p },
-    { .func = time_wday },
-    { .func = time_yday },
-    { .func = time_year },
-    { .func = time_zone },
-    { .func = time_init },
-    { .func = time_init_copy },
-    { .func = time_sunday },
-    { .func = time_monday },
-    { .func = time_tuesday },
-    { .func = time_wednesday },
-    { .func = time_thursday },
-    { .func = time_friday },
-    { .func = time_saturday },
-    { .func = time_utc_offset },
-    { .func = time_utc_offset },
-    { .func = time_utc_offset },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(hash),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(eql),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(eq),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(cmp),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(add),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(sub),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_s),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(inspect),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(asctime),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(ctime),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(day),             MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(dst),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(getgm),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(getlocal),        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(getutc),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(gmt),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(gmtime),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(hour),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(localtime),       MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(mday),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(min),             MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(mon),             MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(month),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(sec),             MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_i),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(usec),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(nsec),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(tv_nsec),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(utc),             MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(utc),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(wday),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(yday),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(year),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(zone),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(initialize),      MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM_Q(sunday),        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(monday),        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(tuesday),       MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(wednesday),     MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(thursday),      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(friday),        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(saturday),      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(gmt_offset),      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(gmtoff),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(utc_offset),      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl time_rom_mt = {
-  TIME_ROM_MT_SIZE, TIME_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&time_rom_data, NULL
+static mrb_mt_entry time_rom_entries[] = {
+  MRB_MT_ENTRY(time_hash,      MRB_SYM(hash),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_eq,        MRB_SYM_Q(eql),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(time_eq,        MRB_OPSYM(eq),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(time_cmp,       MRB_OPSYM(cmp),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(time_plus,      MRB_OPSYM(add),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(time_minus,     MRB_OPSYM(sub),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(time_to_s,      MRB_SYM(to_s),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_to_s,      MRB_SYM(inspect),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_asctime,   MRB_SYM(asctime),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_asctime,   MRB_SYM(ctime),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_day,       MRB_SYM(day),             MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_dst_p,     MRB_SYM_Q(dst),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_getutc,    MRB_SYM(getgm),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_getlocal,  MRB_SYM(getlocal),        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_getutc,    MRB_SYM(getutc),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_utc_p,     MRB_SYM_Q(gmt),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_utc,       MRB_SYM(gmtime),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_hour,      MRB_SYM(hour),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_localtime, MRB_SYM(localtime),       MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_day,       MRB_SYM(mday),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_min,       MRB_SYM(min),             MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_mon,       MRB_SYM(mon),             MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_mon,       MRB_SYM(month),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_sec,       MRB_SYM(sec),             MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_to_i,      MRB_SYM(to_i),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_usec,      MRB_SYM(usec),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_nsec,      MRB_SYM(nsec),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_nsec,      MRB_SYM(tv_nsec),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_utc,       MRB_SYM(utc),             MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_utc_p,     MRB_SYM_Q(utc),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_wday,      MRB_SYM(wday),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_yday,      MRB_SYM(yday),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_year,      MRB_SYM(year),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_zone,      MRB_SYM(zone),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_init,      MRB_SYM(initialize),      MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(time_init_copy, MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(time_sunday,    MRB_SYM_Q(sunday),        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_monday,    MRB_SYM_Q(monday),        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_tuesday,   MRB_SYM_Q(tuesday),       MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_wednesday, MRB_SYM_Q(wednesday),     MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_thursday,  MRB_SYM_Q(thursday),      MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_friday,    MRB_SYM_Q(friday),        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_saturday,  MRB_SYM_Q(saturday),      MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_utc_offset, MRB_SYM(gmt_offset),     MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_utc_offset, MRB_SYM(gmtoff),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(time_utc_offset, MRB_SYM(utc_offset),     MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl time_rom_mt = MRB_MT_ROM_TAB(time_rom_entries);
 
 void
 mrb_mruby_time_gem_init(mrb_state* mrb)
diff --git a/src/array.c b/src/array.c
index c939573d7..2fa2029c4 100644
--- a/src/array.c
+++ b/src/array.c
@@ -2249,92 +2249,45 @@ mrb_ary_to_a(mrb_state *mrb, mrb_value self)
 }
 
 /* ---------------------------*/
-#define ARRAY_ROM_MT_SIZE 36
-static struct {
-  union mrb_mt_ptr vals[ARRAY_ROM_MT_SIZE];
-  mrb_sym keys[ARRAY_ROM_MT_SIZE];
-} array_rom_data = {
-  .vals = {
-    { .func = mrb_ary_plus },
-    { .func = mrb_ary_times },
-    { .func = mrb_ary_push_m },
-    { .func = mrb_ary_aget },
-    { .func = mrb_ary_aset },
-    { .func = mrb_ary_clear },
-    { .func = mrb_ary_cmp },
-    { .func = mrb_ary_concat_m },
-    { .func = mrb_ary_delete },
-    { .func = mrb_ary_delete_at },
-    { .func = mrb_ary_empty_p },
-    { .func = mrb_ary_eq },
-    { .func = mrb_ary_eql },
-    { .func = mrb_ary_first },
-    { .func = mrb_ary_index_m },
-    { .func = mrb_ary_init },
-    { .func = mrb_ary_replace_m },
-    { .func = mrb_ary_join_m },
-    { .func = mrb_ary_last },
-    { .func = mrb_ary_size },
-    { .func = mrb_ary_pop },
-    { .func = mrb_ary_push_m },
-    { .func = mrb_ary_replace_m },
-    { .func = mrb_ary_reverse },
-    { .func = mrb_ary_reverse_bang },
-    { .func = mrb_ary_rindex_m },
-    { .func = mrb_ary_shift_m },
-    { .func = mrb_ary_size },
-    { .func = mrb_ary_aget },
-    { .func = mrb_ary_unshift_m },
-    { .func = mrb_ary_to_a },
-    { .func = mrb_ary_to_a },
-    { .func = mrb_ary_to_s },
-    { .func = mrb_ary_to_s },
-    { .func = mrb_ary_sort_bang },
-    { .func = mrb_ary_svalue },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_OPSYM(add),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(mul),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(lshift),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(aref),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(aset),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(clear),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(cmp),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(concat),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(delete),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(delete_at),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(empty),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(eq),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(eql),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(first),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(index),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(initialize),      MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(join),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(last),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(length),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(pop),             MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(push),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(replace),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(reverse),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(reverse),       MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(rindex),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(shift),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(size),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(slice),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(unshift),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_a),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(entries),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_s),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(inspect),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(sort),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__svalue),        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl array_rom_mt = {
-  ARRAY_ROM_MT_SIZE, ARRAY_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&array_rom_data, NULL
+static mrb_mt_entry array_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_ary_plus,        MRB_OPSYM(add),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_times,       MRB_OPSYM(mul),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_push_m,      MRB_OPSYM(lshift),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_aget,        MRB_OPSYM(aref),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_aset,        MRB_OPSYM(aset),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_clear,       MRB_SYM(clear),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_ary_cmp,         MRB_OPSYM(cmp),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_concat_m,    MRB_SYM(concat),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_delete,      MRB_SYM(delete),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_delete_at,   MRB_SYM(delete_at),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_empty_p,     MRB_SYM_Q(empty),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_ary_eq,          MRB_OPSYM(eq),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_eql,         MRB_SYM_Q(eql),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_first,       MRB_SYM(first),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_index_m,     MRB_SYM(index),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_init,        MRB_SYM(initialize),      MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_ary_replace_m,   MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_ary_join_m,      MRB_SYM(join),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_last,        MRB_SYM(last),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_size,        MRB_SYM(length),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_ary_pop,         MRB_SYM(pop),             MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_ary_push_m,      MRB_SYM(push),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_replace_m,   MRB_SYM(replace),         MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_reverse,     MRB_SYM(reverse),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_ary_reverse_bang, MRB_SYM_B(reverse),      MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_ary_rindex_m,    MRB_SYM(rindex),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_shift_m,     MRB_SYM(shift),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_size,        MRB_SYM(size),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_ary_aget,        MRB_SYM(slice),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_unshift_m,   MRB_SYM(unshift),         MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ary_to_a,        MRB_SYM(to_a),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_ary_to_a,        MRB_SYM(entries),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_ary_to_s,        MRB_SYM(to_s),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_ary_to_s,        MRB_SYM(inspect),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_ary_sort_bang,   MRB_SYM_B(sort),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_ary_svalue,      MRB_SYM(__svalue),        MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl array_rom_mt = MRB_MT_ROM_TAB(array_rom_entries);
 
 void
 mrb_init_array(mrb_state *mrb)
diff --git a/src/class.c b/src/class.c
index 0e1b798cb..56b7d1862 100644
--- a/src/class.c
+++ b/src/class.c
@@ -38,35 +38,12 @@
 #define mt_readonly_p(t) ((t)->alloc & MRB_MT_READONLY_BIT)
 #define mt_frozen_p(t)   ((t)->alloc & MRB_MT_FROZEN_BIT)
 
-/* Helper to get keys array from method table */
-static inline mrb_sym*
-mt_keys(mrb_mt_tbl *t) {
-  return (mrb_sym*)&t->ptr[MT_ALLOC(t)];
-}
-
-/* Helper to get values array from method table */
-static union mrb_mt_ptr*
-mt_vals(mrb_mt_tbl *t) {
-  return t->ptr;
-}
-
-/* Allocates or grows the method table block to exactly new_alloc entries */
+/* Allocates or grows the method table to exactly new_alloc entries */
 static void
 mt_grow(mrb_state *mrb, mrb_mt_tbl *t, int new_alloc)
 {
-  int old_alloc = MT_ALLOC(t);
-  size_t new_block = new_alloc * (sizeof(union mrb_mt_ptr) + sizeof(mrb_sym));
-
-  t->ptr = (union mrb_mt_ptr*)mrb_realloc(mrb, t->ptr, new_block);
-  if (old_alloc > 0) {
-    /* keys used to live at &ptr[old_alloc] */
-    mrb_sym *old_keys = (mrb_sym*)&t->ptr[old_alloc];
-    /* keys must now live at &ptr[new_alloc] */
-    mrb_sym *new_keys = (mrb_sym*)&t->ptr[new_alloc];
-
-    /* move the old key array up to its new position */
-    memmove(new_keys, old_keys, old_alloc * sizeof(mrb_sym));
-  }
+  t->ptr = (mrb_mt_entry*)mrb_realloc(mrb, t->ptr,
+                                       new_alloc * sizeof(mrb_mt_entry));
   t->alloc = (t->alloc & MRB_MT_FLAG_BITS) | new_alloc;
 }
 
@@ -85,19 +62,19 @@ mt_new(mrb_state *mrb)
   return t;
 }
 
-/* Branch-free binary search helper for method table keys */
+/* Branch-free binary search helper for method table entries */
 static inline int
-mt_bsearch_idx(mrb_sym *keys, int size, mrb_sym target)
+mt_bsearch_idx(mrb_mt_entry *entries, int size, mrb_sym target)
 {
   if (size == 0) return 0;
   int n = size;
-  mrb_sym *p = keys;
+  mrb_mt_entry *p = entries;
   /* While more than one element remains, halve the range each iteration */
   while (n > 1) {
     int half = n >> 1;
     MRB_MEM_PREFETCH(p + (half >> 1));
     MRB_MEM_PREFETCH(p + half + (half >> 1));
-    mrb_sym mid_sym = MT_KEY_SYM(p[half]);
+    mrb_sym mid_sym = MT_KEY_SYM(p[half].key);
     /*
      * Update pointer p without a branch:
      * If mid_sym < target, move p forward by half; otherwise keep p unchanged.
@@ -107,8 +84,8 @@ mt_bsearch_idx(mrb_sym *keys, int size, mrb_sym target)
     n -= half;
   }
   /* Final adjustment: if the remaining element is still less than target, advance by one */
-  int offset = (MT_KEY_SYM(*p) < target);
-  return (int)(p - keys) + offset;
+  int offset = (MT_KEY_SYM(p->key) < target);
+  return (int)(p - entries) + offset;
 }
 
 /* Inserts or updates an entry in the method table */
@@ -125,32 +102,30 @@ mt_put(mrb_state *mrb, mrb_mt_tbl *t, mrb_sym sym, mrb_sym flags, union mrb_mt_p
     mt_grow(mrb, t, MT_ALLOC(t) * 2);
   }
 
-  mrb_sym      *keys = mt_keys(t);
-  union mrb_mt_ptr *vals = mt_vals(t);
+  mrb_mt_entry *entries = t->ptr;
 
   /*
    * If table is empty, insertion index is 0.
    * Otherwise, find the insertion/update position branch-free.
    */
-  int lo = mt_bsearch_idx(keys, t->size, sym);
+  int lo = mt_bsearch_idx(entries, t->size, sym);
 
   /* If the key already exists, update its value and return */
-  if (lo < t->size && MT_KEY_SYM(keys[lo]) == sym) {
-    keys[lo] = key;
-    vals[lo] = ptrval;
+  if (lo < t->size && MT_KEY_SYM(entries[lo].key) == sym) {
+    entries[lo].key = key;
+    entries[lo].val = ptrval;
     return;
   }
 
   /* Shift existing entries to make room at index lo */
   if (t->size > lo) {
-    int move_count = t->size - lo;
-    memmove(&vals[lo+1], &vals[lo], move_count * sizeof(union mrb_mt_ptr));
-    memmove(&keys[lo+1], &keys[lo], move_count * sizeof(mrb_sym));
+    memmove(&entries[lo+1], &entries[lo],
+            (t->size - lo) * sizeof(mrb_mt_entry));
   }
 
-  /* Insert the new key and value */
-  keys[lo] = key;
-  vals[lo] = ptrval;
+  /* Insert the new entry */
+  entries[lo].key = key;
+  entries[lo].val = ptrval;
   t->size++;
 }
 
@@ -160,13 +135,12 @@ mt_get(mrb_state *mrb, mrb_mt_tbl *t, mrb_sym sym, union mrb_mt_ptr *pp)
 {
   while (t) {
     if (t->size > 0) {
-      mrb_sym *keys = mt_keys(t);
-      union mrb_mt_ptr *vals = mt_vals(t);
-      int lo = mt_bsearch_idx(keys, t->size, sym);
-      if (lo < t->size && MT_KEY_SYM(keys[lo]) == sym) {
-        if (MRB_MT_REMOVED_P(keys[lo], vals[lo])) return 0; /* removed tombstone */
-        *pp = vals[lo];
-        return keys[lo];
+      mrb_mt_entry *entries = t->ptr;
+      int lo = mt_bsearch_idx(entries, t->size, sym);
+      if (lo < t->size && MT_KEY_SYM(entries[lo].key) == sym) {
+        if (MRB_MT_REMOVED_P(entries[lo])) return 0; /* removed tombstone */
+        *pp = entries[lo].val;
+        return entries[lo].key;
       }
     }
     t = t->next;
@@ -181,18 +155,15 @@ mt_del(mrb_state *mrb, mrb_mt_tbl *t, mrb_sym sym)
   /* Return FALSE if table is null or empty */
   if (!t || t->size == 0) return FALSE;
 
-  mrb_sym      *keys = mt_keys(t);
-  union mrb_mt_ptr *vals = mt_vals(t);
+  mrb_mt_entry *entries = t->ptr;
 
   /* Find the index of `sym` in a branch-free manner */
-  int lo = mt_bsearch_idx(keys, t->size, sym);
+  int lo = mt_bsearch_idx(entries, t->size, sym);
 
   /* If the key exists at index lo, remove it by shifting left */
-  if (lo < t->size && MT_KEY_SYM(keys[lo]) == sym) {
-    int move_count = t->size - lo - 1;
-    /* shift left to remove entry */
-    memmove(&vals[lo],     &vals[lo + 1], move_count * sizeof(union mrb_mt_ptr));
-    memmove(&keys[lo],     &keys[lo + 1], move_count * sizeof(mrb_sym));
+  if (lo < t->size && MT_KEY_SYM(entries[lo].key) == sym) {
+    memmove(&entries[lo], &entries[lo + 1],
+            (t->size - lo - 1) * sizeof(mrb_mt_entry));
     t->size--;
     return TRUE;
   }
@@ -207,9 +178,9 @@ mt_chain_has(mrb_mt_tbl *t, mrb_sym sym)
 {
   while (t) {
     if (t->size > 0) {
-      mrb_sym *keys = mt_keys(t);
-      int lo = mt_bsearch_idx(keys, t->size, sym);
-      if (lo < t->size && MT_KEY_SYM(keys[lo]) == sym) return TRUE;
+      mrb_mt_entry *entries = t->ptr;
+      int lo = mt_bsearch_idx(entries, t->size, sym);
+      if (lo < t->size && MT_KEY_SYM(entries[lo].key) == sym) return TRUE;
     }
     t = t->next;
   }
@@ -232,8 +203,7 @@ mt_copy(mrb_state *mrb, mrb_mt_tbl *t)
   mrb_mt_tbl *t2 = mt_new(mrb);
   if (t->size > 0) {
     mt_grow(mrb, t2, t->size);
-    memcpy(mt_vals(t2), mt_vals(t), t->size * sizeof(union mrb_mt_ptr));
-    memcpy(mt_keys(t2), mt_keys(t), t->size * sizeof(mrb_sym));
+    memcpy(t2->ptr, t->ptr, t->size * sizeof(mrb_mt_entry));
     t2->size = t->size;
   }
   t2->next = t->next;  /* share ROM chain */
@@ -252,22 +222,19 @@ mt_free(mrb_state *mrb, mrb_mt_tbl *t)
   }
 }
 
-/* Sorts parallel vals/keys arrays by key symbol (insertion sort) */
+/* Sorts entries array by key symbol (insertion sort) */
 static void
-mt_sort(union mrb_mt_ptr *vals, mrb_sym *keys, int n)
+mt_sort(mrb_mt_entry *entries, int n)
 {
   for (int i = 1; i < n; i++) {
-    mrb_sym key = keys[i];
-    union mrb_mt_ptr val = vals[i];
-    mrb_sym sym = MT_KEY_SYM(key);
+    mrb_mt_entry e = entries[i];
+    mrb_sym sym = MT_KEY_SYM(e.key);
     int j = i;
-    while (j > 0 && MT_KEY_SYM(keys[j-1]) > sym) {
-      keys[j] = keys[j-1];
-      vals[j] = vals[j-1];
+    while (j > 0 && MT_KEY_SYM(entries[j-1].key) > sym) {
+      entries[j] = entries[j-1];
       j--;
     }
-    keys[j] = key;
-    vals[j] = val;
+    entries[j] = e;
   }
 }
 
@@ -275,9 +242,7 @@ mt_sort(union mrb_mt_ptr *vals, mrb_sym *keys, int n)
 void
 mrb_mt_init_rom(struct RClass *c, mrb_mt_tbl *rom)
 {
-  union mrb_mt_ptr *vals = rom->ptr;
-  mrb_sym *keys = (mrb_sym*)&vals[rom->size];
-  mt_sort(vals, keys, rom->size);
+  mt_sort(rom->ptr, rom->size);
   rom->alloc = rom->size | MRB_MT_READONLY_BIT;
 
   /* push ROM layer */
@@ -313,12 +278,11 @@ mrb_mt_foreach(mrb_state *mrb, struct RClass *c, mrb_mt_foreach_func *fn, void *
 
   /* fast path: single layer */
   if (!t->next) {
+    mrb_mt_entry *entries = t->ptr;
     for (int i = 0; i < t->size; i++) {
-      union mrb_mt_ptr *vals = mt_vals(t);
-      mrb_sym *keys = mt_keys(t);
-      if (MRB_MT_REMOVED_P(keys[i], vals[i])) continue;
-      if (fn(mrb, MT_KEY_SYM(keys[i]),
-             create_method_value(mrb, keys[i], vals[i]), p) != 0)
+      if (MRB_MT_REMOVED_P(entries[i])) continue;
+      if (fn(mrb, MT_KEY_SYM(entries[i].key),
+             create_method_value(mrb, entries[i].key, entries[i].val), p) != 0)
         return;
     }
     return;
@@ -326,19 +290,17 @@ mrb_mt_foreach(mrb_state *mrb, struct RClass *c, mrb_mt_foreach_func *fn, void *
 
   /* multi-layer: iterate each layer, skip if shadowed by a higher one */
   for (mrb_mt_tbl *layer = t; layer; layer = layer->next) {
-    mrb_sym *keys = mt_keys(layer);
-    union mrb_mt_ptr *vals = mt_vals(layer);
+    mrb_mt_entry *entries = layer->ptr;
     for (int i = 0; i < layer->size; i++) {
-      if (MRB_MT_REMOVED_P(keys[i], vals[i])) continue;
-      mrb_sym sym = MT_KEY_SYM(keys[i]);
+      if (MRB_MT_REMOVED_P(entries[i])) continue;
+      mrb_sym sym = MT_KEY_SYM(entries[i].key);
       /* check if shadowed by a higher layer */
       if (layer != t) {
         mrb_bool shadowed = FALSE;
         for (mrb_mt_tbl *upper = t; upper != layer; upper = upper->next) {
           if (upper->size > 0) {
-            mrb_sym *ukeys = mt_keys(upper);
-            int lo = mt_bsearch_idx(ukeys, upper->size, sym);
-            if (lo < upper->size && MT_KEY_SYM(ukeys[lo]) == sym) {
+            int lo = mt_bsearch_idx(upper->ptr, upper->size, sym);
+            if (lo < upper->size && MT_KEY_SYM(upper->ptr[lo].key) == sym) {
               shadowed = TRUE;
               break;
             }
@@ -346,7 +308,7 @@ mrb_mt_foreach(mrb_state *mrb, struct RClass *c, mrb_mt_foreach_func *fn, void *
         }
         if (shadowed) continue;
       }
-      if (fn(mrb, sym, create_method_value(mrb, keys[i], vals[i]), p) != 0)
+      if (fn(mrb, sym, create_method_value(mrb, entries[i].key, entries[i].val), p) != 0)
         return;
     }
   }
@@ -360,11 +322,10 @@ mrb_gc_mark_mt(mrb_state *mrb, struct RClass *c)
   for (mrb_mt_tbl *t = c->mt; t; t = t->next) {
     if (mt_readonly_p(t)) continue; /* ROM layers need no GC marking */
     if (t->size == 0) continue;
-    mrb_sym *keys = mt_keys(t);
-    union mrb_mt_ptr *vals = mt_vals(t);
+    mrb_mt_entry *entries = t->ptr;
     for (int i = 0; i < t->size; i++) {
-      if (MT_KEY_P(keys[i]) && (keys[i] & MRB_MT_FUNC) == 0) {
-        mrb_gc_mark(mrb, (struct RBasic*)vals[i].proc);
+      if (MT_KEY_P(entries[i].key) && (entries[i].key & MRB_MT_FUNC) == 0) {
+        mrb_gc_mark(mrb, (struct RBasic*)entries[i].val.proc);
       }
     }
     children += (size_t)t->size;
@@ -378,8 +339,7 @@ mrb_class_mt_memsize(mrb_state *mrb, struct RClass *c)
 {
   size_t total = 0;
   for (mrb_mt_tbl *h = c->mt; h && !mt_readonly_p(h); h = h->next)
-    total += sizeof(mrb_mt_tbl) + (size_t)MT_ALLOC(h) *
-             (sizeof(union mrb_mt_ptr) + sizeof(mrb_sym));
+    total += sizeof(mrb_mt_tbl) + (size_t)MT_ALLOC(h) * sizeof(mrb_mt_entry);
   return total;
 }
 
@@ -4366,148 +4326,66 @@ static const struct RProc neq_proc = {
 };
 
 /* ---------------------------*/
-#define BOB_ROM_MT_SIZE 11
-static struct {
-  union mrb_mt_ptr vals[BOB_ROM_MT_SIZE];
-  mrb_sym keys[BOB_ROM_MT_SIZE];
-} bob_rom_data = {
-  .vals = {
-    { .func = mrb_obj_equal_m },
-    { .func = mrb_bob_not },
-    { .func = mrb_obj_id_m },
-    { .func = mrb_f_send },
-    { .func = mrb_obj_equal_m },
-    { .func = mrb_do_nothing },
-    { .func = mrb_obj_instance_eval },
-    { .func = mrb_obj_missing },
-    { .func = mrb_do_nothing },
-    { .func = mrb_do_nothing },
-    { .func = mrb_do_nothing },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_OPSYM(eq),                       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(not),                      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__id__),                     MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__send__),                   MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(equal),                    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(initialize),                 MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(instance_eval),              MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(method_missing),             MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(singleton_method_added),     MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(singleton_method_removed),   MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(singleton_method_undefined), MRB_MT_FUNC|MRB_MT_PRIVATE),
-  }
-};
-static mrb_mt_tbl bob_rom_mt = {
-  BOB_ROM_MT_SIZE, BOB_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&bob_rom_data, NULL
+static mrb_mt_entry bob_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_obj_equal_m,    MRB_OPSYM(eq),                       MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_bob_not,        MRB_OPSYM(not),                      MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_obj_id_m,       MRB_SYM(__id__),                     MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_f_send,         MRB_SYM(__send__),                   MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_obj_equal_m,    MRB_SYM_Q(equal),                    MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_do_nothing,     MRB_SYM(initialize),                 MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_obj_instance_eval, MRB_SYM(instance_eval),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_obj_missing,    MRB_SYM(method_missing),             MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_do_nothing,     MRB_SYM(singleton_method_added),     MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_do_nothing,     MRB_SYM(singleton_method_removed),   MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_do_nothing,     MRB_SYM(singleton_method_undefined), MRB_MT_FUNC|MRB_MT_PRIVATE),
 };
+static mrb_mt_tbl bob_rom_mt = MRB_MT_ROM_TAB(bob_rom_entries);
 
-#define CLS_ROM_MT_SIZE 4
-static struct {
-  union mrb_mt_ptr vals[CLS_ROM_MT_SIZE];
-  mrb_sym keys[CLS_ROM_MT_SIZE];
-} cls_rom_data = {
-  .vals = {
-    { .func = mrb_instance_alloc },
-    { .func = mrb_do_nothing },
-    { .func = mrb_class_initialize },
-    { .func = mrb_class_superclass },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(allocate),   MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(inherited),  MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(superclass), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl cls_rom_mt = {
-  CLS_ROM_MT_SIZE, CLS_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&cls_rom_data, NULL
+static mrb_mt_entry cls_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_instance_alloc,    MRB_SYM(allocate),   MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_do_nothing,        MRB_SYM(inherited),  MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_class_initialize,  MRB_SYM(initialize), MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_class_superclass,  MRB_SYM(superclass), MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl cls_rom_mt = MRB_MT_ROM_TAB(cls_rom_entries);
 
-#define MOD_ROM_MT_SIZE 34
-static struct {
-  union mrb_mt_ptr vals[MOD_ROM_MT_SIZE];
-  mrb_sym keys[MOD_ROM_MT_SIZE];
-} mod_rom_data = {
-  .vals = {
-    { .func = mrb_mod_eqq },
-    { .func = mrb_mod_alias },
-    { .func = mrb_mod_ancestors },
-    { .func = mrb_mod_attr_accessor },
-    { .func = mrb_mod_attr_reader },
-    { .func = mrb_mod_attr_writer },
-    { .func = mrb_mod_module_eval },
-    { .func = mrb_do_nothing },
-    { .func = mrb_mod_const_defined },
-    { .func = mrb_mod_const_get },
-    { .func = mrb_mod_const_missing },
-    { .func = mrb_mod_const_set },
-    { .func = mod_define_method },
-    { .func = mrb_mod_dup },
-    { .func = mrb_do_nothing },
-    { .func = mrb_mod_include },
-    { .func = mrb_mod_include_p },
-    { .func = mrb_do_nothing },
-    { .func = mrb_mod_initialize },
-    { .func = mrb_mod_to_s },
-    { .func = mrb_do_nothing },
-    { .func = mrb_do_nothing },
-    { .func = mrb_mod_method_defined },
-    { .func = mrb_do_nothing },
-    { .func = mrb_mod_module_eval },
-    { .func = mrb_mod_module_function },
-    { .func = mrb_mod_prepend },
-    { .func = mrb_do_nothing },
-    { .func = mrb_mod_private },
-    { .func = mrb_mod_protected },
-    { .func = mrb_mod_public },
-    { .func = mrb_mod_remove_const },
-    { .func = mrb_mod_to_s },
-    { .func = mrb_mod_undef },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_OPSYM(eqq),              MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(alias_method),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(ancestors),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(attr_accessor),      MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(attr_reader),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(attr_writer),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(class_eval),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(const_added),        MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM_Q(const_defined),    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(const_get),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(const_missing),      MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(const_set),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(define_method),      MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(dup),               MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(extended),           MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(include),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(include),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(included),           MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(initialize),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(inspect),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(method_added),       MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(method_removed),     MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM_Q(method_defined),   MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(method_undefined),   MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(module_eval),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(module_function),    MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(prepend),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(prepended),          MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(private),            MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(protected),          MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(public),             MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(remove_const),       MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(to_s),              MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(undef_method),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl mod_rom_mt = {
-  MOD_ROM_MT_SIZE, MOD_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&mod_rom_data, NULL
+static mrb_mt_entry mod_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_mod_eqq,            MRB_OPSYM(eqq),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_alias,          MRB_SYM(alias_method),     MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_ancestors,      MRB_SYM(ancestors),        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_mod_attr_accessor,  MRB_SYM(attr_accessor),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_attr_reader,    MRB_SYM(attr_reader),      MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_attr_writer,    MRB_SYM(attr_writer),      MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_module_eval,    MRB_SYM(class_eval),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_do_nothing,         MRB_SYM(const_added),      MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_mod_const_defined,  MRB_SYM_Q(const_defined),  MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_const_get,      MRB_SYM(const_get),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_const_missing,  MRB_SYM(const_missing),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_const_set,      MRB_SYM(const_set),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(mod_define_method,      MRB_SYM(define_method),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_dup,            MRB_SYM(dup),              MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_do_nothing,         MRB_SYM(extended),         MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_mod_include,        MRB_SYM(include),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_include_p,      MRB_SYM_Q(include),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_do_nothing,         MRB_SYM(included),         MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_mod_initialize,     MRB_SYM(initialize),       MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_mod_to_s,           MRB_SYM(inspect),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_do_nothing,         MRB_SYM(method_added),     MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_do_nothing,         MRB_SYM(method_removed),   MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_mod_method_defined, MRB_SYM_Q(method_defined), MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_do_nothing,         MRB_SYM(method_undefined), MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_mod_module_eval,    MRB_SYM(module_eval),      MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_mod_module_function, MRB_SYM(module_function), MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_mod_prepend,        MRB_SYM(prepend),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_do_nothing,         MRB_SYM(prepended),        MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_mod_private,        MRB_SYM(private),          MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_mod_protected,      MRB_SYM(protected),        MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_mod_public,         MRB_SYM(public),           MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_mod_remove_const,   MRB_SYM(remove_const),     MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_mod_to_s,           MRB_SYM(to_s),             MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_mod_undef,          MRB_SYM(undef_method),     MRB_MT_FUNC),
 };
+static mrb_mt_tbl mod_rom_mt = MRB_MT_ROM_TAB(mod_rom_entries);
 
 void
 mrb_init_class(mrb_state *mrb)
diff --git a/src/error.c b/src/error.c
index 88e07c8a1..81b67642c 100644
--- a/src/error.c
+++ b/src/error.c
@@ -892,34 +892,16 @@ mrb_check_error(mrb_state *mrb)
 }
 
 /* ---------------------------*/
-#define EXCEPTION_ROM_MT_SIZE 7
-static struct {
-  union mrb_mt_ptr vals[EXCEPTION_ROM_MT_SIZE];
-  mrb_sym keys[EXCEPTION_ROM_MT_SIZE];
-} exception_rom_data = {
-  .vals = {
-    { .func = exc_exception },
-    { .func = exc_initialize },
-    { .func = exc_to_s },
-    { .func = exc_to_s },
-    { .func = mrb_exc_inspect },
-    { .func = mrb_exc_backtrace },
-    { .func = exc_set_backtrace },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(exception),      MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(initialize),     MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(to_s),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(message),        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(inspect),        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(backtrace),      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(set_backtrace),  MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl exception_rom_mt = {
-  EXCEPTION_ROM_MT_SIZE, EXCEPTION_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&exception_rom_data, NULL
+static mrb_mt_entry exception_rom_entries[] = {
+  MRB_MT_ENTRY(exc_exception,     MRB_SYM(exception),      MRB_MT_FUNC),
+  MRB_MT_ENTRY(exc_initialize,    MRB_SYM(initialize),     MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(exc_to_s,          MRB_SYM(to_s),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(exc_to_s,          MRB_SYM(message),        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_exc_inspect,   MRB_SYM(inspect),        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_exc_backtrace, MRB_SYM(backtrace),      MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(exc_set_backtrace, MRB_SYM(set_backtrace),  MRB_MT_FUNC),
 };
+static mrb_mt_tbl exception_rom_mt = MRB_MT_ROM_TAB(exception_rom_entries);
 
 void
 mrb_init_exception(mrb_state *mrb)
diff --git a/src/hash.c b/src/hash.c
index fb57f55a2..fd3a588b7 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -2303,92 +2303,45 @@ mrb_hash_eql(mrb_state *mrb, mrb_value hash)
 }
 
 /* ---------------------------*/
-#define HASH_ROM_MT_SIZE 36
-static struct {
-  union mrb_mt_ptr vals[HASH_ROM_MT_SIZE];
-  mrb_sym keys[HASH_ROM_MT_SIZE];
-} hash_rom_data = {
-  .vals = {
-    { .func = mrb_hash_equal },
-    { .func = mrb_hash_aget },
-    { .func = mrb_hash_aset },
-    { .func = mrb_hash_clear },
-    { .func = mrb_hash_default },
-    { .func = mrb_hash_set_default },
-    { .func = mrb_hash_default_proc },
-    { .func = mrb_hash_set_default_proc },
-    { .func = mrb_hash_delete },
-    { .func = mrb_hash_eql },
-    { .func = mrb_hash_empty_m },
-    { .func = mrb_hash_has_key },
-    { .func = mrb_hash_has_value },
-    { .func = mrb_hash_has_key },
-    { .func = mrb_hash_init },
-    { .func = mrb_hash_init_copy },
-    { .func = mrb_hash_has_key },
-    { .func = mrb_hash_keys },
-    { .func = mrb_hash_size_m },
-    { .func = mrb_hash_has_key },
-    { .func = mrb_hash_init_copy },
-    { .func = mrb_hash_shift },
-    { .func = mrb_hash_size_m },
-    { .func = mrb_hash_aset },
-    { .func = mrb_hash_has_value },
-    { .func = mrb_hash_values },
-    { .func = mrb_hash_to_s },
-    { .func = mrb_hash_to_s },
-    { .func = mrb_hash_rehash },
-    { .func = mrb_hash_to_hash },
-    { .func = mrb_hash_assoc },
-    { .func = mrb_hash_rassoc },
-    { .func = mrb_hash_merge_m },
-    { .func = mrb_hash_compact },
-    { .func = mrb_hash_pat_values },
-    { .func = mrb_hash_except_keys },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_OPSYM(eq),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(aref),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(aset),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(clear),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(default),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_E(default),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(default_proc),    MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_E(default_proc),  MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__delete),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(eql),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(empty),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(has_key),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(has_value),     MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(include),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(initialize),      MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM_Q(key),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(keys),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(length),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(member),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(replace),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(shift),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(size),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(store),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(value),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(values),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_s),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(inspect),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(rehash),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_hash),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(assoc),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(rassoc),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__merge),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__compact),       MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__pat_values),    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__except),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl hash_rom_mt = {
-  HASH_ROM_MT_SIZE, HASH_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&hash_rom_data, NULL
+static mrb_mt_entry hash_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_hash_equal,           MRB_OPSYM(eq),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_hash_aget,            MRB_OPSYM(aref),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_hash_aset,            MRB_OPSYM(aset),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_hash_clear,           MRB_SYM(clear),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_hash_default,         MRB_SYM(default),         MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_hash_set_default,     MRB_SYM_E(default),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_hash_default_proc,    MRB_SYM(default_proc),    MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_hash_set_default_proc, MRB_SYM_E(default_proc), MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_hash_delete,          MRB_SYM(__delete),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_hash_eql,             MRB_SYM_Q(eql),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_hash_empty_m,         MRB_SYM_Q(empty),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_hash_has_key,         MRB_SYM_Q(has_key),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_hash_has_value,       MRB_SYM_Q(has_value),     MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_hash_has_key,         MRB_SYM_Q(include),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_hash_init,            MRB_SYM(initialize),      MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_hash_init_copy,       MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_hash_has_key,         MRB_SYM_Q(key),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_hash_keys,            MRB_SYM(keys),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_hash_size_m,          MRB_SYM(length),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_hash_has_key,         MRB_SYM_Q(member),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_hash_init_copy,       MRB_SYM(replace),         MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_hash_shift,           MRB_SYM(shift),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_hash_size_m,          MRB_SYM(size),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_hash_aset,            MRB_SYM(store),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_hash_has_value,       MRB_SYM_Q(value),         MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_hash_values,          MRB_SYM(values),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_hash_to_s,            MRB_SYM(to_s),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_hash_to_s,            MRB_SYM(inspect),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_hash_rehash,          MRB_SYM(rehash),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_hash_to_hash,         MRB_SYM(to_hash),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_hash_assoc,           MRB_SYM(assoc),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_hash_rassoc,          MRB_SYM(rassoc),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_hash_merge_m,         MRB_SYM(__merge),         MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_hash_compact,         MRB_SYM(__compact),       MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_hash_pat_values,      MRB_SYM(__pat_values),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_hash_except_keys,     MRB_SYM(__except),        MRB_MT_FUNC),
 };
+static mrb_mt_tbl hash_rom_mt = MRB_MT_ROM_TAB(hash_rom_entries);
 
 void
 mrb_init_hash(mrb_state *mrb)
diff --git a/src/kernel.c b/src/kernel.c
index 612abc16a..45986b00e 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -666,74 +666,36 @@ mrb_p_m(mrb_state *mrb, mrb_value self)
 #endif
 
 /* ---------------------------*/
-#define KERNEL_ROM_MT_SIZE 27
-static struct {
-  union mrb_mt_ptr vals[KERNEL_ROM_MT_SIZE];
-  mrb_sym keys[KERNEL_ROM_MT_SIZE];
-} kernel_rom_data = {
-  .vals = {
-    { .func = mrb_eqq_m },
-    { .func = mrb_cmp_m },
-    { .func = mrb_f_block_given_p_m },
-    { .func = mrb_obj_class_m },
-    { .func = mrb_obj_clone },
-    { .func = mrb_obj_dup },
-    { .func = mrb_obj_equal_m },
-    { .func = mrb_obj_freeze },
-    { .func = mrb_obj_frozen },
-    { .func = mrb_obj_extend },
-    { .func = mrb_obj_hash },
-    { .func = mrb_obj_init_copy },
-    { .func = mrb_obj_inspect },
-    { .func = obj_is_instance_of },
-    { .func = mrb_obj_is_kind_of_m },
-    { .func = mrb_f_block_given_p_m },
-    { .func = mrb_obj_is_kind_of_m },
-    { .func = mrb_false },
-    { .func = mrb_obj_id_m },
-    { .func = mrb_f_raise },
-    { .func = mrb_obj_remove_instance_variable },
-    { .func = obj_respond_to },
-    { .func = mrb_any_to_s },
-    { .func = mrb_obj_ceqq },
-    { .func = mrb_ensure_int_type },
-    { .func = mrb_false },
-    { .func = mrb_obj_method_recursive_p },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_OPSYM(eqq),                      MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(cmp),                       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(block_given),               MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(class),                        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(clone),                        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(dup),                          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(eql),                        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(freeze),                       MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(frozen),                     MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(extend),                       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(hash),                         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(initialize_copy),              MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(inspect),                      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(instance_of),                MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(is_a),                       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(iterator),                   MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM_Q(kind_of),                    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(nil),                        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(object_id),                    MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(raise),                        MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(remove_instance_variable),     MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(respond_to),                 MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_s),                         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__case_eqq),                   MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__to_int),                     MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(respond_to_missing),         MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM_Q(__method_recursive),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl kernel_rom_mt = {
-  KERNEL_ROM_MT_SIZE, KERNEL_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&kernel_rom_data, NULL
+static mrb_mt_entry kernel_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_eqq_m,                        MRB_OPSYM(eqq),                      MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_cmp_m,                        MRB_OPSYM(cmp),                       MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_f_block_given_p_m,            MRB_SYM_Q(block_given),               MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_obj_class_m,                  MRB_SYM(class),                        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_obj_clone,                    MRB_SYM(clone),                        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_obj_dup,                      MRB_SYM(dup),                          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_obj_equal_m,                  MRB_SYM_Q(eql),                        MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_obj_freeze,                   MRB_SYM(freeze),                       MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_obj_frozen,                   MRB_SYM_Q(frozen),                     MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_obj_extend,                   MRB_SYM(extend),                       MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_obj_hash,                     MRB_SYM(hash),                         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_obj_init_copy,                MRB_SYM(initialize_copy),              MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_obj_inspect,                  MRB_SYM(inspect),                      MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(obj_is_instance_of,               MRB_SYM_Q(instance_of),                MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_obj_is_kind_of_m,             MRB_SYM_Q(is_a),                       MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_f_block_given_p_m,            MRB_SYM_Q(iterator),                   MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_obj_is_kind_of_m,             MRB_SYM_Q(kind_of),                    MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_false,                        MRB_SYM_Q(nil),                        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_obj_id_m,                     MRB_SYM(object_id),                    MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_f_raise,                      MRB_SYM(raise),                        MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_obj_remove_instance_variable, MRB_SYM(remove_instance_variable),     MRB_MT_FUNC),
+  MRB_MT_ENTRY(obj_respond_to,                   MRB_SYM_Q(respond_to),                 MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_any_to_s,                     MRB_SYM(to_s),                         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_obj_ceqq,                     MRB_SYM(__case_eqq),                   MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_ensure_int_type,              MRB_SYM(__to_int),                     MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_false,                        MRB_SYM_Q(respond_to_missing),         MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_obj_method_recursive_p,       MRB_SYM_Q(__method_recursive),         MRB_MT_FUNC),
 };
+static mrb_mt_tbl kernel_rom_mt = MRB_MT_ROM_TAB(kernel_rom_entries);
 
 void
 mrb_init_kernel(mrb_state *mrb)
diff --git a/src/numeric.c b/src/numeric.c
index 7f6cb7451..b7034d9b4 100644
--- a/src/numeric.c
+++ b/src/numeric.c
@@ -2299,177 +2299,81 @@ flo_hash(mrb_state *mrb, mrb_value flo)
 #endif
 
 /* ------------------------------------------------------------------------*/
-#define NUMERIC_ROM_MT_SIZE 3
-static struct {
-  union mrb_mt_ptr vals[NUMERIC_ROM_MT_SIZE];
-  mrb_sym keys[NUMERIC_ROM_MT_SIZE];
-} numeric_rom_data = {
-  .vals = {
-    { .func = num_finite_p },
-    { .func = num_infinite_p },
-    { .func = num_eql },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM_Q(finite),   MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(infinite), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(eql),      MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl numeric_rom_mt = {
-  NUMERIC_ROM_MT_SIZE, NUMERIC_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&numeric_rom_data, NULL
+static mrb_mt_entry numeric_rom_entries[] = {
+  MRB_MT_ENTRY(num_finite_p,   MRB_SYM_Q(finite),   MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(num_infinite_p, MRB_SYM_Q(infinite), MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(num_eql,        MRB_SYM_Q(eql),      MRB_MT_FUNC),
 };
+static mrb_mt_tbl numeric_rom_mt = MRB_MT_ROM_TAB(numeric_rom_entries);
 
-#define INTEGER_ROM_MT_SIZE 31
-static struct {
-  union mrb_mt_ptr vals[INTEGER_ROM_MT_SIZE];
-  mrb_sym keys[INTEGER_ROM_MT_SIZE];
-} integer_rom_data = {
-  .vals = {
-    { .func = int_pow },
-    { .func = num_cmp },
-    { .func = num_lt },
-    { .func = num_le },
-    { .func = num_gt },
-    { .func = num_ge },
-    { .func = mrb_obj_itself },
-    { .func = mrb_obj_itself },
-    { .func = int_add },
-    { .func = int_sub },
-    { .func = int_mul },
-    { .func = int_mod },
-    { .func = int_div },
-    { .func = int_quo },
-    { .func = int_idiv },
-    { .func = int_equal },
-    { .func = int_rev },
-    { .func = int_and },
-    { .func = int_or },
-    { .func = int_xor },
-    { .func = int_lshift },
-    { .func = int_rshift },
-    { .func = int_ceil },
-    { .func = int_floor },
-    { .func = int_round },
-    { .func = int_truncate },
-    { .func = int_hash },
-    { .func = int_to_s },
-    { .func = int_to_s },
-    { .func = int_divmod },
-    { .func = coerce_step_counter },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_OPSYM(pow),                  MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(cmp),                  MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(lt),                   MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(le),                   MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(gt),                   MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(ge),                   MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_i),                   MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_int),                 MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(add),                  MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(sub),                  MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(mul),                  MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(mod),                  MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(div),                  MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(quo),                    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(div),                    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(eq),                   MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(neg),                  MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(and),                  MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(or),                   MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(xor),                  MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(lshift),               MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(rshift),               MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(ceil),                   MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(floor),                  MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(round),                  MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(truncate),               MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(hash),                   MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_s),                   MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(inspect),                MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(divmod),                 MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__coerce_step_counter),  MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl integer_rom_mt = {
-  INTEGER_ROM_MT_SIZE, INTEGER_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&integer_rom_data, NULL
+static mrb_mt_entry integer_rom_entries[] = {
+  MRB_MT_ENTRY(int_pow,              MRB_OPSYM(pow),                  MRB_MT_FUNC),
+  MRB_MT_ENTRY(num_cmp,              MRB_OPSYM(cmp),                  MRB_MT_FUNC),
+  MRB_MT_ENTRY(num_lt,               MRB_OPSYM(lt),                   MRB_MT_FUNC),
+  MRB_MT_ENTRY(num_le,               MRB_OPSYM(le),                   MRB_MT_FUNC),
+  MRB_MT_ENTRY(num_gt,               MRB_OPSYM(gt),                   MRB_MT_FUNC),
+  MRB_MT_ENTRY(num_ge,               MRB_OPSYM(ge),                   MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_obj_itself,       MRB_SYM(to_i),                   MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_obj_itself,       MRB_SYM(to_int),                 MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(int_add,              MRB_OPSYM(add),                  MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_sub,              MRB_OPSYM(sub),                  MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_mul,              MRB_OPSYM(mul),                  MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_mod,              MRB_OPSYM(mod),                  MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_div,              MRB_OPSYM(div),                  MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_quo,              MRB_SYM(quo),                    MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_idiv,             MRB_SYM(div),                    MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_equal,            MRB_OPSYM(eq),                   MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_rev,              MRB_OPSYM(neg),                  MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(int_and,              MRB_OPSYM(and),                  MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_or,               MRB_OPSYM(or),                   MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_xor,              MRB_OPSYM(xor),                  MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_lshift,           MRB_OPSYM(lshift),               MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_rshift,           MRB_OPSYM(rshift),               MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_ceil,             MRB_SYM(ceil),                   MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_floor,            MRB_SYM(floor),                  MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_round,            MRB_SYM(round),                  MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_truncate,         MRB_SYM(truncate),               MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_hash,             MRB_SYM(hash),                   MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(int_to_s,             MRB_SYM(to_s),                   MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_to_s,             MRB_SYM(inspect),                MRB_MT_FUNC),
+  MRB_MT_ENTRY(int_divmod,           MRB_SYM(divmod),                 MRB_MT_FUNC),
+  MRB_MT_ENTRY(coerce_step_counter,  MRB_SYM(__coerce_step_counter),  MRB_MT_FUNC),
 };
+static mrb_mt_tbl integer_rom_mt = MRB_MT_ROM_TAB(integer_rom_entries);
 
 #ifndef MRB_NO_FLOAT
-#define FLOAT_ROM_MT_SIZE 29
-static struct {
-  union mrb_mt_ptr vals[FLOAT_ROM_MT_SIZE];
-  mrb_sym keys[FLOAT_ROM_MT_SIZE];
-} float_rom_data = {
-  .vals = {
-    { .func = flo_pow },
-    { .func = flo_div },
-    { .func = flo_div },
-    { .func = flo_div },
-    { .func = flo_idiv },
-    { .func = flo_add },
-    { .func = flo_sub },
-    { .func = flo_mul },
-    { .func = flo_mod },
-    { .func = num_cmp },
-    { .func = num_lt },
-    { .func = num_le },
-    { .func = num_gt },
-    { .func = num_ge },
-    { .func = flo_eq },
-    { .func = flo_ceil },
-    { .func = flo_finite_p },
-    { .func = flo_floor },
-    { .func = flo_infinite_p },
-    { .func = flo_round },
-    { .func = mrb_obj_itself },
-    { .func = flo_to_i },
-    { .func = flo_truncate },
-    { .func = flo_divmod },
-    { .func = flo_to_s },
-    { .func = flo_to_s },
-    { .func = flo_nan_p },
-    { .func = flo_abs },
-    { .func = flo_hash },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_OPSYM(pow),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(div),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(quo),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(fdiv),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(div),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(add),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(sub),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(mul),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(mod),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(cmp),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(lt),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(le),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(gt),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(ge),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(eq),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(ceil),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(finite),    MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(floor),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(infinite),  MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(round),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_f),        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_i),        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(truncate),    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(divmod),      MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_s),        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(inspect),     MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(nan),       MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(abs),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(hash),        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl float_rom_mt = {
-  FLOAT_ROM_MT_SIZE, FLOAT_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&float_rom_data, NULL
+static mrb_mt_entry float_rom_entries[] = {
+  MRB_MT_ENTRY(flo_pow,        MRB_OPSYM(pow),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(flo_div,        MRB_OPSYM(div),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(flo_div,        MRB_SYM(quo),         MRB_MT_FUNC),
+  MRB_MT_ENTRY(flo_div,        MRB_SYM(fdiv),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(flo_idiv,       MRB_SYM(div),         MRB_MT_FUNC),
+  MRB_MT_ENTRY(flo_add,        MRB_OPSYM(add),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(flo_sub,        MRB_OPSYM(sub),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(flo_mul,        MRB_OPSYM(mul),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(flo_mod,        MRB_OPSYM(mod),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(num_cmp,        MRB_OPSYM(cmp),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(num_lt,         MRB_OPSYM(lt),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(num_le,         MRB_OPSYM(le),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(num_gt,         MRB_OPSYM(gt),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(num_ge,         MRB_OPSYM(ge),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(flo_eq,         MRB_OPSYM(eq),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(flo_ceil,       MRB_SYM(ceil),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(flo_finite_p,   MRB_SYM_Q(finite),    MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(flo_floor,      MRB_SYM(floor),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(flo_infinite_p, MRB_SYM_Q(infinite),  MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(flo_round,      MRB_SYM(round),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_obj_itself, MRB_SYM(to_f),        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(flo_to_i,       MRB_SYM(to_i),        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(flo_truncate,   MRB_SYM(truncate),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(flo_divmod,     MRB_SYM(divmod),      MRB_MT_FUNC),
+  MRB_MT_ENTRY(flo_to_s,       MRB_SYM(to_s),        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(flo_to_s,       MRB_SYM(inspect),     MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(flo_nan_p,      MRB_SYM_Q(nan),       MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(flo_abs,        MRB_SYM(abs),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(flo_hash,       MRB_SYM(hash),        MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl float_rom_mt = MRB_MT_ROM_TAB(float_rom_entries);
 #endif /* !MRB_NO_FLOAT */
 
 void
diff --git a/src/object.c b/src/object.c
index d1ac52bdc..92c18c9c7 100644
--- a/src/object.c
+++ b/src/object.c
@@ -322,82 +322,33 @@ false_to_s(mrb_state *mrb, mrb_value obj)
 }
 
 /* ---------------------------*/
-#define NIL_ROM_MT_SIZE 6
-static struct {
-  union mrb_mt_ptr vals[NIL_ROM_MT_SIZE];
-  mrb_sym keys[NIL_ROM_MT_SIZE];
-} nil_rom_data = {
-  .vals = {
-    { .func = false_and },
-    { .func = false_or },
-    { .func = false_xor },
-    { .func = mrb_true },
-    { .func = nil_to_s },
-    { .func = nil_inspect },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_OPSYM(and),    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(or),     MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(xor),    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(nil),    MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_s),     MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(inspect),  MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl nil_rom_mt = {
-  NIL_ROM_MT_SIZE, NIL_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&nil_rom_data, NULL
+static mrb_mt_entry nil_rom_entries[] = {
+  MRB_MT_ENTRY(false_and,   MRB_OPSYM(and),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(false_or,    MRB_OPSYM(or),     MRB_MT_FUNC),
+  MRB_MT_ENTRY(false_xor,   MRB_OPSYM(xor),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_true,    MRB_SYM_Q(nil),    MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(nil_to_s,    MRB_SYM(to_s),     MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(nil_inspect, MRB_SYM(inspect),  MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl nil_rom_mt = MRB_MT_ROM_TAB(nil_rom_entries);
 
-#define TRUE_ROM_MT_SIZE 5
-static struct {
-  union mrb_mt_ptr vals[TRUE_ROM_MT_SIZE];
-  mrb_sym keys[TRUE_ROM_MT_SIZE];
-} true_rom_data = {
-  .vals = {
-    { .func = true_and },
-    { .func = true_or },
-    { .func = true_xor },
-    { .func = true_to_s },
-    { .func = true_to_s },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_OPSYM(and),    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(or),     MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(xor),    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_s),     MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(inspect),  MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl true_rom_mt = {
-  TRUE_ROM_MT_SIZE, TRUE_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&true_rom_data, NULL
+static mrb_mt_entry true_rom_entries[] = {
+  MRB_MT_ENTRY(true_and,  MRB_OPSYM(and),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(true_or,   MRB_OPSYM(or),     MRB_MT_FUNC),
+  MRB_MT_ENTRY(true_xor,  MRB_OPSYM(xor),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(true_to_s, MRB_SYM(to_s),     MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(true_to_s, MRB_SYM(inspect),  MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl true_rom_mt = MRB_MT_ROM_TAB(true_rom_entries);
 
-#define FALSE_ROM_MT_SIZE 5
-static struct {
-  union mrb_mt_ptr vals[FALSE_ROM_MT_SIZE];
-  mrb_sym keys[FALSE_ROM_MT_SIZE];
-} false_rom_data = {
-  .vals = {
-    { .func = false_and },
-    { .func = false_or },
-    { .func = false_xor },
-    { .func = false_to_s },
-    { .func = false_to_s },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_OPSYM(and),    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(or),     MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(xor),    MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_s),     MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(inspect),  MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl false_rom_mt = {
-  FALSE_ROM_MT_SIZE, FALSE_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&false_rom_data, NULL
+static mrb_mt_entry false_rom_entries[] = {
+  MRB_MT_ENTRY(false_and,  MRB_OPSYM(and),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(false_or,   MRB_OPSYM(or),     MRB_MT_FUNC),
+  MRB_MT_ENTRY(false_xor,  MRB_OPSYM(xor),    MRB_MT_FUNC),
+  MRB_MT_ENTRY(false_to_s, MRB_SYM(to_s),     MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(false_to_s, MRB_SYM(inspect),  MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl false_rom_mt = MRB_MT_ROM_TAB(false_rom_entries);
 
 void
 mrb_init_object(mrb_state *mrb)
diff --git a/src/proc.c b/src/proc.c
index 66afb69be..9f3587fdf 100644
--- a/src/proc.c
+++ b/src/proc.c
@@ -545,30 +545,14 @@ mrb_proc_merge_lvar(mrb_state *mrb, mrb_irep *irep, struct REnv *env, int num, c
 }
 
 /* ---------------------------*/
-#define PROC_ROM_MT_SIZE 5
-static struct {
-  union mrb_mt_ptr vals[PROC_ROM_MT_SIZE];
-  mrb_sym keys[PROC_ROM_MT_SIZE];
-} proc_rom_data = {
-  .vals = {
-    { .func = mrb_proc_init_copy },
-    { .func = proc_arity },
-    { .func = proc_eql },
-    { .func = proc_eql },
-    { .func = proc_hash },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(arity),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(eq),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(eql),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(hash),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl proc_rom_mt = {
-  PROC_ROM_MT_SIZE, PROC_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&proc_rom_data, NULL
+static mrb_mt_entry proc_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_proc_init_copy, MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(proc_arity,         MRB_SYM(arity),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(proc_eql,           MRB_OPSYM(eq),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(proc_eql,           MRB_SYM_Q(eql),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(proc_hash,          MRB_SYM(hash),            MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl proc_rom_mt = MRB_MT_ROM_TAB(proc_rom_entries);
 
 void
 mrb_init_proc(mrb_state *mrb)
diff --git a/src/range.c b/src/range.c
index d86a34112..20b365072 100644
--- a/src/range.c
+++ b/src/range.c
@@ -566,50 +566,24 @@ mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp,
 }
 
 /* ---------------------------*/
-#define RANGE_ROM_MT_SIZE 15
-static struct {
-  union mrb_mt_ptr vals[RANGE_ROM_MT_SIZE];
-  mrb_sym keys[RANGE_ROM_MT_SIZE];
-} range_rom_data = {
-  .vals = {
-    { .func = range_beg },
-    { .func = range_end },
-    { .func = range_eq },
-    { .func = range_include },
-    { .func = range_excl },
-    { .func = range_beg },
-    { .func = range_include },
-    { .func = range_initialize },
-    { .func = range_end },
-    { .func = range_include },
-    { .func = range_to_s },
-    { .func = range_inspect },
-    { .func = range_eql },
-    { .func = range_initialize_copy },
-    { .func = range_num_to_a },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(begin),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(end),             MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(eq),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(eqq),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(exclude_end),   MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(first),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(include),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(initialize),      MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(last),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(member),        MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_s),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(inspect),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(eql),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(__num_to_a),      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl range_rom_mt = {
-  RANGE_ROM_MT_SIZE, RANGE_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&range_rom_data, NULL
+static mrb_mt_entry range_rom_entries[] = {
+  MRB_MT_ENTRY(range_beg,             MRB_SYM(begin),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(range_end,             MRB_SYM(end),             MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(range_eq,              MRB_OPSYM(eq),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(range_include,         MRB_OPSYM(eqq),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(range_excl,            MRB_SYM_Q(exclude_end),   MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(range_beg,             MRB_SYM(first),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(range_include,         MRB_SYM_Q(include),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(range_initialize,      MRB_SYM(initialize),      MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(range_end,             MRB_SYM(last),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(range_include,         MRB_SYM_Q(member),        MRB_MT_FUNC),
+  MRB_MT_ENTRY(range_to_s,            MRB_SYM(to_s),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(range_inspect,         MRB_SYM(inspect),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(range_eql,             MRB_SYM_Q(eql),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(range_initialize_copy, MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(range_num_to_a,        MRB_SYM(__num_to_a),      MRB_MT_FUNC|MRB_MT_NOARG),
 };
+static mrb_mt_tbl range_rom_mt = MRB_MT_ROM_TAB(range_rom_entries);
 
 void
 mrb_init_range(mrb_state *mrb)
diff --git a/src/string.c b/src/string.c
index 41b434ed2..817dda8b7 100644
--- a/src/string.c
+++ b/src/string.c
@@ -3508,112 +3508,55 @@ mrb_encoding(mrb_state *mrb, mrb_value self)
 }
 
 /* ---------------------------*/
-#define STRING_ROM_MT_SIZE 46
-static struct {
-  union mrb_mt_ptr vals[STRING_ROM_MT_SIZE];
-  mrb_sym keys[STRING_ROM_MT_SIZE];
-} string_rom_data = {
-  .vals = {
-    { .func = mrb_str_bytesize },
-    { .func = mrb_str_cmp_m },
-    { .func = mrb_str_equal_m },
-    { .func = mrb_str_plus_m },
-    { .func = mrb_str_times },
-    { .func = mrb_str_aref_m },
-    { .func = mrb_str_aset_m },
-    { .func = mrb_str_capitalize },
-    { .func = mrb_str_capitalize_bang },
-    { .func = mrb_str_chomp },
-    { .func = mrb_str_chomp_bang },
-    { .func = mrb_str_chop },
-    { .func = mrb_str_chop_bang },
-    { .func = mrb_str_downcase },
-    { .func = mrb_str_downcase_bang },
-    { .func = mrb_str_empty_p },
-    { .func = mrb_str_eql },
-    { .func = mrb_str_hash_m },
-    { .func = mrb_str_include },
-    { .func = mrb_str_index_m },
-    { .func = mrb_str_init },
-    { .func = mrb_str_replace },
-    { .func = mrb_str_intern },
-    { .func = mrb_str_size },
-    { .func = mrb_str_replace },
-    { .func = mrb_str_reverse },
-    { .func = mrb_str_reverse_bang },
-    { .func = mrb_str_rindex_m },
-    { .func = mrb_str_size },
-    { .func = mrb_str_aref_m },
-    { .func = mrb_str_split_m },
-    { .func = mrb_str_to_i },
-    { .func = mrb_str_to_s },
-    { .func = mrb_str_to_s },
-    { .func = mrb_str_intern },
-    { .func = mrb_str_upcase },
-    { .func = mrb_str_upcase_bang },
-    { .func = mrb_str_inspect },
-    { .func = mrb_str_bytes },
-    { .func = mrb_str_getbyte },
-    { .func = mrb_str_setbyte },
-    { .func = mrb_str_byteindex_m },
-    { .func = mrb_str_byterindex_m },
-    { .func = mrb_str_byteslice },
-    { .func = mrb_str_bytesplice },
-    { .func = sub_replace },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(bytesize),        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(cmp),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(eq),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(add),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(mul),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(aref),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(aset),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(capitalize),      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(capitalize),    MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(chomp),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(chomp),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(chop),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(chop),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(downcase),        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(downcase),      MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(empty),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(eql),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(hash),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_Q(include),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(index),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(initialize),      MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
-    MRB_MT_KEY(MRB_SYM(intern),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(length),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(replace),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(reverse),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(reverse),       MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(rindex),          MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(size),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(slice),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(split),           MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_i),            MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_s),            MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_str),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_sym),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(upcase),          MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM_B(upcase),        MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(inspect),         MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(bytes),           MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(getbyte),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(setbyte),         MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(byteindex),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(byterindex),      MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(byteslice),       MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(bytesplice),      MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(__sub_replace),   MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl string_rom_mt = {
-  STRING_ROM_MT_SIZE, STRING_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&string_rom_data, NULL
+static mrb_mt_entry string_rom_entries[] = {
+  MRB_MT_ENTRY(mrb_str_bytesize,       MRB_SYM(bytesize),        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_cmp_m,          MRB_OPSYM(cmp),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_str_equal_m,        MRB_OPSYM(eq),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_str_plus_m,         MRB_OPSYM(add),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_str_times,          MRB_OPSYM(mul),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_str_aref_m,         MRB_OPSYM(aref),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_str_aset_m,         MRB_OPSYM(aset),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_str_capitalize,     MRB_SYM(capitalize),      MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_capitalize_bang, MRB_SYM_B(capitalize),   MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_chomp,          MRB_SYM(chomp),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_str_chomp_bang,     MRB_SYM_B(chomp),         MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_str_chop,           MRB_SYM(chop),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_chop_bang,      MRB_SYM_B(chop),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_downcase,       MRB_SYM(downcase),        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_downcase_bang,  MRB_SYM_B(downcase),      MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_empty_p,        MRB_SYM_Q(empty),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_eql,            MRB_SYM_Q(eql),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_str_hash_m,         MRB_SYM(hash),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_include,        MRB_SYM_Q(include),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_str_index_m,        MRB_SYM(index),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_str_init,           MRB_SYM(initialize),      MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_str_replace,        MRB_SYM(initialize_copy), MRB_MT_FUNC|MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_str_intern,         MRB_SYM(intern),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_size,           MRB_SYM(length),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_replace,        MRB_SYM(replace),         MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_str_reverse,        MRB_SYM(reverse),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_reverse_bang,   MRB_SYM_B(reverse),       MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_rindex_m,       MRB_SYM(rindex),          MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_str_size,           MRB_SYM(size),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_aref_m,         MRB_SYM(slice),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_str_split_m,        MRB_SYM(split),           MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_str_to_i,           MRB_SYM(to_i),            MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_str_to_s,           MRB_SYM(to_s),            MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_to_s,           MRB_SYM(to_str),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_intern,         MRB_SYM(to_sym),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_upcase,         MRB_SYM(upcase),          MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_upcase_bang,    MRB_SYM_B(upcase),        MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_inspect,        MRB_SYM(inspect),         MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_bytes,          MRB_SYM(bytes),           MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_str_getbyte,        MRB_SYM(getbyte),         MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_str_setbyte,        MRB_SYM(setbyte),         MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_str_byteindex_m,    MRB_SYM(byteindex),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_str_byterindex_m,   MRB_SYM(byterindex),      MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_str_byteslice,      MRB_SYM(byteslice),       MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_str_bytesplice,     MRB_SYM(bytesplice),      MRB_MT_FUNC),
+  MRB_MT_ENTRY(sub_replace,            MRB_SYM(__sub_replace),   MRB_MT_FUNC),
 };
+static mrb_mt_tbl string_rom_mt = MRB_MT_ROM_TAB(string_rom_entries);
 
 void
 mrb_init_string(mrb_state *mrb)
diff --git a/src/symbol.c b/src/symbol.c
index 763e37869..e3e1a978a 100644
--- a/src/symbol.c
+++ b/src/symbol.c
@@ -1001,32 +1001,15 @@ sym_cmp(mrb_state *mrb, mrb_value s1)
 #undef lesser
 
 /* ---------------------------*/
-#define SYMBOL_ROM_MT_SIZE 6
-static struct {
-  union mrb_mt_ptr vals[SYMBOL_ROM_MT_SIZE];
-  mrb_sym keys[SYMBOL_ROM_MT_SIZE];
-} symbol_rom_data = {
-  .vals = {
-    { .func = sym_to_s },
-    { .func = sym_name },
-    { .func = mrb_obj_itself },
-    { .func = sym_inspect },
-    { .func = sym_cmp },
-    { .func = mrb_obj_equal_m },
-  },
-  .keys = {
-    MRB_MT_KEY(MRB_SYM(to_s),    MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(name),    MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(to_sym),  MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(cmp),   MRB_MT_FUNC|MRB_MT_PUBLIC),
-    MRB_MT_KEY(MRB_OPSYM(eq),    MRB_MT_FUNC|MRB_MT_PUBLIC),
-  }
-};
-static mrb_mt_tbl symbol_rom_mt = {
-  SYMBOL_ROM_MT_SIZE, SYMBOL_ROM_MT_SIZE,
-  (union mrb_mt_ptr*)&symbol_rom_data, NULL
+static mrb_mt_entry symbol_rom_entries[] = {
+  MRB_MT_ENTRY(sym_to_s,         MRB_SYM(to_s),    MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(sym_name,         MRB_SYM(name),    MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_obj_itself,   MRB_SYM(to_sym),  MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(sym_inspect,      MRB_SYM(inspect), MRB_MT_FUNC|MRB_MT_NOARG),
+  MRB_MT_ENTRY(sym_cmp,          MRB_OPSYM(cmp),   MRB_MT_FUNC),
+  MRB_MT_ENTRY(mrb_obj_equal_m,  MRB_OPSYM(eq),    MRB_MT_FUNC),
 };
+static mrb_mt_tbl symbol_rom_mt = MRB_MT_ROM_TAB(symbol_rom_entries);
 
 void
 mrb_init_symbol(mrb_state *mrb)