Reject all nonexistent instructions in sexp format (#1756)

1 files changed, 869 insertions, 191 deletions

diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
index 5b50d6091..6cf004167 100644
--- a/src/gen-s-parser.inc
+++ b/src/gen-s-parser.inc
@@ -7,14 +7,22 @@ strncpy(op, s[0]->c_str(), 26);
 switch (op[0]) {
   case 'b': {
     switch (op[1]) {
-      case 'l': return makeBlock(s); // block
+      case 'l':
+        if (strcmp(op, "block") == 0) return makeBlock(s);
+        goto parse_error;
       case 'r': {
         switch (op[2]) {
-          case '\0': return makeBreak(s); // br
+          case '\0':
+            if (strcmp(op, "br") == 0) return makeBreak(s);
+            goto parse_error;
           case '_': {
             switch (op[3]) {
-              case 'i': return makeBreak(s); // br_if
-              case 't': return makeBreakTable(s); // br_table
+              case 'i':
+                if (strcmp(op, "br_if") == 0) return makeBreak(s);
+                goto parse_error;
+              case 't':
+                if (strcmp(op, "br_table") == 0) return makeBreakTable(s);
+                goto parse_error;
               default: goto parse_error;
             }
           }
@@ -28,49 +36,75 @@ switch (op[0]) {
     switch (op[1]) {
       case 'a': {
         switch (op[4]) {
-          case '\0': return makeCall(s); // call
-          case '_': return makeCallIndirect(s); // call_indirect
+          case '\0':
+            if (strcmp(op, "call") == 0) return makeCall(s);
+            goto parse_error;
+          case '_':
+            if (strcmp(op, "call_indirect") == 0) return makeCallIndirect(s);
+            goto parse_error;
           default: goto parse_error;
         }
       }
-      case 'u': return makeHost(s, HostOp::CurrentMemory); // current_memory
+      case 'u':
+        if (strcmp(op, "current_memory") == 0) return makeHost(s, HostOp::CurrentMemory);
+        goto parse_error;
       default: goto parse_error;
     }
   }
-  case 'd': return makeDrop(s); // drop
-  case 'e': return makeThenOrElse(s); // else
+  case 'd':
+    if (strcmp(op, "drop") == 0) return makeDrop(s);
+    goto parse_error;
+  case 'e':
+    if (strcmp(op, "else") == 0) return makeThenOrElse(s);
+    goto parse_error;
   case 'f': {
     switch (op[1]) {
       case '3': {
         switch (op[4]) {
           case 'a': {
             switch (op[5]) {
-              case 'b': return makeUnary(s, UnaryOp::AbsFloat32); // f32.abs
-              case 'd': return makeBinary(s, BinaryOp::AddFloat32); // f32.add
+              case 'b':
+                if (strcmp(op, "f32.abs") == 0) return makeUnary(s, UnaryOp::AbsFloat32);
+                goto parse_error;
+              case 'd':
+                if (strcmp(op, "f32.add") == 0) return makeBinary(s, BinaryOp::AddFloat32);
+                goto parse_error;
               default: goto parse_error;
             }
           }
           case 'c': {
             switch (op[5]) {
-              case 'e': return makeUnary(s, UnaryOp::CeilFloat32); // f32.ceil
+              case 'e':
+                if (strcmp(op, "f32.ceil") == 0) return makeUnary(s, UnaryOp::CeilFloat32);
+                goto parse_error;
               case 'o': {
                 switch (op[6]) {
                   case 'n': {
                     switch (op[7]) {
-                      case 's': return makeConst(s, f32); // f32.const
+                      case 's':
+                        if (strcmp(op, "f32.const") == 0) return makeConst(s, f32);
+                        goto parse_error;
                       case 'v': {
                         switch (op[12]) {
                           case 's': {
                             switch (op[15]) {
-                              case '3': return makeUnary(s, UnaryOp::ConvertSInt32ToFloat32); // f32.convert_s/i32
-                              case '6': return makeUnary(s, UnaryOp::ConvertSInt64ToFloat32); // f32.convert_s/i64
+                              case '3':
+                                if (strcmp(op, "f32.convert_s/i32") == 0) return makeUnary(s, UnaryOp::ConvertSInt32ToFloat32);
+                                goto parse_error;
+                              case '6':
+                                if (strcmp(op, "f32.convert_s/i64") == 0) return makeUnary(s, UnaryOp::ConvertSInt64ToFloat32);
+                                goto parse_error;
                               default: goto parse_error;
                             }
                           }
                           case 'u': {
                             switch (op[15]) {
-                              case '3': return makeUnary(s, UnaryOp::ConvertUInt32ToFloat32); // f32.convert_u/i32
-                              case '6': return makeUnary(s, UnaryOp::ConvertUInt64ToFloat32); // f32.convert_u/i64
+                              case '3':
+                                if (strcmp(op, "f32.convert_u/i32") == 0) return makeUnary(s, UnaryOp::ConvertUInt32ToFloat32);
+                                goto parse_error;
+                              case '6':
+                                if (strcmp(op, "f32.convert_u/i64") == 0) return makeUnary(s, UnaryOp::ConvertUInt64ToFloat32);
+                                goto parse_error;
                               default: goto parse_error;
                             }
                           }
@@ -80,7 +114,9 @@ switch (op[0]) {
                       default: goto parse_error;
                     }
                   }
-                  case 'p': return makeBinary(s, BinaryOp::CopySignFloat32); // f32.copysign
+                  case 'p':
+                    if (strcmp(op, "f32.copysign") == 0) return makeBinary(s, BinaryOp::CopySignFloat32);
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
@@ -89,54 +125,94 @@ switch (op[0]) {
           }
           case 'd': {
             switch (op[5]) {
-              case 'e': return makeUnary(s, UnaryOp::DemoteFloat64); // f32.demote/f64
-              case 'i': return makeBinary(s, BinaryOp::DivFloat32); // f32.div
+              case 'e':
+                if (strcmp(op, "f32.demote/f64") == 0) return makeUnary(s, UnaryOp::DemoteFloat64);
+                goto parse_error;
+              case 'i':
+                if (strcmp(op, "f32.div") == 0) return makeBinary(s, BinaryOp::DivFloat32);
+                goto parse_error;
               default: goto parse_error;
             }
           }
-          case 'e': return makeBinary(s, BinaryOp::EqFloat32); // f32.eq
-          case 'f': return makeUnary(s, UnaryOp::FloorFloat32); // f32.floor
+          case 'e':
+            if (strcmp(op, "f32.eq") == 0) return makeBinary(s, BinaryOp::EqFloat32);
+            goto parse_error;
+          case 'f':
+            if (strcmp(op, "f32.floor") == 0) return makeUnary(s, UnaryOp::FloorFloat32);
+            goto parse_error;
           case 'g': {
             switch (op[5]) {
-              case 'e': return makeBinary(s, BinaryOp::GeFloat32); // f32.ge
-              case 't': return makeBinary(s, BinaryOp::GtFloat32); // f32.gt
+              case 'e':
+                if (strcmp(op, "f32.ge") == 0) return makeBinary(s, BinaryOp::GeFloat32);
+                goto parse_error;
+              case 't':
+                if (strcmp(op, "f32.gt") == 0) return makeBinary(s, BinaryOp::GtFloat32);
+                goto parse_error;
               default: goto parse_error;
             }
           }
           case 'l': {
             switch (op[5]) {
-              case 'e': return makeBinary(s, BinaryOp::LeFloat32); // f32.le
-              case 'o': return makeLoad(s, f32, /*isAtomic=*/false); // f32.load
-              case 't': return makeBinary(s, BinaryOp::LtFloat32); // f32.lt
+              case 'e':
+                if (strcmp(op, "f32.le") == 0) return makeBinary(s, BinaryOp::LeFloat32);
+                goto parse_error;
+              case 'o':
+                if (strcmp(op, "f32.load") == 0) return makeLoad(s, f32, /*isAtomic=*/false);
+                goto parse_error;
+              case 't':
+                if (strcmp(op, "f32.lt") == 0) return makeBinary(s, BinaryOp::LtFloat32);
+                goto parse_error;
               default: goto parse_error;
             }
           }
           case 'm': {
             switch (op[5]) {
-              case 'a': return makeBinary(s, BinaryOp::MaxFloat32); // f32.max
-              case 'i': return makeBinary(s, BinaryOp::MinFloat32); // f32.min
-              case 'u': return makeBinary(s, BinaryOp::MulFloat32); // f32.mul
+              case 'a':
+                if (strcmp(op, "f32.max") == 0) return makeBinary(s, BinaryOp::MaxFloat32);
+                goto parse_error;
+              case 'i':
+                if (strcmp(op, "f32.min") == 0) return makeBinary(s, BinaryOp::MinFloat32);
+                goto parse_error;
+              case 'u':
+                if (strcmp(op, "f32.mul") == 0) return makeBinary(s, BinaryOp::MulFloat32);
+                goto parse_error;
               default: goto parse_error;
             }
           }
           case 'n': {
             switch (op[6]) {
-              case '\0': return makeBinary(s, BinaryOp::NeFloat32); // f32.ne
-              case 'a': return makeUnary(s, UnaryOp::NearestFloat32); // f32.nearest
-              case 'g': return makeUnary(s, UnaryOp::NegFloat32); // f32.neg
+              case '\0':
+                if (strcmp(op, "f32.ne") == 0) return makeBinary(s, BinaryOp::NeFloat32);
+                goto parse_error;
+              case 'a':
+                if (strcmp(op, "f32.nearest") == 0) return makeUnary(s, UnaryOp::NearestFloat32);
+                goto parse_error;
+              case 'g':
+                if (strcmp(op, "f32.neg") == 0) return makeUnary(s, UnaryOp::NegFloat32);
+                goto parse_error;
               default: goto parse_error;
             }
           }
-          case 'r': return makeUnary(s, UnaryOp::ReinterpretInt32); // f32.reinterpret/i32
+          case 'r':
+            if (strcmp(op, "f32.reinterpret/i32") == 0) return makeUnary(s, UnaryOp::ReinterpretInt32);
+            goto parse_error;
           case 's': {
             switch (op[5]) {
-              case 'q': return makeUnary(s, UnaryOp::SqrtFloat32); // f32.sqrt
-              case 't': return makeStore(s, f32, /*isAtomic=*/false); // f32.store
-              case 'u': return makeBinary(s, BinaryOp::SubFloat32); // f32.sub
+              case 'q':
+                if (strcmp(op, "f32.sqrt") == 0) return makeUnary(s, UnaryOp::SqrtFloat32);
+                goto parse_error;
+              case 't':
+                if (strcmp(op, "f32.store") == 0) return makeStore(s, f32, /*isAtomic=*/false);
+                goto parse_error;
+              case 'u':
+                if (strcmp(op, "f32.sub") == 0) return makeBinary(s, BinaryOp::SubFloat32);
+                goto parse_error;
               default: goto parse_error;
             }
           }
-          case 't': return makeUnary(s, UnaryOp::TruncFloat32); // f32.trunc
+          case 't':
+            if (strcmp(op, "f32.trunc") == 0) return makeUnary(s, UnaryOp::TruncFloat32);
+            goto parse_error;
           default: goto parse_error;
         }
       }
@@ -144,32 +220,48 @@ switch (op[0]) {
         switch (op[4]) {
           case 'a': {
             switch (op[5]) {
-              case 'b': return makeUnary(s, UnaryOp::AbsFloat64); // f64.abs
-              case 'd': return makeBinary(s, BinaryOp::AddFloat64); // f64.add
+              case 'b':
+                if (strcmp(op, "f64.abs") == 0) return makeUnary(s, UnaryOp::AbsFloat64);
+                goto parse_error;
+              case 'd':
+                if (strcmp(op, "f64.add") == 0) return makeBinary(s, BinaryOp::AddFloat64);
+                goto parse_error;
               default: goto parse_error;
             }
           }
           case 'c': {
             switch (op[5]) {
-              case 'e': return makeUnary(s, UnaryOp::CeilFloat64); // f64.ceil
+              case 'e':
+                if (strcmp(op, "f64.ceil") == 0) return makeUnary(s, UnaryOp::CeilFloat64);
+                goto parse_error;
               case 'o': {
                 switch (op[6]) {
                   case 'n': {
                     switch (op[7]) {
-                      case 's': return makeConst(s, f64); // f64.const
+                      case 's':
+                        if (strcmp(op, "f64.const") == 0) return makeConst(s, f64);
+                        goto parse_error;
                       case 'v': {
                         switch (op[12]) {
                           case 's': {
                             switch (op[15]) {
-                              case '3': return makeUnary(s, UnaryOp::ConvertSInt32ToFloat64); // f64.convert_s/i32
-                              case '6': return makeUnary(s, UnaryOp::ConvertSInt64ToFloat64); // f64.convert_s/i64
+                              case '3':
+                                if (strcmp(op, "f64.convert_s/i32") == 0) return makeUnary(s, UnaryOp::ConvertSInt32ToFloat64);
+                                goto parse_error;
+                              case '6':
+                                if (strcmp(op, "f64.convert_s/i64") == 0) return makeUnary(s, UnaryOp::ConvertSInt64ToFloat64);
+                                goto parse_error;
                               default: goto parse_error;
                             }
                           }
                           case 'u': {
                             switch (op[15]) {
-                              case '3': return makeUnary(s, UnaryOp::ConvertUInt32ToFloat64); // f64.convert_u/i32
-                              case '6': return makeUnary(s, UnaryOp::ConvertUInt64ToFloat64); // f64.convert_u/i64
+                              case '3':
+                                if (strcmp(op, "f64.convert_u/i32") == 0) return makeUnary(s, UnaryOp::ConvertUInt32ToFloat64);
+                                goto parse_error;
+                              case '6':
+                                if (strcmp(op, "f64.convert_u/i64") == 0) return makeUnary(s, UnaryOp::ConvertUInt64ToFloat64);
+                                goto parse_error;
                               default: goto parse_error;
                             }
                           }
@@ -179,58 +271,100 @@ switch (op[0]) {
                       default: goto parse_error;
                     }
                   }
-                  case 'p': return makeBinary(s, BinaryOp::CopySignFloat64); // f64.copysign
+                  case 'p':
+                    if (strcmp(op, "f64.copysign") == 0) return makeBinary(s, BinaryOp::CopySignFloat64);
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
               default: goto parse_error;
             }
           }
-          case 'd': return makeBinary(s, BinaryOp::DivFloat64); // f64.div
-          case 'e': return makeBinary(s, BinaryOp::EqFloat64); // f64.eq
-          case 'f': return makeUnary(s, UnaryOp::FloorFloat64); // f64.floor
+          case 'd':
+            if (strcmp(op, "f64.div") == 0) return makeBinary(s, BinaryOp::DivFloat64);
+            goto parse_error;
+          case 'e':
+            if (strcmp(op, "f64.eq") == 0) return makeBinary(s, BinaryOp::EqFloat64);
+            goto parse_error;
+          case 'f':
+            if (strcmp(op, "f64.floor") == 0) return makeUnary(s, UnaryOp::FloorFloat64);
+            goto parse_error;
           case 'g': {
             switch (op[5]) {
-              case 'e': return makeBinary(s, BinaryOp::GeFloat64); // f64.ge
-              case 't': return makeBinary(s, BinaryOp::GtFloat64); // f64.gt
+              case 'e':
+                if (strcmp(op, "f64.ge") == 0) return makeBinary(s, BinaryOp::GeFloat64);
+                goto parse_error;
+              case 't':
+                if (strcmp(op, "f64.gt") == 0) return makeBinary(s, BinaryOp::GtFloat64);
+                goto parse_error;
               default: goto parse_error;
             }
           }
           case 'l': {
             switch (op[5]) {
-              case 'e': return makeBinary(s, BinaryOp::LeFloat64); // f64.le
-              case 'o': return makeLoad(s, f64, /*isAtomic=*/false); // f64.load
-              case 't': return makeBinary(s, BinaryOp::LtFloat64); // f64.lt
+              case 'e':
+                if (strcmp(op, "f64.le") == 0) return makeBinary(s, BinaryOp::LeFloat64);
+                goto parse_error;
+              case 'o':
+                if (strcmp(op, "f64.load") == 0) return makeLoad(s, f64, /*isAtomic=*/false);
+                goto parse_error;
+              case 't':
+                if (strcmp(op, "f64.lt") == 0) return makeBinary(s, BinaryOp::LtFloat64);
+                goto parse_error;
               default: goto parse_error;
             }
           }
           case 'm': {
             switch (op[5]) {
-              case 'a': return makeBinary(s, BinaryOp::MaxFloat64); // f64.max
-              case 'i': return makeBinary(s, BinaryOp::MinFloat64); // f64.min
-              case 'u': return makeBinary(s, BinaryOp::MulFloat64); // f64.mul
+              case 'a':
+                if (strcmp(op, "f64.max") == 0) return makeBinary(s, BinaryOp::MaxFloat64);
+                goto parse_error;
+              case 'i':
+                if (strcmp(op, "f64.min") == 0) return makeBinary(s, BinaryOp::MinFloat64);
+                goto parse_error;
+              case 'u':
+                if (strcmp(op, "f64.mul") == 0) return makeBinary(s, BinaryOp::MulFloat64);
+                goto parse_error;
               default: goto parse_error;
             }
           }
           case 'n': {
             switch (op[6]) {
-              case '\0': return makeBinary(s, BinaryOp::NeFloat64); // f64.ne
-              case 'a': return makeUnary(s, UnaryOp::NearestFloat64); // f64.nearest
-              case 'g': return makeUnary(s, UnaryOp::NegFloat64); // f64.neg
+              case '\0':
+                if (strcmp(op, "f64.ne") == 0) return makeBinary(s, BinaryOp::NeFloat64);
+                goto parse_error;
+              case 'a':
+                if (strcmp(op, "f64.nearest") == 0) return makeUnary(s, UnaryOp::NearestFloat64);
+                goto parse_error;
+              case 'g':
+                if (strcmp(op, "f64.neg") == 0) return makeUnary(s, UnaryOp::NegFloat64);
+                goto parse_error;
               default: goto parse_error;
             }
           }
-          case 'p': return makeUnary(s, UnaryOp::PromoteFloat32); // f64.promote/f32
-          case 'r': return makeUnary(s, UnaryOp::ReinterpretInt64); // f64.reinterpret/i64
+          case 'p':
+            if (strcmp(op, "f64.promote/f32") == 0) return makeUnary(s, UnaryOp::PromoteFloat32);
+            goto parse_error;
+          case 'r':
+            if (strcmp(op, "f64.reinterpret/i64") == 0) return makeUnary(s, UnaryOp::ReinterpretInt64);
+            goto parse_error;
           case 's': {
             switch (op[5]) {
-              case 'q': return makeUnary(s, UnaryOp::SqrtFloat64); // f64.sqrt
-              case 't': return makeStore(s, f64, /*isAtomic=*/false); // f64.store
-              case 'u': return makeBinary(s, BinaryOp::SubFloat64); // f64.sub
+              case 'q':
+                if (strcmp(op, "f64.sqrt") == 0) return makeUnary(s, UnaryOp::SqrtFloat64);
+                goto parse_error;
+              case 't':
+                if (strcmp(op, "f64.store") == 0) return makeStore(s, f64, /*isAtomic=*/false);
+                goto parse_error;
+              case 'u':
+                if (strcmp(op, "f64.sub") == 0) return makeBinary(s, BinaryOp::SubFloat64);
+                goto parse_error;
               default: goto parse_error;
             }
           }
-          case 't': return makeUnary(s, UnaryOp::TruncFloat64); // f64.trunc
+          case 't':
+            if (strcmp(op, "f64.trunc") == 0) return makeUnary(s, UnaryOp::TruncFloat64);
+            goto parse_error;
           default: goto parse_error;
         }
       }
@@ -241,12 +375,18 @@ switch (op[0]) {
     switch (op[1]) {
       case 'e': {
         switch (op[4]) {
-          case 'g': return makeGetGlobal(s); // get_global
-          case 'l': return makeGetLocal(s); // get_local
+          case 'g':
+            if (strcmp(op, "get_global") == 0) return makeGetGlobal(s);
+            goto parse_error;
+          case 'l':
+            if (strcmp(op, "get_local") == 0) return makeGetLocal(s);
+            goto parse_error;
           default: goto parse_error;
         }
       }
-      case 'r': return makeHost(s, HostOp::GrowMemory); // grow_memory
+      case 'r':
+        if (strcmp(op, "grow_memory") == 0) return makeHost(s, HostOp::GrowMemory);
+        goto parse_error;
       default: goto parse_error;
     }
   }
@@ -256,24 +396,152 @@ switch (op[0]) {
         switch (op[4]) {
           case 'a': {
             switch (op[5]) {
-              case 'd': return makeBinary(s, BinaryOp::AddInt32); // i32.add
-              case 'n': return makeBinary(s, BinaryOp::AndInt32); // i32.and
+              case 'd':
+                if (strcmp(op, "i32.add") == 0) return makeBinary(s, BinaryOp::AddInt32);
+                goto parse_error;
+              case 'n':
+                if (strcmp(op, "i32.and") == 0) return makeBinary(s, BinaryOp::AndInt32);
+                goto parse_error;
               case 't': {
                 switch (op[11]) {
                   case 'l': {
                     switch (op[15]) {
-                      case '\0': return makeLoad(s, i32, /*isAtomic=*/true); // i32.atomic.load
-                      case '1': return makeLoad(s, i32, /*isAtomic=*/true); // i32.atomic.load16_u
-                      case '8': return makeLoad(s, i32, /*isAtomic=*/true); // i32.atomic.load8_u
+                      case '\0':
+                        if (strcmp(op, "i32.atomic.load") == 0) return makeLoad(s, i32, /*isAtomic=*/true);
+                        goto parse_error;
+                      case '1':
+                        if (strcmp(op, "i32.atomic.load16_u") == 0) return makeLoad(s, i32, /*isAtomic=*/true);
+                        goto parse_error;
+                      case '8':
+                        if (strcmp(op, "i32.atomic.load8_u") == 0) return makeLoad(s, i32, /*isAtomic=*/true);
+                        goto parse_error;
+                      default: goto parse_error;
+                    }
+                  }
+                  case 'r': {
+                    switch (op[14]) {
+                      case '.': {
+                        switch (op[15]) {
+                          case 'a': {
+                            switch (op[16]) {
+                              case 'd':
+                                if (strcmp(op, "i32.atomic.rmw.add") == 0) return makeAtomicRMWOrCmpxchg(s, i32);
+                                goto parse_error;
+                              case 'n':
+                                if (strcmp(op, "i32.atomic.rmw.and") == 0) return makeAtomicRMWOrCmpxchg(s, i32);
+                                goto parse_error;
+                              default: goto parse_error;
+                            }
+                          }
+                          case 'c':
+                            if (strcmp(op, "i32.atomic.rmw.cmpxchg") == 0) return makeAtomicRMWOrCmpxchg(s, i32);
+                            goto parse_error;
+                          case 'o':
+                            if (strcmp(op, "i32.atomic.rmw.or") == 0) return makeAtomicRMWOrCmpxchg(s, i32);
+                            goto parse_error;
+                          case 's':
+                            if (strcmp(op, "i32.atomic.rmw.sub") == 0) return makeAtomicRMWOrCmpxchg(s, i32);
+                            goto parse_error;
+                          case 'x': {
+                            switch (op[16]) {
+                              case 'c':
+                                if (strcmp(op, "i32.atomic.rmw.xchg") == 0) return makeAtomicRMWOrCmpxchg(s, i32);
+                                goto parse_error;
+                              case 'o':
+                                if (strcmp(op, "i32.atomic.rmw.xor") == 0) return makeAtomicRMWOrCmpxchg(s, i32);
+                                goto parse_error;
+                              default: goto parse_error;
+                            }
+                          }
+                          default: goto parse_error;
+                        }
+                      }
+                      case '1': {
+                        switch (op[19]) {
+                          case 'a': {
+                            switch (op[20]) {
+                              case 'd':
+                                if (strcmp(op, "i32.atomic.rmw16_u.add") == 0) return makeAtomicRMWOrCmpxchg(s, i32);
+                                goto parse_error;
+                              case 'n':
+                                if (strcmp(op, "i32.atomic.rmw16_u.and") == 0) return makeAtomicRMWOrCmpxchg(s, i32);
+                                goto parse_error;
+                              default: goto parse_error;
+                            }
+                          }
+                          case 'c':
+                            if (strcmp(op, "i32.atomic.rmw16_u.cmpxchg") == 0) return makeAtomicRMWOrCmpxchg(s, i32);
+                            goto parse_error;
+                          case 'o':
+                            if (strcmp(op, "i32.atomic.rmw16_u.or") == 0) return makeAtomicRMWOrCmpxchg(s, i32);
+                            goto parse_error;
+                          case 's':
+                            if (strcmp(op, "i32.atomic.rmw16_u.sub") == 0) return makeAtomicRMWOrCmpxchg(s, i32);
+                            goto parse_error;
+                          case 'x': {
+                            switch (op[20]) {
+                              case 'c':
+                                if (strcmp(op, "i32.atomic.rmw16_u.xchg") == 0) return makeAtomicRMWOrCmpxchg(s, i32);
+                                goto parse_error;
+                              case 'o':
+                                if (strcmp(op, "i32.atomic.rmw16_u.xor") == 0) return makeAtomicRMWOrCmpxchg(s, i32);
+                                goto parse_error;
+                              default: goto parse_error;
+                            }
+                          }
+                          default: goto parse_error;
+                        }
+                      }
+                      case '8': {
+                        switch (op[18]) {
+                          case 'a': {
+                            switch (op[19]) {
+                              case 'd':
+                                if (strcmp(op, "i32.atomic.rmw8_u.add") == 0) return makeAtomicRMWOrCmpxchg(s, i32);
+                                goto parse_error;
+                              case 'n':
+                                if (strcmp(op, "i32.atomic.rmw8_u.and") == 0) return makeAtomicRMWOrCmpxchg(s, i32);
+                                goto parse_error;
+                              default: goto parse_error;
+                            }
+                          }
+                          case 'c':
+                            if (strcmp(op, "i32.atomic.rmw8_u.cmpxchg") == 0) return makeAtomicRMWOrCmpxchg(s, i32);
+                            goto parse_error;
+                          case 'o':
+                            if (strcmp(op, "i32.atomic.rmw8_u.or") == 0) return makeAtomicRMWOrCmpxchg(s, i32);
+                            goto parse_error;
+                          case 's':
+                            if (strcmp(op, "i32.atomic.rmw8_u.sub") == 0) return makeAtomicRMWOrCmpxchg(s, i32);
+                            goto parse_error;
+                          case 'x': {
+                            switch (op[19]) {
+                              case 'c':
+                                if (strcmp(op, "i32.atomic.rmw8_u.xchg") == 0) return makeAtomicRMWOrCmpxchg(s, i32);
+                                goto parse_error;
+                              case 'o':
+                                if (strcmp(op, "i32.atomic.rmw8_u.xor") == 0) return makeAtomicRMWOrCmpxchg(s, i32);
+                                goto parse_error;
+                              default: goto parse_error;
+                            }
+                          }
+                          default: goto parse_error;
+                        }
+                      }
                       default: goto parse_error;
                     }
                   }
-                  case 'r': return makeAtomicRMWOrCmpxchg(s, i32); // i32.atomic.rmw.add | i32.atomic.rmw.and | i32.atomic.rmw.cmpxchg | i32.atomic.rmw.or | i32.atomic.rmw.sub | i32.atomic.rmw.xchg | i32.atomic.rmw.xor | i32.atomic.rmw16_u.add | i32.atomic.rmw16_u.and | i32.atomic.rmw16_u.cmpxchg | i32.atomic.rmw16_u.or | i32.atomic.rmw16_u.sub | i32.atomic.rmw16_u.xchg | i32.atomic.rmw16_u.xor | i32.atomic.rmw8_u.add | i32.atomic.rmw8_u.and | i32.atomic.rmw8_u.cmpxchg | i32.atomic.rmw8_u.or | i32.atomic.rmw8_u.sub | i32.atomic.rmw8_u.xchg | i32.atomic.rmw8_u.xor
                   case 's': {
                     switch (op[16]) {
-                      case '\0': return makeStore(s, i32, /*isAtomic=*/true); // i32.atomic.store
-                      case '1': return makeStore(s, i32, /*isAtomic=*/true); // i32.atomic.store16
-                      case '8': return makeStore(s, i32, /*isAtomic=*/true); // i32.atomic.store8
+                      case '\0':
+                        if (strcmp(op, "i32.atomic.store") == 0) return makeStore(s, i32, /*isAtomic=*/true);
+                        goto parse_error;
+                      case '1':
+                        if (strcmp(op, "i32.atomic.store16") == 0) return makeStore(s, i32, /*isAtomic=*/true);
+                        goto parse_error;
+                      case '8':
+                        if (strcmp(op, "i32.atomic.store8") == 0) return makeStore(s, i32, /*isAtomic=*/true);
+                        goto parse_error;
                       default: goto parse_error;
                     }
                   }
@@ -285,16 +553,26 @@ switch (op[0]) {
           }
           case 'c': {
             switch (op[5]) {
-              case 'l': return makeUnary(s, UnaryOp::ClzInt32); // i32.clz
-              case 'o': return makeConst(s, i32); // i32.const
-              case 't': return makeUnary(s, UnaryOp::CtzInt32); // i32.ctz
+              case 'l':
+                if (strcmp(op, "i32.clz") == 0) return makeUnary(s, UnaryOp::ClzInt32);
+                goto parse_error;
+              case 'o':
+                if (strcmp(op, "i32.const") == 0) return makeConst(s, i32);
+                goto parse_error;
+              case 't':
+                if (strcmp(op, "i32.ctz") == 0) return makeUnary(s, UnaryOp::CtzInt32);
+                goto parse_error;
               default: goto parse_error;
             }
           }
           case 'd': {
             switch (op[8]) {
-              case 's': return makeBinary(s, BinaryOp::DivSInt32); // i32.div_s
-              case 'u': return makeBinary(s, BinaryOp::DivUInt32); // i32.div_u
+              case 's':
+                if (strcmp(op, "i32.div_s") == 0) return makeBinary(s, BinaryOp::DivSInt32);
+                goto parse_error;
+              case 'u':
+                if (strcmp(op, "i32.div_u") == 0) return makeBinary(s, BinaryOp::DivUInt32);
+                goto parse_error;
               default: goto parse_error;
             }
           }
@@ -302,15 +580,23 @@ switch (op[0]) {
             switch (op[5]) {
               case 'q': {
                 switch (op[6]) {
-                  case '\0': return makeBinary(s, BinaryOp::EqInt32); // i32.eq
-                  case 'z': return makeUnary(s, UnaryOp::EqZInt32); // i32.eqz
+                  case '\0':
+                    if (strcmp(op, "i32.eq") == 0) return makeBinary(s, BinaryOp::EqInt32);
+                    goto parse_error;
+                  case 'z':
+                    if (strcmp(op, "i32.eqz") == 0) return makeUnary(s, UnaryOp::EqZInt32);
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
               case 'x': {
                 switch (op[10]) {
-                  case '1': return makeUnary(s, UnaryOp::ExtendS16Int32); // i32.extend16_s
-                  case '8': return makeUnary(s, UnaryOp::ExtendS8Int32); // i32.extend8_s
+                  case '1':
+                    if (strcmp(op, "i32.extend16_s") == 0) return makeUnary(s, UnaryOp::ExtendS16Int32);
+                    goto parse_error;
+                  case '8':
+                    if (strcmp(op, "i32.extend8_s") == 0) return makeUnary(s, UnaryOp::ExtendS8Int32);
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
@@ -321,15 +607,23 @@ switch (op[0]) {
             switch (op[5]) {
               case 'e': {
                 switch (op[7]) {
-                  case 's': return makeBinary(s, BinaryOp::GeSInt32); // i32.ge_s
-                  case 'u': return makeBinary(s, BinaryOp::GeUInt32); // i32.ge_u
+                  case 's':
+                    if (strcmp(op, "i32.ge_s") == 0) return makeBinary(s, BinaryOp::GeSInt32);
+                    goto parse_error;
+                  case 'u':
+                    if (strcmp(op, "i32.ge_u") == 0) return makeBinary(s, BinaryOp::GeUInt32);
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
               case 't': {
                 switch (op[7]) {
-                  case 's': return makeBinary(s, BinaryOp::GtSInt32); // i32.gt_s
-                  case 'u': return makeBinary(s, BinaryOp::GtUInt32); // i32.gt_u
+                  case 's':
+                    if (strcmp(op, "i32.gt_s") == 0) return makeBinary(s, BinaryOp::GtSInt32);
+                    goto parse_error;
+                  case 'u':
+                    if (strcmp(op, "i32.gt_u") == 0) return makeBinary(s, BinaryOp::GtUInt32);
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
@@ -340,42 +634,86 @@ switch (op[0]) {
             switch (op[5]) {
               case 'e': {
                 switch (op[7]) {
-                  case 's': return makeBinary(s, BinaryOp::LeSInt32); // i32.le_s
-                  case 'u': return makeBinary(s, BinaryOp::LeUInt32); // i32.le_u
+                  case 's':
+                    if (strcmp(op, "i32.le_s") == 0) return makeBinary(s, BinaryOp::LeSInt32);
+                    goto parse_error;
+                  case 'u':
+                    if (strcmp(op, "i32.le_u") == 0) return makeBinary(s, BinaryOp::LeUInt32);
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
               case 'o': {
                 switch (op[8]) {
-                  case '\0': return makeLoad(s, i32, /*isAtomic=*/false); // i32.load
-                  case '1': return makeLoad(s, i32, /*isAtomic=*/false); // i32.load16_s | i32.load16_u
-                  case '8': return makeLoad(s, i32, /*isAtomic=*/false); // i32.load8_s | i32.load8_u
+                  case '\0':
+                    if (strcmp(op, "i32.load") == 0) return makeLoad(s, i32, /*isAtomic=*/false);
+                    goto parse_error;
+                  case '1': {
+                    switch (op[11]) {
+                      case 's':
+                        if (strcmp(op, "i32.load16_s") == 0) return makeLoad(s, i32, /*isAtomic=*/false);
+                        goto parse_error;
+                      case 'u':
+                        if (strcmp(op, "i32.load16_u") == 0) return makeLoad(s, i32, /*isAtomic=*/false);
+                        goto parse_error;
+                      default: goto parse_error;
+                    }
+                  }
+                  case '8': {
+                    switch (op[10]) {
+                      case 's':
+                        if (strcmp(op, "i32.load8_s") == 0) return makeLoad(s, i32, /*isAtomic=*/false);
+                        goto parse_error;
+                      case 'u':
+                        if (strcmp(op, "i32.load8_u") == 0) return makeLoad(s, i32, /*isAtomic=*/false);
+                        goto parse_error;
+                      default: goto parse_error;
+                    }
+                  }
                   default: goto parse_error;
                 }
               }
               case 't': {
                 switch (op[7]) {
-                  case 's': return makeBinary(s, BinaryOp::LtSInt32); // i32.lt_s
-                  case 'u': return makeBinary(s, BinaryOp::LtUInt32); // i32.lt_u
+                  case 's':
+                    if (strcmp(op, "i32.lt_s") == 0) return makeBinary(s, BinaryOp::LtSInt32);
+                    goto parse_error;
+                  case 'u':
+                    if (strcmp(op, "i32.lt_u") == 0) return makeBinary(s, BinaryOp::LtUInt32);
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
               default: goto parse_error;
             }
           }
-          case 'm': return makeBinary(s, BinaryOp::MulInt32); // i32.mul
-          case 'n': return makeBinary(s, BinaryOp::NeInt32); // i32.ne
-          case 'o': return makeBinary(s, BinaryOp::OrInt32); // i32.or
-          case 'p': return makeUnary(s, UnaryOp::PopcntInt32); // i32.popcnt
+          case 'm':
+            if (strcmp(op, "i32.mul") == 0) return makeBinary(s, BinaryOp::MulInt32);
+            goto parse_error;
+          case 'n':
+            if (strcmp(op, "i32.ne") == 0) return makeBinary(s, BinaryOp::NeInt32);
+            goto parse_error;
+          case 'o':
+            if (strcmp(op, "i32.or") == 0) return makeBinary(s, BinaryOp::OrInt32);
+            goto parse_error;
+          case 'p':
+            if (strcmp(op, "i32.popcnt") == 0) return makeUnary(s, UnaryOp::PopcntInt32);
+            goto parse_error;
           case 'r': {
             switch (op[5]) {
               case 'e': {
                 switch (op[6]) {
-                  case 'i': return makeUnary(s, UnaryOp::ReinterpretFloat32); // i32.reinterpret/f32
+                  case 'i':
+                    if (strcmp(op, "i32.reinterpret/f32") == 0) return makeUnary(s, UnaryOp::ReinterpretFloat32);
+                    goto parse_error;
                   case 'm': {
                     switch (op[8]) {
-                      case 's': return makeBinary(s, BinaryOp::RemSInt32); // i32.rem_s
-                      case 'u': return makeBinary(s, BinaryOp::RemUInt32); // i32.rem_u
+                      case 's':
+                        if (strcmp(op, "i32.rem_s") == 0) return makeBinary(s, BinaryOp::RemSInt32);
+                        goto parse_error;
+                      case 'u':
+                        if (strcmp(op, "i32.rem_u") == 0) return makeBinary(s, BinaryOp::RemUInt32);
+                        goto parse_error;
                       default: goto parse_error;
                     }
                   }
@@ -384,8 +722,12 @@ switch (op[0]) {
               }
               case 'o': {
                 switch (op[7]) {
-                  case 'l': return makeBinary(s, BinaryOp::RotLInt32); // i32.rotl
-                  case 'r': return makeBinary(s, BinaryOp::RotRInt32); // i32.rotr
+                  case 'l':
+                    if (strcmp(op, "i32.rotl") == 0) return makeBinary(s, BinaryOp::RotLInt32);
+                    goto parse_error;
+                  case 'r':
+                    if (strcmp(op, "i32.rotr") == 0) return makeBinary(s, BinaryOp::RotRInt32);
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
@@ -396,11 +738,17 @@ switch (op[0]) {
             switch (op[5]) {
               case 'h': {
                 switch (op[6]) {
-                  case 'l': return makeBinary(s, BinaryOp::ShlInt32); // i32.shl
+                  case 'l':
+                    if (strcmp(op, "i32.shl") == 0) return makeBinary(s, BinaryOp::ShlInt32);
+                    goto parse_error;
                   case 'r': {
                     switch (op[8]) {
-                      case 's': return makeBinary(s, BinaryOp::ShrSInt32); // i32.shr_s
-                      case 'u': return makeBinary(s, BinaryOp::ShrUInt32); // i32.shr_u
+                      case 's':
+                        if (strcmp(op, "i32.shr_s") == 0) return makeBinary(s, BinaryOp::ShrSInt32);
+                        goto parse_error;
+                      case 'u':
+                        if (strcmp(op, "i32.shr_u") == 0) return makeBinary(s, BinaryOp::ShrUInt32);
+                        goto parse_error;
                       default: goto parse_error;
                     }
                   }
@@ -409,13 +757,21 @@ switch (op[0]) {
               }
               case 't': {
                 switch (op[9]) {
-                  case '\0': return makeStore(s, i32, /*isAtomic=*/false); // i32.store
-                  case '1': return makeStore(s, i32, /*isAtomic=*/false); // i32.store16
-                  case '8': return makeStore(s, i32, /*isAtomic=*/false); // i32.store8
+                  case '\0':
+                    if (strcmp(op, "i32.store") == 0) return makeStore(s, i32, /*isAtomic=*/false);
+                    goto parse_error;
+                  case '1':
+                    if (strcmp(op, "i32.store16") == 0) return makeStore(s, i32, /*isAtomic=*/false);
+                    goto parse_error;
+                  case '8':
+                    if (strcmp(op, "i32.store8") == 0) return makeStore(s, i32, /*isAtomic=*/false);
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
-              case 'u': return makeBinary(s, BinaryOp::SubInt32); // i32.sub
+              case 'u':
+                if (strcmp(op, "i32.sub") == 0) return makeBinary(s, BinaryOp::SubInt32);
+                goto parse_error;
               default: goto parse_error;
             }
           }
@@ -423,15 +779,23 @@ switch (op[0]) {
             switch (op[10]) {
               case 's': {
                 switch (op[13]) {
-                  case '3': return makeUnary(s, UnaryOp::TruncSFloat32ToInt32); // i32.trunc_s/f32
-                  case '6': return makeUnary(s, UnaryOp::TruncSFloat64ToInt32); // i32.trunc_s/f64
+                  case '3':
+                    if (strcmp(op, "i32.trunc_s/f32") == 0) return makeUnary(s, UnaryOp::TruncSFloat32ToInt32);
+                    goto parse_error;
+                  case '6':
+                    if (strcmp(op, "i32.trunc_s/f64") == 0) return makeUnary(s, UnaryOp::TruncSFloat64ToInt32);
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
               case 'u': {
                 switch (op[13]) {
-                  case '3': return makeUnary(s, UnaryOp::TruncUFloat32ToInt32); // i32.trunc_u/f32
-                  case '6': return makeUnary(s, UnaryOp::TruncUFloat64ToInt32); // i32.trunc_u/f64
+                  case '3':
+                    if (strcmp(op, "i32.trunc_u/f32") == 0) return makeUnary(s, UnaryOp::TruncUFloat32ToInt32);
+                    goto parse_error;
+                  case '6':
+                    if (strcmp(op, "i32.trunc_u/f64") == 0) return makeUnary(s, UnaryOp::TruncUFloat64ToInt32);
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
@@ -440,12 +804,18 @@ switch (op[0]) {
           }
           case 'w': {
             switch (op[5]) {
-              case 'a': return makeAtomicWait(s, i32); // i32.wait
-              case 'r': return makeUnary(s, UnaryOp::WrapInt64); // i32.wrap/i64
+              case 'a':
+                if (strcmp(op, "i32.wait") == 0) return makeAtomicWait(s, i32);
+                goto parse_error;
+              case 'r':
+                if (strcmp(op, "i32.wrap/i64") == 0) return makeUnary(s, UnaryOp::WrapInt64);
+                goto parse_error;
               default: goto parse_error;
             }
           }
-          case 'x': return makeBinary(s, BinaryOp::XorInt32); // i32.xor
+          case 'x':
+            if (strcmp(op, "i32.xor") == 0) return makeBinary(s, BinaryOp::XorInt32);
+            goto parse_error;
           default: goto parse_error;
         }
       }
@@ -453,26 +823,194 @@ switch (op[0]) {
         switch (op[4]) {
           case 'a': {
             switch (op[5]) {
-              case 'd': return makeBinary(s, BinaryOp::AddInt64); // i64.add
-              case 'n': return makeBinary(s, BinaryOp::AndInt64); // i64.and
+              case 'd':
+                if (strcmp(op, "i64.add") == 0) return makeBinary(s, BinaryOp::AddInt64);
+                goto parse_error;
+              case 'n':
+                if (strcmp(op, "i64.and") == 0) return makeBinary(s, BinaryOp::AndInt64);
+                goto parse_error;
               case 't': {
                 switch (op[11]) {
                   case 'l': {
                     switch (op[15]) {
-                      case '\0': return makeLoad(s, i64, /*isAtomic=*/true); // i64.atomic.load
-                      case '1': return makeLoad(s, i64, /*isAtomic=*/true); // i64.atomic.load16_u
-                      case '3': return makeLoad(s, i64, /*isAtomic=*/true); // i64.atomic.load32_u
-                      case '8': return makeLoad(s, i64, /*isAtomic=*/true); // i64.atomic.load8_u
+                      case '\0':
+                        if (strcmp(op, "i64.atomic.load") == 0) return makeLoad(s, i64, /*isAtomic=*/true);
+                        goto parse_error;
+                      case '1':
+                        if (strcmp(op, "i64.atomic.load16_u") == 0) return makeLoad(s, i64, /*isAtomic=*/true);
+                        goto parse_error;
+                      case '3':
+                        if (strcmp(op, "i64.atomic.load32_u") == 0) return makeLoad(s, i64, /*isAtomic=*/true);
+                        goto parse_error;
+                      case '8':
+                        if (strcmp(op, "i64.atomic.load8_u") == 0) return makeLoad(s, i64, /*isAtomic=*/true);
+                        goto parse_error;
+                      default: goto parse_error;
+                    }
+                  }
+                  case 'r': {
+                    switch (op[14]) {
+                      case '.': {
+                        switch (op[15]) {
+                          case 'a': {
+                            switch (op[16]) {
+                              case 'd':
+                                if (strcmp(op, "i64.atomic.rmw.add") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                                goto parse_error;
+                              case 'n':
+                                if (strcmp(op, "i64.atomic.rmw.and") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                                goto parse_error;
+                              default: goto parse_error;
+                            }
+                          }
+                          case 'c':
+                            if (strcmp(op, "i64.atomic.rmw.cmpxchg") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                            goto parse_error;
+                          case 'o':
+                            if (strcmp(op, "i64.atomic.rmw.or") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                            goto parse_error;
+                          case 's':
+                            if (strcmp(op, "i64.atomic.rmw.sub") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                            goto parse_error;
+                          case 'x': {
+                            switch (op[16]) {
+                              case 'c':
+                                if (strcmp(op, "i64.atomic.rmw.xchg") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                                goto parse_error;
+                              case 'o':
+                                if (strcmp(op, "i64.atomic.rmw.xor") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                                goto parse_error;
+                              default: goto parse_error;
+                            }
+                          }
+                          default: goto parse_error;
+                        }
+                      }
+                      case '1': {
+                        switch (op[19]) {
+                          case 'a': {
+                            switch (op[20]) {
+                              case 'd':
+                                if (strcmp(op, "i64.atomic.rmw16_u.add") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                                goto parse_error;
+                              case 'n':
+                                if (strcmp(op, "i64.atomic.rmw16_u.and") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                                goto parse_error;
+                              default: goto parse_error;
+                            }
+                          }
+                          case 'c':
+                            if (strcmp(op, "i64.atomic.rmw16_u.cmpxchg") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                            goto parse_error;
+                          case 'o':
+                            if (strcmp(op, "i64.atomic.rmw16_u.or") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                            goto parse_error;
+                          case 's':
+                            if (strcmp(op, "i64.atomic.rmw16_u.sub") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                            goto parse_error;
+                          case 'x': {
+                            switch (op[20]) {
+                              case 'c':
+                                if (strcmp(op, "i64.atomic.rmw16_u.xchg") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                                goto parse_error;
+                              case 'o':
+                                if (strcmp(op, "i64.atomic.rmw16_u.xor") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                                goto parse_error;
+                              default: goto parse_error;
+                            }
+                          }
+                          default: goto parse_error;
+                        }
+                      }
+                      case '3': {
+                        switch (op[19]) {
+                          case 'a': {
+                            switch (op[20]) {
+                              case 'd':
+                                if (strcmp(op, "i64.atomic.rmw32_u.add") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                                goto parse_error;
+                              case 'n':
+                                if (strcmp(op, "i64.atomic.rmw32_u.and") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                                goto parse_error;
+                              default: goto parse_error;
+                            }
+                          }
+                          case 'c':
+                            if (strcmp(op, "i64.atomic.rmw32_u.cmpxchg") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                            goto parse_error;
+                          case 'o':
+                            if (strcmp(op, "i64.atomic.rmw32_u.or") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                            goto parse_error;
+                          case 's':
+                            if (strcmp(op, "i64.atomic.rmw32_u.sub") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                            goto parse_error;
+                          case 'x': {
+                            switch (op[20]) {
+                              case 'c':
+                                if (strcmp(op, "i64.atomic.rmw32_u.xchg") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                                goto parse_error;
+                              case 'o':
+                                if (strcmp(op, "i64.atomic.rmw32_u.xor") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                                goto parse_error;
+                              default: goto parse_error;
+                            }
+                          }
+                          default: goto parse_error;
+                        }
+                      }
+                      case '8': {
+                        switch (op[18]) {
+                          case 'a': {
+                            switch (op[19]) {
+                              case 'd':
+                                if (strcmp(op, "i64.atomic.rmw8_u.add") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                                goto parse_error;
+                              case 'n':
+                                if (strcmp(op, "i64.atomic.rmw8_u.and") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                                goto parse_error;
+                              default: goto parse_error;
+                            }
+                          }
+                          case 'c':
+                            if (strcmp(op, "i64.atomic.rmw8_u.cmpxchg") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                            goto parse_error;
+                          case 'o':
+                            if (strcmp(op, "i64.atomic.rmw8_u.or") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                            goto parse_error;
+                          case 's':
+                            if (strcmp(op, "i64.atomic.rmw8_u.sub") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                            goto parse_error;
+                          case 'x': {
+                            switch (op[19]) {
+                              case 'c':
+                                if (strcmp(op, "i64.atomic.rmw8_u.xchg") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                                goto parse_error;
+                              case 'o':
+                                if (strcmp(op, "i64.atomic.rmw8_u.xor") == 0) return makeAtomicRMWOrCmpxchg(s, i64);
+                                goto parse_error;
+                              default: goto parse_error;
+                            }
+                          }
+                          default: goto parse_error;
+                        }
+                      }
                       default: goto parse_error;
                     }
                   }
-                  case 'r': return makeAtomicRMWOrCmpxchg(s, i64); // i64.atomic.rmw.add | i64.atomic.rmw.and | i64.atomic.rmw.cmpxchg | i64.atomic.rmw.or | i64.atomic.rmw.sub | i64.atomic.rmw.xchg | i64.atomic.rmw.xor | i64.atomic.rmw16_u.add | i64.atomic.rmw16_u.and | i64.atomic.rmw16_u.cmpxchg | i64.atomic.rmw16_u.or | i64.atomic.rmw16_u.sub | i64.atomic.rmw16_u.xchg | i64.atomic.rmw16_u.xor | i64.atomic.rmw32_u.add | i64.atomic.rmw32_u.and | i64.atomic.rmw32_u.cmpxchg | i64.atomic.rmw32_u.or | i64.atomic.rmw32_u.sub | i64.atomic.rmw32_u.xchg | i64.atomic.rmw32_u.xor | i64.atomic.rmw8_u.add | i64.atomic.rmw8_u.and | i64.atomic.rmw8_u.cmpxchg | i64.atomic.rmw8_u.or | i64.atomic.rmw8_u.sub | i64.atomic.rmw8_u.xchg | i64.atomic.rmw8_u.xor
                   case 's': {
                     switch (op[16]) {
-                      case '\0': return makeStore(s, i64, /*isAtomic=*/true); // i64.atomic.store
-                      case '1': return makeStore(s, i64, /*isAtomic=*/true); // i64.atomic.store16
-                      case '3': return makeStore(s, i64, /*isAtomic=*/true); // i64.atomic.store32
-                      case '8': return makeStore(s, i64, /*isAtomic=*/true); // i64.atomic.store8
+                      case '\0':
+                        if (strcmp(op, "i64.atomic.store") == 0) return makeStore(s, i64, /*isAtomic=*/true);
+                        goto parse_error;
+                      case '1':
+                        if (strcmp(op, "i64.atomic.store16") == 0) return makeStore(s, i64, /*isAtomic=*/true);
+                        goto parse_error;
+                      case '3':
+                        if (strcmp(op, "i64.atomic.store32") == 0) return makeStore(s, i64, /*isAtomic=*/true);
+                        goto parse_error;
+                      case '8':
+                        if (strcmp(op, "i64.atomic.store8") == 0) return makeStore(s, i64, /*isAtomic=*/true);
+                        goto parse_error;
                       default: goto parse_error;
                     }
                   }
@@ -484,16 +1022,26 @@ switch (op[0]) {
           }
           case 'c': {
             switch (op[5]) {
-              case 'l': return makeUnary(s, UnaryOp::ClzInt64); // i64.clz
-              case 'o': return makeConst(s, i64); // i64.const
-              case 't': return makeUnary(s, UnaryOp::CtzInt64); // i64.ctz
+              case 'l':
+                if (strcmp(op, "i64.clz") == 0) return makeUnary(s, UnaryOp::ClzInt64);
+                goto parse_error;
+              case 'o':
+                if (strcmp(op, "i64.const") == 0) return makeConst(s, i64);
+                goto parse_error;
+              case 't':
+                if (strcmp(op, "i64.ctz") == 0) return makeUnary(s, UnaryOp::CtzInt64);
+                goto parse_error;
               default: goto parse_error;
             }
           }
           case 'd': {
             switch (op[8]) {
-              case 's': return makeBinary(s, BinaryOp::DivSInt64); // i64.div_s
-              case 'u': return makeBinary(s, BinaryOp::DivUInt64); // i64.div_u
+              case 's':
+                if (strcmp(op, "i64.div_s") == 0) return makeBinary(s, BinaryOp::DivSInt64);
+                goto parse_error;
+              case 'u':
+                if (strcmp(op, "i64.div_u") == 0) return makeBinary(s, BinaryOp::DivUInt64);
+                goto parse_error;
               default: goto parse_error;
             }
           }
@@ -501,20 +1049,34 @@ switch (op[0]) {
             switch (op[5]) {
               case 'q': {
                 switch (op[6]) {
-                  case '\0': return makeBinary(s, BinaryOp::EqInt64); // i64.eq
-                  case 'z': return makeUnary(s, UnaryOp::EqZInt64); // i64.eqz
+                  case '\0':
+                    if (strcmp(op, "i64.eq") == 0) return makeBinary(s, BinaryOp::EqInt64);
+                    goto parse_error;
+                  case 'z':
+                    if (strcmp(op, "i64.eqz") == 0) return makeUnary(s, UnaryOp::EqZInt64);
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
               case 'x': {
                 switch (op[10]) {
-                  case '1': return makeUnary(s, UnaryOp::ExtendS16Int64); // i64.extend16_s
-                  case '3': return makeUnary(s, UnaryOp::ExtendS32Int64); // i64.extend32_s
-                  case '8': return makeUnary(s, UnaryOp::ExtendS8Int64); // i64.extend8_s
+                  case '1':
+                    if (strcmp(op, "i64.extend16_s") == 0) return makeUnary(s, UnaryOp::ExtendS16Int64);
+                    goto parse_error;
+                  case '3':
+                    if (strcmp(op, "i64.extend32_s") == 0) return makeUnary(s, UnaryOp::ExtendS32Int64);
+                    goto parse_error;
+                  case '8':
+                    if (strcmp(op, "i64.extend8_s") == 0) return makeUnary(s, UnaryOp::ExtendS8Int64);
+                    goto parse_error;
                   case '_': {
                     switch (op[11]) {
-                      case 's': return makeUnary(s, UnaryOp::ExtendSInt32); // i64.extend_s/i32
-                      case 'u': return makeUnary(s, UnaryOp::ExtendUInt32); // i64.extend_u/i32
+                      case 's':
+                        if (strcmp(op, "i64.extend_s/i32") == 0) return makeUnary(s, UnaryOp::ExtendSInt32);
+                        goto parse_error;
+                      case 'u':
+                        if (strcmp(op, "i64.extend_u/i32") == 0) return makeUnary(s, UnaryOp::ExtendUInt32);
+                        goto parse_error;
                       default: goto parse_error;
                     }
                   }
@@ -528,15 +1090,23 @@ switch (op[0]) {
             switch (op[5]) {
               case 'e': {
                 switch (op[7]) {
-                  case 's': return makeBinary(s, BinaryOp::GeSInt64); // i64.ge_s
-                  case 'u': return makeBinary(s, BinaryOp::GeUInt64); // i64.ge_u
+                  case 's':
+                    if (strcmp(op, "i64.ge_s") == 0) return makeBinary(s, BinaryOp::GeSInt64);
+                    goto parse_error;
+                  case 'u':
+                    if (strcmp(op, "i64.ge_u") == 0) return makeBinary(s, BinaryOp::GeUInt64);
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
               case 't': {
                 switch (op[7]) {
-                  case 's': return makeBinary(s, BinaryOp::GtSInt64); // i64.gt_s
-                  case 'u': return makeBinary(s, BinaryOp::GtUInt64); // i64.gt_u
+                  case 's':
+                    if (strcmp(op, "i64.gt_s") == 0) return makeBinary(s, BinaryOp::GtSInt64);
+                    goto parse_error;
+                  case 'u':
+                    if (strcmp(op, "i64.gt_u") == 0) return makeBinary(s, BinaryOp::GtUInt64);
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
@@ -547,43 +1117,97 @@ switch (op[0]) {
             switch (op[5]) {
               case 'e': {
                 switch (op[7]) {
-                  case 's': return makeBinary(s, BinaryOp::LeSInt64); // i64.le_s
-                  case 'u': return makeBinary(s, BinaryOp::LeUInt64); // i64.le_u
+                  case 's':
+                    if (strcmp(op, "i64.le_s") == 0) return makeBinary(s, BinaryOp::LeSInt64);
+                    goto parse_error;
+                  case 'u':
+                    if (strcmp(op, "i64.le_u") == 0) return makeBinary(s, BinaryOp::LeUInt64);
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
               case 'o': {
                 switch (op[8]) {
-                  case '\0': return makeLoad(s, i64, /*isAtomic=*/false); // i64.load
-                  case '1': return makeLoad(s, i64, /*isAtomic=*/false); // i64.load16_s | i64.load16_u
-                  case '3': return makeLoad(s, i64, /*isAtomic=*/false); // i64.load32_s | i64.load32_u
-                  case '8': return makeLoad(s, i64, /*isAtomic=*/false); // i64.load8_s | i64.load8_u
+                  case '\0':
+                    if (strcmp(op, "i64.load") == 0) return makeLoad(s, i64, /*isAtomic=*/false);
+                    goto parse_error;
+                  case '1': {
+                    switch (op[11]) {
+                      case 's':
+                        if (strcmp(op, "i64.load16_s") == 0) return makeLoad(s, i64, /*isAtomic=*/false);
+                        goto parse_error;
+                      case 'u':
+                        if (strcmp(op, "i64.load16_u") == 0) return makeLoad(s, i64, /*isAtomic=*/false);
+                        goto parse_error;
+                      default: goto parse_error;
+                    }
+                  }
+                  case '3': {
+                    switch (op[11]) {
+                      case 's':
+                        if (strcmp(op, "i64.load32_s") == 0) return makeLoad(s, i64, /*isAtomic=*/false);
+                        goto parse_error;
+                      case 'u':
+                        if (strcmp(op, "i64.load32_u") == 0) return makeLoad(s, i64, /*isAtomic=*/false);
+                        goto parse_error;
+                      default: goto parse_error;
+                    }
+                  }
+                  case '8': {
+                    switch (op[10]) {
+                      case 's':
+                        if (strcmp(op, "i64.load8_s") == 0) return makeLoad(s, i64, /*isAtomic=*/false);
+                        goto parse_error;
+                      case 'u':
+                        if (strcmp(op, "i64.load8_u") == 0) return makeLoad(s, i64, /*isAtomic=*/false);
+                        goto parse_error;
+                      default: goto parse_error;
+                    }
+                  }
                   default: goto parse_error;
                 }
               }
               case 't': {
                 switch (op[7]) {
-                  case 's': return makeBinary(s, BinaryOp::LtSInt64); // i64.lt_s
-                  case 'u': return makeBinary(s, BinaryOp::LtUInt64); // i64.lt_u
+                  case 's':
+                    if (strcmp(op, "i64.lt_s") == 0) return makeBinary(s, BinaryOp::LtSInt64);
+                    goto parse_error;
+                  case 'u':
+                    if (strcmp(op, "i64.lt_u") == 0) return makeBinary(s, BinaryOp::LtUInt64);
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
               default: goto parse_error;
             }
           }
-          case 'm': return makeBinary(s, BinaryOp::MulInt64); // i64.mul
-          case 'n': return makeBinary(s, BinaryOp::NeInt64); // i64.ne
-          case 'o': return makeBinary(s, BinaryOp::OrInt64); // i64.or
-          case 'p': return makeUnary(s, UnaryOp::PopcntInt64); // i64.popcnt
+          case 'm':
+            if (strcmp(op, "i64.mul") == 0) return makeBinary(s, BinaryOp::MulInt64);
+            goto parse_error;
+          case 'n':
+            if (strcmp(op, "i64.ne") == 0) return makeBinary(s, BinaryOp::NeInt64);
+            goto parse_error;
+          case 'o':
+            if (strcmp(op, "i64.or") == 0) return makeBinary(s, BinaryOp::OrInt64);
+            goto parse_error;
+          case 'p':
+            if (strcmp(op, "i64.popcnt") == 0) return makeUnary(s, UnaryOp::PopcntInt64);
+            goto parse_error;
           case 'r': {
             switch (op[5]) {
               case 'e': {
                 switch (op[6]) {
-                  case 'i': return makeUnary(s, UnaryOp::ReinterpretFloat64); // i64.reinterpret/f64
+                  case 'i':
+                    if (strcmp(op, "i64.reinterpret/f64") == 0) return makeUnary(s, UnaryOp::ReinterpretFloat64);
+                    goto parse_error;
                   case 'm': {
                     switch (op[8]) {
-                      case 's': return makeBinary(s, BinaryOp::RemSInt64); // i64.rem_s
-                      case 'u': return makeBinary(s, BinaryOp::RemUInt64); // i64.rem_u
+                      case 's':
+                        if (strcmp(op, "i64.rem_s") == 0) return makeBinary(s, BinaryOp::RemSInt64);
+                        goto parse_error;
+                      case 'u':
+                        if (strcmp(op, "i64.rem_u") == 0) return makeBinary(s, BinaryOp::RemUInt64);
+                        goto parse_error;
                       default: goto parse_error;
                     }
                   }
@@ -592,8 +1216,12 @@ switch (op[0]) {
               }
               case 'o': {
                 switch (op[7]) {
-                  case 'l': return makeBinary(s, BinaryOp::RotLInt64); // i64.rotl
-                  case 'r': return makeBinary(s, BinaryOp::RotRInt64); // i64.rotr
+                  case 'l':
+                    if (strcmp(op, "i64.rotl") == 0) return makeBinary(s, BinaryOp::RotLInt64);
+                    goto parse_error;
+                  case 'r':
+                    if (strcmp(op, "i64.rotr") == 0) return makeBinary(s, BinaryOp::RotRInt64);
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
@@ -604,11 +1232,17 @@ switch (op[0]) {
             switch (op[5]) {
               case 'h': {
                 switch (op[6]) {
-                  case 'l': return makeBinary(s, BinaryOp::ShlInt64); // i64.shl
+                  case 'l':
+                    if (strcmp(op, "i64.shl") == 0) return makeBinary(s, BinaryOp::ShlInt64);
+                    goto parse_error;
                   case 'r': {
                     switch (op[8]) {
-                      case 's': return makeBinary(s, BinaryOp::ShrSInt64); // i64.shr_s
-                      case 'u': return makeBinary(s, BinaryOp::ShrUInt64); // i64.shr_u
+                      case 's':
+                        if (strcmp(op, "i64.shr_s") == 0) return makeBinary(s, BinaryOp::ShrSInt64);
+                        goto parse_error;
+                      case 'u':
+                        if (strcmp(op, "i64.shr_u") == 0) return makeBinary(s, BinaryOp::ShrUInt64);
+                        goto parse_error;
                       default: goto parse_error;
                     }
                   }
@@ -617,14 +1251,24 @@ switch (op[0]) {
               }
               case 't': {
                 switch (op[9]) {
-                  case '\0': return makeStore(s, i64, /*isAtomic=*/false); // i64.store
-                  case '1': return makeStore(s, i64, /*isAtomic=*/false); // i64.store16
-                  case '3': return makeStore(s, i64, /*isAtomic=*/false); // i64.store32
-                  case '8': return makeStore(s, i64, /*isAtomic=*/false); // i64.store8
+                  case '\0':
+                    if (strcmp(op, "i64.store") == 0) return makeStore(s, i64, /*isAtomic=*/false);
+                    goto parse_error;
+                  case '1':
+                    if (strcmp(op, "i64.store16") == 0) return makeStore(s, i64, /*isAtomic=*/false);
+                    goto parse_error;
+                  case '3':
+                    if (strcmp(op, "i64.store32") == 0) return makeStore(s, i64, /*isAtomic=*/false);
+                    goto parse_error;
+                  case '8':
+                    if (strcmp(op, "i64.store8") == 0) return makeStore(s, i64, /*isAtomic=*/false);
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
-              case 'u': return makeBinary(s, BinaryOp::SubInt64); // i64.sub
+              case 'u':
+                if (strcmp(op, "i64.sub") == 0) return makeBinary(s, BinaryOp::SubInt64);
+                goto parse_error;
               default: goto parse_error;
             }
           }
@@ -632,40 +1276,66 @@ switch (op[0]) {
             switch (op[10]) {
               case 's': {
                 switch (op[13]) {
-                  case '3': return makeUnary(s, UnaryOp::TruncSFloat32ToInt64); // i64.trunc_s/f32
-                  case '6': return makeUnary(s, UnaryOp::TruncSFloat64ToInt64); // i64.trunc_s/f64
+                  case '3':
+                    if (strcmp(op, "i64.trunc_s/f32") == 0) return makeUnary(s, UnaryOp::TruncSFloat32ToInt64);
+                    goto parse_error;
+                  case '6':
+                    if (strcmp(op, "i64.trunc_s/f64") == 0) return makeUnary(s, UnaryOp::TruncSFloat64ToInt64);
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
               case 'u': {
                 switch (op[13]) {
-                  case '3': return makeUnary(s, UnaryOp::TruncUFloat32ToInt64); // i64.trunc_u/f32
-                  case '6': return makeUnary(s, UnaryOp::TruncUFloat64ToInt64); // i64.trunc_u/f64
+                  case '3':
+                    if (strcmp(op, "i64.trunc_u/f32") == 0) return makeUnary(s, UnaryOp::TruncUFloat32ToInt64);
+                    goto parse_error;
+                  case '6':
+                    if (strcmp(op, "i64.trunc_u/f64") == 0) return makeUnary(s, UnaryOp::TruncUFloat64ToInt64);
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
               default: goto parse_error;
             }
           }
-          case 'w': return makeAtomicWait(s, i64); // i64.wait
-          case 'x': return makeBinary(s, BinaryOp::XorInt64); // i64.xor
+          case 'w':
+            if (strcmp(op, "i64.wait") == 0) return makeAtomicWait(s, i64);
+            goto parse_error;
+          case 'x':
+            if (strcmp(op, "i64.xor") == 0) return makeBinary(s, BinaryOp::XorInt64);
+            goto parse_error;
           default: goto parse_error;
         }
       }
-      case 'f': return makeIf(s); // if
+      case 'f':
+        if (strcmp(op, "if") == 0) return makeIf(s);
+        goto parse_error;
       default: goto parse_error;
     }
   }
-  case 'l': return makeLoop(s); // loop
-  case 'n': return makeNop(); // nop
-  case 'r': return makeReturn(s); // return
+  case 'l':
+    if (strcmp(op, "loop") == 0) return makeLoop(s);
+    goto parse_error;
+  case 'n':
+    if (strcmp(op, "nop") == 0) return makeNop();
+    goto parse_error;
+  case 'r':
+    if (strcmp(op, "return") == 0) return makeReturn(s);
+    goto parse_error;
   case 's': {
     switch (op[2]) {
-      case 'l': return makeSelect(s); // select
+      case 'l':
+        if (strcmp(op, "select") == 0) return makeSelect(s);
+        goto parse_error;
       case 't': {
         switch (op[4]) {
-          case 'g': return makeSetGlobal(s); // set_global
-          case 'l': return makeSetLocal(s); // set_local
+          case 'g':
+            if (strcmp(op, "set_global") == 0) return makeSetGlobal(s);
+            goto parse_error;
+          case 'l':
+            if (strcmp(op, "set_local") == 0) return makeSetLocal(s);
+            goto parse_error;
           default: goto parse_error;
         }
       }
@@ -674,13 +1344,21 @@ switch (op[0]) {
   }
   case 't': {
     switch (op[1]) {
-      case 'e': return makeTeeLocal(s); // tee_local
-      case 'h': return makeThenOrElse(s); // then
+      case 'e':
+        if (strcmp(op, "tee_local") == 0) return makeTeeLocal(s);
+        goto parse_error;
+      case 'h':
+        if (strcmp(op, "then") == 0) return makeThenOrElse(s);
+        goto parse_error;
       default: goto parse_error;
     }
   }
-  case 'u': return makeUnreachable(); // unreachable
-  case 'w': return makeAtomicWake(s); // wake
+  case 'u':
+    if (strcmp(op, "unreachable") == 0) return makeUnreachable();
+    goto parse_error;
+  case 'w':
+    if (strcmp(op, "wake") == 0) return makeAtomicWake(s);
+    goto parse_error;
   default: goto parse_error;
 }
 parse_error: