From cca419c982aae5a977229d009fcd2d584c3f146b Mon Sep 17 00:00:00 2001 From: Nick Lewycky Date: Thu, 8 Aug 2019 19:02:09 -0700 Subject: [PATCH 01/16] Add the --enable-threads flag and thread it as far as runtime-core. --- lib/runtime-core/src/backend.rs | 1 + src/bin/wasmer.rs | 11 +++++++++++ 2 files changed, 12 insertions(+) diff --git a/lib/runtime-core/src/backend.rs b/lib/runtime-core/src/backend.rs index 7725a18ffd6..2bb2303180d 100644 --- a/lib/runtime-core/src/backend.rs +++ b/lib/runtime-core/src/backend.rs @@ -114,6 +114,7 @@ impl Default for MemoryBoundCheckMode { #[derive(Debug, Default)] pub struct Features { pub simd: bool, + pub threads: bool, } /// Configuration data for the compiler diff --git a/src/bin/wasmer.rs b/src/bin/wasmer.rs index be0939e433a..eae0548e89e 100644 --- a/src/bin/wasmer.rs +++ b/src/bin/wasmer.rs @@ -85,6 +85,10 @@ struct PrestandardFeatures { #[structopt(long = "enable-simd")] simd: bool, + /// Enable support for the threads proposal. + #[structopt(long = "enable-threads")] + threads: bool, + /// Enable support for all pre-standard proposals. #[structopt(long = "enable-all")] all: bool, @@ -375,6 +379,9 @@ fn execute_wasm(options: &Run) -> Result<(), String> { if options.features.simd || options.features.all { features.enable_simd(); } + if options.features.threads || options.features.all { + features.enable_threads(); + } wasm_binary = wabt::wat2wasm_with_features(wasm_binary, features) .map_err(|e| format!("Can't convert from wast to wasm: {:?}", e))?; } @@ -427,6 +434,7 @@ fn execute_wasm(options: &Run) -> Result<(), String> { track_state, features: Features { simd: options.features.simd || options.features.all, + threads: options.features.threads || options.features.all, }, }, &*compiler, @@ -440,6 +448,7 @@ fn execute_wasm(options: &Run) -> Result<(), String> { track_state, features: Features { simd: options.features.simd || options.features.all, + threads: options.features.threads || options.features.all, }, ..Default::default() }, @@ -487,6 +496,7 @@ fn execute_wasm(options: &Run) -> Result<(), String> { track_state, features: Features { simd: options.features.simd || options.features.all, + threads: options.features.threads || options.features.all, }, ..Default::default() }, @@ -819,6 +829,7 @@ fn validate_wasm(validate: Validate) -> Result<(), String> { &wasm_binary, Features { simd: validate.features.simd || validate.features.all, + threads: validate.features.threads || validate.features.all, }, ) .map_err(|err| format!("Validation failed: {}", err))?; From 86346d6ebe417c7dc82bf275796a25e123a796d8 Mon Sep 17 00:00:00 2001 From: Nick Lewycky Date: Thu, 8 Aug 2019 19:10:46 -0700 Subject: [PATCH 02/16] Thread the feature support through to wasmparser. --- lib/runtime-core/src/codegen.rs | 2 +- lib/runtime-core/src/lib.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/runtime-core/src/codegen.rs b/lib/runtime-core/src/codegen.rs index 422e463028d..e69b9637c6b 100644 --- a/lib/runtime-core/src/codegen.rs +++ b/lib/runtime-core/src/codegen.rs @@ -140,7 +140,7 @@ impl< pub fn validating_parser_config(features: &Features) -> wasmparser::ValidatingParserConfig { wasmparser::ValidatingParserConfig { operator_config: wasmparser::OperatorValidatorConfig { - enable_threads: false, + enable_threads: features.threads, enable_reference_types: false, enable_simd: features.simd, enable_bulk_memory: false, diff --git a/lib/runtime-core/src/lib.rs b/lib/runtime-core/src/lib.rs index c12db47d936..c286cd67e02 100644 --- a/lib/runtime-core/src/lib.rs +++ b/lib/runtime-core/src/lib.rs @@ -140,7 +140,7 @@ pub fn validate_and_report_errors_with_features( enable_bulk_memory: false, enable_multi_value: false, enable_reference_types: false, - enable_threads: false, + enable_threads: features.threads, }, mutable_global_imports: true, }; From 7f3837abc520d0da335d48554c3b5576c7c46f3b Mon Sep 17 00:00:00 2001 From: Nick Lewycky Date: Thu, 8 Aug 2019 19:15:20 -0700 Subject: [PATCH 03/16] Enable threads in spectests. --- lib/spectests/tests/spectest.rs | 21 +++++++++++++++++---- 1 file changed, 17 insertions(+), 4 deletions(-) diff --git a/lib/spectests/tests/spectest.rs b/lib/spectests/tests/spectest.rs index 41268923155..b85b9b0fe8c 100644 --- a/lib/spectests/tests/spectest.rs +++ b/lib/spectests/tests/spectest.rs @@ -167,6 +167,7 @@ mod tests { let mut features = wabt::Features::new(); features.enable_simd(); + features.enable_threads(); let mut parser: ScriptParser = ScriptParser::from_source_and_name_with_features(&source, filename, features) .expect(&format!("Failed to parse script {}", &filename)); @@ -203,7 +204,10 @@ mod tests { let spectest_import_object = get_spectest_import_object(®istered_modules); let config = CompilerConfig { - features: Features { simd: true }, + features: Features { + simd: true, + threads: true, + }, ..Default::default() }; let module = wasmer_runtime_core::compile_with_config( @@ -630,7 +634,10 @@ mod tests { // println!("AssertInvalid"); let result = panic::catch_unwind(|| { let config = CompilerConfig { - features: Features { simd: true }, + features: Features { + simd: true, + threads: true, + }, ..Default::default() }; wasmer_runtime_core::compile_with_config( @@ -681,7 +688,10 @@ mod tests { let result = panic::catch_unwind(|| { let config = CompilerConfig { - features: Features { simd: true }, + features: Features { + simd: true, + threads: true, + }, ..Default::default() }; wasmer_runtime_core::compile_with_config( @@ -798,7 +808,10 @@ mod tests { let spectest_import_object = get_spectest_import_object(®istered_modules); let config = CompilerConfig { - features: Features { simd: true }, + features: Features { + simd: true, + threads: true, + }, ..Default::default() }; let module = wasmer_runtime_core::compile_with_config( From f2077c204b4224e24aa81aaca748e68aed213d72 Mon Sep 17 00:00:00 2001 From: Nick Lewycky Date: Thu, 15 Aug 2019 16:39:42 -0700 Subject: [PATCH 04/16] Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses. --- lib/llvm-backend/src/code.rs | 285 +++++++++++++++++++++++++++++ lib/llvm-backend/src/intrinsics.rs | 2 + 2 files changed, 287 insertions(+) diff --git a/lib/llvm-backend/src/code.rs b/lib/llvm-backend/src/code.rs index 004d0e3867e..7332594cecd 100644 --- a/lib/llvm-backend/src/code.rs +++ b/lib/llvm-backend/src/code.rs @@ -491,6 +491,53 @@ fn resolve_memory_ptr( Ok(builder.build_int_to_ptr(effective_address_int, ptr_ty, &state.var_name())) } +fn trap_if_misaligned( + builder: &Builder, + intrinsics: &Intrinsics, + context: &Context, + function: &FunctionValue, + memarg: &MemoryImmediate, + ptr: PointerValue +) { + let align = match memarg.flags & 2 { + 0 => 1, + 1 => 2, + 2 => 4, + 3 => 8, + _ => unreachable!("this match is fully covered"), + }; + let value = builder.build_ptr_to_int(ptr, intrinsics.i64_ty, ""); + let and = builder.build_and(value, intrinsics.i64_ty.const_int(align-1, false), "misaligncheck"); + let misaligned = builder.build_int_compare( + IntPredicate::NE, + and, + intrinsics.i64_zero, + ""); + let misaligned = builder.build_call(intrinsics.expect_i1, &[ + misaligned.as_basic_value_enum(), + intrinsics.i1_zero.as_basic_value_enum()], "").try_as_basic_value().left().unwrap().into_int_value(); + + let continue_block = + context.append_basic_block(function, "aligned_access_continue_block"); + let not_aligned_block = + context.append_basic_block(function, "misaligned_trap_block"); + builder.build_conditional_branch( + misaligned, + &continue_block, + ¬_aligned_block, + ); + + builder.position_at_end(¬_aligned_block); + builder.build_call( + intrinsics.throw_trap, + &[intrinsics.trap_misaligned_atomic], + "throw", + ); + builder.build_unreachable(); + + builder.position_at_end(&continue_block); +} + #[derive(Debug)] pub struct CodegenError { pub message: String, @@ -4395,6 +4442,244 @@ impl FunctionCodeGenerator for LLVMFunctionCodeGenerator { let res = builder.build_bitcast(res, intrinsics.i128_ty, ""); state.push1(res); } +/* + Operator::Wake { ref memarg: _ } => { + unimplemented!(); + } + Operator::I32Wait { ref memarg: _ } => { + unimplemented!(); + } + Operator::I64Wait { ref memarg: _ } => { + unimplemented!(); + } +*/ + Operator::Fence { flags: _ } => { + // fence is a no-op + } + Operator::I32AtomicLoad { ref memarg } => { + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i32_ptr_ty, + 4, + )?; + trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); + let result = builder.build_load(effective_address, &state.var_name()); + // TODO: LLVMSetAlignment(result.as_value_ref(), 4) + // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); + state.push1(result); + } + Operator::I64AtomicLoad { ref memarg } => { + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i64_ptr_ty, + 8, + )?; + trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); + let result = builder.build_load(effective_address, &state.var_name()); + // TODO: LLVMSetAlignment(result.as_value_ref(), 8) + // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); + state.push1(result); + } + Operator::I32AtomicLoad8U { ref memarg } => { + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i8_ptr_ty, + 1, + )?; + trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); + let narrow_result = builder.build_load(effective_address, &state.var_name()).into_int_value(); + // TODO: LLVMSetAlignment(result.as_value_ref(), 1) + // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); + let result = builder.build_int_z_extend(narrow_result, intrinsics.i32_ty, &state.var_name()); + state.push1(result); + } + Operator::I32AtomicLoad16U { ref memarg } => { + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i16_ptr_ty, + 2, + )?; + trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); + let narrow_result = builder.build_load(effective_address, &state.var_name()).into_int_value(); + // TODO: LLVMSetAlignment(result.as_value_ref(), 2) + // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); + let result = builder.build_int_z_extend(narrow_result, intrinsics.i32_ty, &state.var_name()); + state.push1(result); + } + Operator::I64AtomicLoad8U { ref memarg } => { + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i8_ptr_ty, + 1, + )?; + trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); + let narrow_result = builder.build_load(effective_address, &state.var_name()).into_int_value(); + // TODO: LLVMSetAlignment(result.as_value_ref(), 1) + // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); + let result = builder.build_int_z_extend(narrow_result, intrinsics.i64_ty, &state.var_name()); + state.push1(result); + } + Operator::I64AtomicLoad16U { ref memarg } => { + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i16_ptr_ty, + 2, + )?; + trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); + let narrow_result = builder.build_load(effective_address, &state.var_name()).into_int_value(); + // TODO: LLVMSetAlignment(result.as_value_ref(), 2) + // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); + let result = builder.build_int_z_extend(narrow_result, intrinsics.i64_ty, &state.var_name()); + state.push1(result); + } + Operator::I64AtomicLoad32U { ref memarg } => { + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i16_ptr_ty, + 4, + )?; + trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); + let narrow_result = builder.build_load(effective_address, &state.var_name()).into_int_value(); + // TODO: LLVMSetAlignment(result.as_value_ref(), 4) + // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); + let result = builder.build_int_z_extend(narrow_result, intrinsics.i64_ty, &state.var_name()); + state.push1(result); + } + Operator::I32AtomicStore { ref memarg } => { + let value = state.pop1()?; + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i32_ptr_ty, + 4, + )?; + trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); + builder.build_store(effective_address, value); + // TODO: LLVMSetAlignment(result.as_value_ref(), 4) + // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); + } + Operator::I64AtomicStore { ref memarg } => { + let value = state.pop1()?; + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i64_ptr_ty, + 8, + )?; + trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); + builder.build_store(effective_address, value); + // TODO: LLVMSetAlignment(result.as_value_ref(), 8) + // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); + } + Operator::I32AtomicStore8 { ref memarg } | Operator::I64AtomicStore8 { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i8_ptr_ty, + 1, + )?; + trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); + let narrow_value = builder.build_int_truncate(value, intrinsics.i8_ty, &state.var_name()); + builder.build_store(effective_address, narrow_value); + // TODO: LLVMSetAlignment(result.as_value_ref(), 1) + // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); + } + Operator::I32AtomicStore16 { ref memarg } | Operator::I64AtomicStore16 { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i16_ptr_ty, + 2, + )?; + trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); + let narrow_value = builder.build_int_truncate(value, intrinsics.i16_ty, &state.var_name()); + builder.build_store(effective_address, narrow_value); + // TODO: LLVMSetAlignment(result.as_value_ref(), 2) + // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); + } + Operator::I64AtomicStore32 { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i32_ptr_ty, + 4, + )?; + trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); + let narrow_value = builder.build_int_truncate(value, intrinsics.i32_ty, &state.var_name()); + builder.build_store(effective_address, narrow_value); + // TODO: LLVMSetAlignment(result.as_value_ref(), 4) + // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); + } Operator::MemoryGrow { reserved } => { let memory_index = MemoryIndex::new(reserved as usize); diff --git a/lib/llvm-backend/src/intrinsics.rs b/lib/llvm-backend/src/intrinsics.rs index 46b65a22719..22f1b3cfd5d 100644 --- a/lib/llvm-backend/src/intrinsics.rs +++ b/lib/llvm-backend/src/intrinsics.rs @@ -131,6 +131,7 @@ pub struct Intrinsics { pub trap_call_indirect_oob: BasicValueEnum, pub trap_memory_oob: BasicValueEnum, pub trap_illegal_arithmetic: BasicValueEnum, + pub trap_misaligned_atomic: BasicValueEnum, // VM intrinsics. pub memory_grow_dynamic_local: FunctionValue, @@ -458,6 +459,7 @@ impl Intrinsics { trap_call_indirect_oob: i32_ty.const_int(3, false).as_basic_value_enum(), trap_memory_oob: i32_ty.const_int(2, false).as_basic_value_enum(), trap_illegal_arithmetic: i32_ty.const_int(4, false).as_basic_value_enum(), + trap_misaligned_atomic: i32_ty.const_int(5, false).as_basic_value_enum(), // VM intrinsics. memory_grow_dynamic_local: module.add_function( From aecce465c722a40432f05e9025b781534bbb0002 Mon Sep 17 00:00:00 2001 From: Nick Lewycky Date: Fri, 16 Aug 2019 15:17:36 -0700 Subject: [PATCH 05/16] Implement atomic.rmw operations including atomic.rmw.cmpxchg. --- lib/llvm-backend/src/code.rs | 1916 ++++++++++++++++++++++++++++++++-- 1 file changed, 1847 insertions(+), 69 deletions(-) diff --git a/lib/llvm-backend/src/code.rs b/lib/llvm-backend/src/code.rs index 7332594cecd..70d20595815 100644 --- a/lib/llvm-backend/src/code.rs +++ b/lib/llvm-backend/src/code.rs @@ -8,7 +8,7 @@ use inkwell::{ BasicValue, BasicValueEnum, FloatValue, FunctionValue, IntValue, PhiValue, PointerValue, VectorValue, }, - AddressSpace, FloatPredicate, IntPredicate, + AddressSpace, AtomicOrdering, AtomicRMWBinOp, FloatPredicate, IntPredicate, }; use smallvec::SmallVec; use std::sync::{Arc, RwLock}; @@ -497,7 +497,7 @@ fn trap_if_misaligned( context: &Context, function: &FunctionValue, memarg: &MemoryImmediate, - ptr: PointerValue + ptr: PointerValue, ) { let align = match memarg.flags & 2 { 0 => 1, @@ -507,25 +507,29 @@ fn trap_if_misaligned( _ => unreachable!("this match is fully covered"), }; let value = builder.build_ptr_to_int(ptr, intrinsics.i64_ty, ""); - let and = builder.build_and(value, intrinsics.i64_ty.const_int(align-1, false), "misaligncheck"); - let misaligned = builder.build_int_compare( - IntPredicate::NE, - and, - intrinsics.i64_zero, - ""); - let misaligned = builder.build_call(intrinsics.expect_i1, &[ - misaligned.as_basic_value_enum(), - intrinsics.i1_zero.as_basic_value_enum()], "").try_as_basic_value().left().unwrap().into_int_value(); - - let continue_block = - context.append_basic_block(function, "aligned_access_continue_block"); - let not_aligned_block = - context.append_basic_block(function, "misaligned_trap_block"); - builder.build_conditional_branch( - misaligned, - &continue_block, - ¬_aligned_block, + let and = builder.build_and( + value, + intrinsics.i64_ty.const_int(align - 1, false), + "misaligncheck", ); + let misaligned = builder.build_int_compare(IntPredicate::NE, and, intrinsics.i64_zero, ""); + let misaligned = builder + .build_call( + intrinsics.expect_i1, + &[ + misaligned.as_basic_value_enum(), + intrinsics.i1_zero.as_basic_value_enum(), + ], + "", + ) + .try_as_basic_value() + .left() + .unwrap() + .into_int_value(); + + let continue_block = context.append_basic_block(function, "aligned_access_continue_block"); + let not_aligned_block = context.append_basic_block(function, "misaligned_trap_block"); + builder.build_conditional_branch(misaligned, &continue_block, ¬_aligned_block); builder.position_at_end(¬_aligned_block); builder.build_call( @@ -4442,17 +4446,17 @@ impl FunctionCodeGenerator for LLVMFunctionCodeGenerator { let res = builder.build_bitcast(res, intrinsics.i128_ty, ""); state.push1(res); } -/* - Operator::Wake { ref memarg: _ } => { - unimplemented!(); - } - Operator::I32Wait { ref memarg: _ } => { - unimplemented!(); - } - Operator::I64Wait { ref memarg: _ } => { - unimplemented!(); - } -*/ + /* + Operator::Wake { ref memarg: _ } => { + unimplemented!(); + } + Operator::I32Wait { ref memarg: _ } => { + unimplemented!(); + } + Operator::I64Wait { ref memarg: _ } => { + unimplemented!(); + } + */ Operator::Fence { flags: _ } => { // fence is a no-op } @@ -4468,9 +4472,16 @@ impl FunctionCodeGenerator for LLVMFunctionCodeGenerator { intrinsics.i32_ptr_ty, 4, )?; - trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); let result = builder.build_load(effective_address, &state.var_name()); - // TODO: LLVMSetAlignment(result.as_value_ref(), 4) + // TODO: LLVMSetAlignment(result.as_value_ref(), 4); // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); state.push1(result); } @@ -4486,9 +4497,16 @@ impl FunctionCodeGenerator for LLVMFunctionCodeGenerator { intrinsics.i64_ptr_ty, 8, )?; - trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); let result = builder.build_load(effective_address, &state.var_name()); - // TODO: LLVMSetAlignment(result.as_value_ref(), 8) + // TODO: LLVMSetAlignment(result.as_value_ref(), 8); // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); state.push1(result); } @@ -4504,11 +4522,21 @@ impl FunctionCodeGenerator for LLVMFunctionCodeGenerator { intrinsics.i8_ptr_ty, 1, )?; - trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); - let narrow_result = builder.build_load(effective_address, &state.var_name()).into_int_value(); - // TODO: LLVMSetAlignment(result.as_value_ref(), 1) + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_result = builder + .build_load(effective_address, &state.var_name()) + .into_int_value(); + // TODO: LLVMSetAlignment(result.as_value_ref(), 1); // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); - let result = builder.build_int_z_extend(narrow_result, intrinsics.i32_ty, &state.var_name()); + let result = + builder.build_int_z_extend(narrow_result, intrinsics.i32_ty, &state.var_name()); state.push1(result); } Operator::I32AtomicLoad16U { ref memarg } => { @@ -4523,11 +4551,21 @@ impl FunctionCodeGenerator for LLVMFunctionCodeGenerator { intrinsics.i16_ptr_ty, 2, )?; - trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); - let narrow_result = builder.build_load(effective_address, &state.var_name()).into_int_value(); - // TODO: LLVMSetAlignment(result.as_value_ref(), 2) + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_result = builder + .build_load(effective_address, &state.var_name()) + .into_int_value(); + // TODO: LLVMSetAlignment(result.as_value_ref(), 2); // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); - let result = builder.build_int_z_extend(narrow_result, intrinsics.i32_ty, &state.var_name()); + let result = + builder.build_int_z_extend(narrow_result, intrinsics.i32_ty, &state.var_name()); state.push1(result); } Operator::I64AtomicLoad8U { ref memarg } => { @@ -4542,11 +4580,21 @@ impl FunctionCodeGenerator for LLVMFunctionCodeGenerator { intrinsics.i8_ptr_ty, 1, )?; - trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); - let narrow_result = builder.build_load(effective_address, &state.var_name()).into_int_value(); - // TODO: LLVMSetAlignment(result.as_value_ref(), 1) + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_result = builder + .build_load(effective_address, &state.var_name()) + .into_int_value(); + // TODO: LLVMSetAlignment(result.as_value_ref(), 1); // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); - let result = builder.build_int_z_extend(narrow_result, intrinsics.i64_ty, &state.var_name()); + let result = + builder.build_int_z_extend(narrow_result, intrinsics.i64_ty, &state.var_name()); state.push1(result); } Operator::I64AtomicLoad16U { ref memarg } => { @@ -4561,11 +4609,21 @@ impl FunctionCodeGenerator for LLVMFunctionCodeGenerator { intrinsics.i16_ptr_ty, 2, )?; - trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); - let narrow_result = builder.build_load(effective_address, &state.var_name()).into_int_value(); - // TODO: LLVMSetAlignment(result.as_value_ref(), 2) + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_result = builder + .build_load(effective_address, &state.var_name()) + .into_int_value(); + // TODO: LLVMSetAlignment(result.as_value_ref(), 2); // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); - let result = builder.build_int_z_extend(narrow_result, intrinsics.i64_ty, &state.var_name()); + let result = + builder.build_int_z_extend(narrow_result, intrinsics.i64_ty, &state.var_name()); state.push1(result); } Operator::I64AtomicLoad32U { ref memarg } => { @@ -4580,11 +4638,21 @@ impl FunctionCodeGenerator for LLVMFunctionCodeGenerator { intrinsics.i16_ptr_ty, 4, )?; - trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); - let narrow_result = builder.build_load(effective_address, &state.var_name()).into_int_value(); - // TODO: LLVMSetAlignment(result.as_value_ref(), 4) + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_result = builder + .build_load(effective_address, &state.var_name()) + .into_int_value(); + // TODO: LLVMSetAlignment(result.as_value_ref(), 4); // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); - let result = builder.build_int_z_extend(narrow_result, intrinsics.i64_ty, &state.var_name()); + let result = + builder.build_int_z_extend(narrow_result, intrinsics.i64_ty, &state.var_name()); state.push1(result); } Operator::I32AtomicStore { ref memarg } => { @@ -4600,9 +4668,16 @@ impl FunctionCodeGenerator for LLVMFunctionCodeGenerator { intrinsics.i32_ptr_ty, 4, )?; - trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); builder.build_store(effective_address, value); - // TODO: LLVMSetAlignment(result.as_value_ref(), 4) + // TODO: LLVMSetAlignment(result.as_value_ref(), 4); // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); } Operator::I64AtomicStore { ref memarg } => { @@ -4618,9 +4693,16 @@ impl FunctionCodeGenerator for LLVMFunctionCodeGenerator { intrinsics.i64_ptr_ty, 8, )?; - trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); builder.build_store(effective_address, value); - // TODO: LLVMSetAlignment(result.as_value_ref(), 8) + // TODO: LLVMSetAlignment(result.as_value_ref(), 8); // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); } Operator::I32AtomicStore8 { ref memarg } | Operator::I64AtomicStore8 { ref memarg } => { @@ -4636,13 +4718,22 @@ impl FunctionCodeGenerator for LLVMFunctionCodeGenerator { intrinsics.i8_ptr_ty, 1, )?; - trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); - let narrow_value = builder.build_int_truncate(value, intrinsics.i8_ty, &state.var_name()); + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i8_ty, &state.var_name()); builder.build_store(effective_address, narrow_value); - // TODO: LLVMSetAlignment(result.as_value_ref(), 1) + // TODO: LLVMSetAlignment(result.as_value_ref(), 1); // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); } - Operator::I32AtomicStore16 { ref memarg } | Operator::I64AtomicStore16 { ref memarg } => { + Operator::I32AtomicStore16 { ref memarg } + | Operator::I64AtomicStore16 { ref memarg } => { let value = state.pop1()?.into_int_value(); let effective_address = resolve_memory_ptr( builder, @@ -4655,10 +4746,18 @@ impl FunctionCodeGenerator for LLVMFunctionCodeGenerator { intrinsics.i16_ptr_ty, 2, )?; - trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); - let narrow_value = builder.build_int_truncate(value, intrinsics.i16_ty, &state.var_name()); + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i16_ty, &state.var_name()); builder.build_store(effective_address, narrow_value); - // TODO: LLVMSetAlignment(result.as_value_ref(), 2) + // TODO: LLVMSetAlignment(result.as_value_ref(), 2); // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); } Operator::I64AtomicStore32 { ref memarg } => { @@ -4674,12 +4773,1691 @@ impl FunctionCodeGenerator for LLVMFunctionCodeGenerator { intrinsics.i32_ptr_ty, 4, )?; - trap_if_misaligned(builder, intrinsics, context, &function, memarg, effective_address); - let narrow_value = builder.build_int_truncate(value, intrinsics.i32_ty, &state.var_name()); + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i32_ty, &state.var_name()); builder.build_store(effective_address, narrow_value); - // TODO: LLVMSetAlignment(result.as_value_ref(), 4) + // TODO: LLVMSetAlignment(result.as_value_ref(), 4); // TODO: LLVMSetOrdering(result.as_value_ref(), LLVMAtomicOrderingSequentiallyConsistent); } + Operator::I32AtomicRmw8UAdd { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i8_ptr_ty, + 1, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i8_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Add, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i32_ty, &state.var_name()); + state.push1(old); + } + Operator::I32AtomicRmw16UAdd { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i16_ptr_ty, + 2, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i16_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Add, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i32_ty, &state.var_name()); + state.push1(old); + } + Operator::I32AtomicRmwAdd { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i32_ptr_ty, + 4, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Add, + effective_address, + value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + state.push1(old); + } + Operator::I64AtomicRmw8UAdd { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i8_ptr_ty, + 1, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i8_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Add, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i64_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmw16UAdd { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i16_ptr_ty, + 2, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i16_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Add, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i64_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmw32UAdd { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i32_ptr_ty, + 4, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i32_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Add, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i64_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmwAdd { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i64_ptr_ty, + 8, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Add, + effective_address, + value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + state.push1(old); + } + Operator::I32AtomicRmw8USub { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i8_ptr_ty, + 1, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i8_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Sub, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i32_ty, &state.var_name()); + state.push1(old); + } + Operator::I32AtomicRmw16USub { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i16_ptr_ty, + 2, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i16_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Sub, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i32_ty, &state.var_name()); + state.push1(old); + } + Operator::I32AtomicRmwSub { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i32_ptr_ty, + 4, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Sub, + effective_address, + value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + state.push1(old); + } + Operator::I64AtomicRmw8USub { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i8_ptr_ty, + 1, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i8_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Sub, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i64_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmw16USub { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i16_ptr_ty, + 2, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i16_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Sub, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i64_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmw32USub { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i32_ptr_ty, + 4, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i32_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Sub, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i64_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmwSub { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i64_ptr_ty, + 8, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Sub, + effective_address, + value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + state.push1(old); + } + Operator::I32AtomicRmw8UAnd { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i8_ptr_ty, + 1, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i8_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::And, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i32_ty, &state.var_name()); + state.push1(old); + } + Operator::I32AtomicRmw16UAnd { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i16_ptr_ty, + 2, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i16_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::And, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i32_ty, &state.var_name()); + state.push1(old); + } + Operator::I32AtomicRmwAnd { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i32_ptr_ty, + 4, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::And, + effective_address, + value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + state.push1(old); + } + Operator::I64AtomicRmw8UAnd { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i8_ptr_ty, + 1, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i8_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::And, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i64_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmw16UAnd { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i16_ptr_ty, + 2, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i16_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::And, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i64_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmw32UAnd { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i32_ptr_ty, + 4, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i32_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::And, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i64_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmwAnd { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i64_ptr_ty, + 8, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::And, + effective_address, + value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + state.push1(old); + } + Operator::I32AtomicRmw8UOr { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i8_ptr_ty, + 1, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i8_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Or, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i32_ty, &state.var_name()); + state.push1(old); + } + Operator::I32AtomicRmw16UOr { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i16_ptr_ty, + 2, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i16_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Or, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i32_ty, &state.var_name()); + state.push1(old); + } + Operator::I32AtomicRmwOr { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i32_ptr_ty, + 4, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Or, + effective_address, + value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i32_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmw8UOr { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i8_ptr_ty, + 1, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i8_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Or, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i64_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmw16UOr { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i16_ptr_ty, + 2, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i16_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Or, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i64_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmw32UOr { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i32_ptr_ty, + 4, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i32_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Or, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i64_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmwOr { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i64_ptr_ty, + 8, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Or, + effective_address, + value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + state.push1(old); + } + Operator::I32AtomicRmw8UXor { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i8_ptr_ty, + 1, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i8_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Xor, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i32_ty, &state.var_name()); + state.push1(old); + } + Operator::I32AtomicRmw16UXor { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i16_ptr_ty, + 2, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i16_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Xor, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i32_ty, &state.var_name()); + state.push1(old); + } + Operator::I32AtomicRmwXor { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i32_ptr_ty, + 4, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Xor, + effective_address, + value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + state.push1(old); + } + Operator::I64AtomicRmw8UXor { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i8_ptr_ty, + 1, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i8_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Xor, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i64_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmw16UXor { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i16_ptr_ty, + 2, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i16_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Xor, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i64_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmw32UXor { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i32_ptr_ty, + 4, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i32_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Xor, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i64_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmwXor { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i64_ptr_ty, + 8, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Xor, + effective_address, + value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + state.push1(old); + } + Operator::I32AtomicRmw8UXchg { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i8_ptr_ty, + 1, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i8_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Xchg, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i32_ty, &state.var_name()); + state.push1(old); + } + Operator::I32AtomicRmw16UXchg { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i16_ptr_ty, + 2, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i16_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Xchg, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i32_ty, &state.var_name()); + state.push1(old); + } + Operator::I32AtomicRmwXchg { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i32_ptr_ty, + 4, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Xchg, + effective_address, + value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + state.push1(old); + } + Operator::I64AtomicRmw8UXchg { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i8_ptr_ty, + 1, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i8_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Xchg, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i64_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmw16UXchg { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i16_ptr_ty, + 2, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i16_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Xchg, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i64_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmw32UXchg { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i32_ptr_ty, + 4, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_value = + builder.build_int_truncate(value, intrinsics.i32_ty, &state.var_name()); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Xchg, + effective_address, + narrow_value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_int_z_extend(old, intrinsics.i64_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmwXchg { ref memarg } => { + let value = state.pop1()?.into_int_value(); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i64_ptr_ty, + 8, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let old = builder + .build_atomicrmw( + AtomicRMWBinOp::Xchg, + effective_address, + value, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + state.push1(old); + } + Operator::I32AtomicRmw8UCmpxchg { ref memarg } => { + let (cmp, new) = state.pop2()?; + let (cmp, new) = (cmp.into_int_value(), new.into_int_value()); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i8_ptr_ty, + 1, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_cmp = + builder.build_int_truncate(cmp, intrinsics.i8_ty, &state.var_name()); + let narrow_new = + builder.build_int_truncate(new, intrinsics.i8_ty, &state.var_name()); + let old = builder + .build_cmpxchg( + effective_address, + narrow_cmp, + narrow_new, + AtomicOrdering::SequentiallyConsistent, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder + .build_extract_value(old, 0, "") + .unwrap() + .into_int_value(); + let old = builder.build_int_z_extend(old, intrinsics.i32_ty, &state.var_name()); + state.push1(old); + } + Operator::I32AtomicRmw16UCmpxchg { ref memarg } => { + let (cmp, new) = state.pop2()?; + let (cmp, new) = (cmp.into_int_value(), new.into_int_value()); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i16_ptr_ty, + 2, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_cmp = + builder.build_int_truncate(cmp, intrinsics.i16_ty, &state.var_name()); + let narrow_new = + builder.build_int_truncate(new, intrinsics.i16_ty, &state.var_name()); + let old = builder + .build_cmpxchg( + effective_address, + narrow_cmp, + narrow_new, + AtomicOrdering::SequentiallyConsistent, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder + .build_extract_value(old, 0, "") + .unwrap() + .into_int_value(); + let old = builder.build_int_z_extend(old, intrinsics.i32_ty, &state.var_name()); + state.push1(old); + } + Operator::I32AtomicRmwCmpxchg { ref memarg } => { + let (cmp, new) = state.pop2()?; + let (cmp, new) = (cmp.into_int_value(), new.into_int_value()); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i32_ptr_ty, + 4, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let old = builder + .build_cmpxchg( + effective_address, + cmp, + new, + AtomicOrdering::SequentiallyConsistent, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_extract_value(old, 0, "").unwrap(); + state.push1(old); + } + Operator::I64AtomicRmw8UCmpxchg { ref memarg } => { + let (cmp, new) = state.pop2()?; + let (cmp, new) = (cmp.into_int_value(), new.into_int_value()); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i8_ptr_ty, + 1, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_cmp = + builder.build_int_truncate(cmp, intrinsics.i8_ty, &state.var_name()); + let narrow_new = + builder.build_int_truncate(new, intrinsics.i8_ty, &state.var_name()); + let old = builder + .build_cmpxchg( + effective_address, + narrow_cmp, + narrow_new, + AtomicOrdering::SequentiallyConsistent, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder + .build_extract_value(old, 0, "") + .unwrap() + .into_int_value(); + let old = builder.build_int_z_extend(old, intrinsics.i64_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmw16UCmpxchg { ref memarg } => { + let (cmp, new) = state.pop2()?; + let (cmp, new) = (cmp.into_int_value(), new.into_int_value()); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i16_ptr_ty, + 2, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_cmp = + builder.build_int_truncate(cmp, intrinsics.i16_ty, &state.var_name()); + let narrow_new = + builder.build_int_truncate(new, intrinsics.i16_ty, &state.var_name()); + let old = builder + .build_cmpxchg( + effective_address, + narrow_cmp, + narrow_new, + AtomicOrdering::SequentiallyConsistent, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder + .build_extract_value(old, 0, "") + .unwrap() + .into_int_value(); + let old = builder.build_int_z_extend(old, intrinsics.i64_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmw32UCmpxchg { ref memarg } => { + let (cmp, new) = state.pop2()?; + let (cmp, new) = (cmp.into_int_value(), new.into_int_value()); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i32_ptr_ty, + 4, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let narrow_cmp = + builder.build_int_truncate(cmp, intrinsics.i32_ty, &state.var_name()); + let narrow_new = + builder.build_int_truncate(new, intrinsics.i32_ty, &state.var_name()); + let old = builder + .build_cmpxchg( + effective_address, + narrow_cmp, + narrow_new, + AtomicOrdering::SequentiallyConsistent, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder + .build_extract_value(old, 0, "") + .unwrap() + .into_int_value(); + let old = builder.build_int_z_extend(old, intrinsics.i64_ty, &state.var_name()); + state.push1(old); + } + Operator::I64AtomicRmwCmpxchg { ref memarg } => { + let (cmp, new) = state.pop2()?; + let (cmp, new) = (cmp.into_int_value(), new.into_int_value()); + let effective_address = resolve_memory_ptr( + builder, + intrinsics, + context, + &function, + &mut state, + &mut ctx, + memarg, + intrinsics.i64_ptr_ty, + 8, + )?; + trap_if_misaligned( + builder, + intrinsics, + context, + &function, + memarg, + effective_address, + ); + let old = builder + .build_cmpxchg( + effective_address, + cmp, + new, + AtomicOrdering::SequentiallyConsistent, + AtomicOrdering::SequentiallyConsistent, + ) + .unwrap(); + let old = builder.build_extract_value(old, 0, "").unwrap(); + state.push1(old); + } Operator::MemoryGrow { reserved } => { let memory_index = MemoryIndex::new(reserved as usize); From c8378329c14656fb48adc8feec15ef3ede4df6f4 Mon Sep 17 00:00:00 2001 From: Nick Lewycky Date: Fri, 16 Aug 2019 15:23:40 -0700 Subject: [PATCH 06/16] Expound upon Fence's empty implementation being correct. --- lib/llvm-backend/src/code.rs | 26 ++++++++++++++++---------- 1 file changed, 16 insertions(+), 10 deletions(-) diff --git a/lib/llvm-backend/src/code.rs b/lib/llvm-backend/src/code.rs index 70d20595815..8fc03334a98 100644 --- a/lib/llvm-backend/src/code.rs +++ b/lib/llvm-backend/src/code.rs @@ -4447,18 +4447,24 @@ impl FunctionCodeGenerator for LLVMFunctionCodeGenerator { state.push1(res); } /* - Operator::Wake { ref memarg: _ } => { - unimplemented!(); - } - Operator::I32Wait { ref memarg: _ } => { - unimplemented!(); - } - Operator::I64Wait { ref memarg: _ } => { - unimplemented!(); - } + Operator::Wake { ref memarg: _ } => { + unimplemented!(); + } + Operator::I32Wait { ref memarg: _ } => { + unimplemented!(); + } + Operator::I64Wait { ref memarg: _ } => { + unimplemented!(); + } */ Operator::Fence { flags: _ } => { - // fence is a no-op + // Fence is a nop. + // + // Fence was added to preserve information about fences from + // source languages. If in the future Wasm extends the memory + // model, and if we hadn't recorded what fences used to be there, + // it would lead to data races that weren't present in the + // original source language. } Operator::I32AtomicLoad { ref memarg } => { let effective_address = resolve_memory_ptr( From 0eba1532322d460a44b8582c1a528b7cb1401353 Mon Sep 17 00:00:00 2001 From: Nick Lewycky Date: Mon, 19 Aug 2019 15:18:22 -0700 Subject: [PATCH 07/16] Implement shared static memory similarly to unshared static memory. --- lib/runtime-core/src/memory/mod.rs | 62 ++++++---- lib/runtime-core/src/memory/static_/mod.rs | 2 - lib/runtime-core/src/memory/static_/shared.rs | 113 ++++++++++++++++-- 3 files changed, 148 insertions(+), 29 deletions(-) diff --git a/lib/runtime-core/src/memory/mod.rs b/lib/runtime-core/src/memory/mod.rs index d7c32dc98bb..a7510b818a3 100644 --- a/lib/runtime-core/src/memory/mod.rs +++ b/lib/runtime-core/src/memory/mod.rs @@ -12,12 +12,15 @@ use std::{ cell::{Cell, RefCell}, fmt, mem, rc::Rc, + sync::Arc, }; pub use self::dynamic::DynamicMemory; -pub use self::static_::{SharedStaticMemory, StaticMemory}; +pub use self::static_::StaticMemory; pub use self::view::{Atomically, MemoryView}; +use parking_lot::Mutex; + mod dynamic; pub mod ptr; mod static_; @@ -151,20 +154,10 @@ impl Memory { unsafe { MemoryView::new(base as _, length as u32) } } - /// Convert this memory to a shared memory if the shared flag - /// is present in the description used to create it. - pub fn shared(self) -> Option { - if self.desc.shared { - Some(SharedMemory { desc: self.desc }) - } else { - None - } - } - pub(crate) fn vm_local_memory(&self) -> *mut vm::LocalMemory { match &self.variant { MemoryVariant::Unshared(unshared_mem) => unshared_mem.vm_local_memory(), - MemoryVariant::Shared(_) => unimplemented!(), + MemoryVariant::Shared(shared_mem) => shared_mem.vm_local_memory(), } } } @@ -241,7 +234,7 @@ impl UnsharedMemory { MemoryType::SharedStatic => panic!("attempting to create shared unshared memory"), }; - Ok(UnsharedMemory { + Ok(Self { internal: Rc::new(UnsharedMemoryInternal { storage: RefCell::new(storage), local: Cell::new(local), @@ -289,27 +282,56 @@ impl Clone for UnsharedMemory { } pub struct SharedMemory { - #[allow(dead_code)] - desc: MemoryDescriptor, + internal: Arc, +} + +pub struct SharedMemoryInternal { + memory: RefCell>, + local: Cell, + lock: Mutex<()>, } impl SharedMemory { fn new(desc: MemoryDescriptor) -> Result { - Ok(Self { desc }) + let mut local = vm::LocalMemory { + base: std::ptr::null_mut(), + bound: 0, + memory: std::ptr::null_mut(), + }; + + let memory = StaticMemory::new(desc, &mut local)?; + + Ok(Self { + internal: Arc::new(SharedMemoryInternal { + memory: RefCell::new(memory), + local: Cell::new(local), + lock: Mutex::new(()), + }), + }) } - pub fn grow(&self, _delta: Pages) -> Result { - unimplemented!() + pub fn grow(&self, delta: Pages) -> Result { + let _guard = self.internal.lock.lock(); + let mut local = self.internal.local.get(); + let pages = self.internal.memory.borrow_mut().grow(delta, &mut local); + pages } pub fn size(&self) -> Pages { - unimplemented!() + let _guard = self.internal.lock.lock(); + self.internal.memory.borrow_mut().size() + } + + pub(crate) fn vm_local_memory(&self) -> *mut vm::LocalMemory { + self.internal.local.as_ptr() } } impl Clone for SharedMemory { fn clone(&self) -> Self { - unimplemented!() + SharedMemory { + internal: Arc::clone(&self.internal), + } } } diff --git a/lib/runtime-core/src/memory/static_/mod.rs b/lib/runtime-core/src/memory/static_/mod.rs index b2ef0fa5a6c..5e5b0a3a0d3 100644 --- a/lib/runtime-core/src/memory/static_/mod.rs +++ b/lib/runtime-core/src/memory/static_/mod.rs @@ -3,8 +3,6 @@ pub const SAFE_STATIC_HEAP_SIZE: usize = 1 << 32; // 4 GiB #[doc(hidden)] pub const SAFE_STATIC_GUARD_SIZE: usize = 1 << 31; // 2 GiB -mod shared; mod unshared; -pub use self::shared::SharedStaticMemory; pub use self::unshared::StaticMemory; diff --git a/lib/runtime-core/src/memory/static_/shared.rs b/lib/runtime-core/src/memory/static_/shared.rs index a18a0cbe98b..f996334e78a 100644 --- a/lib/runtime-core/src/memory/static_/shared.rs +++ b/lib/runtime-core/src/memory/static_/shared.rs @@ -1,11 +1,110 @@ -use crate::sys; -use parking_lot::Mutex; -use std::sync::atomic::AtomicUsize; +/*use crate::error::GrowError; +use crate::{ + error::CreationError, + memory::static_::{SAFE_STATIC_GUARD_SIZE, SAFE_STATIC_HEAP_SIZE}, + sys, + types::MemoryDescriptor, + units::Pages, + vm, +}; -// Remove this attribute once this is used. -#[allow(dead_code)] +use parking_lot::{Mutex, MutexGuard}; + +/// This is an internal-only api. +/// +/// A static memory allocates 6GB of *virtual* memory when created +/// in order to allow the WebAssembly module to contain no bounds-checks. +/// +/// Additionally, static memories stay at a single virtual address, so there is no need +/// to reload its address on each use. +/// +/// Static memories take a relatively long time to create, so if memories are short-lived, +/// it's recommended that a dynamic memory is used. There is currently no user-facing api that +/// allows them to select the type of memory used however. pub struct SharedStaticMemory { memory: sys::Memory, - current: AtomicUsize, - lock: Mutex<()>, + current: Pages, + max: Option, +} + +impl SharedStaticMemory { + pub(in crate::memory) fn new( + desc: MemoryDescriptor, + local: &mut vm::LocalMemory, + ) -> Result, CreationError> { + let memory = { + let mut memory = sys::Memory::with_size(SAFE_STATIC_HEAP_SIZE + SAFE_STATIC_GUARD_SIZE) + .map_err(|_| CreationError::UnableToCreateMemory)?; + if desc.minimum != Pages(0) { + unsafe { + memory + .protect(0..desc.minimum.bytes().0, sys::Protect::ReadWrite) + .map_err(|_| CreationError::UnableToCreateMemory)?; + } + } + + memory + }; + + let mut storage = Box::new(SharedStaticMemory { + memory, + current: desc.minimum, + max: desc.maximum, + lock: Mutex::new(()), + }); + let storage_ptr: *mut SharedStaticMemory = &mut *storage; + + local.base = storage.memory.as_ptr(); + local.bound = desc.minimum.bytes().0; + local.memory = storage_ptr as *mut (); + + Ok(storage) + } + + pub fn lock(&mut self) -> MutexGuard<()> { + self.lock.lock() + } + + pub fn size(&self, _: &MutexGuard<()>) -> Pages { + self.current + } + + pub fn grow(&mut self, delta: Pages, local: &mut vm::LocalMemory, _: &MutexGuard<()>) -> Result { + let new_pages = self.current.checked_add(delta).map_err(|e| e.into())?; + + if let Some(max) = self.max { + if new_pages > max { + return Err(GrowError::ExceededMaxPagesForMemory( + new_pages.0 as usize, + max.0 as usize, + )); + } + } + + let _ = unsafe { + self.memory + .protect( + self.current.bytes().0..new_pages.bytes().0, + sys::Protect::ReadWrite, + ) + .map_err(|e| e.into()) + }?; + + local.bound = new_pages.bytes().0; + + let old_pages = self.current; + + self.current = new_pages; + + Ok(old_pages) + } + + pub fn as_slice(&self) -> &[u8] { + unsafe { &self.memory.as_slice()[0..self.current.bytes().0] } + } + + pub fn as_slice_mut(&mut self) -> &mut [u8] { + unsafe { &mut self.memory.as_slice_mut()[0..self.current.bytes().0] } + } } +*/ From d66b805529e5490299aacc62194918dce789634f Mon Sep 17 00:00:00 2001 From: Nick Lewycky Date: Mon, 19 Aug 2019 17:26:15 -0700 Subject: [PATCH 08/16] Add misaligned atomic access trap display for WasmTrapInfo. --- lib/runtime-core/src/typed_func.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/lib/runtime-core/src/typed_func.rs b/lib/runtime-core/src/typed_func.rs index 76cf452d86b..91da26cbe37 100644 --- a/lib/runtime-core/src/typed_func.rs +++ b/lib/runtime-core/src/typed_func.rs @@ -23,6 +23,7 @@ pub enum WasmTrapInfo { MemoryOutOfBounds = 2, CallIndirectOOB = 3, IllegalArithmetic = 4, + MisalignedAtomicAccess = 5, Unknown, } @@ -39,6 +40,7 @@ impl fmt::Display for WasmTrapInfo { WasmTrapInfo::MemoryOutOfBounds => "memory out-of-bounds access", WasmTrapInfo::CallIndirectOOB => "`call_indirect` out-of-bounds", WasmTrapInfo::IllegalArithmetic => "illegal arithmetic operation", + WasmTrapInfo::MisalignedAtomicAccess => "misaligned atomic access", WasmTrapInfo::Unknown => "unknown", } ) From 172ef77ddd571a1deb5cfb5c9ea9dd1da6b52949 Mon Sep 17 00:00:00 2001 From: Nick Lewycky Date: Mon, 19 Aug 2019 17:26:35 -0700 Subject: [PATCH 09/16] Use the static intrinsics for static shared memory too. --- lib/runtime-core/src/vm.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/runtime-core/src/vm.rs b/lib/runtime-core/src/vm.rs index 9726931b009..51f883318d1 100644 --- a/lib/runtime-core/src/vm.rs +++ b/lib/runtime-core/src/vm.rs @@ -208,7 +208,7 @@ fn get_intrinsics_for_module(m: &ModuleInfo) -> *const Intrinsics { match mem_desc.memory_type() { MemoryType::Dynamic => &INTRINSICS_LOCAL_DYNAMIC_MEMORY, MemoryType::Static => &INTRINSICS_LOCAL_STATIC_MEMORY, - MemoryType::SharedStatic => unimplemented!(), + MemoryType::SharedStatic => &INTRINSICS_LOCAL_STATIC_MEMORY, } } LocalOrImport::Import(import_mem_index) => { @@ -216,7 +216,7 @@ fn get_intrinsics_for_module(m: &ModuleInfo) -> *const Intrinsics { match mem_desc.memory_type() { MemoryType::Dynamic => &INTRINSICS_IMPORTED_DYNAMIC_MEMORY, MemoryType::Static => &INTRINSICS_IMPORTED_STATIC_MEMORY, - MemoryType::SharedStatic => unimplemented!(), + MemoryType::SharedStatic => &INTRINSICS_IMPORTED_STATIC_MEMORY, } } } From 0ba73ac50c6ed60621d2e75ad6d2eeace97ad730 Mon Sep 17 00:00:00 2001 From: Nick Lewycky Date: Tue, 20 Aug 2019 10:39:53 -0700 Subject: [PATCH 10/16] Correct flipped misalignment test. --- lib/llvm-backend/src/code.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/lib/llvm-backend/src/code.rs b/lib/llvm-backend/src/code.rs index 8fc03334a98..d8c00aed27d 100644 --- a/lib/llvm-backend/src/code.rs +++ b/lib/llvm-backend/src/code.rs @@ -512,13 +512,13 @@ fn trap_if_misaligned( intrinsics.i64_ty.const_int(align - 1, false), "misaligncheck", ); - let misaligned = builder.build_int_compare(IntPredicate::NE, and, intrinsics.i64_zero, ""); - let misaligned = builder + let aligned = builder.build_int_compare(IntPredicate::EQ, and, intrinsics.i64_zero, ""); + let aligned = builder .build_call( intrinsics.expect_i1, &[ - misaligned.as_basic_value_enum(), - intrinsics.i1_zero.as_basic_value_enum(), + aligned.as_basic_value_enum(), + intrinsics.i1_ty.const_int(1, false).as_basic_value_enum(), ], "", ) @@ -529,7 +529,7 @@ fn trap_if_misaligned( let continue_block = context.append_basic_block(function, "aligned_access_continue_block"); let not_aligned_block = context.append_basic_block(function, "misaligned_trap_block"); - builder.build_conditional_branch(misaligned, &continue_block, ¬_aligned_block); + builder.build_conditional_branch(aligned, &continue_block, ¬_aligned_block); builder.position_at_end(¬_aligned_block); builder.build_call( From dcf70167dae7f89f3ae1d0b89208ba9666d3c6a8 Mon Sep 17 00:00:00 2001 From: Nick Lewycky Date: Tue, 20 Aug 2019 11:03:22 -0700 Subject: [PATCH 11/16] Fix i64.atomic.load32_u and all alignment checks. --- lib/llvm-backend/src/code.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/llvm-backend/src/code.rs b/lib/llvm-backend/src/code.rs index d8c00aed27d..a9ae4e55c24 100644 --- a/lib/llvm-backend/src/code.rs +++ b/lib/llvm-backend/src/code.rs @@ -499,7 +499,7 @@ fn trap_if_misaligned( memarg: &MemoryImmediate, ptr: PointerValue, ) { - let align = match memarg.flags & 2 { + let align = match memarg.flags & 3 { 0 => 1, 1 => 2, 2 => 4, @@ -4641,7 +4641,7 @@ impl FunctionCodeGenerator for LLVMFunctionCodeGenerator { &mut state, &mut ctx, memarg, - intrinsics.i16_ptr_ty, + intrinsics.i32_ptr_ty, 4, )?; trap_if_misaligned( From 1568084d429de41e03f7802ffda39b765fe0daf2 Mon Sep 17 00:00:00 2001 From: Nick Lewycky Date: Tue, 20 Aug 2019 11:16:59 -0700 Subject: [PATCH 12/16] Add atomic.wast which we have zero failures on with the llvm backend. Enable shared memory usage in simd.wast. Exclude atomic.wast on singlepass and clif. --- lib/spectests/spectests/atomic.wast | 473 ++++++++++++++++++++++++++++ lib/spectests/spectests/simd.wast | 4 +- lib/spectests/tests/excludes.txt | 4 +- 3 files changed, 477 insertions(+), 4 deletions(-) create mode 100644 lib/spectests/spectests/atomic.wast diff --git a/lib/spectests/spectests/atomic.wast b/lib/spectests/spectests/atomic.wast new file mode 100644 index 00000000000..de6b3ade5aa --- /dev/null +++ b/lib/spectests/spectests/atomic.wast @@ -0,0 +1,473 @@ +;; atomic.wast from WebAssembly test suite. +;; https://github.com/WebAssembly/testsuite/blob/master/LICENSE +;; +;; Modified by Wasmer to parse with the wabt spec test parser, replacing +;; '_u.add' with '.add_u' and similarly for 'sub', 'and', 'or', 'xor', 'xchg' +;; and 'cmpxchg'. + +;; atomic operations + +(module + (memory 1 1 shared) + + (func (export "init") (param $value i64) (i64.store (i32.const 0) (local.get $value))) + + (func (export "i32.atomic.load") (param $addr i32) (result i32) (i32.atomic.load (local.get $addr))) + (func (export "i64.atomic.load") (param $addr i32) (result i64) (i64.atomic.load (local.get $addr))) + (func (export "i32.atomic.load8_u") (param $addr i32) (result i32) (i32.atomic.load8_u (local.get $addr))) + (func (export "i32.atomic.load16_u") (param $addr i32) (result i32) (i32.atomic.load16_u (local.get $addr))) + (func (export "i64.atomic.load8_u") (param $addr i32) (result i64) (i64.atomic.load8_u (local.get $addr))) + (func (export "i64.atomic.load16_u") (param $addr i32) (result i64) (i64.atomic.load16_u (local.get $addr))) + (func (export "i64.atomic.load32_u") (param $addr i32) (result i64) (i64.atomic.load32_u (local.get $addr))) + + (func (export "i32.atomic.store") (param $addr i32) (param $value i32) (i32.atomic.store (local.get $addr) (local.get $value))) + (func (export "i64.atomic.store") (param $addr i32) (param $value i64) (i64.atomic.store (local.get $addr) (local.get $value))) + (func (export "i32.atomic.store8") (param $addr i32) (param $value i32) (i32.atomic.store8 (local.get $addr) (local.get $value))) + (func (export "i32.atomic.store16") (param $addr i32) (param $value i32) (i32.atomic.store16 (local.get $addr) (local.get $value))) + (func (export "i64.atomic.store8") (param $addr i32) (param $value i64) (i64.atomic.store8 (local.get $addr) (local.get $value))) + (func (export "i64.atomic.store16") (param $addr i32) (param $value i64) (i64.atomic.store16 (local.get $addr) (local.get $value))) + (func (export "i64.atomic.store32") (param $addr i32) (param $value i64) (i64.atomic.store32 (local.get $addr) (local.get $value))) + + (func (export "i32.atomic.rmw.add") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw.add (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw.add") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw.add (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw8.add_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw8.add_u (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw16.add_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw16.add_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw8.add_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw8.add_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw16.add_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw16.add_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw32.add_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw32.add_u (local.get $addr) (local.get $value))) + + (func (export "i32.atomic.rmw.sub") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw.sub (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw.sub") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw.sub (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw8.sub_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw8.sub_u (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw16.sub_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw16.sub_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw8.sub_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw8.sub_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw16.sub_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw16.sub_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw32.sub_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw32.sub_u (local.get $addr) (local.get $value))) + + (func (export "i32.atomic.rmw.and") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw.and (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw.and") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw.and (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw8.and_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw8.and_u (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw16.and_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw16.and_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw8.and_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw8.and_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw16.and_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw16.and_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw32.and_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw32.and_u (local.get $addr) (local.get $value))) + + (func (export "i32.atomic.rmw.or") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw.or (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw.or") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw.or (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw8.or_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw8.or_u (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw16.or_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw16.or_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw8.or_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw8.or_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw16.or_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw16.or_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw32.or_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw32.or_u (local.get $addr) (local.get $value))) + + (func (export "i32.atomic.rmw.xor") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw.xor (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw.xor") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw.xor (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw8.xor_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw8.xor_u (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw16.xor_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw16.xor_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw8.xor_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw8.xor_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw16.xor_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw16.xor_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw32.xor_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw32.xor_u (local.get $addr) (local.get $value))) + + (func (export "i32.atomic.rmw.xchg") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw.xchg (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw.xchg") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw.xchg (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw8.xchg_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw8.xchg_u (local.get $addr) (local.get $value))) + (func (export "i32.atomic.rmw16.xchg_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw16.xchg_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw8.xchg_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw8.xchg_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw16.xchg_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw16.xchg_u (local.get $addr) (local.get $value))) + (func (export "i64.atomic.rmw32.xchg_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw32.xchg_u (local.get $addr) (local.get $value))) + + (func (export "i32.atomic.rmw.cmpxchg") (param $addr i32) (param $expected i32) (param $value i32) (result i32) (i32.atomic.rmw.cmpxchg (local.get $addr) (local.get $expected) (local.get $value))) + (func (export "i64.atomic.rmw.cmpxchg") (param $addr i32) (param $expected i64) (param $value i64) (result i64) (i64.atomic.rmw.cmpxchg (local.get $addr) (local.get $expected) (local.get $value))) + (func (export "i32.atomic.rmw8.cmpxchg_u") (param $addr i32) (param $expected i32) (param $value i32) (result i32) (i32.atomic.rmw8.cmpxchg_u (local.get $addr) (local.get $expected) (local.get $value))) + (func (export "i32.atomic.rmw16.cmpxchg_u") (param $addr i32) (param $expected i32) (param $value i32) (result i32) (i32.atomic.rmw16.cmpxchg_u (local.get $addr) (local.get $expected) (local.get $value))) + (func (export "i64.atomic.rmw8.cmpxchg_u") (param $addr i32) (param $expected i64) (param $value i64) (result i64) (i64.atomic.rmw8.cmpxchg_u (local.get $addr) (local.get $expected) (local.get $value))) + (func (export "i64.atomic.rmw16.cmpxchg_u") (param $addr i32) (param $expected i64) (param $value i64) (result i64) (i64.atomic.rmw16.cmpxchg_u (local.get $addr) (local.get $expected) (local.get $value))) + (func (export "i64.atomic.rmw32.cmpxchg_u") (param $addr i32) (param $expected i64) (param $value i64) (result i64) (i64.atomic.rmw32.cmpxchg_u (local.get $addr) (local.get $expected) (local.get $value))) + +) + +;; *.atomic.load* + +(invoke "init" (i64.const 0x0706050403020100)) + +(assert_return (invoke "i32.atomic.load" (i32.const 0)) (i32.const 0x03020100)) +(assert_return (invoke "i32.atomic.load" (i32.const 4)) (i32.const 0x07060504)) + +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0706050403020100)) + +(assert_return (invoke "i32.atomic.load8_u" (i32.const 0)) (i32.const 0x00)) +(assert_return (invoke "i32.atomic.load8_u" (i32.const 5)) (i32.const 0x05)) + +(assert_return (invoke "i32.atomic.load16_u" (i32.const 0)) (i32.const 0x0100)) +(assert_return (invoke "i32.atomic.load16_u" (i32.const 6)) (i32.const 0x0706)) + +(assert_return (invoke "i64.atomic.load8_u" (i32.const 0)) (i64.const 0x00)) +(assert_return (invoke "i64.atomic.load8_u" (i32.const 5)) (i64.const 0x05)) + +(assert_return (invoke "i64.atomic.load16_u" (i32.const 0)) (i64.const 0x0100)) +(assert_return (invoke "i64.atomic.load16_u" (i32.const 6)) (i64.const 0x0706)) + +(assert_return (invoke "i64.atomic.load32_u" (i32.const 0)) (i64.const 0x03020100)) +(assert_return (invoke "i64.atomic.load32_u" (i32.const 4)) (i64.const 0x07060504)) + +;; *.atomic.store* + +(invoke "init" (i64.const 0x0000000000000000)) + +(assert_return (invoke "i32.atomic.store" (i32.const 0) (i32.const 0xffeeddcc))) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x00000000ffeeddcc)) + +(assert_return (invoke "i64.atomic.store" (i32.const 0) (i64.const 0x0123456789abcdef))) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0123456789abcdef)) + +(assert_return (invoke "i32.atomic.store8" (i32.const 1) (i32.const 0x42))) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0123456789ab42ef)) + +(assert_return (invoke "i32.atomic.store16" (i32.const 4) (i32.const 0x8844))) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0123884489ab42ef)) + +(assert_return (invoke "i64.atomic.store8" (i32.const 1) (i64.const 0x99))) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0123884489ab99ef)) + +(assert_return (invoke "i64.atomic.store16" (i32.const 4) (i64.const 0xcafe))) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0123cafe89ab99ef)) + +(assert_return (invoke "i64.atomic.store32" (i32.const 4) (i64.const 0xdeadbeef))) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0xdeadbeef89ab99ef)) + +;; *.atomic.rmw*.add + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw.add" (i32.const 0) (i32.const 0x12345678)) (i32.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111123456789)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw.add" (i32.const 0) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1212121213131313)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw8.add_u" (i32.const 0) (i32.const 0xcdcdcdcd)) (i32.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111111111de)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw16.add_u" (i32.const 0) (i32.const 0xcafecafe)) (i32.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111dc0f)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw8.add_u" (i32.const 0) (i64.const 0x4242424242424242)) (i64.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111153)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw16.add_u" (i32.const 0) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111d000)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw32.add_u" (i32.const 0) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111dbccb7f6)) + +;; *.atomic.rmw*.sub + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw.sub" (i32.const 0) (i32.const 0x12345678)) (i32.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111fedcba99)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw.sub" (i32.const 0) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x101010100f0f0f0f)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw8.sub_u" (i32.const 0) (i32.const 0xcdcdcdcd)) (i32.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111144)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw16.sub_u" (i32.const 0) (i32.const 0xcafecafe)) (i32.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111114613)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw8.sub_u" (i32.const 0) (i64.const 0x4242424242424242)) (i64.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111111111cf)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw16.sub_u" (i32.const 0) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111115222)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw32.sub_u" (i32.const 0) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111146556a2c)) + +;; *.atomic.rmw*.and + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw.and" (i32.const 0) (i32.const 0x12345678)) (i32.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111110101010)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw.and" (i32.const 0) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0101010100000000)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw8.and_u" (i32.const 0) (i32.const 0xcdcdcdcd)) (i32.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111101)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw16.and_u" (i32.const 0) (i32.const 0xcafecafe)) (i32.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111110010)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw8.and_u" (i32.const 0) (i64.const 0x4242424242424242)) (i64.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111100)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw16.and_u" (i32.const 0) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111001)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw32.and_u" (i32.const 0) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111100110001)) + +;; *.atomic.rmw*.or + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw.or" (i32.const 0) (i32.const 0x12345678)) (i32.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111113355779)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw.or" (i32.const 0) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111113131313)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw8.or_u" (i32.const 0) (i32.const 0xcdcdcdcd)) (i32.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111111111dd)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw16.or_u" (i32.const 0) (i32.const 0xcafecafe)) (i32.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111dbff)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw8.or_u" (i32.const 0) (i64.const 0x4242424242424242)) (i64.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111153)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw16.or_u" (i32.const 0) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111bfff)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw32.or_u" (i32.const 0) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111dbbbb7f5)) + +;; *.atomic.rmw*.xor + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw.xor" (i32.const 0) (i32.const 0x12345678)) (i32.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111103254769)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw.xor" (i32.const 0) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1010101013131313)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw8.xor_u" (i32.const 0) (i32.const 0xcdcdcdcd)) (i32.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111111111dc)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw16.xor_u" (i32.const 0) (i32.const 0xcafecafe)) (i32.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111dbef)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw8.xor_u" (i32.const 0) (i64.const 0x4242424242424242)) (i64.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111153)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw16.xor_u" (i32.const 0) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111affe)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw32.xor_u" (i32.const 0) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111dbaab7f4)) + +;; *.atomic.rmw*.xchg + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw.xchg" (i32.const 0) (i32.const 0x12345678)) (i32.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111112345678)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw.xchg" (i32.const 0) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0101010102020202)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw8.xchg_u" (i32.const 0) (i32.const 0xcdcdcdcd)) (i32.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111111111cd)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw16.xchg_u" (i32.const 0) (i32.const 0xcafecafe)) (i32.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111cafe)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw8.xchg_u" (i32.const 0) (i64.const 0x4242424242424242)) (i64.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111142)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw16.xchg_u" (i32.const 0) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111beef)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw32.xchg_u" (i32.const 0) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111cabba6e5)) + +;; *.atomic.rmw*.cmpxchg (compare false) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw.cmpxchg" (i32.const 0) (i32.const 0) (i32.const 0x12345678)) (i32.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111111)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw.cmpxchg" (i32.const 0) (i64.const 0) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111111)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw8.cmpxchg_u" (i32.const 0) (i32.const 0) (i32.const 0xcdcdcdcd)) (i32.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111111)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw16.cmpxchg_u" (i32.const 0) (i32.const 0) (i32.const 0xcafecafe)) (i32.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111111)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw8.cmpxchg_u" (i32.const 0) (i64.const 0) (i64.const 0x4242424242424242)) (i64.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111111)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw16.cmpxchg_u" (i32.const 0) (i64.const 0) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111111)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw32.cmpxchg_u" (i32.const 0) (i64.const 0) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111111)) + +;; *.atomic.rmw*.cmpxchg (compare true) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw.cmpxchg" (i32.const 0) (i32.const 0x11111111) (i32.const 0x12345678)) (i32.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111112345678)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw.cmpxchg" (i32.const 0) (i64.const 0x1111111111111111) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0101010102020202)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw8.cmpxchg_u" (i32.const 0) (i32.const 0x11) (i32.const 0xcdcdcdcd)) (i32.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111111111cd)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i32.atomic.rmw16.cmpxchg_u" (i32.const 0) (i32.const 0x1111) (i32.const 0xcafecafe)) (i32.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111cafe)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw8.cmpxchg_u" (i32.const 0) (i64.const 0x11) (i64.const 0x4242424242424242)) (i64.const 0x11)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111142)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw16.cmpxchg_u" (i32.const 0) (i64.const 0x1111) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111beef)) + +(invoke "init" (i64.const 0x1111111111111111)) +(assert_return (invoke "i64.atomic.rmw32.cmpxchg_u" (i32.const 0) (i64.const 0x11111111) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111)) +(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111cabba6e5)) + + +;; unaligned accesses + +(assert_trap (invoke "i32.atomic.load" (i32.const 1)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.load" (i32.const 1)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.load16_u" (i32.const 1)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.load16_u" (i32.const 1)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.load32_u" (i32.const 1)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.store" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.store" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.store16" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.store16" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.store32" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw.add" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw.add" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw16.add_u" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw16.add_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw32.add_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw.sub" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw.sub" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw16.sub_u" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw16.sub_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw32.sub_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw.and" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw.and" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw16.and_u" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw16.and_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw32.and_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw.or" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw.or" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw16.or_u" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw16.or_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw32.or_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw.xor" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw.xor" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw16.xor_u" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw16.xor_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw32.xor_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw.xchg" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw.xchg" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw16.xchg_u" (i32.const 1) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw16.xchg_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw32.xchg_u" (i32.const 1) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw.cmpxchg" (i32.const 1) (i32.const 0) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw.cmpxchg" (i32.const 1) (i64.const 0) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i32.atomic.rmw16.cmpxchg_u" (i32.const 1) (i32.const 0) (i32.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw16.cmpxchg_u" (i32.const 1) (i64.const 0) (i64.const 0)) "unaligned atomic") +(assert_trap (invoke "i64.atomic.rmw32.cmpxchg_u" (i32.const 1) (i64.const 0) (i64.const 0)) "unaligned atomic") + +;; unshared memory + +(assert_invalid (module (memory 1 1) (func (drop (i32.atomic.load (i32.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.load (i32.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i32.atomic.load16_u (i32.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.load16_u (i32.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.load32_u (i32.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (i32.atomic.store (i32.const 0) (i32.const 0)))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (i64.atomic.store (i32.const 0) (i64.const 0)))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (i32.atomic.store16 (i32.const 0) (i32.const 0)))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (i64.atomic.store16 (i32.const 0) (i64.const 0)))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (i64.atomic.store32 (i32.const 0) (i64.const 0)))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i32.atomic.rmw.add (i32.const 0) (i32.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.rmw.add (i32.const 0) (i64.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i32.atomic.rmw16.add_u (i32.const 0) (i32.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.rmw16.add_u (i32.const 0) (i64.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.rmw32.add_u (i32.const 0) (i64.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i32.atomic.rmw.sub (i32.const 0) (i32.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.rmw.sub (i32.const 0) (i64.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i32.atomic.rmw16.sub_u (i32.const 0) (i32.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.rmw16.sub_u (i32.const 0) (i64.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.rmw32.sub_u (i32.const 0) (i64.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i32.atomic.rmw.and (i32.const 0) (i32.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.rmw.and (i32.const 0) (i64.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i32.atomic.rmw16.and_u (i32.const 0) (i32.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.rmw16.and_u (i32.const 0) (i64.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.rmw32.and_u (i32.const 0) (i64.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i32.atomic.rmw.or (i32.const 0) (i32.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.rmw.or (i32.const 0) (i64.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i32.atomic.rmw16.or_u (i32.const 0) (i32.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.rmw16.or_u (i32.const 0) (i64.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.rmw32.or_u (i32.const 0) (i64.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i32.atomic.rmw.xor (i32.const 0) (i32.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.rmw.xor (i32.const 0) (i64.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i32.atomic.rmw16.xor_u (i32.const 0) (i32.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.rmw16.xor_u (i32.const 0) (i64.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.rmw32.xor_u (i32.const 0) (i64.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i32.atomic.rmw.xchg (i32.const 0) (i32.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.rmw.xchg (i32.const 0) (i64.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i32.atomic.rmw16.xchg_u (i32.const 0) (i32.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.rmw16.xchg_u (i32.const 0) (i64.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.rmw32.xchg_u (i32.const 0) (i64.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i32.atomic.rmw.cmpxchg (i32.const 0) (i32.const 0) (i32.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.rmw.cmpxchg (i32.const 0) (i64.const 0) (i64.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i32.atomic.rmw16.cmpxchg_u (i32.const 0) (i32.const 0) (i32.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.rmw16.cmpxchg_u (i32.const 0) (i64.const 0) (i64.const 0))))) "atomic accesses require shared memory") +(assert_invalid (module (memory 1 1) (func (drop (i64.atomic.rmw32.cmpxchg_u (i32.const 0) (i64.const 0) (i64.const 0))))) "atomic accesses require shared memory") diff --git a/lib/spectests/spectests/simd.wast b/lib/spectests/spectests/simd.wast index 1041004f40d..c59e087c09b 100644 --- a/lib/spectests/spectests/simd.wast +++ b/lib/spectests/spectests/simd.wast @@ -589,9 +589,7 @@ ;; Test that LLVM undef isn't introduced by SIMD shifts greater than the scalar width. (module -;; wabt says "memories may not be shared" -;; (memory 1 1 shared) - (memory 1 1) + (memory 1 1 shared) (func (export "test-simd-shift-mask") (param $v v128) (result i32) (block $0 (block $1 diff --git a/lib/spectests/tests/excludes.txt b/lib/spectests/tests/excludes.txt index a2e6752c5d8..5402157ede3 100644 --- a/lib/spectests/tests/excludes.txt +++ b/lib/spectests/tests/excludes.txt @@ -17,6 +17,7 @@ # # Cranelift +clif:skip:atomic.wast:* # Threads not implemented clif:skip:simd.wast:* # SIMD not implemented clif:skip:simd_binaryen.wast:* # SIMD not implemented @@ -860,6 +861,7 @@ llvm:skip:unreachable.wast:*:windows llvm:skip:unwind.wast:*:windows # Singlepass +singlepass:skip:atomic.wast:* # Threads not implemented singlepass:skip:simd.wast:* # SIMD not implemented singlepass:skip:simd_binaryen.wast:* # SIMD not implemented @@ -1767,4 +1769,4 @@ singlepass:fail:unwind.wast:239 # AssertTrap - expected trap, got Runtime:Error singlepass:fail:unwind.wast:245 # AssertTrap - expected trap, got Runtime:Error unknown error singlepass:fail:unwind.wast:251 # AssertTrap - expected trap, got Runtime:Error unknown error singlepass:fail:unwind.wast:257 # AssertTrap - expected trap, got Runtime:Error unknown error -singlepass:fail:unwind.wast:263 # AssertTrap - expected trap, got Runtime:Error unknown error \ No newline at end of file +singlepass:fail:unwind.wast:263 # AssertTrap - expected trap, got Runtime:Error unknown error From 70d561a1ddf0fcc21490a439b61f976a86af9a6a Mon Sep 17 00:00:00 2001 From: Nick Lewycky Date: Tue, 20 Aug 2019 11:27:43 -0700 Subject: [PATCH 13/16] Remove SharedStaticMemory and simplify surrounding code. --- .../{static_/unshared.rs => static_.rs} | 14 +-- lib/runtime-core/src/memory/static_/mod.rs | 8 -- lib/runtime-core/src/memory/static_/shared.rs | 110 ------------------ 3 files changed, 6 insertions(+), 126 deletions(-) rename lib/runtime-core/src/memory/{static_/unshared.rs => static_.rs} (92%) delete mode 100644 lib/runtime-core/src/memory/static_/mod.rs delete mode 100644 lib/runtime-core/src/memory/static_/shared.rs diff --git a/lib/runtime-core/src/memory/static_/unshared.rs b/lib/runtime-core/src/memory/static_.rs similarity index 92% rename from lib/runtime-core/src/memory/static_/unshared.rs rename to lib/runtime-core/src/memory/static_.rs index 602a02bace9..957e53eafd7 100644 --- a/lib/runtime-core/src/memory/static_/unshared.rs +++ b/lib/runtime-core/src/memory/static_.rs @@ -1,12 +1,10 @@ use crate::error::GrowError; -use crate::{ - error::CreationError, - memory::static_::{SAFE_STATIC_GUARD_SIZE, SAFE_STATIC_HEAP_SIZE}, - sys, - types::MemoryDescriptor, - units::Pages, - vm, -}; +use crate::{error::CreationError, sys, types::MemoryDescriptor, units::Pages, vm}; + +#[doc(hidden)] +pub const SAFE_STATIC_HEAP_SIZE: usize = 1 << 32; // 4 GiB +#[doc(hidden)] +pub const SAFE_STATIC_GUARD_SIZE: usize = 1 << 31; // 2 GiB /// This is an internal-only api. /// diff --git a/lib/runtime-core/src/memory/static_/mod.rs b/lib/runtime-core/src/memory/static_/mod.rs deleted file mode 100644 index 5e5b0a3a0d3..00000000000 --- a/lib/runtime-core/src/memory/static_/mod.rs +++ /dev/null @@ -1,8 +0,0 @@ -#[doc(hidden)] -pub const SAFE_STATIC_HEAP_SIZE: usize = 1 << 32; // 4 GiB -#[doc(hidden)] -pub const SAFE_STATIC_GUARD_SIZE: usize = 1 << 31; // 2 GiB - -mod unshared; - -pub use self::unshared::StaticMemory; diff --git a/lib/runtime-core/src/memory/static_/shared.rs b/lib/runtime-core/src/memory/static_/shared.rs deleted file mode 100644 index f996334e78a..00000000000 --- a/lib/runtime-core/src/memory/static_/shared.rs +++ /dev/null @@ -1,110 +0,0 @@ -/*use crate::error::GrowError; -use crate::{ - error::CreationError, - memory::static_::{SAFE_STATIC_GUARD_SIZE, SAFE_STATIC_HEAP_SIZE}, - sys, - types::MemoryDescriptor, - units::Pages, - vm, -}; - -use parking_lot::{Mutex, MutexGuard}; - -/// This is an internal-only api. -/// -/// A static memory allocates 6GB of *virtual* memory when created -/// in order to allow the WebAssembly module to contain no bounds-checks. -/// -/// Additionally, static memories stay at a single virtual address, so there is no need -/// to reload its address on each use. -/// -/// Static memories take a relatively long time to create, so if memories are short-lived, -/// it's recommended that a dynamic memory is used. There is currently no user-facing api that -/// allows them to select the type of memory used however. -pub struct SharedStaticMemory { - memory: sys::Memory, - current: Pages, - max: Option, -} - -impl SharedStaticMemory { - pub(in crate::memory) fn new( - desc: MemoryDescriptor, - local: &mut vm::LocalMemory, - ) -> Result, CreationError> { - let memory = { - let mut memory = sys::Memory::with_size(SAFE_STATIC_HEAP_SIZE + SAFE_STATIC_GUARD_SIZE) - .map_err(|_| CreationError::UnableToCreateMemory)?; - if desc.minimum != Pages(0) { - unsafe { - memory - .protect(0..desc.minimum.bytes().0, sys::Protect::ReadWrite) - .map_err(|_| CreationError::UnableToCreateMemory)?; - } - } - - memory - }; - - let mut storage = Box::new(SharedStaticMemory { - memory, - current: desc.minimum, - max: desc.maximum, - lock: Mutex::new(()), - }); - let storage_ptr: *mut SharedStaticMemory = &mut *storage; - - local.base = storage.memory.as_ptr(); - local.bound = desc.minimum.bytes().0; - local.memory = storage_ptr as *mut (); - - Ok(storage) - } - - pub fn lock(&mut self) -> MutexGuard<()> { - self.lock.lock() - } - - pub fn size(&self, _: &MutexGuard<()>) -> Pages { - self.current - } - - pub fn grow(&mut self, delta: Pages, local: &mut vm::LocalMemory, _: &MutexGuard<()>) -> Result { - let new_pages = self.current.checked_add(delta).map_err(|e| e.into())?; - - if let Some(max) = self.max { - if new_pages > max { - return Err(GrowError::ExceededMaxPagesForMemory( - new_pages.0 as usize, - max.0 as usize, - )); - } - } - - let _ = unsafe { - self.memory - .protect( - self.current.bytes().0..new_pages.bytes().0, - sys::Protect::ReadWrite, - ) - .map_err(|e| e.into()) - }?; - - local.bound = new_pages.bytes().0; - - let old_pages = self.current; - - self.current = new_pages; - - Ok(old_pages) - } - - pub fn as_slice(&self) -> &[u8] { - unsafe { &self.memory.as_slice()[0..self.current.bytes().0] } - } - - pub fn as_slice_mut(&mut self) -> &mut [u8] { - unsafe { &mut self.memory.as_slice_mut()[0..self.current.bytes().0] } - } -} -*/ From 2882c759579010fc9f3d46d617c1106b4f0cf912 Mon Sep 17 00:00:00 2001 From: Nick Lewycky Date: Tue, 20 Aug 2019 11:30:30 -0700 Subject: [PATCH 14/16] No need to emit any alignment check for byte-aligned accesses. --- lib/llvm-backend/src/code.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/lib/llvm-backend/src/code.rs b/lib/llvm-backend/src/code.rs index a9ae4e55c24..224b4a8c192 100644 --- a/lib/llvm-backend/src/code.rs +++ b/lib/llvm-backend/src/code.rs @@ -500,7 +500,9 @@ fn trap_if_misaligned( ptr: PointerValue, ) { let align = match memarg.flags & 3 { - 0 => 1, + 0 => { + return; /* No alignment to check. */ + } 1 => 2, 2 => 4, 3 => 8, From 08ee2c02979b95f1421e041195bc6345952badb5 Mon Sep 17 00:00:00 2001 From: Nick Lewycky Date: Tue, 20 Aug 2019 12:59:35 -0700 Subject: [PATCH 15/16] Run `cargo update`. --- Cargo.lock | 500 ++++++++++++++++++++++++++++------------------------- 1 file changed, 268 insertions(+), 232 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 086fe7c18e9..76844c0d328 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -28,7 +28,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "arrayvec" -version = "0.4.10" +version = "0.4.11" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)", @@ -36,38 +36,36 @@ dependencies = [ [[package]] name = "atty" -version = "0.2.11" +version = "0.2.13" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", - "termion 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "autocfg" -version = "0.1.4" +version = "0.1.6" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "backtrace" -version = "0.3.26" +version = "0.3.35" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)", - "backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)", + "backtrace-sys 0.1.31 (registry+https://github.com/rust-lang/crates.io-index)", "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", - "rustc-demangle 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", + "rustc-demangle 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "backtrace-sys" -version = "0.1.28" +version = "0.1.31" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "cc 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -75,9 +73,9 @@ name = "bincode" version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)", + "autocfg 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)", "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)", - "serde 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)", + "serde 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -85,18 +83,18 @@ name = "bindgen" version = "0.51.0" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)", + "bitflags 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)", "cexpr 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)", "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)", "clang-sys 0.28.1 (registry+https://github.com/rust-lang/crates.io-index)", "clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)", - "env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)", + "env_logger 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)", "fxhash 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)", "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)", "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)", "peeking_take_while 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)", - "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)", + "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)", "regex 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)", "shlex 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)", "which 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)", @@ -104,19 +102,30 @@ dependencies = [ [[package]] name = "bitflags" -version = "1.0.4" +version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "blake2b_simd" -version = "0.5.6" +version = "0.5.7" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)", - "arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)", + "arrayvec 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)", "constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)", ] +[[package]] +name = "bstr" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)", + "memchr 2.2.1 (registry+https://github.com/rust-lang/crates.io-index)", + "regex-automata 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)", + "serde 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", +] + [[package]] name = "byteorder" version = "1.3.2" @@ -152,8 +161,8 @@ name = "cargo_toml" version = "0.6.4" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "serde 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)", - "serde_derive 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)", + "serde 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", + "serde_derive 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", "toml 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -170,12 +179,12 @@ dependencies = [ "clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)", "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)", "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)", - "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)", - "serde 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)", - "serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)", - "syn 0.15.34 (registry+https://github.com/rust-lang/crates.io-index)", + "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)", + "serde 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", + "serde_json 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)", + "syn 0.15.44 (registry+https://github.com/rust-lang/crates.io-index)", "tempfile 3.1.0 (registry+https://github.com/rust-lang/crates.io-index)", - "toml 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)", + "toml 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -212,8 +221,8 @@ version = "0.28.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "glob 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", - "libloading 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", + "libloading 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -222,11 +231,11 @@ version = "2.33.0" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)", - "atty 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)", - "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)", + "atty 0.2.13 (registry+https://github.com/rust-lang/crates.io-index)", + "bitflags 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)", "strsim 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)", "textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)", - "unicode-width 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", + "unicode-width 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)", "vec_map 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -235,12 +244,12 @@ name = "cloudabi" version = "0.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)", + "bitflags 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "cmake" -version = "0.1.40" +version = "0.1.41" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "cc 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)", @@ -310,25 +319,25 @@ name = "criterion" version = "0.2.11" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "atty 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)", + "atty 0.2.13 (registry+https://github.com/rust-lang/crates.io-index)", "cast 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)", "clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)", "criterion-plot 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)", - "csv 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)", + "csv 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)", "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)", "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "num-traits 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)", "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)", "rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)", "rand_xoshiro 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", "rayon 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)", "rayon-core 1.5.0 (registry+https://github.com/rust-lang/crates.io-index)", - "serde 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)", - "serde_derive 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)", - "serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)", + "serde 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", + "serde_derive 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", + "serde_json 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)", "tinytemplate 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)", - "walkdir 2.2.7 (registry+https://github.com/rust-lang/crates.io-index)", + "walkdir 2.2.9 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -355,7 +364,7 @@ name = "crossbeam-epoch" version = "0.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)", + "arrayvec 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)", "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)", "crossbeam-utils 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)", "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)", @@ -382,18 +391,19 @@ dependencies = [ [[package]] name = "csv" -version = "1.0.7" +version = "1.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "csv-core 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", + "bstr 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)", + "csv-core 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)", "itoa 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)", - "ryu 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)", - "serde 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)", + "ryu 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)", + "serde 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "csv-core" -version = "0.1.5" +version = "0.1.6" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "memchr 2.2.1 (registry+https://github.com/rust-lang/crates.io-index)", @@ -404,7 +414,7 @@ name = "digest" version = "0.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)", + "generic-array 0.12.3 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -412,13 +422,13 @@ name = "dynasm" version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)", + "bitflags 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)", "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)", "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)", "owning_ref 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)", "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)", - "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)", - "syn 0.15.34 (registry+https://github.com/rust-lang/crates.io-index)", + "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)", + "syn 0.15.44 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -447,14 +457,14 @@ dependencies = [ [[package]] name = "env_logger" -version = "0.6.1" +version = "0.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "atty 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)", + "atty 0.2.13 (registry+https://github.com/rust-lang/crates.io-index)", "humantime 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)", "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)", "regex 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)", - "termcolor 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)", + "termcolor 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -463,7 +473,7 @@ version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "errno-dragonfly 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -473,7 +483,7 @@ version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "gcc 0.3.55 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -481,7 +491,7 @@ name = "failure" version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "backtrace 0.3.26 (registry+https://github.com/rust-lang/crates.io-index)", + "backtrace 0.3.35 (registry+https://github.com/rust-lang/crates.io-index)", "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -491,8 +501,8 @@ version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)", - "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)", - "syn 0.15.34 (registry+https://github.com/rust-lang/crates.io-index)", + "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)", + "syn 0.15.44 (registry+https://github.com/rust-lang/crates.io-index)", "synstructure 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -529,7 +539,7 @@ dependencies = [ [[package]] name = "generic-array" -version = "0.12.0" +version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "typenum 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)", @@ -537,11 +547,12 @@ dependencies = [ [[package]] name = "getrandom" -version = "0.1.7" +version = "0.1.10" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", + "wasi 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -587,21 +598,22 @@ dependencies = [ [[package]] name = "indexmap" -version = "1.0.2" +version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "serde 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)", + "serde 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "inkwell" version = "0.1.0" -source = "git+https://github.com/wasmerio/inkwell?branch=llvm8-0#4c5359e507b8a3439c9e2c7fff5c336224069638" +source = "git+https://github.com/wasmerio/inkwell?branch=llvm8-0#8c386c8eeccaea68681710e3822c40153a8030a3" dependencies = [ "either 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)", "enum-methods 0.0.8 (registry+https://github.com/rust-lang/crates.io-index)", "inkwell_internal_macros 0.1.0 (git+https://github.com/wasmerio/inkwell?branch=llvm8-0)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "llvm-sys 80.1.1 (registry+https://github.com/rust-lang/crates.io-index)", "regex 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -609,12 +621,12 @@ dependencies = [ [[package]] name = "inkwell_internal_macros" version = "0.1.0" -source = "git+https://github.com/wasmerio/inkwell?branch=llvm8-0#4c5359e507b8a3439c9e2c7fff5c336224069638" +source = "git+https://github.com/wasmerio/inkwell?branch=llvm8-0#8c386c8eeccaea68681710e3822c40153a8030a3" dependencies = [ "cargo_toml 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)", "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)", - "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)", - "syn 0.15.34 (registry+https://github.com/rust-lang/crates.io-index)", + "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)", + "syn 0.15.44 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -650,12 +662,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "libc" -version = "0.2.60" +version = "0.2.62" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "libloading" -version = "0.5.1" +version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "cc 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)", @@ -669,7 +681,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "cc 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)", "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "regex 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)", "semver 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -695,7 +707,7 @@ name = "memchr" version = "2.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -703,7 +715,7 @@ name = "memmap" version = "0.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -712,7 +724,7 @@ name = "memmap" version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -729,10 +741,10 @@ name = "nix" version = "0.14.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)", + "bitflags 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)", "cc 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)", "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -763,22 +775,17 @@ name = "num-traits" version = "0.2.8" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)", + "autocfg 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "num_cpus" -version = "1.10.0" +version = "1.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", ] -[[package]] -name = "numtoa" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" - [[package]] name = "owning_ref" version = "0.3.3" @@ -793,7 +800,7 @@ version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -814,8 +821,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)", "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", - "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", + "redox_syscall 0.1.56 (registry+https://github.com/rust-lang/crates.io-index)", "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)", "smallvec 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", @@ -848,6 +855,14 @@ dependencies = [ "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", ] +[[package]] +name = "proc-macro2" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "unicode-xid 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)", +] + [[package]] name = "quick-error" version = "1.2.2" @@ -860,19 +875,27 @@ source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "quote" -version = "0.6.12" +version = "0.6.13" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)", ] +[[package]] +name = "quote" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "proc-macro2 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)", +] + [[package]] name = "rand" version = "0.4.6" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)", "rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", @@ -883,8 +906,8 @@ name = "rand" version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "getrandom 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "getrandom 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "rand_chacha 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)", "rand_core 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)", "rand_hc 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)", @@ -904,12 +927,12 @@ name = "rand_core" version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)", + "rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "rand_core" -version = "0.4.0" +version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] @@ -917,7 +940,7 @@ name = "rand_core" version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "getrandom 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)", + "getrandom 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -935,8 +958,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)", "fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", - "rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", + "rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)", "rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -955,7 +978,7 @@ name = "raw-cpuid" version = "6.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)", + "bitflags 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)", "cc 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)", "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -979,7 +1002,7 @@ dependencies = [ "crossbeam-queue 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", "crossbeam-utils 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)", "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)", - "num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)", + "num_cpus 1.10.1 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -992,16 +1015,8 @@ dependencies = [ [[package]] name = "redox_syscall" -version = "0.1.54" -source = "registry+https://github.com/rust-lang/crates.io-index" - -[[package]] -name = "redox_termios" -version = "0.1.1" +version = "0.1.56" source = "registry+https://github.com/rust-lang/crates.io-index" -dependencies = [ - "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)", -] [[package]] name = "regex" @@ -1014,6 +1029,14 @@ dependencies = [ "thread_local 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)", ] +[[package]] +name = "regex-automata" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)", +] + [[package]] name = "regex-syntax" version = "0.6.11" @@ -1021,7 +1044,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "remove_dir_all" -version = "0.5.1" +version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1029,12 +1052,12 @@ dependencies = [ [[package]] name = "rgb" -version = "0.8.13" +version = "0.8.14" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "rustc-demangle" -version = "0.1.15" +version = "0.1.16" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] @@ -1047,12 +1070,12 @@ dependencies = [ [[package]] name = "ryu" -version = "0.2.8" +version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "same-file" -version = "1.0.4" +version = "1.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "winapi-util 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1078,8 +1101,8 @@ version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)", - "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)", - "syn 0.15.34 (registry+https://github.com/rust-lang/crates.io-index)", + "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)", + "syn 0.15.44 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -1097,10 +1120,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "serde" -version = "1.0.98" +version = "1.0.99" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "serde_derive 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)", + "serde_derive 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -1109,35 +1132,35 @@ version = "0.0.7" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)", - "serde 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)", + "serde 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "serde_bytes" -version = "0.11.1" +version = "0.11.2" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "serde 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)", + "serde 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "serde_derive" -version = "1.0.98" +version = "1.0.99" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)", - "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)", - "syn 0.15.34 (registry+https://github.com/rust-lang/crates.io-index)", + "proc-macro2 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)", + "quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)", + "syn 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "serde_json" -version = "1.0.39" +version = "1.0.40" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "itoa 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)", - "ryu 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)", - "serde 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)", + "ryu 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)", + "serde 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -1176,8 +1199,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "heck 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)", "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)", - "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)", - "syn 0.15.34 (registry+https://github.com/rust-lang/crates.io-index)", + "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)", + "syn 0.15.44 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -1192,14 +1215,24 @@ dependencies = [ [[package]] name = "syn" -version = "0.15.34" +version = "0.15.44" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)", - "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)", + "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)", "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", ] +[[package]] +name = "syn" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "proc-macro2 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)", + "quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)", + "unicode-xid 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)", +] + [[package]] name = "synom" version = "0.11.3" @@ -1214,8 +1247,8 @@ version = "0.10.2" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)", - "quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)", - "syn 0.15.34 (registry+https://github.com/rust-lang/crates.io-index)", + "quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)", + "syn 0.15.44 (registry+https://github.com/rust-lang/crates.io-index)", "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -1231,7 +1264,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", - "serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)", + "serde_json 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -1240,30 +1273,19 @@ version = "3.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "cfg-if 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "rand 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)", - "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)", - "remove_dir_all 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)", + "redox_syscall 0.1.56 (registry+https://github.com/rust-lang/crates.io-index)", + "remove_dir_all 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "termcolor" -version = "1.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -dependencies = [ - "wincolor 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)", -] - -[[package]] -name = "termion" -version = "1.5.2" +version = "1.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", - "numtoa 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", - "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)", - "redox_termios 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)", + "wincolor 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -1271,7 +1293,7 @@ name = "textwrap" version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "unicode-width 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", + "unicode-width 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -1287,8 +1309,8 @@ name = "time" version = "0.1.42" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", - "redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", + "redox_syscall 0.1.56 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -1297,8 +1319,8 @@ name = "tinytemplate" version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "serde 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)", - "serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)", + "serde 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", + "serde_json 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -1306,15 +1328,15 @@ name = "toml" version = "0.4.10" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "serde 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)", + "serde 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "toml" -version = "0.5.1" +version = "0.5.3" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "serde 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)", + "serde 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -1329,7 +1351,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "unicode-width" -version = "0.1.5" +version = "0.1.6" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] @@ -1342,6 +1364,11 @@ name = "unicode-xid" version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" +[[package]] +name = "unicode-xid" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" + [[package]] name = "vec_map" version = "0.8.1" @@ -1362,9 +1389,9 @@ name = "wabt" version = "0.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "serde 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)", - "serde_derive 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)", - "serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)", + "serde 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", + "serde_derive 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", + "serde_json 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)", "wabt-sys 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -1374,20 +1401,25 @@ version = "0.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "cc 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)", - "cmake 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)", + "cmake 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)", "glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "walkdir" -version = "2.2.7" +version = "2.2.9" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "same-file 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)", + "same-file 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", "winapi-util 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", ] +[[package]] +name = "wasi" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" + [[package]] name = "wasmer" version = "0.6.0" @@ -1420,19 +1452,19 @@ dependencies = [ "cranelift-codegen 0.31.0 (registry+https://github.com/rust-lang/crates.io-index)", "cranelift-entity 0.31.0 (registry+https://github.com/rust-lang/crates.io-index)", "cranelift-native 0.31.0 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "nix 0.14.1 (registry+https://github.com/rust-lang/crates.io-index)", "rayon 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)", - "serde 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)", + "serde 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", "serde-bench 0.0.7 (registry+https://github.com/rust-lang/crates.io-index)", - "serde_bytes 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)", - "serde_derive 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)", + "serde_bytes 0.11.2 (registry+https://github.com/rust-lang/crates.io-index)", + "serde_derive 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", "target-lexicon 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)", "wasmer-clif-fork-frontend 0.33.0 (registry+https://github.com/rust-lang/crates.io-index)", "wasmer-clif-fork-wasm 0.33.0 (registry+https://github.com/rust-lang/crates.io-index)", "wasmer-runtime-core 0.6.0", "wasmer-win-exception-handler 0.6.0", - "wasmparser 0.35.1 (registry+https://github.com/rust-lang/crates.io-index)", + "wasmparser 0.35.3 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -1457,14 +1489,14 @@ dependencies = [ "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)", "wasmer-clif-fork-frontend 0.33.0 (registry+https://github.com/rust-lang/crates.io-index)", - "wasmparser 0.35.1 (registry+https://github.com/rust-lang/crates.io-index)", + "wasmparser 0.35.3 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "wasmer-dev-utils" version = "0.6.0" dependencies = [ - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -1473,7 +1505,7 @@ version = "0.6.0" dependencies = [ "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)", "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "rand 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)", "time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)", "wasmer-runtime-core 0.6.0", @@ -1497,7 +1529,7 @@ dependencies = [ name = "wasmer-kernel-loader" version = "0.1.0" dependencies = [ - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "wasmer-runtime-core 0.6.0", ] @@ -1510,7 +1542,7 @@ dependencies = [ "goblin 0.0.24 (registry+https://github.com/rust-lang/crates.io-index)", "inkwell 0.1.0 (git+https://github.com/wasmerio/inkwell?branch=llvm8-0)", "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "nix 0.14.1 (registry+https://github.com/rust-lang/crates.io-index)", "regex 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)", "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1518,7 +1550,7 @@ dependencies = [ "smallvec 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)", "wabt 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)", "wasmer-runtime-core 0.6.0", - "wasmparser 0.35.1 (registry+https://github.com/rust-lang/crates.io-index)", + "wasmparser 0.35.3 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -1554,7 +1586,7 @@ name = "wasmer-runtime-c-api" version = "0.6.0" dependencies = [ "cbindgen 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "wasmer-runtime 0.6.0", "wasmer-runtime-core 0.6.0", ] @@ -1564,26 +1596,26 @@ name = "wasmer-runtime-core" version = "0.6.0" dependencies = [ "bincode 1.1.4 (registry+https://github.com/rust-lang/crates.io-index)", - "blake2b_simd 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)", + "blake2b_simd 0.5.7 (registry+https://github.com/rust-lang/crates.io-index)", "cc 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)", "colored 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)", "digest 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)", "errno 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)", "field-offset 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)", "hex 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)", - "indexmap 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)", + "indexmap 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)", "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "nix 0.14.1 (registry+https://github.com/rust-lang/crates.io-index)", "page_size 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)", "parking_lot 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)", "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)", - "serde 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)", + "serde 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", "serde-bench 0.0.7 (registry+https://github.com/rust-lang/crates.io-index)", - "serde_bytes 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)", - "serde_derive 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)", + "serde_bytes 0.11.2 (registry+https://github.com/rust-lang/crates.io-index)", + "serde_derive 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)", "smallvec 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)", - "wasmparser 0.35.1 (registry+https://github.com/rust-lang/crates.io-index)", + "wasmparser 0.35.3 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -1596,11 +1628,11 @@ dependencies = [ "dynasm 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)", "dynasmrt 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)", "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "nix 0.14.1 (registry+https://github.com/rust-lang/crates.io-index)", "smallvec 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)", "wasmer-runtime-core 0.6.0", - "wasmparser 0.35.1 (registry+https://github.com/rust-lang/crates.io-index)", + "wasmparser 0.35.3 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -1621,7 +1653,7 @@ version = "0.6.0" dependencies = [ "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)", "generational-arena 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)", "rand 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)", "time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1647,8 +1679,8 @@ name = "wasmer-win-exception-handler" version = "0.6.0" dependencies = [ "bindgen 0.51.0 (registry+https://github.com/rust-lang/crates.io-index)", - "cmake 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "cmake 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", "regex 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)", "wasmer-runtime-core 0.6.0", "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1656,7 +1688,7 @@ dependencies = [ [[package]] name = "wasmparser" -version = "0.35.1" +version = "0.35.3" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] @@ -1665,7 +1697,7 @@ version = "2.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", - "libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -1707,7 +1739,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "wincolor" -version = "1.0.1" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1721,7 +1753,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "cgmath 0.16.1 (registry+https://github.com/rust-lang/crates.io-index)", "lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)", - "rgb 0.8.13 (registry+https://github.com/rust-lang/crates.io-index)", + "rgb 0.8.14 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -1730,15 +1762,16 @@ dependencies = [ "checksum ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b" "checksum approx 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "08abcc3b4e9339e33a3d0a5ed15d84a687350c05689d825e0f6655eef9e76a94" "checksum arrayref 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "0d382e583f07208808f6b1249e60848879ba3543f57c32277bf52d69c2f0f0ee" -"checksum arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "92c7fb76bc8826a8b33b4ee5bb07a247a81e76764ab4d55e8f73e3a4d8808c71" -"checksum atty 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "9a7d5b8723950951411ee34d271d99dddcc2035a16ab25310ea2c8cfd4369652" -"checksum autocfg 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "0e49efa51329a5fd37e7c79db4621af617cd4e3e5bc224939808d076077077bf" -"checksum backtrace 0.3.26 (registry+https://github.com/rust-lang/crates.io-index)" = "1a13fc43f04daf08ab4f71e3d27e1fc27fc437d3e95ac0063a796d92fb40f39b" -"checksum backtrace-sys 0.1.28 (registry+https://github.com/rust-lang/crates.io-index)" = "797c830ac25ccc92a7f8a7b9862bde440715531514594a6154e3d4a54dd769b6" +"checksum arrayvec 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)" = "b8d73f9beda665eaa98ab9e4f7442bd4e7de6652587de55b2525e52e29c1b0ba" +"checksum atty 0.2.13 (registry+https://github.com/rust-lang/crates.io-index)" = "1803c647a3ec87095e7ae7acfca019e98de5ec9a7d01343f611cf3152ed71a90" +"checksum autocfg 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "b671c8fb71b457dd4ae18c4ba1e59aa81793daacc361d82fcd410cef0d491875" +"checksum backtrace 0.3.35 (registry+https://github.com/rust-lang/crates.io-index)" = "1371048253fa3bac6704bfd6bbfc922ee9bdcee8881330d40f308b81cc5adc55" +"checksum backtrace-sys 0.1.31 (registry+https://github.com/rust-lang/crates.io-index)" = "82a830b4ef2d1124a711c71d263c5abdc710ef8e907bd508c88be475cebc422b" "checksum bincode 1.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "9f04a5e50dc80b3d5d35320889053637d15011aed5e66b66b37ae798c65da6f7" "checksum bindgen 0.51.0 (registry+https://github.com/rust-lang/crates.io-index)" = "18270cdd7065ec045a6bb4bdcd5144d14a78b3aedb3bc5111e688773ac8b9ad0" -"checksum bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "228047a76f468627ca71776ecdebd732a3423081fcf5125585bcd7c49886ce12" -"checksum blake2b_simd 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)" = "461f4b879a8eb70c1debf7d0788a9a5ff15f1ea9d25925fea264ef4258bed6b2" +"checksum bitflags 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3d155346769a6855b86399e9bc3814ab343cd3d62c7e985113d46a0ec3c281fd" +"checksum blake2b_simd 0.5.7 (registry+https://github.com/rust-lang/crates.io-index)" = "bf775a81bb2d464e20ff170ac20316c7b08a43d11dbc72f0f82e8e8d3d6d0499" +"checksum bstr 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "94cdf78eb7e94c566c1f5dbe2abf8fc70a548fc902942a48c4b3a98b48ca9ade" "checksum byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "a7c3dd8985a7111efc5c80b44e23ecdd8c007de8ade3b96595387e812b957cf5" "checksum c2-chacha 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7d64d04786e0f528460fc884753cf8dddcc466be308f6026f8e355c41a0e4101" "checksum capstone 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "031ba51c39151a1d6336ec859646153187204b0147c7b3f6fe2de636f1b8dbb3" @@ -1753,7 +1786,7 @@ dependencies = [ "checksum clang-sys 0.28.1 (registry+https://github.com/rust-lang/crates.io-index)" = "81de550971c976f176130da4b2978d3b524eaa0fd9ac31f3ceb5ae1231fb4853" "checksum clap 2.33.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5067f5bb2d80ef5d68b4c87db81601f0b75bca627bc2ef76b141d7b846a3c6d9" "checksum cloudabi 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f" -"checksum cmake 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "2ca4386c8954b76a8415b63959337d940d724b336cabd3afe189c2b51a7e1ff0" +"checksum cmake 0.1.41 (registry+https://github.com/rust-lang/crates.io-index)" = "3c84c596dcf125d6781f58e3f4254677ec2a6d8aa56e8501ac277100990b3229" "checksum colored 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "6cdb90b60f2927f8d76139c72dbde7e10c3a2bc47c8594c9c7a66529f2687c03" "checksum constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8ff012e225ce166d4422e0e78419d901719760f62ae2b7969ca6b564d1b54a9e" "checksum cranelift-bforest 0.31.0 (registry+https://github.com/rust-lang/crates.io-index)" = "409f92af3dd276e112b72873a3ef02613e3c5f55b81d5d5d04f3157d4f8b8c54" @@ -1767,14 +1800,14 @@ dependencies = [ "checksum crossbeam-epoch 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "fedcd6772e37f3da2a9af9bf12ebe046c0dfe657992377b4df982a2b54cd37a9" "checksum crossbeam-queue 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7c979cd6cfe72335896575c6b5688da489e420d36a27a0b9eb0c73db574b4a4b" "checksum crossbeam-utils 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "04973fa96e96579258a5091af6003abde64af786b860f18622b82e026cca60e6" -"checksum csv 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)" = "9044e25afb0924b5a5fc5511689b0918629e85d68ea591e5e87fbf1e85ea1b3b" -"checksum csv-core 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "fa5cdef62f37e6ffe7d1f07a381bc0db32b7a3ff1cac0de56cb0d81e71f53d65" +"checksum csv 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "37519ccdfd73a75821cac9319d4fce15a81b9fcf75f951df5b9988aa3a0af87d" +"checksum csv-core 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "9b5cadb6b25c77aeff80ba701712494213f4a8418fcda2ee11b6560c3ad0bf4c" "checksum digest 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5" "checksum dynasm 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f36d49ab6f8ecc642d2c6ee10fda04ba68003ef0277300866745cdde160e6b40" "checksum dynasmrt 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a4c408a211e7f5762829f5e46bdff0c14bc3b1517a21a4bb781c716bf88b0c68" "checksum either 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "5527cfe0d098f36e3f8839852688e63c8fff1c90b2b405aef730615f9a7bcf7b" "checksum enum-methods 0.0.8 (registry+https://github.com/rust-lang/crates.io-index)" = "7798e7da2d4cb0d6d6fc467e8d6b5bf247e9e989f786dde1732d79899c32bb10" -"checksum env_logger 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b61fa891024a945da30a9581546e8cfaf5602c7b3f4c137a2805cf388f92075a" +"checksum env_logger 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "aafcde04e90a5226a6443b7aabdb016ba2f8307c847d524724bd9b346dd1a2d3" "checksum errno 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "c2a071601ed01b988f896ab14b95e67335d1eeb50190932a1320f7fe3cadc84e" "checksum errno-dragonfly 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "14ca354e36190500e1e1fb267c647932382b54053c50b14970856c0b00a35067" "checksum failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "795bd83d3abeb9220f257e597aa0080a508b27533824adf336529648f6abf7e2" @@ -1784,23 +1817,23 @@ dependencies = [ "checksum fxhash 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c" "checksum gcc 0.3.55 (registry+https://github.com/rust-lang/crates.io-index)" = "8f5f3913fa0bfe7ee1fd8248b6b9f42a5af4b9d65ec2dd2c3c26132b950ecfc2" "checksum generational-arena 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4024f96ffa0ebaaf36aa589cd41f2fd69f3a5e6fd02c86e11e12cdf41d5b46a3" -"checksum generic-array 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3c0f28c2f5bfb5960175af447a2da7c18900693738343dc896ffbcabd9839592" -"checksum getrandom 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "cd8e190892c840661957ba9f32dacfb3eb405e657f9f9f60485605f0bb37d6f8" +"checksum generic-array 0.12.3 (registry+https://github.com/rust-lang/crates.io-index)" = "c68f0274ae0e023facc3c97b2e00f076be70e254bc851d972503b328db79b2ec" +"checksum getrandom 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "6171a6cc63fbabbe27c2b5ee268e8b7fe5dc1eb0dd2dfad537c1dfed6f69117e" "checksum glob 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "8be18de09a56b60ed0edf84bc9df007e30040691af7acd1c41874faac5895bfb" "checksum glob 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574" "checksum goblin 0.0.24 (registry+https://github.com/rust-lang/crates.io-index)" = "e3fa261d919c1ae9d1e4533c4a2f99e10938603c4208d56c05bec7a872b661b0" "checksum heck 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "20564e78d53d2bb135c343b3f47714a56af2061f1c928fdb541dc7b9fdd94205" "checksum hex 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "805026a5d0141ffc30abb3be3173848ad46a1b1664fe632428479619a3644d77" "checksum humantime 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3ca7e5f2e110db35f93b837c81797f3714500b81d517bf20c431b16d3ca4f114" -"checksum indexmap 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7e81a7c05f79578dbc15793d8b619db9ba32b4577003ef3af1a91c416798c58d" +"checksum indexmap 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a4d6d89e0948bf10c08b9ecc8ac5b83f07f857ebe2c0cbe38de15b4e4f510356" "checksum inkwell 0.1.0 (git+https://github.com/wasmerio/inkwell?branch=llvm8-0)" = "" "checksum inkwell_internal_macros 0.1.0 (git+https://github.com/wasmerio/inkwell?branch=llvm8-0)" = "" "checksum itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5b8467d9c1cebe26feb08c640139247fac215782d35371ade9a2136ed6085358" "checksum itoa 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)" = "501266b7edd0174f8530248f87f99c88fbe60ca4ef3dd486835b8d8d53136f7f" "checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d" "checksum lazy_static 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bc5729f27f159ddd61f4df6228e827e86643d4d3e7c32183cb30a1c08f604a14" -"checksum libc 0.2.60 (registry+https://github.com/rust-lang/crates.io-index)" = "d44e80633f007889c7eff624b709ab43c92d708caad982295768a7b13ca3b5eb" -"checksum libloading 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a5692f82b51823e27c4118b3e5c0d98aee9be90633ebc71ad12afef380b50219" +"checksum libc 0.2.62 (registry+https://github.com/rust-lang/crates.io-index)" = "34fcd2c08d2f832f376f4173a231990fa5aef4e99fb569867318a227ef4c06ba" +"checksum libloading 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f2b111a074963af1d37a139918ac6d49ad1d0d5e47f72fd55388619691a7d753" "checksum llvm-sys 80.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2110cd4daf9cd8e39dd3b933b1a2a2ac7315e91f7c92b3a20beab526c63b5978" "checksum lock_api 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f8912e782533a93a167888781b836336a6ca5da6175c05944c86cf28c31104dc" "checksum log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "14b6052be84e6b71ab17edffc2eeabf5c2c3ae1fdb464aae35ac50c67a44e1f7" @@ -1813,8 +1846,7 @@ dependencies = [ "checksum nom 4.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "2ad2a91a8e869eeb30b9cb3119ae87773a8f4ae617f41b1eb9c154b2905f7bd6" "checksum num-traits 0.1.43 (registry+https://github.com/rust-lang/crates.io-index)" = "92e5113e9fd4cc14ded8e499429f396a20f98c772a47cc8622a736e1ec843c31" "checksum num-traits 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "6ba9a427cfca2be13aa6f6403b0b7e7368fe982bfa16fccc450ce74c46cd9b32" -"checksum num_cpus 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1a23f0ed30a54abaa0c7e83b1d2d87ada7c3c23078d1d87815af3e3b6385fbba" -"checksum numtoa 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b8f8bdf33df195859076e54ab11ee78a1b208382d3a26ec40d142ffc1ecc49ef" +"checksum num_cpus 1.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "bcef43580c035376c0705c42792c294b66974abbfd2789b511784023f71f3273" "checksum owning_ref 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "cdf84f41639e037b484f93433aa3897863b561ed65c6e59c7073d7c561710f37" "checksum page_size 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f89ef58b3d32420dbd1a43d2f38ae92f6239ef12bb556ab09ca55445f5a67242" "checksum parking_lot 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f842b1982eb6c2fe34036a4fbfb06dd185a3f5c8edfaacdf7d1ea10b07de6252" @@ -1823,14 +1855,16 @@ dependencies = [ "checksum plain 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6" "checksum ppv-lite86 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "e3cbf9f658cdb5000fcf6f362b8ea2ba154b9f146a61c7a20d647034c6b6561b" "checksum proc-macro2 0.4.30 (registry+https://github.com/rust-lang/crates.io-index)" = "cf3d2011ab5c909338f7887f4fc896d35932e29146c12c8d01da6b22a80ba759" +"checksum proc-macro2 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "4c5c2380ae88876faae57698be9e9775e3544decad214599c3a6266cca6ac802" "checksum quick-error 1.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9274b940887ce9addde99c4eee6b5c44cc494b182b97e73dc8ffdcb3397fd3f0" "checksum quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6e920b65c65f10b2ae65c831a81a073a89edd28c7cce89475bff467ab4167a" -"checksum quote 0.6.12 (registry+https://github.com/rust-lang/crates.io-index)" = "faf4799c5d274f3868a4aae320a0a182cbd2baee377b378f080e16a23e9d80db" +"checksum quote 0.6.13 (registry+https://github.com/rust-lang/crates.io-index)" = "6ce23b6b870e8f94f81fb0a363d65d86675884b34a09043c81e5562f11c1f8e1" +"checksum quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "053a8c8bcc71fcce321828dc897a98ab9760bef03a4fc36693c231e5b3216cfe" "checksum rand 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293" "checksum rand 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d47eab0e83d9693d40f825f86948aa16eff6750ead4bdffc4ab95b8b3a7f052c" "checksum rand_chacha 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "03a2a90da8c7523f554344f921aa97283eadf6ac484a6d2a7d0212fa7f8d6853" "checksum rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b" -"checksum rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d0e7a549d590831370895ab7ba4ea0c1b6b011d106b5ff2da6eee112615e6dc0" +"checksum rand_core 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc" "checksum rand_core 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "615e683324e75af5d43d8f7a39ffe3ee4a9dc42c5c701167a71dc59c3a493aca" "checksum rand_hc 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c" "checksum rand_os 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071" @@ -1839,26 +1873,26 @@ dependencies = [ "checksum rayon 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a4b0186e22767d5b9738a05eab7c6ac90b15db17e5b5f9bd87976dd7d89a10a4" "checksum rayon-core 1.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ebbe0df8435ac0c397d467b6cad6d25543d06e8a019ef3f6af3c384597515bd2" "checksum rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2" -"checksum redox_syscall 0.1.54 (registry+https://github.com/rust-lang/crates.io-index)" = "12229c14a0f65c4f1cb046a3b52047cdd9da1f4b30f8a39c5063c8bae515e252" -"checksum redox_termios 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7e891cfe48e9100a70a3b6eb652fef28920c117d366339687bd5576160db0f76" +"checksum redox_syscall 0.1.56 (registry+https://github.com/rust-lang/crates.io-index)" = "2439c63f3f6139d1b57529d16bc3b8bb855230c8efcc5d3a896c8bea7c3b1e84" "checksum regex 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "88c3d9193984285d544df4a30c23a4e62ead42edf70a4452ceb76dac1ce05c26" +"checksum regex-automata 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "92b73c2a1770c255c240eaa4ee600df1704a38dc3feaa6e949e7fcd4f8dc09f9" "checksum regex-syntax 0.6.11 (registry+https://github.com/rust-lang/crates.io-index)" = "b143cceb2ca5e56d5671988ef8b15615733e7ee16cd348e064333b251b89343f" -"checksum remove_dir_all 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3488ba1b9a2084d38645c4c08276a1752dcbf2c7130d74f1569681ad5d2799c5" -"checksum rgb 0.8.13 (registry+https://github.com/rust-lang/crates.io-index)" = "4f089652ca87f5a82a62935ec6172a534066c7b97be003cc8f702ee9a7a59c92" -"checksum rustc-demangle 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)" = "a7f4dccf6f4891ebcc0c39f9b6eb1a83b9bf5d747cb439ec6fba4f3b977038af" +"checksum remove_dir_all 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4a83fa3702a688b9359eccba92d153ac33fd2e8462f9e0e3fdf155239ea7792e" +"checksum rgb 0.8.14 (registry+https://github.com/rust-lang/crates.io-index)" = "2089e4031214d129e201f8c3c8c2fe97cd7322478a0d1cdf78e7029b0042efdb" +"checksum rustc-demangle 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "4c691c0e608126e00913e33f0ccf3727d5fc84573623b8d65b2df340b5201783" "checksum rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a" -"checksum ryu 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "b96a9549dc8d48f2c283938303c4b5a77aa29bfbc5b54b084fb1630408899a8f" -"checksum same-file 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "8f20c4be53a8a1ff4c1f1b2bd14570d2f634628709752f0702ecdd2b3f9a5267" +"checksum ryu 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c92464b447c0ee8c4fb3824ecc8383b81717b9f1e74ba2e72540aef7b9f82997" +"checksum same-file 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "585e8ddcedc187886a30fa705c47985c3fa88d06624095856b36ca0b82ff4421" "checksum scopeguard 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b42e15e59b18a828bbf5c58ea01debb36b9b096346de35d941dcb89009f24a0d" "checksum scroll 0.9.2 (registry+https://github.com/rust-lang/crates.io-index)" = "2f84d114ef17fd144153d608fba7c446b0145d038985e7a8cc5d08bb0ce20383" "checksum scroll_derive 0.9.5 (registry+https://github.com/rust-lang/crates.io-index)" = "8f1aa96c45e7f5a91cb7fabe7b279f02fea7126239fc40b732316e8b6a2d0fcb" "checksum semver 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403" "checksum semver-parser 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3" -"checksum serde 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)" = "7fe5626ac617da2f2d9c48af5515a21d5a480dbd151e01bb1c355e26a3e68113" +"checksum serde 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)" = "fec2851eb56d010dc9a21b89ca53ee75e6528bab60c11e89d38390904982da9f" "checksum serde-bench 0.0.7 (registry+https://github.com/rust-lang/crates.io-index)" = "d733da87e79faaac25616e33d26299a41143fd4cd42746cbb0e91d8feea243fd" -"checksum serde_bytes 0.11.1 (registry+https://github.com/rust-lang/crates.io-index)" = "aaff47db6ef8771cca5d88febef2f22f47f645420e51226374049f68c6b08569" -"checksum serde_derive 1.0.98 (registry+https://github.com/rust-lang/crates.io-index)" = "01e69e1b8a631f245467ee275b8c757b818653c6d704cdbcaeb56b56767b529c" -"checksum serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)" = "5a23aa71d4a4d43fdbfaac00eff68ba8a06a51759a89ac3304323e800c4dd40d" +"checksum serde_bytes 0.11.2 (registry+https://github.com/rust-lang/crates.io-index)" = "45af0182ff64abaeea290235eb67da3825a576c5d53e642c4d5b652e12e6effc" +"checksum serde_derive 1.0.99 (registry+https://github.com/rust-lang/crates.io-index)" = "cb4dc18c61206b08dc98216c98faa0232f4337e1e1b8574551d5bad29ea1b425" +"checksum serde_json 1.0.40 (registry+https://github.com/rust-lang/crates.io-index)" = "051c49229f282f7c6f3813f8286cc1e3323e8051823fce42c7ea80fe13521704" "checksum shlex 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7fdf1b9db47230893d76faad238fd6097fd6d6a9245cd7a4d90dbd639536bbd2" "checksum smallvec 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "ab606a9c5e214920bb66c458cd7be8ef094f813f20fe77a54cc7dbfff220d4b7" "checksum stable_deref_trait 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "dba1a27d3efae4351c8051072d619e3ade2820635c3958d826bfea39d59b54c8" @@ -1866,34 +1900,36 @@ dependencies = [ "checksum structopt 0.2.18 (registry+https://github.com/rust-lang/crates.io-index)" = "16c2cdbf9cc375f15d1b4141bc48aeef444806655cd0e904207edc8d68d86ed7" "checksum structopt-derive 0.2.18 (registry+https://github.com/rust-lang/crates.io-index)" = "53010261a84b37689f9ed7d395165029f9cc7abb9f56bbfe86bee2597ed25107" "checksum syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)" = "d3b891b9015c88c576343b9b3e41c2c11a51c219ef067b264bd9c8aa9b441dad" -"checksum syn 0.15.34 (registry+https://github.com/rust-lang/crates.io-index)" = "a1393e4a97a19c01e900df2aec855a29f71cf02c402e2f443b8d2747c25c5dbe" +"checksum syn 0.15.44 (registry+https://github.com/rust-lang/crates.io-index)" = "9ca4b3b69a77cbe1ffc9e198781b7acb0c7365a883670e8f1c1bc66fba79a5c5" +"checksum syn 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "158521e6f544e7e3dcfc370ac180794aa38cb34a1b1e07609376d4adcf429b93" "checksum synom 0.11.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a393066ed9010ebaed60b9eafa373d4b1baac186dd7e008555b0f702b51945b6" "checksum synstructure 0.10.2 (registry+https://github.com/rust-lang/crates.io-index)" = "02353edf96d6e4dc81aea2d8490a7e9db177bf8acb0e951c24940bf866cb313f" "checksum take_mut 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f764005d11ee5f36500a149ace24e00e3da98b0158b3e2d53a7495660d3f4d60" "checksum target-lexicon 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1b0ab4982b8945c35cc1c46a83a9094c414f6828a099ce5dcaa8ee2b04642dcb" "checksum tempfile 3.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6e24d9338a0a5be79593e2fa15a648add6138caa803e2d5bc782c371732ca9" -"checksum termcolor 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "4096add70612622289f2fdcdbd5086dc81c1e2675e6ae58d6c4f62a16c6d7f2f" -"checksum termion 1.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dde0593aeb8d47accea5392b39350015b5eccb12c0d98044d856983d89548dea" +"checksum termcolor 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "96d6098003bde162e4277c70665bd87c326f5a0c3f3fbfb285787fa482d54e6e" "checksum textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060" "checksum thread_local 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c6b53e329000edc2b34dbe8545fd20e55a333362d0a321909685a19bd28c3f1b" "checksum time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)" = "db8dcfca086c1143c9270ac42a2bbd8a7ee477b78ac8e45b19abfb0cbede4b6f" "checksum tinytemplate 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "4574b75faccaacddb9b284faecdf0b544b80b6b294f3d062d325c5726a209c20" "checksum toml 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "758664fc71a3a69038656bee8b6be6477d2a6c315a6b81f7081f591bffa4111f" -"checksum toml 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b8c96d7873fa7ef8bdeb3a9cda3ac48389b4154f32b9803b4bc26220b677b039" +"checksum toml 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "c7aabe75941d914b72bf3e5d3932ed92ce0664d49d8432305a8b547c37227724" "checksum typenum 1.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "612d636f949607bdf9b123b4a6f6d966dedf3ff669f7f045890d3a4a73948169" "checksum unicode-segmentation 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1967f4cdfc355b37fd76d2a954fb2ed3871034eb4f26d60537d88795cfc332a9" -"checksum unicode-width 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "882386231c45df4700b275c7ff55b6f3698780a650026380e72dabe76fa46526" +"checksum unicode-width 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "7007dbd421b92cc6e28410fe7362e2e0a2503394908f417b68ec8d1c364c4e20" "checksum unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "8c1f860d7d29cf02cb2f3f359fd35991af3d30bac52c57d265a3c461074cb4dc" "checksum unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc" +"checksum unicode-xid 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "826e7639553986605ec5979c7dd957c7895e93eabed50ab2ffa7f6128a75097c" "checksum vec_map 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "05c78687fb1a80548ae3250346c3db86a80a7cdd77bda190189f2d0a0987c81a" "checksum version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd" "checksum void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d" "checksum wabt 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "94b5f5d6984ca42df66280baa8a15ac188a173ddaf4580b574a98931c01920e7" "checksum wabt-sys 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b064c81821100adb4b71923cecfc67fef083db21c3bbd454b0162c7ffe63eeaa" -"checksum walkdir 2.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "9d9d7ed3431229a144296213105a390676cc49c9b6a72bd19f3176c98e129fa1" +"checksum walkdir 2.2.9 (registry+https://github.com/rust-lang/crates.io-index)" = "9658c94fa8b940eab2250bd5a457f9c48b748420d71293b165c8cdbe2f55f71e" +"checksum wasi 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fd5442abcac6525a045cc8c795aedb60da7a2e5e89c7bf18a0d5357849bb23c7" "checksum wasmer-clif-fork-frontend 0.33.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3bd6bec1587a3b11222f4ff129fd119785713c41de413f54f99d3c03743812f4" "checksum wasmer-clif-fork-wasm 0.33.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a8f323e612fe2549391255a09f89c927d7feb0ec4bf0c2cad9e3c089bdca42fc" -"checksum wasmparser 0.35.1 (registry+https://github.com/rust-lang/crates.io-index)" = "29f51d6103c622680dc4e17fb8173371efda8e529d97a2ba10ddf847d07705f8" +"checksum wasmparser 0.35.3 (registry+https://github.com/rust-lang/crates.io-index)" = "099aaf77635ffad3d9ab57253c29b16a46e93755c3e54cfe33fb8cf4b54f760b" "checksum which 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b57acb10231b9493c8472b20cb57317d0679a49e0bdbee44b3b803a6473af164" "checksum winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a" "checksum winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "f10e386af2b13e47c89e7236a7a14a086791a2b88ebad6df9bf42040195cf770" @@ -1901,5 +1937,5 @@ dependencies = [ "checksum winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" "checksum winapi-util 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7168bab6e1daee33b4557efd0e95d5ca70a03706d39fa5f3fe7a236f584b03c9" "checksum winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" -"checksum wincolor 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "561ed901ae465d6185fa7864d63fbd5720d0ef718366c9a4dc83cf6170d7e9ba" +"checksum wincolor 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "96f5016b18804d24db43cebf3c77269e7569b8954a8464501c216cc5e070eaa9" "checksum winconsole 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3ef84b96d10db72dd980056666d7f1e7663ce93d82fa33b63e71c966f4cf5032" From e6ec261cd54a3c079f85b473338aade3bfbde978 Mon Sep 17 00:00:00 2001 From: Nick Lewycky Date: Wed, 21 Aug 2019 15:01:21 -0700 Subject: [PATCH 16/16] Remove commented out code. --- lib/llvm-backend/src/code.rs | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/lib/llvm-backend/src/code.rs b/lib/llvm-backend/src/code.rs index 224b4a8c192..1f78ccc5bf0 100644 --- a/lib/llvm-backend/src/code.rs +++ b/lib/llvm-backend/src/code.rs @@ -4448,17 +4448,6 @@ impl FunctionCodeGenerator for LLVMFunctionCodeGenerator { let res = builder.build_bitcast(res, intrinsics.i128_ty, ""); state.push1(res); } - /* - Operator::Wake { ref memarg: _ } => { - unimplemented!(); - } - Operator::I32Wait { ref memarg: _ } => { - unimplemented!(); - } - Operator::I64Wait { ref memarg: _ } => { - unimplemented!(); - } - */ Operator::Fence { flags: _ } => { // Fence is a nop. //