Merge remote-tracking branch 'origin/master' into inject-rules

src/lib.rs

@@ -1,5 +1,6 @@
 extern crate parity_wasm;
 extern crate env_logger;
+extern crate byteorder;
 #[macro_use] extern crate log;
 #[macro_use] extern crate lazy_static;
 
@@ -11,9 +12,13 @@ mod symbols;
 mod logger;
 mod ext;
 mod pack;
+mod nondeterminism_check;
+mod runtime_type;
 
 pub use optimizer::{optimize, Error as OptimizerError};
 pub use gas::inject_gas_counter;
 pub use logger::init_log;
 pub use ext::externalize;
-pub use pack::pack_instance;
+pub use pack::pack_instance;
+pub use nondeterminism_check::is_deterministic;
+pub use runtime_type::inject_runtime_type;

src/nondeterminism_check.rs

@@ -0,0 +1,138 @@
+use parity_wasm::{elements};
+use parity_wasm::elements::{ Section, Opcode };
+use parity_wasm::elements::Opcode::*;
+
+fn have_nondeterministic_opcodes (opcodes: &[Opcode]) -> bool {
+	for opcode in opcodes {
+		match *opcode {
+			F32Abs |
+			F32Neg |
+			F32Ceil |
+			F32Floor |
+			F32Trunc |
+			F32Nearest |
+			F32Sqrt |
+			F32Add |
+			F32Sub |
+			F32Mul |
+			F32Div |
+			F32Min |
+			F32Max |
+			F32Copysign |
+			F64Abs |
+			F64Neg |
+			F64Ceil |
+			F64Floor |
+			F64Trunc |
+			F64Nearest |
+			F64Sqrt |
+			F64Add |
+			F64Sub |
+			F64Mul |
+			F64Div |
+			F64Min |
+			F64Max |
+			F64Copysign |
+			I32TruncSF32 |
+			I32TruncUF32 |
+			I32TruncSF64 |
+			I32TruncUF64 |
+			I64TruncSF32 |
+			I64TruncUF32 |
+			I64TruncSF64 |
+			I64TruncUF64 |
+			F32ConvertSI32 |
+			F32ConvertUI32 |
+			F32ConvertSI64 |
+			F32ConvertUI64 |
+			F32DemoteF64 |
+			F64ConvertSI32 |
+			F64ConvertUI32 |
+			F64ConvertSI64 |
+			F64ConvertUI64 |
+			F64PromoteF32 |
+			I32ReinterpretF32 |
+			I64ReinterpretF64 |
+			F32ReinterpretI32 |
+			F64ReinterpretI64 |
+			F32Eq |
+			F32Ne |
+			F32Lt |
+			F32Gt |
+			F32Le |
+			F32Ge |
+			F64Eq |
+			F64Ne |
+			F64Lt |
+			F64Gt |
+			F64Le |
+			F64Ge
+				=> return true,
+			_ 	=> continue
+		}
+	}
+	false
+}
+
+
+
+
+pub fn is_deterministic(module: &elements::Module) -> bool {
+	for section in module.sections() {
+		match *section {
+			Section::Code(ref cs) => {
+				for body in cs.bodies() {
+					if have_nondeterministic_opcodes(body.code().elements()) {
+						return false;
+					}
+				}
+			},
+			_ => continue
+			}
+		}
+	true
+}
+
+#[cfg(test)]
+mod tests {
+	use parity_wasm::{builder, elements};
+	use super::*;
+
+	#[test]
+	fn nondeterminism_found() {
+		let module = builder::module()
+			.function().signature().return_type().f32().build()
+			.body()
+				.with_opcodes(elements::Opcodes::new(
+					vec![
+						elements::Opcode::F32Const(1), // unrelated to this test matter
+						elements::Opcode::F32Const(1), // unrelated to this test matter
+						elements::Opcode::F32Add,
+						elements::Opcode::End
+					]
+				))
+				.build()
+			.build()
+		.build();
+		assert_eq!(false, is_deterministic(&module));
+	}
+
+	#[test]
+	fn nondeterminism_not() {
+		let module = builder::module()
+			.function().signature().return_type().i32().build()
+			.body()
+				.with_opcodes(elements::Opcodes::new(
+					vec![
+						elements::Opcode::I32Const(1),
+						elements::Opcode::I32Const(1),
+						elements::Opcode::I32Add,
+						elements::Opcode::End
+					]
+				))
+				.build()
+			.build()
+		.build();
+		assert_eq!(true, is_deterministic(&module));
+	}
+}

src/runtime_type.rs

@@ -0,0 +1,43 @@
+use parity_wasm::{elements, builder};
+use self::elements::{ Module, GlobalEntry, External, ExportEntry, GlobalType, ValueType, InitExpr, Opcode, Internal };
+use byteorder::{ LittleEndian, ByteOrder };
+
+pub fn inject_runtime_type(module: Module, runtime_type: &[u8], runtime_version: u32) -> Module {
+	let runtime_type: u32 = LittleEndian::read_u32(&runtime_type);
+	let globals_count: u32 = match module.global_section() {
+		Some(ref section) => section.entries().len() as u32,
+		None => 0
+	};
+	let imported_globals_count: u32 = match module.import_section() {
+		Some(ref section) => section.entries().iter().filter(|e| match *e.external() {
+			External::Global(ref _a) => true,
+			_ => false
+		}).count() as u32,
+		None => 0
+	};
+	let total_globals_count: u32 = globals_count + imported_globals_count;
+
+	builder::from_module(module)
+		.with_global(GlobalEntry::new(GlobalType::new(ValueType::I32, false), InitExpr::new(vec![Opcode::I32Const(runtime_type as i32), Opcode::End])))
+		.with_export(ExportEntry::new("RUNTIME_TYPE".into(), Internal::Global(total_globals_count)))
+		.with_global(GlobalEntry::new(GlobalType::new(ValueType::I32, false), InitExpr::new(vec![Opcode::I32Const(runtime_version as i32), Opcode::End])))
+		.with_export(ExportEntry::new("RUNTIME_VERSION".into(), Internal::Global(total_globals_count + 1)))
+	.build()
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	#[test]
+	fn it_injects() {
+		let mut module = builder::module()
+			.with_global(GlobalEntry::new(GlobalType::new(ValueType::I32, false), InitExpr::new(vec![Opcode::I32Const(42 as i32)])))
+		.build();
+		module = inject_runtime_type(module, b"emcc", 1);
+		let global_section = module.global_section().expect("Global section expected");
+		assert_eq!(3, global_section.entries().len());
+		let export_section = module.export_section().expect("Export section expected");
+		assert!(export_section.entries().iter().find(|e| e.field() == "RUNTIME_TYPE" ).is_some());
+		assert!(export_section.entries().iter().find(|e| e.field() == "RUNTIME_VERSION" ).is_some());
+	}
+}