lib9p: idl: Have bitfield bit names be less heuristic

7 files changed, 234 insertions, 163 deletions

diff --git a/lib9p/idl.gen b/lib9p/idl.gen
index b75ffd6..af70097 100755
--- a/lib9p/idl.gen
+++ b/lib9p/idl.gen
@@ -499,45 +499,75 @@ enum {idprefix}version {{
                     ret += f"#define {prefix}{name.ljust(namewidth)} (({c_typename(typ)})UINT{typ.static_size*8}_C({val}))\n"
             case idl.Bitfield():
                 ret += f"typedef {c_typename(typ.prim)} {c_typename(typ)};\n"
-                names = [
-                    typ.bits[n] or f" {n}" for n in reversed(range(0, len(typ.bits)))
-                ]
-                if aliases := [k for k in typ.names if k not in typ.bits]:
-                    names.append("")
-                    names.extend(aliases)
-                prefix = f"{idprefix.upper()}{typ.typname.upper()}_"
-                namewidth = max(len(add_prefix(prefix, name)) for name in names)
 
-                ret += "\n"
-                for name in names:
-                    if name == "":
-                        ret += "\n"
-                        continue
+                def bitname(val: idl.Bit | idl.BitAlias) -> str:
+                    s = val.bitname
+                    match val:
+                        case idl.Bit(cat=idl.BitCat.RESERVED):
+                            s = "_RESERVED_" + s
+                        case idl.Bit(cat=idl.BitCat.SUBFIELD):
+                            assert isinstance(typ, idl.Bitfield)
+                            n = sum(
+                                1
+                                for b in typ.bits[: val.num]
+                                if b.cat == idl.BitCat.SUBFIELD
+                                and b.bitname == val.bitname
+                            )
+                            s = f"_{s}_{n}"
+                        case idl.Bit(cat=idl.BitCat.UNUSED):
+                            return ""
+                    return add_prefix(f"{idprefix.upper()}{typ.typname.upper()}_", s)
 
-                    if name.startswith(" "):
-                        vers = typ.in_versions
-                        c_name = ""
-                        c_val = f"1<<{name[1:]}"
-                    else:
-                        vers = typ.names[name].in_versions
-                        c_name = add_prefix(prefix, name)
-                        c_val = f"{typ.names[name].val}"
+                namewidth = max(
+                    len(bitname(val)) for val in [*typ.bits, *typ.names.values()]
+                )
 
+                ret += "\n"
+                for bit in reversed(typ.bits):
+                    vers = bit.in_versions
+                    if bit.cat == idl.BitCat.UNUSED:
+                        vers = typ.in_versions
                     ret += ifdef_push(2, c_ver_ifdef(vers))
 
                     # It is important all of the `beg` strings have
                     # the same length.
                     end = ""
-                    if name.startswith(" "):
-                        beg = "/* unused"
-                        end = " */"
-                    elif _ifdef_stack[-1]:
-                        beg = "#  define"
-                    else:
-                        beg = "#define  "
+                    match bit.cat:
+                        case (
+                            idl.BitCat.USED | idl.BitCat.RESERVED | idl.BitCat.SUBFIELD
+                        ):
+                            if _ifdef_stack[-1]:
+                                beg = "#  define"
+                            else:
+                                beg = "#define  "
+                        case idl.BitCat.UNUSED:
+                            beg = "/* unused"
+                            end = " */"
+
+                    c_name = bitname(bit)
+                    c_val = f"1<<{bit.num}"
+                    ret += f"{beg} {c_name:<{namewidth}}  (({c_typename(typ)})({c_val})){end}\n"
+                if aliases := [
+                    alias
+                    for alias in typ.names.values()
+                    if isinstance(alias, idl.BitAlias)
+                ]:
+                    ret += "\n"
 
-                    ret += f"{beg} {c_name.ljust(namewidth)}  (({c_typename(typ)})({c_val})){end}\n"
+                    for alias in aliases:
+                        ret += ifdef_push(2, c_ver_ifdef(alias.in_versions))
+
+                        end = ""
+                        if _ifdef_stack[-1]:
+                            beg = "#  define"
+                        else:
+                            beg = "#define  "
+
+                        c_name = bitname(alias)
+                        c_val = alias.val
+                        ret += f"{beg} {c_name:<{namewidth}}  (({c_typename(typ)})({c_val})){end}\n"
                 ret += ifdef_pop(1)
+                del bitname
             case idl.Struct():  # and idl.Message():
                 ret += c_typename(typ) + " {"
                 if not typ.members:
@@ -554,6 +584,7 @@ enum {idprefix}version {{
                     ret += f"\t{c_typename(member.typ, member).ljust(typewidth)}  {'*' if member.cnt else ' '}{member.membname};\n"
                 ret += ifdef_pop(1)
                 ret += "};\n"
+        del typ
     ret += ifdef_pop(0)
 
     ret += """
@@ -746,8 +777,13 @@ const char *const _{idprefix}table_ver_name[{c_ver_enum('NUM')}] = {{
             ret += (
                 f"\t[{c_ver_enum(ver)}]{' '*(verwidth-len(ver))} = 0b"
                 + "".join(
-                    "1" if typ.bit_is_valid(bitname, ver) else "0"
-                    for bitname in reversed(typ.bits)
+                    (
+                        "1"
+                        if bit.cat in (idl.BitCat.USED, idl.BitCat.SUBFIELD)
+                        and ver in bit.in_versions
+                        else "0"
+                    )
+                    for bit in reversed(typ.bits)
                 )
                 + ",\n"
             )
diff --git a/lib9p/idl/0000-README.md b/lib9p/idl/0000-README.md
index 036de22..e19a1e8 100644
--- a/lib9p/idl/0000-README.md
+++ b/lib9p/idl/0000-README.md
@@ -41,6 +41,11 @@ and messages (which are a special-case of structures).
 
 	msg Tname = "size[4,val=end-&size] typ[1,val=TYP] tag[tag] REST..."
 
+Bitfield bit names may be wrapped in `reserved(...)` or
+`subfield(...)`; reserved indicates that the bit is named but is not
+allowed to be used, and subfield indicates that the bit is part of a
+num/enum that is handled by an alias.
+
 Struct fields that have numeric types (either primitives or `num`
 types) can add to their type `,val=` and/or `,max=` to specify what
 the exact value must be and/or what the maximum (inclusive) value is.
diff --git a/lib9p/idl/2002-9P2000.9p b/lib9p/idl/2002-9P2000.9p
index 438e02f..2a4f7ed 100644
--- a/lib9p/idl/2002-9P2000.9p
+++ b/lib9p/idl/2002-9P2000.9p
@@ -42,7 +42,7 @@ bitfield dm = 4
 	# that the file is mounted by the kernel as a 9P transport;
 	# that the kernel has a lock on doing I/O on it, so userspace
 	# can't do I/O on it.
-	"28=_PLAN9_MOUNT"
+	"28=reserved(PLAN9_MOUNT)"
 	"27=AUTH"
 	"26=TMP"
 	#...
@@ -63,7 +63,7 @@ bitfield qt = 1
 	"7=DIR"
 	"6=APPEND"
 	"5=EXCL"
-	"4=_PLAN9_MOUNT" # See "_PLAN9_MOUNT" in "dm" above.
+	"4=reserved(PLAN9_MOUNT)" # See "PLAN9_MOUNT" in "dm" above.
 	"3=AUTH"
 	# Fun historical fact: QTTMP was a relatively late addition to
 	# Plan 9, in 2003-12.
@@ -107,12 +107,12 @@ struct stat = "stat_size[2,val=end-&kern_type]"
 # "O"pen flags (flags to pass to Topen and Tcreate)
 # Unused bits *must* be 0.
 bitfield o = 1
-	"0=mode_0" # low bit of the 2-bit READ/WRITE/RDWR/EXEC enum
-	"1=mode_1" # high bit of the 2-bit READ/WRITE/RDWR/EXEC enum
+	"0=subfield(mode)" # low bit of the 2-bit READ/WRITE/RDWR/EXEC enum
+	"1=subfield(mode)" # high bit of the 2-bit READ/WRITE/RDWR/EXEC enum
 	#"2=unused"
 	#"3=unused"
 	"4=TRUNC"
-	#"5=_reserved_CEXEC" # close-on-exec
+	"5=reserved(CEXEC)" # close-on-exec
 	"6=RCLOSE" # remove-on-close
 	#"7=unused"
 
diff --git a/lib9p/idl/__init__.py b/lib9p/idl/__init__.py
index 04e1791..70eaf57 100644
--- a/lib9p/idl/__init__.py
+++ b/lib9p/idl/__init__.py
@@ -16,7 +16,7 @@ __all__ = [
     "Type",
     "Primitive",
     "Number",
-    *["Bitfield", "BitfieldVal"],
+    *["Bitfield", "Bit", "BitCat", "BitAlias"],
     *["Struct", "StructMember", "Expr", "ExprOp", "ExprSym", "ExprLit"],
     "Message",
 ]
@@ -74,27 +74,49 @@ class Number:
         return self.static_size
 
 
-class BitfieldVal:
+class BitCat(enum.Enum):
+    UNUSED = 1
+    USED = 2
+    RESERVED = 3
+    SUBFIELD = 4
+
+
+class Bit:
     bitname: str
     in_versions: set[str]
+    num: int
+    cat: BitCat
 
-    val: str
+    def __init__(self, num: int) -> None:
+        self.bitname = ""
+        self.in_versions = set()
+        self.num = num
+        self.cat = BitCat.UNUSED
 
-    def __init__(self) -> None:
+
+class BitAlias:
+    bitname: str
+    in_versions: set[str]
+    val: str  # FIXME: Don't have bitfield aliases be raw C expressions
+
+    def __init__(self, name: str, val: str) -> None:
+        self.bitname = name
         self.in_versions = set()
+        self.val = val
 
 
 class Bitfield:
     typname: str
     in_versions: set[str]
-
     prim: Primitive
+    bits: list[Bit]
+    names: dict[str, Bit | BitAlias]
 
-    bits: list[str]  # bitnames
-    names: dict[str, BitfieldVal]  # bits *and* aliases
-
-    def __init__(self) -> None:
+    def __init__(self, name: str, prim: Primitive) -> None:
+        self.typname = name
         self.in_versions = set()
+        self.prim = prim
+        self.bits = [Bit(i) for i in range(prim.static_size * 8)]
         self.names = {}
 
     @property
@@ -107,21 +129,6 @@ class Bitfield:
     def max_size(self, version: str) -> int:
         return self.static_size
 
-    def bit_is_valid(self, bit: str | int, ver: str | None = None) -> bool:
-        """Return whether the given bit is valid in the given protocol
-        version.
-
-        """
-        bitname = self.bits[bit] if isinstance(bit, int) else bit
-        assert bitname in self.bits
-        if not bitname:
-            return False
-        if bitname.startswith("_"):
-            return False
-        if ver and (ver not in self.names[bitname].in_versions):
-            return False
-        return True
-
 
 class ExprLit:
     val: int
@@ -278,6 +285,8 @@ T = typing.TypeVar("T", Number, Bitfield, Struct, Message)
 
 re_priname = "(?:1|2|4|8)"  # primitive names
 re_symname = "(?:[a-zA-Z_][a-zA-Z_0-9]*)"  # "symbol" names; most *.9p-defined names
+re_symname_u = "(?:[A-Z_][A-Z_0-9]*)"  # upper-case "symbol" names; bit names
+re_symname_l = "(?:[a-z_][a-z_0-9]*)"  # lower-case "symbol" names; bit names
 re_impname = r"(?:\*|" + re_symname + ")"  # names we can import
 re_msgname = r"(?:[TR][a-zA-Z_0-9]*)"  # names a message can be
 
@@ -287,8 +296,18 @@ re_expr = f"(?:(?:-|\\+|[0-9]+|&?{re_symname})+)"
 
 re_numspec = f"(?P<name>{re_symname})\\s*=\\s*(?P<val>\\S+)"
 
-re_bitspec_bit = f"(?P<bit>[0-9]+)\\s*=\\s*(?P<name>{re_symname})"
-re_bitspec_alias = f"(?P<name>{re_symname})\\s*=\\s*(?P<val>\\S+)"
+re_bitspec_bit = (
+    "(?P<bitnum>[0-9]+)\\s*=\\s*(?:"
+    + "|".join(
+        [
+            f"(?P<name_used>{re_symname_u})",
+            f"reserved\\((?P<name_reserved>{re_symname_u})\\)",
+            f"subfield\\((?P<name_subfield>{re_symname_l})\\)",
+        ]
+    )
+    + ")"
+)
+re_bitspec_alias = f"(?P<name>{re_symname_u})\\s*=\\s*(?P<val>\\S+)"
 
 re_memberspec = f"(?:(?P<cnt>{re_symname})\\*\\()?(?P<name>{re_symname})\\[(?P<typ>{re_memtype})(?:,max=(?P<max>{re_expr})|,val=(?P<val>{re_expr}))*\\]\\)?"
 
@@ -309,36 +328,48 @@ def parse_numspec(ver: str, n: Number, spec: str) -> None:
 def parse_bitspec(ver: str, bf: Bitfield, spec: str) -> None:
     spec = spec.strip()
 
-    bit: int | None
-    val: BitfieldVal
     if m := re.fullmatch(re_bitspec_bit, spec):
-        bit = int(m.group("bit"))
-        name = m.group("name")
-
-        val = BitfieldVal()
-        val.bitname = name
-        val.val = f"1<<{bit}"
-        val.in_versions.add(ver)
-
-        if bit < 0 or bit >= len(bf.bits):
-            raise ValueError(f"{bf.typname}: bit {bit} is out-of-bounds")
-        if bf.bits[bit]:
-            raise ValueError(f"{bf.typname}: bit {bit} already assigned")
-        bf.bits[bit] = val.bitname
+        bitnum = int(m.group("bitnum"))
+        if bitnum < 0 or bitnum >= len(bf.bits):
+            raise ValueError(f"{bf.typname}: bit num {bitnum} out-of-bounds")
+        bit = bf.bits[bitnum]
+        if bit.cat != BitCat.UNUSED:
+            raise ValueError(f"{bf.typname}: bit num {bitnum} already assigned")
+        if name := m.group("name_used"):
+            bit.bitname = name
+            bit.cat = BitCat.USED
+            bit.in_versions.add(ver)
+        elif name := m.group("name_reserved"):
+            bit.bitname = name
+            bit.cat = BitCat.RESERVED
+            bit.in_versions.add(ver)
+        elif name := m.group("name_subfield"):
+            bit.bitname = name
+            bit.cat = BitCat.SUBFIELD
+            bit.in_versions.add(ver)
+        if bit.bitname:
+            if bit.bitname in bf.names:
+                other = bf.names[bit.bitname]
+                if (
+                    isinstance(other, Bit)
+                    and other.cat == bit.cat
+                    and bit.cat == BitCat.SUBFIELD
+                ):
+                    return
+                raise ValueError(
+                    f"{bf.typname}: bit name {bit.bitname!r} already assigned"
+                )
+            bf.names[bit.bitname] = bit
     elif m := re.fullmatch(re_bitspec_alias, spec):
-        name = m.group("name")
-        valstr = m.group("val")
-
-        val = BitfieldVal()
-        val.bitname = name
-        val.val = valstr
-        val.in_versions.add(ver)
+        alias = BitAlias(m.group("name"), m.group("val"))
+        alias.in_versions.add(ver)
+        if alias.bitname in bf.names:
+            raise ValueError(
+                f"{bf.typname}: bit name {alias.bitname!r} already assigned"
+            )
+        bf.names[alias.bitname] = alias
     else:
-        raise SyntaxError(f"invalid bitfield spec {repr(spec)}")
-
-    if val.bitname in bf.names:
-        raise ValueError(f"{bf.typname}: name {val.bitname} already assigned")
-    bf.names[val.bitname] = val
+        raise SyntaxError(f"invalid bitfield spec {spec!r}")
 
 
 def parse_expr(expr: str) -> Expr:
@@ -467,6 +498,9 @@ def parse_file(
                                         typ.in_versions.add(version)
                                     case Bitfield():
                                         typ.in_versions.add(version)
+                                        for bit in typ.bits:
+                                            if other_version in bit.in_versions:
+                                                bit.in_versions.add(version)
                                         for val in typ.names.values():
                                             if other_version in val.in_versions:
                                                 val.in_versions.add(version)
@@ -498,15 +532,11 @@ def parse_file(
                     env[num.typname] = num
                     prev = num
                 elif m := re.fullmatch(re_line_bitfield, line):
-                    bf = Bitfield()
-                    bf.typname = m.group("name")
-                    bf.in_versions.add(version)
-
                     prim = env[m.group("prim")]
                     assert isinstance(prim, Primitive)
-                    bf.prim = prim
 
-                    bf.bits = (prim.static_size * 8) * [""]
+                    bf = Bitfield(m.group("name"), prim)
+                    bf.in_versions.add(version)
 
                     if bf.typname in env:
                         raise ValueError(f"duplicate type name {bf.typname!r}")
diff --git a/lib9p/include/lib9p/9p.generated.h b/lib9p/include/lib9p/9p.generated.h
index a1c9958..f107b1f 100644
--- a/lib9p/include/lib9p/9p.generated.h
+++ b/lib9p/include/lib9p/9p.generated.h
@@ -176,62 +176,62 @@ struct lib9p_s {
 /* size = 4 ; max_iov = 1 ; max_copy = 4 */
 typedef uint32_t lib9p_dm_t;
 
-#define   LIB9P_DM_DIR           ((lib9p_dm_t)(1<<31))
-#define   LIB9P_DM_APPEND        ((lib9p_dm_t)(1<<30))
-#define   LIB9P_DM_EXCL          ((lib9p_dm_t)(1<<29))
-#define   _LIB9P_DM_PLAN9_MOUNT  ((lib9p_dm_t)(1<<28))
-#define   LIB9P_DM_AUTH          ((lib9p_dm_t)(1<<27))
-#define   LIB9P_DM_TMP           ((lib9p_dm_t)(1<<26))
-/* unused                        ((lib9p_dm_t)(1<<25)) */
-/* unused                        ((lib9p_dm_t)(1<<24)) */
+#define   LIB9P_DM_DIR                    ((lib9p_dm_t)(1<<31))
+#define   LIB9P_DM_APPEND                 ((lib9p_dm_t)(1<<30))
+#define   LIB9P_DM_EXCL                   ((lib9p_dm_t)(1<<29))
+#define   _LIB9P_DM_RESERVED_PLAN9_MOUNT  ((lib9p_dm_t)(1<<28))
+#define   LIB9P_DM_AUTH                   ((lib9p_dm_t)(1<<27))
+#define   LIB9P_DM_TMP                    ((lib9p_dm_t)(1<<26))
+/* unused                                 ((lib9p_dm_t)(1<<25)) */
+/* unused                                 ((lib9p_dm_t)(1<<24)) */
 #if CONFIG_9P_ENABLE_9P2000_u
-#  define LIB9P_DM_DEVICE        ((lib9p_dm_t)(1<<23))
+#  define LIB9P_DM_DEVICE                 ((lib9p_dm_t)(1<<23))
 #endif /* CONFIG_9P_ENABLE_9P2000_u */
-/* unused                        ((lib9p_dm_t)(1<<22)) */
+/* unused                                 ((lib9p_dm_t)(1<<22)) */
 #if CONFIG_9P_ENABLE_9P2000_u
-#  define LIB9P_DM_NAMEDPIPE     ((lib9p_dm_t)(1<<21))
-#  define LIB9P_DM_SOCKET        ((lib9p_dm_t)(1<<20))
-#  define LIB9P_DM_SETUID        ((lib9p_dm_t)(1<<19))
-#  define LIB9P_DM_SETGID        ((lib9p_dm_t)(1<<18))
+#  define LIB9P_DM_NAMEDPIPE              ((lib9p_dm_t)(1<<21))
+#  define LIB9P_DM_SOCKET                 ((lib9p_dm_t)(1<<20))
+#  define LIB9P_DM_SETUID                 ((lib9p_dm_t)(1<<19))
+#  define LIB9P_DM_SETGID                 ((lib9p_dm_t)(1<<18))
 #endif /* CONFIG_9P_ENABLE_9P2000_u */
-/* unused                        ((lib9p_dm_t)(1<<17)) */
-/* unused                        ((lib9p_dm_t)(1<<16)) */
-/* unused                        ((lib9p_dm_t)(1<<15)) */
-/* unused                        ((lib9p_dm_t)(1<<14)) */
-/* unused                        ((lib9p_dm_t)(1<<13)) */
-/* unused                        ((lib9p_dm_t)(1<<12)) */
-/* unused                        ((lib9p_dm_t)(1<<11)) */
-/* unused                        ((lib9p_dm_t)(1<<10)) */
-/* unused                        ((lib9p_dm_t)(1<<9)) */
-#define   LIB9P_DM_OWNER_R       ((lib9p_dm_t)(1<<8))
-#define   LIB9P_DM_OWNER_W       ((lib9p_dm_t)(1<<7))
-#define   LIB9P_DM_OWNER_X       ((lib9p_dm_t)(1<<6))
-#define   LIB9P_DM_GROUP_R       ((lib9p_dm_t)(1<<5))
-#define   LIB9P_DM_GROUP_W       ((lib9p_dm_t)(1<<4))
-#define   LIB9P_DM_GROUP_X       ((lib9p_dm_t)(1<<3))
-#define   LIB9P_DM_OTHER_R       ((lib9p_dm_t)(1<<2))
-#define   LIB9P_DM_OTHER_W       ((lib9p_dm_t)(1<<1))
-#define   LIB9P_DM_OTHER_X       ((lib9p_dm_t)(1<<0))
-
-#define   LIB9P_DM_PERM_MASK     ((lib9p_dm_t)(0777))
+/* unused                                 ((lib9p_dm_t)(1<<17)) */
+/* unused                                 ((lib9p_dm_t)(1<<16)) */
+/* unused                                 ((lib9p_dm_t)(1<<15)) */
+/* unused                                 ((lib9p_dm_t)(1<<14)) */
+/* unused                                 ((lib9p_dm_t)(1<<13)) */
+/* unused                                 ((lib9p_dm_t)(1<<12)) */
+/* unused                                 ((lib9p_dm_t)(1<<11)) */
+/* unused                                 ((lib9p_dm_t)(1<<10)) */
+/* unused                                 ((lib9p_dm_t)(1<<9)) */
+#define   LIB9P_DM_OWNER_R                ((lib9p_dm_t)(1<<8))
+#define   LIB9P_DM_OWNER_W                ((lib9p_dm_t)(1<<7))
+#define   LIB9P_DM_OWNER_X                ((lib9p_dm_t)(1<<6))
+#define   LIB9P_DM_GROUP_R                ((lib9p_dm_t)(1<<5))
+#define   LIB9P_DM_GROUP_W                ((lib9p_dm_t)(1<<4))
+#define   LIB9P_DM_GROUP_X                ((lib9p_dm_t)(1<<3))
+#define   LIB9P_DM_OTHER_R                ((lib9p_dm_t)(1<<2))
+#define   LIB9P_DM_OTHER_W                ((lib9p_dm_t)(1<<1))
+#define   LIB9P_DM_OTHER_X                ((lib9p_dm_t)(1<<0))
+
+#define   LIB9P_DM_PERM_MASK              ((lib9p_dm_t)(0777))
 
 #endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
 #if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
 /* size = 1 ; max_iov = 1 ; max_copy = 1 */
 typedef uint8_t lib9p_qt_t;
 
-#define   LIB9P_QT_DIR           ((lib9p_qt_t)(1<<7))
-#define   LIB9P_QT_APPEND        ((lib9p_qt_t)(1<<6))
-#define   LIB9P_QT_EXCL          ((lib9p_qt_t)(1<<5))
-#define   _LIB9P_QT_PLAN9_MOUNT  ((lib9p_qt_t)(1<<4))
-#define   LIB9P_QT_AUTH          ((lib9p_qt_t)(1<<3))
-#define   LIB9P_QT_TMP           ((lib9p_qt_t)(1<<2))
+#define   LIB9P_QT_DIR                    ((lib9p_qt_t)(1<<7))
+#define   LIB9P_QT_APPEND                 ((lib9p_qt_t)(1<<6))
+#define   LIB9P_QT_EXCL                   ((lib9p_qt_t)(1<<5))
+#define   _LIB9P_QT_RESERVED_PLAN9_MOUNT  ((lib9p_qt_t)(1<<4))
+#define   LIB9P_QT_AUTH                   ((lib9p_qt_t)(1<<3))
+#define   LIB9P_QT_TMP                    ((lib9p_qt_t)(1<<2))
 #if CONFIG_9P_ENABLE_9P2000_u
-#  define LIB9P_QT_SYMLINK       ((lib9p_qt_t)(1<<1))
+#  define LIB9P_QT_SYMLINK                ((lib9p_qt_t)(1<<1))
 #endif /* CONFIG_9P_ENABLE_9P2000_u */
-/* unused                        ((lib9p_qt_t)(1<<0)) */
+/* unused                                 ((lib9p_qt_t)(1<<0)) */
 
-#define   LIB9P_QT_FILE          ((lib9p_qt_t)(0))
+#define   LIB9P_QT_FILE                   ((lib9p_qt_t)(0))
 
 #endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
 #if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
@@ -244,21 +244,21 @@ typedef uint32_t lib9p_nuid_t;
 /* size = 1 ; max_iov = 1 ; max_copy = 1 */
 typedef uint8_t lib9p_o_t;
 
-/* unused                    ((lib9p_o_t)(1<<7)) */
-#define   LIB9P_O_RCLOSE     ((lib9p_o_t)(1<<6))
-/* unused                    ((lib9p_o_t)(1<<5)) */
-#define   LIB9P_O_TRUNC      ((lib9p_o_t)(1<<4))
-/* unused                    ((lib9p_o_t)(1<<3)) */
-/* unused                    ((lib9p_o_t)(1<<2)) */
-#define   LIB9P_O_mode_1     ((lib9p_o_t)(1<<1))
-#define   LIB9P_O_mode_0     ((lib9p_o_t)(1<<0))
-
-#define   LIB9P_O_READ       ((lib9p_o_t)(0))
-#define   LIB9P_O_WRITE      ((lib9p_o_t)(1))
-#define   LIB9P_O_RDWR       ((lib9p_o_t)(2))
-#define   LIB9P_O_EXEC       ((lib9p_o_t)(3))
-#define   LIB9P_O_MODE_MASK  ((lib9p_o_t)(0b00000011))
-#define   LIB9P_O_FLAG_MASK  ((lib9p_o_t)(0b11111100))
+/* unused                          ((lib9p_o_t)(1<<7)) */
+#define   LIB9P_O_RCLOSE           ((lib9p_o_t)(1<<6))
+#define   _LIB9P_O_RESERVED_CEXEC  ((lib9p_o_t)(1<<5))
+#define   LIB9P_O_TRUNC            ((lib9p_o_t)(1<<4))
+/* unused                          ((lib9p_o_t)(1<<3)) */
+/* unused                          ((lib9p_o_t)(1<<2)) */
+#define   _LIB9P_O_mode_1          ((lib9p_o_t)(1<<1))
+#define   _LIB9P_O_mode_0          ((lib9p_o_t)(1<<0))
+
+#define   LIB9P_O_READ             ((lib9p_o_t)(0))
+#define   LIB9P_O_WRITE            ((lib9p_o_t)(1))
+#define   LIB9P_O_RDWR             ((lib9p_o_t)(2))
+#define   LIB9P_O_EXEC             ((lib9p_o_t)(3))
+#define   LIB9P_O_MODE_MASK        ((lib9p_o_t)(0b00000011))
+#define   LIB9P_O_FLAG_MASK        ((lib9p_o_t)(0b11111100))
 
 #endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
 #if CONFIG_9P_ENABLE_9P2000_L
diff --git a/lib9p/include/lib9p/9p.h b/lib9p/include/lib9p/9p.h
index 44b5410..4ecb172 100644
--- a/lib9p/include/lib9p/9p.h
+++ b/lib9p/include/lib9p/9p.h
@@ -139,12 +139,11 @@ bool lib9p_Rmsg_marshal(struct lib9p_ctx *ctx, enum lib9p_msg_type typ, void *bo
 
 /** Assert that a `struct lib9p_stat` object looks valid.  */
 static inline void lib9p_stat_assert(struct lib9p_stat stat) {
-	assert( ((bool)(stat.file_mode & LIB9P_DM_DIR         )) == ((bool)(stat.file_qid.type & LIB9P_QT_DIR         )) );
-	assert( ((bool)(stat.file_mode & LIB9P_DM_APPEND      )) == ((bool)(stat.file_qid.type & LIB9P_QT_APPEND      )) );
-	assert( ((bool)(stat.file_mode & LIB9P_DM_EXCL        )) == ((bool)(stat.file_qid.type & LIB9P_QT_EXCL        )) );
-	assert( ((bool)(stat.file_mode & _LIB9P_DM_PLAN9_MOUNT)) == ((bool)(stat.file_qid.type & _LIB9P_QT_PLAN9_MOUNT)) );
-	assert( ((bool)(stat.file_mode & LIB9P_DM_AUTH        )) == ((bool)(stat.file_qid.type & LIB9P_QT_AUTH        )) );
-	assert( ((bool)(stat.file_mode & LIB9P_DM_TMP         )) == ((bool)(stat.file_qid.type & LIB9P_QT_TMP         )) );
+	assert( ((bool)(stat.file_mode & LIB9P_DM_DIR   )) == ((bool)(stat.file_qid.type & LIB9P_QT_DIR   )) );
+	assert( ((bool)(stat.file_mode & LIB9P_DM_APPEND)) == ((bool)(stat.file_qid.type & LIB9P_QT_APPEND)) );
+	assert( ((bool)(stat.file_mode & LIB9P_DM_EXCL  )) == ((bool)(stat.file_qid.type & LIB9P_QT_EXCL  )) );
+	assert( ((bool)(stat.file_mode & LIB9P_DM_AUTH  )) == ((bool)(stat.file_qid.type & LIB9P_QT_AUTH  )) );
+	assert( ((bool)(stat.file_mode & LIB9P_DM_TMP   )) == ((bool)(stat.file_qid.type & LIB9P_QT_TMP   )) );
 	assert( (stat.file_size == 0) || !(stat.file_mode & LIB9P_DM_DIR) );
 }
 
diff --git a/lib9p/tests/test_compile.c b/lib9p/tests/test_compile.c
index 989bf20..0e33522 100644
--- a/lib9p/tests/test_compile.c
+++ b/lib9p/tests/test_compile.c
@@ -8,7 +8,7 @@ int main(void) {
     x = LIB9P_DM_DIR;
     x = LIB9P_DM_APPEND;
     x = LIB9P_DM_EXCL;
-    x = _LIB9P_DM_PLAN9_MOUNT;
+    x = _LIB9P_DM_RESERVED_PLAN9_MOUNT;
     x = LIB9P_DM_AUTH;
     x = LIB9P_DM_TMP;
     x = LIB9P_DM_DEVICE;
@@ -29,16 +29,17 @@ int main(void) {
     x = LIB9P_QT_DIR;
     x = LIB9P_QT_APPEND;
     x = LIB9P_QT_EXCL;
-    x = _LIB9P_QT_PLAN9_MOUNT;
+    x = _LIB9P_QT_RESERVED_PLAN9_MOUNT;
     x = LIB9P_QT_AUTH;
     x = LIB9P_QT_TMP;
     x = LIB9P_QT_SYMLINK;
     x = LIB9P_QT_FILE;
     x = LIB9P_NUID_NONUID;
     x = LIB9P_O_RCLOSE;
+    x = _LIB9P_O_RESERVED_CEXEC;
     x = LIB9P_O_TRUNC;
-    x = LIB9P_O_mode_1;
-    x = LIB9P_O_mode_0;
+    x = _LIB9P_O_mode_1;
+    x = _LIB9P_O_mode_0;
     x = LIB9P_O_READ;
     x = LIB9P_O_WRITE;
     x = LIB9P_O_RDWR;