1 files changed, 16 insertions, 6 deletions

diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
index f0787600e..68fb293e8 100644
--- a/src/wasm/wasm-binary.cpp
+++ b/src/wasm/wasm-binary.cpp
@@ -670,7 +670,7 @@ void WasmBinaryWriter::visitBreak(Break *curr) {
     // then either the condition or the value is unreachable, which is
     // extremely rare, and may require us to make the stack polymorphic
     // (if the block we branch to has a value, we may lack one as we
-    // are not a taken branch; the wasm spec on the other hand does
+    // are not a reachable branch; the wasm spec on the other hand does
     // presume the br_if emits a value of the right type, even if it
     // popped unreachable)
     o << int8_t(BinaryConsts::Unreachable);
@@ -683,11 +683,10 @@ void WasmBinaryWriter::visitSwitch(Switch *curr) {
     recurse(curr->value);
   }
   recurse(curr->condition);
-  if (!BranchUtils::isBranchTaken(curr)) {
-    // if the branch is not taken, then it's dangerous to emit it, as
-    // wasm type checking rules are stricter than ours - we tolerate
-    // an untaken branch to a target with a different value, but not
-    // wasm. so just don't emit it
+  if (!BranchUtils::isBranchReachable(curr)) {
+    // if the branch is not reachable, then it's dangerous to emit it, as
+    // wasm type checking rules are different, especially in unreachable
+    // code. so just don't emit that unreachable code.
     o << int8_t(BinaryConsts::Unreachable);
     return;
   }
@@ -1049,6 +1048,11 @@ void WasmBinaryWriter::visitUnary(Unary *curr) {
     case ReinterpretFloat64: o << int8_t(BinaryConsts::I64ReinterpretF64); break;
     case ReinterpretInt32: o << int8_t(BinaryConsts::F32ReinterpretI32); break;
     case ReinterpretInt64: o << int8_t(BinaryConsts::F64ReinterpretI64); break;
+    case ExtendS8Int32: o << int8_t(BinaryConsts::I32ExtendS8); break;
+    case ExtendS16Int32: o << int8_t(BinaryConsts::I32ExtendS16); break;
+    case ExtendS8Int64: o << int8_t(BinaryConsts::I64ExtendS8); break;
+    case ExtendS16Int64: o << int8_t(BinaryConsts::I64ExtendS16); break;
+    case ExtendS32Int64: o << int8_t(BinaryConsts::I64ExtendS32); break;
     default: abort();
   }
   if (curr->type == unreachable) {
@@ -2679,6 +2683,12 @@ bool WasmBinaryBuilder::maybeVisitUnary(Expression*& out, uint8_t code) {
     case BinaryConsts::F32ReinterpretI32: curr = allocator.alloc<Unary>(); curr->op = ReinterpretInt32;    curr->type = f32; break;
     case BinaryConsts::F64ReinterpretI64: curr = allocator.alloc<Unary>(); curr->op = ReinterpretInt64;    curr->type = f64; break;
 
+    case BinaryConsts::I32ExtendS8:  curr = allocator.alloc<Unary>(); curr->op = ExtendS8Int32; curr->type = i32; break;
+    case BinaryConsts::I32ExtendS16: curr = allocator.alloc<Unary>(); curr->op = ExtendS16Int32; curr->type = i32; break;
+    case BinaryConsts::I64ExtendS8:  curr = allocator.alloc<Unary>(); curr->op = ExtendS8Int64; curr->type = i64; break;
+    case BinaryConsts::I64ExtendS16: curr = allocator.alloc<Unary>(); curr->op = ExtendS16Int64; curr->type = i64; break;
+    case BinaryConsts::I64ExtendS32: curr = allocator.alloc<Unary>(); curr->op = ExtendS32Int64; curr->type = i64; break;
+
     default: return false;
   }
   if (debug) std::cerr << "zz node: Unary" << std::endl;