add I32ReinterpretF32 in binary format, for now

4 files changed, 436 insertions, 4 deletions

diff --git a/auto_update_tests.py b/auto_update_tests.py
index 4fbe7f8ce..273f05cb6 100755
--- a/auto_update_tests.py
+++ b/auto_update_tests.py
@@ -12,7 +12,7 @@ for asm in sorted(os.listdir('test')):
     open(os.path.join('test', wasm), 'w').write(actual)
 
 for wasm in sorted(os.listdir('test')):
-  if wasm.endswith('.wast'):
+  if wasm.endswith('.wast') and os.path.basename(wasm) not in ['kitchen_sink.wast']: # i64s in kitchen_sink
     print '..', wasm
     asm = wasm.replace('.wast', '.2asm.js')
     actual, err = subprocess.Popen([os.path.join('bin', 'wasm2asm'), os.path.join('test', wasm)], stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
diff --git a/check.py b/check.py
index 7c963a7c7..b36f66de6 100755
--- a/check.py
+++ b/check.py
@@ -276,7 +276,7 @@ for t in spec_tests:
 print '\n[ checking wasm2asm testcases... ]\n'
 
 for wasm in tests + [os.path.join('spec', name) for name in ['address.wast']]:#spec_tests:
-  if wasm.endswith('.wast'):
+  if wasm.endswith('.wast') and os.path.basename(wasm) not in ['kitchen_sink.wast']: # i64s in kitchen_sink
     print '..', wasm
     asm = os.path.basename(wasm).replace('.wast', '.2asm.js')
     actual, err = subprocess.Popen([os.path.join('bin', 'wasm2asm'), os.path.join('test', wasm)], stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
index 34b8711f5..c5f844f34 100644
--- a/src/wasm-binary.h
+++ b/src/wasm-binary.h
@@ -286,6 +286,7 @@ enum ASTNodes {
   F64ConvertF32       = 0xb2,
   F64ReinterpretI64   = 0xb3,
   I64ReinterpretF64   = 0xb5,
+  I32ReinterpretF32   = 0xfe, // XXX not in v8 spec doc
 
   I32LoadMem8S = 0x20,
   I32LoadMem8U = 0x21,
@@ -805,7 +806,7 @@ public:
       case DemoteFloat64:    o << int8_t(BinaryConsts::F32ConvertF64); break;
       case PromoteFloat32:   o << int8_t(BinaryConsts::F64ConvertF32); break;
       case ReinterpretFloat: o << int8_t(curr->type == f32 ? BinaryConsts::F32ReinterpretI32 : BinaryConsts::F64ReinterpretI64); break;
-      case ReinterpretInt:   assert(curr->type == f64); o << int8_t(BinaryConsts::I64ReinterpretF64); break; // XX what about f32?
+      case ReinterpretInt:   o << int8_t(curr->type == i32 ? BinaryConsts::I32ReinterpretF32 : BinaryConsts::I64ReinterpretF64); break;
       default: abort();
     }
     recurse(curr->value);
@@ -1487,7 +1488,7 @@ public:
       case BinaryConsts::F32ReinterpretI32: curr->op = ReinterpretFloat;  curr->type = i32; break;
       case BinaryConsts::F64ReinterpretI64: curr->op = ReinterpretFloat;  curr->type = i64; break;
       case BinaryConsts::I64ReinterpretF64: curr->op = ReinterpretInt;    curr->type = f64; break;
-      // XXX what about f32 reinterpret?
+      case BinaryConsts::I32ReinterpretF32: curr->op = ReinterpretInt;    curr->type = f32; break;
 
       default: return false;
     }
diff --git a/test/kitchen_sink.wast b/test/kitchen_sink.wast
new file mode 100644
index 000000000..f55b4cbb6
--- /dev/null
+++ b/test/kitchen_sink.wast
@@ -0,0 +1,431 @@
+(module
+  (memory 4096 4096 (segment 1026 "\14\00"))
+  (func $kitchensink (result i32)
+    (block $block0
+      (i32.add
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.sub
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.mul
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.div_s
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.div_u
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.rem_s
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.rem_u
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.and
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.or
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.xor
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.shl
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.shr_u
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.shr_s
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.eq
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.ne
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.lt_s
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.le_s
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.lt_u
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.le_u
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.gt_s
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.ge_s
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.gt_u
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.ge_u
+        (i32.const 10)
+        (i32.const 10)
+      )
+      (i32.clz
+        (i32.const 10)
+      )
+      (i32.ctz
+        (i32.const 10)
+      )
+      (i32.popcnt
+        (i32.const 10)
+      )
+      (i64.add
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.sub
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.mul
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.div_s
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.div_u
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.rem_s
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.rem_u
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.and
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.or
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.xor
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.shl
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.shr_u
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.shr_s
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.eq
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.ne
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.lt_s
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.le_s
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.lt_u
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.le_u
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.gt_s
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.ge_s
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.gt_u
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.ge_u
+        (i64.const 100)
+        (i64.const 100)
+      )
+      (i64.clz
+        (i64.const 100)
+      )
+      (i64.ctz
+        (i64.const 100)
+      )
+      (i64.popcnt
+        (i64.const 100)
+      )
+      (f32.add
+        (f32.const 10)
+        (f32.const 10)
+      )
+      (f32.sub
+        (f32.const 10)
+        (f32.const 10)
+      )
+      (f32.mul
+        (f32.const 10)
+        (f32.const 10)
+      )
+      (f32.div
+        (f32.const 10)
+        (f32.const 10)
+      )
+      (f32.min
+        (f32.const 10)
+        (f32.const 10)
+      )
+      (f32.max
+        (f32.const 10)
+        (f32.const 10)
+      )
+      (f32.abs
+        (f32.const 10)
+      )
+      (f32.neg
+        (f32.const 10)
+      )
+      (f32.copysign
+        (f32.const 10)
+        (f32.const 10)
+      )
+      (f32.ceil
+        (f32.const 10)
+      )
+      (f32.floor
+        (f32.const 10)
+      )
+      (f32.trunc
+        (f32.const 10)
+      )
+      (f32.nearest
+        (f32.const 10)
+      )
+      (f32.sqrt
+        (f32.const 10)
+      )
+      (f32.eq
+        (f32.const 10)
+        (f32.const 10)
+      )
+      (f32.ne
+        (f32.const 10)
+        (f32.const 10)
+      )
+      (f32.lt
+        (f32.const 10)
+        (f32.const 10)
+      )
+      (f32.le
+        (f32.const 10)
+        (f32.const 10)
+      )
+      (f32.gt
+        (f32.const 10)
+        (f32.const 10)
+      )
+      (f32.ge
+        (f32.const 10)
+        (f32.const 10)
+      )
+      (f64.add
+        (f64.const 10)
+        (f64.const 10)
+      )
+      (f64.sub
+        (f64.const 10)
+        (f64.const 10)
+      )
+      (f64.mul
+        (f64.const 10)
+        (f64.const 10)
+      )
+      (f64.div
+        (f64.const 10)
+        (f64.const 10)
+      )
+      (f64.min
+        (f64.const 10)
+        (f64.const 10)
+      )
+      (f64.max
+        (f64.const 10)
+        (f64.const 10)
+      )
+      (f64.abs
+        (f64.const 10)
+      )
+      (f64.neg
+        (f64.const 10)
+      )
+      (f64.copysign
+        (f64.const 10)
+        (f64.const 10)
+      )
+      (f64.ceil
+        (f64.const 10)
+      )
+      (f64.floor
+        (f64.const 10)
+      )
+      (f64.trunc
+        (f64.const 10)
+      )
+      (f64.nearest
+        (f64.const 10)
+      )
+      (f64.sqrt
+        (f64.const 10)
+      )
+      (f64.eq
+        (f64.const 10)
+        (f64.const 10)
+      )
+      (f64.ne
+        (f64.const 10)
+        (f64.const 10)
+      )
+      (f64.lt
+        (f64.const 10)
+        (f64.const 10)
+      )
+      (f64.le
+        (f64.const 10)
+        (f64.const 10)
+      )
+      (f64.gt
+        (f64.const 10)
+        (f64.const 10)
+      )
+      (f64.ge
+        (f64.const 10)
+        (f64.const 10)
+      )
+      (i32.trunc_s/f32
+        (f32.const 10)
+      )
+      (i32.trunc_s/f64
+        (f64.const 10)
+      )
+      (i32.trunc_u/f32
+        (f32.const 10)
+      )
+      (i32.trunc_u/f64
+        (f64.const 10)
+      )
+      (i32.wrap/i64
+        (i64.const 100)
+      )
+      (i64.trunc_s/f32
+        (f32.const 10)
+      )
+      (i64.trunc_s/f64
+        (f64.const 10)
+      )
+      (i64.trunc_u/f32
+        (f32.const 10)
+      )
+      (i64.trunc_u/f64
+        (f64.const 10)
+      )
+      (i64.extend_s/i32
+        (i32.const 10)
+      )
+      (i64.extend_u/i32
+        (i32.const 10)
+      )
+      (f32.convert_s/i32
+        (i32.const 10)
+      )
+      (f32.convert_u/i32
+        (i32.const 10)
+      )
+      (f32.convert_s/i64
+        (i64.const 100)
+      )
+      (f32.convert_u/i64
+        (i64.const 100)
+      )
+      (f32.demote/f64
+        (f64.const 10)
+      )
+      (f32.reinterpret/i32
+        (i32.const 10)
+      )
+      (f64.convert_s/i32
+        (i32.const 10)
+      )
+      (f64.convert_u/i32
+        (i32.const 10)
+      )
+      (f64.convert_s/i64
+        (i64.const 100)
+      )
+      (f64.convert_u/i64
+        (i64.const 100)
+      )
+      (f64.promote/f32
+        (f32.const 10)
+      )
+      (f64.reinterpret/i64
+        (i64.const 100)
+      )
+      (i32.reinterpret/f32
+        (f32.const 10)
+      )
+      (i64.reinterpret/f64
+        (f64.const 10)
+      )
+      (i32.const 0)
+    )
+  )
+)