all opcodes

src/elements/mod.rs

@@ -12,7 +12,7 @@ pub use self::module::Module;
 pub use self::section::Section;
 pub use self::import_entry::{ImportEntry, MemoryType, TableType, External};
 pub use self::export_entry::{ExportEntry, Internal};
-pub use self::primitives::{VarUint32, VarUint7, VarUint1, VarInt7, Uint32, CountedList};
+pub use self::primitives::{VarUint32, VarUint7, VarUint1, VarInt7, Uint32, Uint64, VarUint64, CountedList};
 pub use self::types::{ValueType, BlockType};
 pub use self::ops::{Opcode, Opcodes};
 

src/elements/ops.rs

@@ -1,8 +1,15 @@
 use std::io;
-use super::{Deserialize, Error, VarUint7, VarInt7, VarUint1, VarUint32, CountedList, BlockType};
+use super::{Deserialize, Error, VarUint7, 
+    VarUint1, VarUint32, CountedList, BlockType,
+    Uint32, VarUint64, Uint64
+};
 
 pub struct Opcodes(Vec<Opcode>);
 
+impl Opcodes {
+    pub fn elements(&self) -> &[Opcode] { &self.0 }
+}
+
 pub enum Opcode {
     Unreachable,
     Nop,
@@ -213,17 +220,266 @@ impl Deserialize for Opcode {
                 0x00 => Unreachable,
                 0x01 => Nop,
                 0x02 => Block(BlockType::deserialize(reader)?, Opcodes::deserialize(reader)?),
+                0x03 => Loop(BlockType::deserialize(reader)?, Opcodes::deserialize(reader)?),
+                0x04 => If(BlockType::deserialize(reader)?, Opcodes::deserialize(reader)?),
+                0x05 => Else,
                 0x0b => End,
 
-                0x20 => SetLocal(VarUint32::deserialize(reader)?.into()),
+                0x0c => Br(VarUint32::deserialize(reader)?.into()),
+                0x0d => BrIf(VarUint32::deserialize(reader)?.into()),
+                0x0e => { 
+                    let t1: Vec<u32> = CountedList::<VarUint32>::deserialize(reader)?
+                        .into_inner()
+                        .into_iter()
+                        .map(Into::into)
+                        .collect();
+
+                    BrTable(t1, VarUint32::deserialize(reader)?.into())
+                },
+                0x0f => Return,
+                0x10 => Call(VarUint32::deserialize(reader)?.into()),
+                0x11 => CallIndirect(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint1::deserialize(reader)?.into()),
+                0x1a => Drop,
+                0x1b => Select,
+
+                0x20 => GetLocal(VarUint32::deserialize(reader)?.into()),
                 0x21 => SetLocal(VarUint32::deserialize(reader)?.into()),
+                0x22 => TeeLocal(VarUint32::deserialize(reader)?.into()),
                 0x23 => GetGlobal(VarUint32::deserialize(reader)?.into()),
                 0x24 => SetGlobal(VarUint32::deserialize(reader)?.into()),
 
-                0x41 => I32Const(VarUint32::deserialize(reader)?.into()),
+                0x28 => I32Load(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
 
+                0x29 => I64Load(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+                0x2a => F32Load(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+                0x2b => F64Load(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+                0x2c => I32Load8S(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+                0x2d => I32Load8U(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+                0x2e => I32Load16S(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+                0x2f => I32Load16U(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+                0x30 => I64Load8S(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+                0x31 => I64Load8U(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+                0x32 => I64Load16S(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+                0x33 => I64Load16U(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+                0x34 => I64Load32S(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+                0x35 => I64Load32U(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+                0x36 => I32Store(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+                0x37 => I64Store(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+                0x38 => F32Store(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+                0x39 => F64Store(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+                0x3a => I32Store8(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+                0x3b => I32Store16(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+                0x3c => I64Store8(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+                0x3d => I64Store16(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+                0x3e => I64Store32(
+                    VarUint32::deserialize(reader)?.into(), 
+                    VarUint32::deserialize(reader)?.into()),
+
+
+                0x3f => CurrentMemory(VarUint1::deserialize(reader)?.into()),
+                0x40 => GrowMemory(VarUint1::deserialize(reader)?.into()),
+
+                0x41 => I32Const(VarUint32::deserialize(reader)?.into()),
+                0x42 => I64Const(VarUint64::deserialize(reader)?.into()),
+                0x43 => F32Const(Uint32::deserialize(reader)?.into()),
+                0x44 => F64Const(Uint64::deserialize(reader)?.into()),
+                0x45 => I32Eqz,
+                0x46 => I32Eq,
+                0x47 => I32Ne,
+                0x48 => I32LtS,
+                0x49 => I32LtU,
+                0x4a => I32GtS,
+                0x4b => I32GtU,
+                0x4c => I32LeS,
+                0x4d => I32LeU,
+                0x4e => I32GeS,
+                0x4f => I32GeU,
+                
+                0x50 => I64Eqz,
+                0x51 => I64Eq,
+                0x52 => I64Ne,
+                0x53 => I64LtS,
+                0x54 => I64LtU,
+                0x55 => I64GtS,
+                0x56 => I64GtU,
+                0x57 => I64LeS,
+                0x58 => I64LeU,
+                0x59 => I64GeS,
+                0x5a => I64GeU,
+
+                0x5b => F32Eq,
+                0x5c => F32Ne,
+                0x5d => F32Lt,
+                0x5e => F32Gt,
+                0x5f => F32Le,
+                0x60 => F32Ge,
+
+                0x61 => F64Eq,
+                0x62 => F64Ne,
+                0x63 => F64Lt,
+                0x64 => F64Gt,
+                0x65 => F64Le,
+                0x66 => F64Ge,
+
+                0x67 => I32Clz,
+                0x68 => I32Ctz,
+                0x69 => I32Popcnt,
                 0x6a => I32Add,
+                0x6b => I32Sub,
+                0x6c => I32Mul,
+                0x6d => I32DivS,
+                0x6e => I32DivU,
+                0x6f => I32RemS,
+                0x70 => I32RemU,
                 0x71 => I32And,
+                0x72 => I32Or,
+                0x73 => I32Xor,
+                0x74 => I32Shl,
+                0x75 => I32ShlS,
+                0x76 => I32ShrU,
+                0x77 => I32Rotl,
+                0x78 => I32Rotr,
+
+                0x79 => I64Clz,
+                0x7a => I64Ctz,
+                0x7b => I64Popcnt,
+                0x7c => I64Add,
+                0x7d => I64Sub,
+                0x7e => I64Mul,
+                0x7f => I64DivS,
+                0x80 => I64DivU,
+                0x81 => I64RemS,
+                0x82 => I64RemU,
+                0x83 => I64And,
+                0x84 => I64Or,
+                0x85 => I64Xor,
+                0x86 => I64Shl,
+                0x87 => I64ShrS,
+                0x88 => I64ShrU,
+                0x89 => I64Rotl,
+                0x8a => I64Rotr,
+                0x8b => F32Abs,
+                0x8c => F32Neg,
+                0x8d => F32Ceil,
+                0x8e => F32Floor,
+                0x8f => F32Trunc,
+                0x90 => F32Nearest,
+                0x91 => F32Sqrt,
+                0x92 => F32Add,
+                0x93 => F32Sub,
+                0x94 => F32Mul,
+                0x95 => F32Div,
+                0x96 => F32Min,
+                0x97 => F32Max,
+                0x98 => F32Copysign,
+                0x99 => F64Abs,
+                0x9a => F64Neg,
+                0x9b => F64Ceil,
+                0x9c => F64Floor,
+                0x9d => F64Trunc,
+                0x9e => F64Nearest,
+                0x9f => F64Sqrt,
+                0xa0 => F64Add,
+                0xa1 => F64Sub,
+                0xa2 => F64Mul,
+                0xa3 => F64Div,
+                0xa4 => F64Min,
+                0xa5 => F64Max,
+                0xa6 => F64Copysign,
+
+                0xa7 => I32WarpI64,
+                0xa8 => I32TruncSF32,
+                0xa9 => I32TruncUF32,
+                0xaa => I32TruncSF64,
+                0xab => I32TruncUF64,
+                0xac => I64ExtendSI32,
+                0xad => I64ExtendUI32,
+                0xae => I64TruncSF32,
+                0xaf => I64TruncUF32,
+                0xb0 => I64TruncSF64,
+                0xb1 => I64TruncUF64,
+                0xb2 => F32ConvertSI32,
+                0xb3 => F32ConvertUI32,
+                0xb4 => F32ConvertSI64,
+                0xb5 => F32ConvertUI64,
+                0xb6 => F32DemoteF64,
+                0xb7 => F64ConvertSI32,
+                0xb8 => F64ConvertUI32,
+                0xb9 => F64ConvertSI64,
+                0xba => F64ConvertUI64,
+                0xbb => F64PromoteF32,
+
+                0xbc => I32ReinterpretF32,
+                0xbd => I64ReinterpretF64,
+                0xbe => F32ReinterpretI32,
+                0xbf => F64ReinterpretI64,
 
                 _ => { return Err(Error::UnknownOpcode(val)); }
             }

src/elements/primitives.rs

@@ -37,6 +37,36 @@ impl Deserialize for VarUint32 {
     }
 }
 
+
+#[derive(Copy, Clone)]
+pub struct VarUint64(u64);
+
+impl From<VarUint64> for u64 {
+    fn from(var: VarUint64) -> u64 {
+        var.0
+    }
+}
+
+impl Deserialize for VarUint64 {
+    type Error = Error;
+
+    fn deserialize<R: io::Read>(reader: &mut R) -> Result<Self, Self::Error> {
+        let mut res = 0;
+        let mut shift = 0;
+        let mut u8buf = [0u8; 1];
+        loop {
+            reader.read_exact(&mut u8buf)?;
+            let b = u8buf[0] as u64;
+            res |= (b & 0x7f) << shift;
+            shift += 7;
+            if (b >> 7) == 0 {
+                break;
+            }
+        }
+        Ok(VarUint64(res))
+    }
+}
+
 #[derive(Copy, Clone)]
 pub struct VarUint7(u8);
 
@@ -98,6 +128,27 @@ impl From<Uint32> for u32 {
     }
 }
 
+
+#[derive(Copy, Clone)]
+pub struct Uint64(u64);
+
+impl Deserialize for Uint64 {
+    type Error = Error;
+
+    fn deserialize<R: io::Read>(reader: &mut R) -> Result<Self, Self::Error> {
+        let mut buf = [0u8; 8];
+        reader.read_exact(&mut buf)?;
+        // todo check range
+        Ok(Uint64(LittleEndian::read_u64(&buf)))
+    }
+}
+
+impl From<Uint64> for u64 {
+    fn from(var: Uint64) -> u64 {
+        var.0
+    }
+}
+
 #[derive(Copy, Clone)]
 pub struct VarUint1(bool);
 

src/elements/section.rs

@@ -231,6 +231,11 @@ pub struct Local {
     value_type: ValueType,
 }
 
+impl Local {
+    pub fn count(&self) -> u32 { self.count }
+    pub fn value_type(&self) -> ValueType { self.value_type }
+}
+
 impl Deserialize for Local {
      type Error = Error;
 
@@ -246,6 +251,11 @@ pub struct FunctionBody {
     opcodes: Opcodes,
 }
 
+impl FunctionBody {
+    pub fn locals(&self) -> &[Local] { &self.locals }
+    pub fn code(&self) -> &Opcodes { &self.opcodes }
+}
+
 impl Deserialize for FunctionBody {
      type Error = Error;