fluencelabs/wasmer
1
0
Fork 0
mirror of https://github.com/fluencelabs/wasmer synced 2024-12-14 14:45:40 +00:00
Code Issues Projects Releases Wiki Activity
f77d9bfe32
wasmer/lib/llvm-backend/src/code.rs

8005 lines
338 KiB
Rust
Raw Normal View History

Implement many wasm instructions
2019-02-09 23:53:40 +00:00
use inkwell::{
builder::Builder,
context::Context,
Actually unmap the code after it's done being used
2019-03-01 01:20:18 +00:00
module::{Linkage, Module},
Get control flow working (fingers crossed)
2019-02-13 02:02:00 +00:00
passes::PassManager,
Set target triple and datalayout when creating the LLVM module.
2019-10-23 23:04:29 +00:00
targets::{CodeModel, InitializationConfig, RelocMode, Target, TargetMachine},
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
types::{BasicType, BasicTypeEnum, FunctionType, PointerType, VectorType},
values::{
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
BasicValue, BasicValueEnum, FloatValue, FunctionValue, IntValue, MetadataValue, PhiValue,
PointerValue, VectorValue,
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
},
Set target triple and datalayout when creating the LLVM module.
2019-10-23 23:04:29 +00:00
AddressSpace, AtomicOrdering, AtomicRMWBinOp, FloatPredicate, IntPredicate, OptimizationLevel,
Implement many wasm instructions
2019-02-09 23:53:40 +00:00
};
Add some branching instructions
2019-02-12 03:34:04 +00:00
use smallvec::SmallVec;
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
use std::cell::RefCell;
use std::rc::Rc;
Fix compilation errors and warnings
2019-05-26 16:13:37 +00:00
use std::sync::{Arc, RwLock};
Implement many wasm instructions
2019-02-09 23:53:40 +00:00
use wasmer_runtime_core::{
Thread whether state tracking is enabled into the LLVM backend.
2019-10-23 06:15:05 +00:00
backend::{Backend, CacheGen, CompilerConfig, Token},
Implement caching for parser refactor
2019-05-06 01:11:47 +00:00
cache::{Artifact, Error as CacheError},
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
codegen::*,
implement load* and store* instructions
2019-02-14 23:13:58 +00:00
memory::MemoryType,
Implement caching for parser refactor
2019-05-06 01:11:47 +00:00
module::{ModuleInfo, ModuleInner},
Remove previous LLVM parser code
2019-05-07 04:41:31 +00:00
structures::{Map, TypedIndex},
Implement memory and global operations
2019-02-15 02:08:20 +00:00
types::{
Swap code lazily when tiering up from singlepass to LLVM. Does not handle long-running functions, but should work at least.
2019-08-08 20:26:17 +00:00
FuncIndex, FuncSig, GlobalIndex, LocalOrImport, MemoryIndex, SigIndex, TableIndex, Type,
Implement memory and global operations
2019-02-15 02:08:20 +00:00
},
implement load* and store* instructions
2019-02-14 23:13:58 +00:00
};
Remove previous LLVM parser code
2019-05-07 04:41:31 +00:00
use wasmparser::{BinaryReaderError, MemoryImmediate, Operator, Type as WpType};
Implement many wasm instructions
2019-02-09 23:53:40 +00:00
Remove previous LLVM parser code
2019-05-07 04:41:31 +00:00
use crate::backend::LLVMBackend;
Add bounds checking for memory accesses on dynamic memories
2019-03-04 05:56:30 +00:00
use crate::intrinsics::{CtxType, GlobalCache, Intrinsics, MemoryCache};
Update for new wasmparser.rs version.
2019-07-01 23:11:38 +00:00
use crate::read_info::{blocktype_to_type, type_to_type};
Populating LLVM stack maps into MSM/FSM.
2019-07-22 18:55:43 +00:00
use crate::stackmap::{StackmapEntry, StackmapEntryKind, StackmapRegistry, ValueSemantic};
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
use crate::state::{ControlFrame, ExtraInfo, IfElseState, State};
Get control flow (at least according to the llvm verifier) working. Next up: - Importing vm intrinsics.
2019-03-01 23:48:43 +00:00
use crate::trampolines::generate_trampolines;
Implement many wasm instructions
2019-02-09 23:53:40 +00:00
Cargo fmt
2019-08-16 02:13:00 +00:00
fn func_sig_to_llvm(
context: &Context,
intrinsics: &Intrinsics,
sig: &FuncSig,
type_to_llvm: fn(intrinsics: &Intrinsics, ty: Type) -> BasicTypeEnum,
) -> FunctionType {
Add some branching instructions
2019-02-12 03:34:04 +00:00
let user_param_types = sig.params().iter().map(|&ty| type_to_llvm(intrinsics, ty));
implement load* and store* instructions
2019-02-14 23:13:58 +00:00
let param_types: Vec<_> = std::iter::once(intrinsics.ctx_ptr_ty.as_basic_type_enum())
.chain(user_param_types)
.collect();
Implement many wasm instructions
2019-02-09 23:53:40 +00:00
match sig.returns() {
implement load* and store* instructions
2019-02-14 23:13:58 +00:00
&[] => intrinsics.void_ty.fn_type(&param_types, false),
&[single_value] => type_to_llvm(intrinsics, single_value).fn_type(&param_types, false),
Implement many wasm instructions
2019-02-09 23:53:40 +00:00
returns @ _ => {
let basic_types: Vec<_> = returns
.iter()
Add some branching instructions
2019-02-12 03:34:04 +00:00
.map(|&ty| type_to_llvm(intrinsics, ty))
Implement many wasm instructions
2019-02-09 23:53:40 +00:00
.collect();
context
.struct_type(&basic_types, false)
.fn_type(&param_types, false)
}
}
}
Add some branching instructions
2019-02-12 03:34:04 +00:00
fn type_to_llvm(intrinsics: &Intrinsics, ty: Type) -> BasicTypeEnum {
Implement many wasm instructions
2019-02-09 23:53:40 +00:00
match ty {
Add some branching instructions
2019-02-12 03:34:04 +00:00
Type::I32 => intrinsics.i32_ty.as_basic_type_enum(),
Type::I64 => intrinsics.i64_ty.as_basic_type_enum(),
Type::F32 => intrinsics.f32_ty.as_basic_type_enum(),
Type::F64 => intrinsics.f64_ty.as_basic_type_enum(),
Add V128 stubs to allow LLVM backend to build again.
2019-07-02 22:01:50 +00:00
Type::V128 => intrinsics.i128_ty.as_basic_type_enum(),
Implement many wasm instructions
2019-02-09 23:53:40 +00:00
}
}
Allow only integers for LLVM function param/return values.
2019-08-16 02:07:03 +00:00
fn type_to_llvm_int_only(intrinsics: &Intrinsics, ty: Type) -> BasicTypeEnum {
match ty {
Type::I32 | Type::F32 => intrinsics.i32_ty.as_basic_type_enum(),
Type::I64 | Type::F64 => intrinsics.i64_ty.as_basic_type_enum(),
Type::V128 => intrinsics.i128_ty.as_basic_type_enum(),
}
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
// Create a vector where each lane contains the same value.
fn splat_vector(
builder: &Builder,
intrinsics: &Intrinsics,
value: BasicValueEnum,
vec_ty: VectorType,
name: &str,
) -> VectorValue {
// Use insert_element to insert the element into an undef vector, then use
// shuffle vector to copy that lane to all lanes.
builder.build_shuffle_vector(
Reformat.
2019-07-10 21:28:07 +00:00
builder.build_insert_element(vec_ty.get_undef(), value, intrinsics.i32_zero, ""),
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
vec_ty.get_undef(),
intrinsics.i32_ty.vec_type(vec_ty.get_size()).const_zero(),
name,
)
}
// Convert floating point vector to integer and saturate when out of range.
// TODO: generalize to non-vectors using FloatMathType, IntMathType, etc. for
// https://github.com/WebAssembly/nontrapping-float-to-int-conversions/blob/master/proposals/nontrapping-float-to-int-conversion/Overview.md
fn trunc_sat(
builder: &Builder,
intrinsics: &Intrinsics,
fvec_ty: VectorType,
ivec_ty: VectorType,
lower_bound: u64, // Exclusive (lowest representable value)
upper_bound: u64, // Exclusive (greatest representable value)
Fix bugs in V128 support based on results from testing against simd spec test. These is one test failure remaining with V128 global variables. * Fix trunc_sat. We need both the largest float that can be converted to an int and the largest int, they are not the same number. * Implement calling of functions that take V128 by passing in two i64's. * Improve support for V128 in spectests. Parse binary modules with the same features as the outer spectest. Fix compilation error involving Result in emitted .rs file. Handle V128 in more cases when producing .rs file. Parse the wast script with SIMD enabled. * Adjust the WAVM spectest so that it parses with WABT and mostly passes with wasmer. Wabt is particular about ints not having decimal places and floats having decimal places. Wasmer does not support mutable globals or shared memory. Tests of shuffles are disabled. Some assert_invalid tests that wabt won't even parse are disabled.
2019-07-18 19:52:59 +00:00
int_min_value: u64,
int_max_value: u64,
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
value: IntValue,
name: &str,
) -> IntValue {
// a) Compare vector with itself to identify NaN lanes.
// b) Compare vector with splat of inttofp(upper_bound) to identify
// lanes that need to saturate to max.
// c) Compare vector with splat of inttofp(lower_bound) to identify
// lanes that need to saturate to min.
// d) Use vector select (not shuffle) to pick from either the
// splat vector or the input vector depending on whether the
Fix bugs in V128 support based on results from testing against simd spec test. These is one test failure remaining with V128 global variables. * Fix trunc_sat. We need both the largest float that can be converted to an int and the largest int, they are not the same number. * Implement calling of functions that take V128 by passing in two i64's. * Improve support for V128 in spectests. Parse binary modules with the same features as the outer spectest. Fix compilation error involving Result in emitted .rs file. Handle V128 in more cases when producing .rs file. Parse the wast script with SIMD enabled. * Adjust the WAVM spectest so that it parses with WABT and mostly passes with wasmer. Wabt is particular about ints not having decimal places and floats having decimal places. Wasmer does not support mutable globals or shared memory. Tests of shuffles are disabled. Some assert_invalid tests that wabt won't even parse are disabled.
2019-07-18 19:52:59 +00:00
// comparison indicates that we have an unrepresentable value. Replace
// unrepresentable values with zero.
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
// e) Now that the value is safe, fpto[su]i it.
Fix bugs in V128 support based on results from testing against simd spec test. These is one test failure remaining with V128 global variables. * Fix trunc_sat. We need both the largest float that can be converted to an int and the largest int, they are not the same number. * Implement calling of functions that take V128 by passing in two i64's. * Improve support for V128 in spectests. Parse binary modules with the same features as the outer spectest. Fix compilation error involving Result in emitted .rs file. Handle V128 in more cases when producing .rs file. Parse the wast script with SIMD enabled. * Adjust the WAVM spectest so that it parses with WABT and mostly passes with wasmer. Wabt is particular about ints not having decimal places and floats having decimal places. Wasmer does not support mutable globals or shared memory. Tests of shuffles are disabled. Some assert_invalid tests that wabt won't even parse are disabled.
2019-07-18 19:52:59 +00:00
// f) Use our previous comparison results to replace certain zeros with
// int_min or int_max.
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Fix bugs in V128 support based on results from testing against simd spec test. These is one test failure remaining with V128 global variables. * Fix trunc_sat. We need both the largest float that can be converted to an int and the largest int, they are not the same number. * Implement calling of functions that take V128 by passing in two i64's. * Improve support for V128 in spectests. Parse binary modules with the same features as the outer spectest. Fix compilation error involving Result in emitted .rs file. Handle V128 in more cases when producing .rs file. Parse the wast script with SIMD enabled. * Adjust the WAVM spectest so that it parses with WABT and mostly passes with wasmer. Wabt is particular about ints not having decimal places and floats having decimal places. Wasmer does not support mutable globals or shared memory. Tests of shuffles are disabled. Some assert_invalid tests that wabt won't even parse are disabled.
2019-07-18 19:52:59 +00:00
let is_signed = int_min_value != 0;
Improve panic/unreachable/unimplemented usage. Refactor a little.
2019-07-22 19:15:56 +00:00
let ivec_element_ty = ivec_ty.get_element_type().into_int_type();
Fix bugs in V128 support based on results from testing against simd spec test. These is one test failure remaining with V128 global variables. * Fix trunc_sat. We need both the largest float that can be converted to an int and the largest int, they are not the same number. * Implement calling of functions that take V128 by passing in two i64's. * Improve support for V128 in spectests. Parse binary modules with the same features as the outer spectest. Fix compilation error involving Result in emitted .rs file. Handle V128 in more cases when producing .rs file. Parse the wast script with SIMD enabled. * Adjust the WAVM spectest so that it parses with WABT and mostly passes with wasmer. Wabt is particular about ints not having decimal places and floats having decimal places. Wasmer does not support mutable globals or shared memory. Tests of shuffles are disabled. Some assert_invalid tests that wabt won't even parse are disabled.
2019-07-18 19:52:59 +00:00
let int_min_value = splat_vector(
builder,
intrinsics,
Improve panic/unreachable/unimplemented usage. Refactor a little.
2019-07-22 19:15:56 +00:00
ivec_element_ty
Reformat.
2019-07-18 20:40:24 +00:00
.const_int(int_min_value, is_signed)
.as_basic_value_enum(),
Fix bugs in V128 support based on results from testing against simd spec test. These is one test failure remaining with V128 global variables. * Fix trunc_sat. We need both the largest float that can be converted to an int and the largest int, they are not the same number. * Implement calling of functions that take V128 by passing in two i64's. * Improve support for V128 in spectests. Parse binary modules with the same features as the outer spectest. Fix compilation error involving Result in emitted .rs file. Handle V128 in more cases when producing .rs file. Parse the wast script with SIMD enabled. * Adjust the WAVM spectest so that it parses with WABT and mostly passes with wasmer. Wabt is particular about ints not having decimal places and floats having decimal places. Wasmer does not support mutable globals or shared memory. Tests of shuffles are disabled. Some assert_invalid tests that wabt won't even parse are disabled.
2019-07-18 19:52:59 +00:00
ivec_ty,
"",
);
let int_max_value = splat_vector(
builder,
intrinsics,
Improve panic/unreachable/unimplemented usage. Refactor a little.
2019-07-22 19:15:56 +00:00
ivec_element_ty
Reformat.
2019-07-18 20:40:24 +00:00
.const_int(int_max_value, is_signed)
.as_basic_value_enum(),
Fix bugs in V128 support based on results from testing against simd spec test. These is one test failure remaining with V128 global variables. * Fix trunc_sat. We need both the largest float that can be converted to an int and the largest int, they are not the same number. * Implement calling of functions that take V128 by passing in two i64's. * Improve support for V128 in spectests. Parse binary modules with the same features as the outer spectest. Fix compilation error involving Result in emitted .rs file. Handle V128 in more cases when producing .rs file. Parse the wast script with SIMD enabled. * Adjust the WAVM spectest so that it parses with WABT and mostly passes with wasmer. Wabt is particular about ints not having decimal places and floats having decimal places. Wasmer does not support mutable globals or shared memory. Tests of shuffles are disabled. Some assert_invalid tests that wabt won't even parse are disabled.
2019-07-18 19:52:59 +00:00
ivec_ty,
"",
);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let lower_bound = if is_signed {
builder.build_signed_int_to_float(
Improve panic/unreachable/unimplemented usage. Refactor a little.
2019-07-22 19:15:56 +00:00
ivec_element_ty.const_int(lower_bound, is_signed),
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
fvec_ty.get_element_type().into_float_type(),
"",
)
} else {
builder.build_unsigned_int_to_float(
Improve panic/unreachable/unimplemented usage. Refactor a little.
2019-07-22 19:15:56 +00:00
ivec_element_ty.const_int(lower_bound, is_signed),
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
fvec_ty.get_element_type().into_float_type(),
"",
)
};
let upper_bound = if is_signed {
builder.build_signed_int_to_float(
Improve panic/unreachable/unimplemented usage. Refactor a little.
2019-07-22 19:15:56 +00:00
ivec_element_ty.const_int(upper_bound, is_signed),
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
fvec_ty.get_element_type().into_float_type(),
"",
)
} else {
builder.build_unsigned_int_to_float(
Improve panic/unreachable/unimplemented usage. Refactor a little.
2019-07-22 19:15:56 +00:00
ivec_element_ty.const_int(upper_bound, is_signed),
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
fvec_ty.get_element_type().into_float_type(),
"",
)
};
let value = builder
.build_bitcast(value, fvec_ty, "")
.into_vector_value();
let zero = fvec_ty.const_zero();
let lower_bound = splat_vector(
builder,
intrinsics,
lower_bound.as_basic_value_enum(),
fvec_ty,
"",
);
let upper_bound = splat_vector(
builder,
intrinsics,
upper_bound.as_basic_value_enum(),
fvec_ty,
"",
);
Fix bugs in V128 support based on results from testing against simd spec test. These is one test failure remaining with V128 global variables. * Fix trunc_sat. We need both the largest float that can be converted to an int and the largest int, they are not the same number. * Implement calling of functions that take V128 by passing in two i64's. * Improve support for V128 in spectests. Parse binary modules with the same features as the outer spectest. Fix compilation error involving Result in emitted .rs file. Handle V128 in more cases when producing .rs file. Parse the wast script with SIMD enabled. * Adjust the WAVM spectest so that it parses with WABT and mostly passes with wasmer. Wabt is particular about ints not having decimal places and floats having decimal places. Wasmer does not support mutable globals or shared memory. Tests of shuffles are disabled. Some assert_invalid tests that wabt won't even parse are disabled.
2019-07-18 19:52:59 +00:00
let nan_cmp = builder.build_float_compare(FloatPredicate::UNO, value, zero, "nan");
Reformat.
2019-07-18 20:40:24 +00:00
let above_upper_bound_cmp =
builder.build_float_compare(FloatPredicate::OGT, value, upper_bound, "above_upper_bound");
let below_lower_bound_cmp =
builder.build_float_compare(FloatPredicate::OLT, value, lower_bound, "below_lower_bound");
let not_representable = builder.build_or(
builder.build_or(nan_cmp, above_upper_bound_cmp, ""),
below_lower_bound_cmp,
"not_representable_as_int",
);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let value = builder
Fix bugs in V128 support based on results from testing against simd spec test. These is one test failure remaining with V128 global variables. * Fix trunc_sat. We need both the largest float that can be converted to an int and the largest int, they are not the same number. * Implement calling of functions that take V128 by passing in two i64's. * Improve support for V128 in spectests. Parse binary modules with the same features as the outer spectest. Fix compilation error involving Result in emitted .rs file. Handle V128 in more cases when producing .rs file. Parse the wast script with SIMD enabled. * Adjust the WAVM spectest so that it parses with WABT and mostly passes with wasmer. Wabt is particular about ints not having decimal places and floats having decimal places. Wasmer does not support mutable globals or shared memory. Tests of shuffles are disabled. Some assert_invalid tests that wabt won't even parse are disabled.
2019-07-18 19:52:59 +00:00
.build_select(not_representable, zero, value, "safe_to_convert")
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
.into_vector_value();
Fix bugs in V128 support based on results from testing against simd spec test. These is one test failure remaining with V128 global variables. * Fix trunc_sat. We need both the largest float that can be converted to an int and the largest int, they are not the same number. * Implement calling of functions that take V128 by passing in two i64's. * Improve support for V128 in spectests. Parse binary modules with the same features as the outer spectest. Fix compilation error involving Result in emitted .rs file. Handle V128 in more cases when producing .rs file. Parse the wast script with SIMD enabled. * Adjust the WAVM spectest so that it parses with WABT and mostly passes with wasmer. Wabt is particular about ints not having decimal places and floats having decimal places. Wasmer does not support mutable globals or shared memory. Tests of shuffles are disabled. Some assert_invalid tests that wabt won't even parse are disabled.
2019-07-18 19:52:59 +00:00
let value = if is_signed {
builder.build_float_to_signed_int(value, ivec_ty, "as_int")
} else {
builder.build_float_to_unsigned_int(value, ivec_ty, "as_int")
};
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let value = builder
Fix bugs in V128 support based on results from testing against simd spec test. These is one test failure remaining with V128 global variables. * Fix trunc_sat. We need both the largest float that can be converted to an int and the largest int, they are not the same number. * Implement calling of functions that take V128 by passing in two i64's. * Improve support for V128 in spectests. Parse binary modules with the same features as the outer spectest. Fix compilation error involving Result in emitted .rs file. Handle V128 in more cases when producing .rs file. Parse the wast script with SIMD enabled. * Adjust the WAVM spectest so that it parses with WABT and mostly passes with wasmer. Wabt is particular about ints not having decimal places and floats having decimal places. Wasmer does not support mutable globals or shared memory. Tests of shuffles are disabled. Some assert_invalid tests that wabt won't even parse are disabled.
2019-07-18 19:52:59 +00:00
.build_select(above_upper_bound_cmp, int_max_value, value, "")
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
.into_vector_value();
Fix bugs in V128 support based on results from testing against simd spec test. These is one test failure remaining with V128 global variables. * Fix trunc_sat. We need both the largest float that can be converted to an int and the largest int, they are not the same number. * Implement calling of functions that take V128 by passing in two i64's. * Improve support for V128 in spectests. Parse binary modules with the same features as the outer spectest. Fix compilation error involving Result in emitted .rs file. Handle V128 in more cases when producing .rs file. Parse the wast script with SIMD enabled. * Adjust the WAVM spectest so that it parses with WABT and mostly passes with wasmer. Wabt is particular about ints not having decimal places and floats having decimal places. Wasmer does not support mutable globals or shared memory. Tests of shuffles are disabled. Some assert_invalid tests that wabt won't even parse are disabled.
2019-07-18 19:52:59 +00:00
let res = builder
.build_select(below_lower_bound_cmp, int_min_value, value, name)
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
.into_vector_value();
builder
.build_bitcast(res, intrinsics.i128_ty, "")
.into_int_value()
}
Simplify trap_if_not_representable_as_int. Fix typo in function name. Use two fcmp instructions instead of unpacking the bits of the IEEE float and using integer arithmetic to determine details about its value.
2019-07-11 23:24:09 +00:00
fn trap_if_not_representable_as_int(
Add partiality to float truncation
2019-03-05 19:50:56 +00:00
builder: &Builder,
intrinsics: &Intrinsics,
context: &Context,
function: &FunctionValue,
Fix the Trunc[SU] operations, makes conversions.wast pass.
2019-07-29 22:01:00 +00:00
lower_bound: u64, // Inclusive (not a trapping value)
upper_bound: u64, // Inclusive (not a trapping value)
Add partiality to float truncation
2019-03-05 19:50:56 +00:00
value: FloatValue,
) {
let float_ty = value.get_type();
Fix the Trunc[SU] operations, makes conversions.wast pass.
2019-07-29 22:01:00 +00:00
let int_ty = if float_ty == intrinsics.f32_ty {
intrinsics.i32_ty
} else {
intrinsics.i64_ty
};
Add partiality to float truncation
2019-03-05 19:50:56 +00:00
Fix the Trunc[SU] operations, makes conversions.wast pass.
2019-07-29 22:01:00 +00:00
let lower_bound = builder
.build_bitcast(int_ty.const_int(lower_bound, false), float_ty, "")
.into_float_value();
let upper_bound = builder
.build_bitcast(int_ty.const_int(upper_bound, false), float_ty, "")
.into_float_value();
Simplify trap_if_not_representable_as_int. Fix typo in function name. Use two fcmp instructions instead of unpacking the bits of the IEEE float and using integer arithmetic to determine details about its value.
2019-07-11 23:24:09 +00:00
// The 'U' in the float predicate is short for "unordered" which means that
// the comparison will compare true if either operand is a NaN. Thus, NaNs
// are out of bounds.
let above_upper_bound_cmp =
builder.build_float_compare(FloatPredicate::UGT, value, upper_bound, "above_upper_bound");
let below_lower_bound_cmp =
builder.build_float_compare(FloatPredicate::ULT, value, lower_bound, "below_lower_bound");
let out_of_bounds = builder.build_or(
above_upper_bound_cmp,
below_lower_bound_cmp,
"out_of_bounds",
Add partiality to float truncation
2019-03-05 19:50:56 +00:00
);
Simplify trap_if_not_representable_as_int. Fix typo in function name. Use two fcmp instructions instead of unpacking the bits of the IEEE float and using integer arithmetic to determine details about its value.
2019-07-11 23:24:09 +00:00
let failure_block = context.append_basic_block(function, "conversion_failure_block");
let continue_block = context.append_basic_block(function, "conversion_success_block");
Add partiality to float truncation
2019-03-05 19:50:56 +00:00
Simplify trap_if_not_representable_as_int. Fix typo in function name. Use two fcmp instructions instead of unpacking the bits of the IEEE float and using integer arithmetic to determine details about its value.
2019-07-11 23:24:09 +00:00
builder.build_conditional_branch(out_of_bounds, &failure_block, &continue_block);
Add partiality to float truncation
2019-03-05 19:50:56 +00:00
builder.position_at_end(&failure_block);
builder.build_call(
intrinsics.throw_trap,
&[intrinsics.trap_illegal_arithmetic],
"throw",
);
builder.build_unreachable();
builder.position_at_end(&continue_block);
}
Up to 1242 passing spectests
2019-03-04 23:51:45 +00:00
fn trap_if_zero_or_overflow(
builder: &Builder,
intrinsics: &Intrinsics,
context: &Context,
function: &FunctionValue,
left: IntValue,
right: IntValue,
) {
let int_type = left.get_type();
let (min_value, neg_one_value) = if int_type == intrinsics.i32_ty {
let min_value = int_type.const_int(i32::min_value() as u64, false);
let neg_one_value = int_type.const_int(-1i32 as u32 as u64, false);
(min_value, neg_one_value)
} else if int_type == intrinsics.i64_ty {
let min_value = int_type.const_int(i64::min_value() as u64, false);
let neg_one_value = int_type.const_int(-1i64 as u64, false);
(min_value, neg_one_value)
} else {
unreachable!()
};
let should_trap = builder.build_or(
builder.build_int_compare(
IntPredicate::EQ,
right,
int_type.const_int(0, false),
"divisor_is_zero",
),
builder.build_and(
builder.build_int_compare(IntPredicate::EQ, left, min_value, "left_is_min"),
builder.build_int_compare(IntPredicate::EQ, right, neg_one_value, "right_is_neg_one"),
"div_will_overflow",
),
"div_should_trap",
);
let should_trap = builder
.build_call(
intrinsics.expect_i1,
&[
should_trap.as_basic_value_enum(),
intrinsics.i1_ty.const_int(0, false).as_basic_value_enum(),
],
"should_trap_expect",
)
.try_as_basic_value()
.left()
.unwrap()
.into_int_value();
let shouldnt_trap_block = context.append_basic_block(function, "shouldnt_trap_block");
let should_trap_block = context.append_basic_block(function, "should_trap_block");
builder.build_conditional_branch(should_trap, &should_trap_block, &shouldnt_trap_block);
builder.position_at_end(&should_trap_block);
builder.build_call(
intrinsics.throw_trap,
Add illegal arithmetic runtime error
2019-03-05 03:56:02 +00:00
&[intrinsics.trap_illegal_arithmetic],
Up to 1242 passing spectests
2019-03-04 23:51:45 +00:00
"throw",
);
builder.build_unreachable();
builder.position_at_end(&shouldnt_trap_block);
}
fn trap_if_zero(
builder: &Builder,
intrinsics: &Intrinsics,
context: &Context,
function: &FunctionValue,
value: IntValue,
) {
let int_type = value.get_type();
let should_trap = builder.build_int_compare(
IntPredicate::EQ,
value,
int_type.const_int(0, false),
"divisor_is_zero",
);
let should_trap = builder
.build_call(
intrinsics.expect_i1,
&[
should_trap.as_basic_value_enum(),
intrinsics.i1_ty.const_int(0, false).as_basic_value_enum(),
],
"should_trap_expect",
)
.try_as_basic_value()
.left()
.unwrap()
.into_int_value();
let shouldnt_trap_block = context.append_basic_block(function, "shouldnt_trap_block");
let should_trap_block = context.append_basic_block(function, "should_trap_block");
builder.build_conditional_branch(should_trap, &should_trap_block, &shouldnt_trap_block);
builder.position_at_end(&should_trap_block);
builder.build_call(
intrinsics.throw_trap,
Add illegal arithmetic runtime error
2019-03-05 03:56:02 +00:00
&[intrinsics.trap_illegal_arithmetic],
Up to 1242 passing spectests
2019-03-04 23:51:45 +00:00
"throw",
);
builder.build_unreachable();
builder.position_at_end(&shouldnt_trap_block);
}
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
fn v128_into_int_vec(
builder: &Builder,
intrinsics: &Intrinsics,
value: BasicValueEnum,
info: ExtraInfo,
int_vec_ty: VectorType,
) -> VectorValue {
let value = match info {
ExtraInfo::None => value,
ExtraInfo::PendingF32NaN => {
let value = builder.build_bitcast(value, intrinsics.f32x4_ty, "");
canonicalize_nans(builder, intrinsics, value)
}
ExtraInfo::PendingF64NaN => {
let value = builder.build_bitcast(value, intrinsics.f64x2_ty, "");
canonicalize_nans(builder, intrinsics, value)
}
};
builder
.build_bitcast(value, int_vec_ty, "")
.into_vector_value()
}
fn v128_into_i8x16(
builder: &Builder,
intrinsics: &Intrinsics,
value: BasicValueEnum,
info: ExtraInfo,
) -> VectorValue {
v128_into_int_vec(builder, intrinsics, value, info, intrinsics.i8x16_ty)
}
fn v128_into_i16x8(
builder: &Builder,
intrinsics: &Intrinsics,
value: BasicValueEnum,
info: ExtraInfo,
) -> VectorValue {
v128_into_int_vec(builder, intrinsics, value, info, intrinsics.i16x8_ty)
}
fn v128_into_i32x4(
builder: &Builder,
intrinsics: &Intrinsics,
value: BasicValueEnum,
info: ExtraInfo,
) -> VectorValue {
v128_into_int_vec(builder, intrinsics, value, info, intrinsics.i32x4_ty)
}
fn v128_into_i64x2(
builder: &Builder,
intrinsics: &Intrinsics,
value: BasicValueEnum,
info: ExtraInfo,
) -> VectorValue {
v128_into_int_vec(builder, intrinsics, value, info, intrinsics.i64x2_ty)
}
// If the value is pending a 64-bit canonicalization, do it now.
// Return a f32x4 vector.
fn v128_into_f32x4(
builder: &Builder,
intrinsics: &Intrinsics,
value: BasicValueEnum,
info: ExtraInfo,
) -> VectorValue {
let value = if info == ExtraInfo::PendingF64NaN {
let value = builder.build_bitcast(value, intrinsics.f64x2_ty, "");
canonicalize_nans(builder, intrinsics, value)
} else {
value
};
builder
.build_bitcast(value, intrinsics.f32x4_ty, "")
.into_vector_value()
}
// If the value is pending a 32-bit canonicalization, do it now.
// Return a f64x2 vector.
fn v128_into_f64x2(
builder: &Builder,
intrinsics: &Intrinsics,
value: BasicValueEnum,
info: ExtraInfo,
) -> VectorValue {
let value = if info == ExtraInfo::PendingF32NaN {
let value = builder.build_bitcast(value, intrinsics.f32x4_ty, "");
canonicalize_nans(builder, intrinsics, value)
} else {
value
};
builder
.build_bitcast(value, intrinsics.f64x2_ty, "")
.into_vector_value()
}
fn apply_pending_canonicalization(
builder: &Builder,
intrinsics: &Intrinsics,
value: BasicValueEnum,
info: ExtraInfo,
) -> BasicValueEnum {
match info {
ExtraInfo::None => value,
ExtraInfo::PendingF32NaN => {
if value.get_type().is_vector_type()
|| value.get_type() == intrinsics.i128_ty.as_basic_type_enum()
{
let ty = value.get_type();
let value = builder.build_bitcast(value, intrinsics.f32x4_ty, "");
let value = canonicalize_nans(builder, intrinsics, value);
builder.build_bitcast(value, ty, "")
} else {
canonicalize_nans(builder, intrinsics, value)
}
}
ExtraInfo::PendingF64NaN => {
if value.get_type().is_vector_type()
|| value.get_type() == intrinsics.i128_ty.as_basic_type_enum()
{
let ty = value.get_type();
let value = builder.build_bitcast(value, intrinsics.f64x2_ty, "");
let value = canonicalize_nans(builder, intrinsics, value);
builder.build_bitcast(value, ty, "")
} else {
canonicalize_nans(builder, intrinsics, value)
}
}
}
}
Improve NaN handling by canonicalizing NaNs before most operations. Not handled here is @llvm.minnum and @llvm.maxnum which should be replaced with @llvm.minimum and @llvm.maximum, but using those currently leads to LLVM backend fatal errors.
2019-07-26 00:55:57 +00:00
// Replaces any NaN with the canonical QNaN, otherwise leaves the value alone.
fn canonicalize_nans(
builder: &Builder,
intrinsics: &Intrinsics,
value: BasicValueEnum,
) -> BasicValueEnum {
let f_ty = value.get_type();
let canonicalized = if f_ty.is_vector_type() {
let value = value.into_vector_value();
let f_ty = f_ty.into_vector_type();
let zero = f_ty.const_zero();
let nan_cmp = builder.build_float_compare(FloatPredicate::UNO, value, zero, "nan");
let canonical_qnan = f_ty
.get_element_type()
.into_float_type()
.const_float(std::f64::NAN);
let canonical_qnan = splat_vector(
builder,
intrinsics,
canonical_qnan.as_basic_value_enum(),
f_ty,
"",
);
builder
.build_select(nan_cmp, canonical_qnan, value, "")
.as_basic_value_enum()
} else {
let value = value.into_float_value();
let f_ty = f_ty.into_float_type();
let zero = f_ty.const_zero();
let nan_cmp = builder.build_float_compare(FloatPredicate::UNO, value, zero, "nan");
let canonical_qnan = f_ty.const_float(std::f64::NAN);
builder
.build_select(nan_cmp, canonical_qnan, value, "")
.as_basic_value_enum()
};
canonicalized
}
implement load* and store* instructions
2019-02-14 23:13:58 +00:00
fn resolve_memory_ptr(
builder: &Builder,
intrinsics: &Intrinsics,
Add bounds checking for memory accesses on dynamic memories
2019-03-04 05:56:30 +00:00
context: &Context,
function: &FunctionValue,
implement load* and store* instructions
2019-02-14 23:13:58 +00:00
state: &mut State,
ctx: &mut CtxType,
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
memarg: &MemoryImmediate,
implement load* and store* instructions
2019-02-14 23:13:58 +00:00
ptr_ty: PointerType,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
value_size: usize,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
context_field_ptr_to_base_tbaa: MetadataValue,
context_field_ptr_to_bounds_tbaa: MetadataValue,
implement load* and store* instructions
2019-02-14 23:13:58 +00:00
) -> Result<PointerValue, BinaryReaderError> {
Rewrite resolve_memory_ptr to use GEPs as much as possible. ptr_to_int and int_to_ptr are not treated the same as type-safe pointer operations. LLVM intentionally performs fewer optimizations to code using the former as compared with the latter. We don't need that in our code, standard pointer optimizations are safe for us.
2019-10-24 22:15:53 +00:00
// Look up the memory base (as pointer) and bounds (as unsigned integer).
Remove transmutes.
2019-05-07 11:20:18 +00:00
let memory_cache = ctx.memory(MemoryIndex::new(0), intrinsics);
Rewrite resolve_memory_ptr to use GEPs as much as possible. ptr_to_int and int_to_ptr are not treated the same as type-safe pointer operations. LLVM intentionally performs fewer optimizations to code using the former as compared with the latter. We don't need that in our code, standard pointer optimizations are safe for us.
2019-10-24 22:15:53 +00:00
let (mem_base, mem_bound) = match memory_cache {
Add bounds checking for memory accesses on dynamic memories
2019-03-04 05:56:30 +00:00
MemoryCache::Dynamic {
ptr_to_base_ptr,
ptr_to_bounds,
} => {
let base = builder
.build_load(ptr_to_base_ptr, "base")
.into_pointer_value();
let bounds = builder.build_load(ptr_to_bounds, "bounds").into_int_value();
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
base.as_instruction_value()
.unwrap()
.set_metadata(context_field_ptr_to_base_tbaa, tbaa_kind);
bounds
.as_instruction_value()
.unwrap()
.set_metadata(context_field_ptr_to_bounds_tbaa, tbaa_kind);
Rewrite resolve_memory_ptr to use GEPs as much as possible. ptr_to_int and int_to_ptr are not treated the same as type-safe pointer operations. LLVM intentionally performs fewer optimizations to code using the former as compared with the latter. We don't need that in our code, standard pointer optimizations are safe for us.
2019-10-24 22:15:53 +00:00
(base, bounds)
Add bounds checking for memory accesses on dynamic memories
2019-03-04 05:56:30 +00:00
}
Rewrite resolve_memory_ptr to use GEPs as much as possible. ptr_to_int and int_to_ptr are not treated the same as type-safe pointer operations. LLVM intentionally performs fewer optimizations to code using the former as compared with the latter. We don't need that in our code, standard pointer optimizations are safe for us.
2019-10-24 22:15:53 +00:00
MemoryCache::Static { base_ptr, bounds } => (base_ptr, bounds),
Add bounds checking for memory accesses on dynamic memories
2019-03-04 05:56:30 +00:00
};
Rewrite resolve_memory_ptr to use GEPs as much as possible. ptr_to_int and int_to_ptr are not treated the same as type-safe pointer operations. LLVM intentionally performs fewer optimizations to code using the former as compared with the latter. We don't need that in our code, standard pointer optimizations are safe for us.
2019-10-24 22:15:53 +00:00
let mem_base = builder
.build_bitcast(mem_base, intrinsics.i8_ptr_ty, &state.var_name())
.into_pointer_value();
// Compute the offset over the memory_base.
let imm_offset = intrinsics.i64_ty.const_int(memarg.offset as u64, false);
let var_offset_i32 = state.pop1()?.into_int_value();
let var_offset =
builder.build_int_z_extend(var_offset_i32, intrinsics.i64_ty, &state.var_name());
let effective_offset = builder.build_int_add(var_offset, imm_offset, &state.var_name());
Add bounds checking for memory accesses on dynamic memories
2019-03-04 05:56:30 +00:00
Rewrite resolve_memory_ptr to use GEPs as much as possible. ptr_to_int and int_to_ptr are not treated the same as type-safe pointer operations. LLVM intentionally performs fewer optimizations to code using the former as compared with the latter. We don't need that in our code, standard pointer optimizations are safe for us.
2019-10-24 22:15:53 +00:00
if let MemoryCache::Dynamic { .. } = memory_cache {
// If the memory is dynamic, do a bounds check. For static we rely on
// the size being a multiple of the page size and hitting a reserved
// but unreadable memory.
let value_size_v = intrinsics.i64_ty.const_int(value_size as u64, false);
let load_offset_end =
builder.build_int_add(effective_offset, value_size_v, &state.var_name());
let ptr_in_bounds = builder.build_int_compare(
IntPredicate::ULE,
load_offset_end,
mem_bound,
&state.var_name(),
);
let ptr_in_bounds = builder
.build_call(
intrinsics.expect_i1,
&[
ptr_in_bounds.as_basic_value_enum(),
intrinsics.i1_ty.const_int(1, false).as_basic_value_enum(),
],
"ptr_in_bounds_expect",
)
.try_as_basic_value()
.left()
.unwrap()
.into_int_value();
let in_bounds_continue_block =
context.append_basic_block(function, "in_bounds_continue_block");
let not_in_bounds_block = context.append_basic_block(function, "not_in_bounds_block");
builder.build_conditional_branch(
ptr_in_bounds,
&in_bounds_continue_block,
&not_in_bounds_block,
);
builder.position_at_end(&not_in_bounds_block);
builder.build_call(
intrinsics.throw_trap,
&[intrinsics.trap_memory_oob],
"throw",
);
builder.build_unreachable();
builder.position_at_end(&in_bounds_continue_block);
}
Add bounds checking for memory accesses on dynamic memories
2019-03-04 05:56:30 +00:00
Rewrite resolve_memory_ptr to use GEPs as much as possible. ptr_to_int and int_to_ptr are not treated the same as type-safe pointer operations. LLVM intentionally performs fewer optimizations to code using the former as compared with the latter. We don't need that in our code, standard pointer optimizations are safe for us.
2019-10-24 22:15:53 +00:00
let ptr = unsafe { builder.build_gep(mem_base, &[effective_offset], &state.var_name()) };
Ok(builder
.build_bitcast(ptr, ptr_ty, &state.var_name())
.into_pointer_value())
implement load* and store* instructions
2019-02-14 23:13:58 +00:00
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
fn emit_stack_map(
Swap code lazily when tiering up from singlepass to LLVM. Does not handle long-running functions, but should work at least.
2019-08-08 20:26:17 +00:00
_module_info: &ModuleInfo,
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
intrinsics: &Intrinsics,
builder: &Builder,
local_function_id: usize,
target: &mut StackmapRegistry,
kind: StackmapEntryKind,
locals: &[PointerValue],
state: &State,
Swap code lazily when tiering up from singlepass to LLVM. Does not handle long-running functions, but should work at least.
2019-08-08 20:26:17 +00:00
_ctx: &mut CtxType,
Populating LLVM stack maps into MSM/FSM.
2019-07-22 18:55:43 +00:00
opcode_offset: usize,
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
) {
let stackmap_id = target.entries.len();
Use Vec::with_capacity in various places.
2019-08-09 19:23:29 +00:00
let mut params = Vec::with_capacity(2 + locals.len() + state.stack.len());
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
params.push(
intrinsics
.i64_ty
.const_int(stackmap_id as u64, false)
.as_basic_value_enum(),
);
params.push(intrinsics.i32_ty.const_int(0, false).as_basic_value_enum());
let locals: Vec<_> = locals.iter().map(|x| x.as_basic_value_enum()).collect();
Use Vec::with_capacity in various places.
2019-08-09 19:23:29 +00:00
let mut value_semantics: Vec<ValueSemantic> =
Vec::with_capacity(locals.len() + state.stack.len());
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
params.extend_from_slice(&locals);
Populating LLVM stack maps into MSM/FSM.
2019-07-22 18:55:43 +00:00
value_semantics.extend((0..locals.len()).map(ValueSemantic::WasmLocal));
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
params.extend(state.stack.iter().map(|x| x.0));
Populating LLVM stack maps into MSM/FSM.
2019-07-22 18:55:43 +00:00
value_semantics.extend((0..state.stack.len()).map(ValueSemantic::WasmStack));
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
Merge remote-tracking branch 'origin/master' into feature/llvm-osr
2019-08-21 22:49:25 +00:00
// FIXME: Information needed for Abstract -> Runtime state transform is not fully preserved
// to accelerate compilation and reduce memory usage. Check this again when we try to support
// "full" LLVM OSR.
Resolve semantics for more values.
2019-08-01 15:28:39 +00:00
assert_eq!(params.len(), value_semantics.len() + 2);
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
builder.build_call(intrinsics.experimental_stackmap, &params, &state.var_name());
target.entries.push(StackmapEntry {
kind,
local_function_id,
local_count: locals.len(),
stack_count: state.stack.len(),
Populating LLVM stack maps into MSM/FSM.
2019-07-22 18:55:43 +00:00
opcode_offset,
value_semantics,
Allow a range of instruction offsets to be used in ip lookup.
2019-07-30 14:25:15 +00:00
is_start: true,
});
}
fn finalize_opcode_stack_map(
intrinsics: &Intrinsics,
builder: &Builder,
local_function_id: usize,
target: &mut StackmapRegistry,
kind: StackmapEntryKind,
opcode_offset: usize,
) {
let stackmap_id = target.entries.len();
builder.build_call(
intrinsics.experimental_stackmap,
&[
intrinsics
.i64_ty
.const_int(stackmap_id as u64, false)
.as_basic_value_enum(),
intrinsics.i32_ty.const_int(0, false).as_basic_value_enum(),
],
"opcode_stack_map_end",
);
target.entries.push(StackmapEntry {
kind,
local_function_id,
local_count: 0,
stack_count: 0,
opcode_offset,
value_semantics: vec![],
is_start: false,
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
});
}
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
fn trap_if_misaligned(
builder: &Builder,
intrinsics: &Intrinsics,
context: &Context,
function: &FunctionValue,
memarg: &MemoryImmediate,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
ptr: PointerValue,
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
) {
Fix i64.atomic.load32_u and all alignment checks.
2019-08-20 18:03:22 +00:00
let align = match memarg.flags & 3 {
No need to emit any alignment check for byte-aligned accesses.
2019-08-20 18:30:30 +00:00
0 => {
return; /* No alignment to check. */
}
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
1 => 2,
2 => 4,
3 => 8,
_ => unreachable!("this match is fully covered"),
};
let value = builder.build_ptr_to_int(ptr, intrinsics.i64_ty, "");
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
let and = builder.build_and(
value,
intrinsics.i64_ty.const_int(align - 1, false),
"misaligncheck",
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
);
Correct flipped misalignment test.
2019-08-20 17:39:53 +00:00
let aligned = builder.build_int_compare(IntPredicate::EQ, and, intrinsics.i64_zero, "");
let aligned = builder
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
.build_call(
intrinsics.expect_i1,
&[
Correct flipped misalignment test.
2019-08-20 17:39:53 +00:00
aligned.as_basic_value_enum(),
intrinsics.i1_ty.const_int(1, false).as_basic_value_enum(),
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
],
"",
)
.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");
Correct flipped misalignment test.
2019-08-20 17:39:53 +00:00
builder.build_conditional_branch(aligned, &continue_block, &not_aligned_block);
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
builder.position_at_end(&not_aligned_block);
builder.build_call(
intrinsics.throw_trap,
&[intrinsics.trap_misaligned_atomic],
"throw",
);
builder.build_unreachable();
builder.position_at_end(&continue_block);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
#[derive(Debug)]
pub struct CodegenError {
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
pub message: String,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Implement InternalEvent::Breakpoint in the llvm backend. Enable now-working metering unit tests when run with the llvm backend.
2019-08-01 19:12:53 +00:00
// This is only called by C++ code, the 'pub' + '#[no_mangle]' combination
// prevents unused function elimination.
#[no_mangle]
pub unsafe extern "C" fn callback_trampoline(
b: *mut Option<Box<dyn std::any::Any>>,
callback: *mut BreakpointHandler,
) {
let callback = Box::from_raw(callback);
let result: Result<(), Box<dyn std::any::Any>> = callback(BreakpointInfo { fault: None });
match result {
Ok(()) => *b = None,
Err(e) => *b = Some(e),
}
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
pub struct LLVMModuleCodeGenerator {
Remove transmutes.
2019-05-07 11:20:18 +00:00
context: Option<Context>,
builder: Option<Builder>,
intrinsics: Option<Intrinsics>,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
functions: Vec<LLVMFunctionCodeGenerator>,
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
signatures: Map<SigIndex, FunctionType>,
signatures_raw: Map<SigIndex, FuncSig>,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
function_signatures: Option<Arc<Map<FuncIndex, SigIndex>>>,
func_import_count: usize,
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
personality_func: FunctionValue,
module: Module,
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
stackmaps: Rc<RefCell<StackmapRegistry>>,
Thread whether state tracking is enabled into the LLVM backend.
2019-10-23 06:15:05 +00:00
track_state: bool,
Set target triple and datalayout when creating the LLVM module.
2019-10-23 23:04:29 +00:00
target_machine: TargetMachine,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
memory_tbaa: MetadataValue,
locals_tbaa: MetadataValue,
globals_tbaa: MetadataValue,
context_field_ptr_to_base_tbaa: MetadataValue,
context_field_ptr_to_bounds_tbaa: MetadataValue,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
pub struct LLVMFunctionCodeGenerator {
Remove transmutes.
2019-05-07 11:20:18 +00:00
context: Option<Context>,
builder: Option<Builder>,
Insert allocas as a contiguous block at the top of the entry block. This minimizes the chance we accidentally get categorized as having a dynamic alloca.
2019-10-24 02:21:12 +00:00
alloca_builder: Option<Builder>,
Remove transmutes.
2019-05-07 11:20:18 +00:00
intrinsics: Option<Intrinsics>,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state: State,
function: FunctionValue,
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
func_sig: FuncSig,
signatures: Map<SigIndex, FunctionType>,
Implement feed_local
2019-05-01 01:11:44 +00:00
locals: Vec<PointerValue>, // Contains params and locals
num_params: usize,
Update LLVM FCG begin_body
2019-05-03 05:14:25 +00:00
ctx: Option<CtxType<'static>>,
Fix LLVM refactor unreachable depth
2019-05-05 18:56:02 +00:00
unreachable_depth: usize,
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
stackmaps: Rc<RefCell<StackmapRegistry>>,
index: usize,
Populating LLVM stack maps into MSM/FSM.
2019-07-22 18:55:43 +00:00
opcode_offset: usize,
Thread whether state tracking is enabled into the LLVM backend.
2019-10-23 06:15:05 +00:00
track_state: bool,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
memory_tbaa: MetadataValue,
locals_tbaa: MetadataValue,
globals_tbaa: MetadataValue,
context_field_ptr_to_base_tbaa: MetadataValue,
context_field_ptr_to_bounds_tbaa: MetadataValue,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
impl FunctionCodeGenerator<CodegenError> for LLVMFunctionCodeGenerator {
Remove parser refactor commented out code, unused imports and fields
2019-05-05 19:28:40 +00:00
fn feed_return(&mut self, _ty: WpType) -> Result<(), CodegenError> {
Implement feed_local
2019-05-01 01:11:44 +00:00
Ok(())
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Remove parser refactor commented out code, unused imports and fields
2019-05-05 19:28:40 +00:00
fn feed_param(&mut self, _ty: WpType) -> Result<(), CodegenError> {
Implement feed_local
2019-05-01 01:11:44 +00:00
Ok(())
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Insert allocas as a contiguous block at the top of the entry block. This minimizes the chance we accidentally get categorized as having a dynamic alloca.
2019-10-24 02:21:12 +00:00
fn feed_local(&mut self, ty: WpType, count: usize) -> Result<(), CodegenError> {
Implement feed_local
2019-05-01 01:11:44 +00:00
let param_len = self.num_params;
let wasmer_ty = type_to_type(ty)?;
Remove transmutes.
2019-05-07 11:20:18 +00:00
let intrinsics = self.intrinsics.as_ref().unwrap();
let ty = type_to_llvm(intrinsics, wasmer_ty);
Implement feed_local
2019-05-01 01:11:44 +00:00
let default_value = match wasmer_ty {
Remove transmutes.
2019-05-07 11:20:18 +00:00
Type::I32 => intrinsics.i32_zero.as_basic_value_enum(),
Type::I64 => intrinsics.i64_zero.as_basic_value_enum(),
Type::F32 => intrinsics.f32_zero.as_basic_value_enum(),
Type::F64 => intrinsics.f64_zero.as_basic_value_enum(),
Add V128 stubs to allow LLVM backend to build again.
2019-07-02 22:01:50 +00:00
Type::V128 => intrinsics.i128_zero.as_basic_value_enum(),
Implement feed_local
2019-05-01 01:11:44 +00:00
};
Remove transmutes.
2019-05-07 11:20:18 +00:00
let builder = self.builder.as_ref().unwrap();
Insert allocas as a contiguous block at the top of the entry block. This minimizes the chance we accidentally get categorized as having a dynamic alloca.
2019-10-24 02:21:12 +00:00
let alloca_builder = self.alloca_builder.as_ref().unwrap();
Remove transmutes.
2019-05-07 11:20:18 +00:00
Insert allocas as a contiguous block at the top of the entry block. This minimizes the chance we accidentally get categorized as having a dynamic alloca.
2019-10-24 02:21:12 +00:00
for local_idx in 0..count {
let alloca =
alloca_builder.build_alloca(ty, &format!("local{}", param_len + local_idx));
Remove transmutes.
2019-05-07 11:20:18 +00:00
builder.build_store(alloca, default_value);
Insert allocas as a contiguous block at the top of the entry block. This minimizes the chance we accidentally get categorized as having a dynamic alloca.
2019-10-24 02:21:12 +00:00
if local_idx == 0 {
alloca_builder.position_before(
&alloca
.as_instruction()
.unwrap()
.get_next_instruction()
.unwrap(),
);
}
Implement feed_local
2019-05-01 01:11:44 +00:00
self.locals.push(alloca);
}
Ok(())
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Update LLVM FCG begin_body
2019-05-03 05:14:25 +00:00
fn begin_body(&mut self, module_info: &ModuleInfo) -> Result<(), CodegenError> {
let start_of_code_block = self
.context
Remove transmutes.
2019-05-07 11:20:18 +00:00
.as_ref()
.unwrap()
Update LLVM FCG begin_body
2019-05-03 05:14:25 +00:00
.append_basic_block(&self.function, "start_of_code");
let entry_end_inst = self
.builder
Remove transmutes.
2019-05-07 11:20:18 +00:00
.as_ref()
.unwrap()
Update LLVM FCG begin_body
2019-05-03 05:14:25 +00:00
.build_unconditional_branch(&start_of_code_block);
Remove transmutes.
2019-05-07 11:20:18 +00:00
self.builder
.as_ref()
.unwrap()
.position_at_end(&start_of_code_block);
Update LLVM FCG begin_body
2019-05-03 05:14:25 +00:00
Remove transmutes.
2019-05-07 11:20:18 +00:00
let cache_builder = self.context.as_ref().unwrap().create_builder();
Update LLVM FCG begin_body
2019-05-03 05:14:25 +00:00
cache_builder.position_before(&entry_end_inst);
let module_info =
unsafe { ::std::mem::transmute::<&ModuleInfo, &'static ModuleInfo>(module_info) };
let function = unsafe {
::std::mem::transmute::<&FunctionValue, &'static FunctionValue>(&self.function)
};
Remove transmutes.
2019-05-07 11:20:18 +00:00
let ctx = CtxType::new(module_info, function, cache_builder);
Update LLVM FCG begin_body
2019-05-03 05:14:25 +00:00
self.ctx = Some(ctx);
TwoHalves & trying to get cowsay to compile again
2019-07-24 18:44:28 +00:00
{
Merge remote-tracking branch 'origin/master' into feature/llvm-osr
2019-08-14 23:33:26 +00:00
let state = &mut self.state;
TwoHalves & trying to get cowsay to compile again
2019-07-24 18:44:28 +00:00
let builder = self.builder.as_ref().unwrap();
let intrinsics = self.intrinsics.as_ref().unwrap();
Thread whether state tracking is enabled into the LLVM backend.
2019-10-23 06:15:05 +00:00
if self.track_state {
let mut stackmaps = self.stackmaps.borrow_mut();
emit_stack_map(
&module_info,
&intrinsics,
&builder,
self.index,
&mut *stackmaps,
StackmapEntryKind::FunctionHeader,
&self.locals,
&state,
self.ctx.as_mut().unwrap(),
::std::usize::MAX,
);
finalize_opcode_stack_map(
&intrinsics,
&builder,
self.index,
&mut *stackmaps,
StackmapEntryKind::FunctionHeader,
::std::usize::MAX,
);
}
TwoHalves & trying to get cowsay to compile again
2019-07-24 18:44:28 +00:00
}
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Ok(())
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
fn feed_event(&mut self, event: Event, module_info: &ModuleInfo) -> Result<(), CodegenError> {
let mut state = &mut self.state;
Remove transmutes.
2019-05-07 11:20:18 +00:00
let builder = self.builder.as_ref().unwrap();
let context = self.context.as_ref().unwrap();
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let function = self.function;
Remove transmutes.
2019-05-07 11:20:18 +00:00
let intrinsics = self.intrinsics.as_ref().unwrap();
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let locals = &self.locals;
let info = module_info;
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
let signatures = &self.signatures;
Update LLVM FCG begin_body
2019-05-03 05:14:25 +00:00
let mut ctx = self.ctx.as_mut().unwrap();
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Populating LLVM stack maps into MSM/FSM.
2019-07-22 18:55:43 +00:00
let mut opcode_offset: Option<usize> = None;
Reset LLVM related code to master
2019-06-03 00:36:26 +00:00
let op = match event {
Populating LLVM stack maps into MSM/FSM.
2019-07-22 18:55:43 +00:00
Event::Wasm(x) => {
opcode_offset = Some(self.opcode_offset);
self.opcode_offset += 1;
x
}
Add support for internal fields.
2019-07-31 20:10:51 +00:00
Event::Internal(x) => {
match x {
InternalEvent::FunctionBegin(_) | InternalEvent::FunctionEnd => {
return Ok(());
}
Implement InternalEvent::Breakpoint in the llvm backend. Enable now-working metering unit tests when run with the llvm backend.
2019-08-01 19:12:53 +00:00
InternalEvent::Breakpoint(callback) => {
let raw = Box::into_raw(Box::new(callback)) as u64;
let callback = intrinsics.i64_ty.const_int(raw, false);
builder.build_call(
intrinsics.throw_breakpoint,
&[callback.as_basic_value_enum()],
"",
);
Add support for internal fields.
2019-07-31 20:10:51 +00:00
return Ok(());
}
InternalEvent::GetInternal(idx) => {
if state.reachable {
let idx = idx as usize;
let field_ptr = ctx.internal_field(idx, intrinsics, builder);
let result = builder.build_load(field_ptr, "get_internal");
state.push1(result);
}
}
InternalEvent::SetInternal(idx) => {
if state.reachable {
let idx = idx as usize;
let field_ptr = ctx.internal_field(idx, intrinsics, builder);
let v = state.pop1()?;
builder.build_store(field_ptr, v);
}
}
}
Update LLVM FCG begin_body
2019-05-03 05:14:25 +00:00
return Ok(());
}
Reset LLVM related code to master
2019-06-03 00:36:26 +00:00
Event::WasmOwned(ref x) => x,
};
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
if !state.reachable {
match *op {
Operator::Block { ty: _ } | Operator::Loop { ty: _ } | Operator::If { ty: _ } => {
Fix LLVM refactor unreachable depth
2019-05-05 18:56:02 +00:00
self.unreachable_depth += 1;
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
return Ok(());
}
Operator::Else => {
Fix LLVM refactor unreachable depth
2019-05-05 18:56:02 +00:00
if self.unreachable_depth != 0 {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
return Ok(());
}
}
Operator::End => {
Fix LLVM refactor unreachable depth
2019-05-05 18:56:02 +00:00
if self.unreachable_depth != 0 {
self.unreachable_depth -= 1;
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
return Ok(());
}
}
_ => {
return Ok(());
}
}
}
match *op {
/***************************
* Control Flow instructions.
* https://github.com/sunfishcode/wasm-reference-manual/blob/master/WebAssembly.md#control-flow-instructions
***************************/
Operator::Block { ty } => {
let current_block = builder.get_insert_block().ok_or(BinaryReaderError {
message: "not currently in a block",
offset: -1isize as usize,
})?;
let end_block = context.append_basic_block(&function, "end");
builder.position_at_end(&end_block);
Update for new wasmparser.rs version.
2019-07-01 23:11:38 +00:00
let phis = if let Ok(wasmer_ty) = blocktype_to_type(ty) {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let llvm_ty = type_to_llvm(intrinsics, wasmer_ty);
[llvm_ty]
.iter()
.map(|&ty| builder.build_phi(ty, &state.var_name()))
.collect()
} else {
SmallVec::new()
};
state.push_block(end_block, phis);
builder.position_at_end(&current_block);
}
Operator::Loop { ty } => {
let loop_body = context.append_basic_block(&function, "loop_body");
let loop_next = context.append_basic_block(&function, "loop_outer");
builder.build_unconditional_branch(&loop_body);
builder.position_at_end(&loop_next);
Update for new wasmparser.rs version.
2019-07-01 23:11:38 +00:00
let phis = if let Ok(wasmer_ty) = blocktype_to_type(ty) {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let llvm_ty = type_to_llvm(intrinsics, wasmer_ty);
[llvm_ty]
.iter()
.map(|&ty| builder.build_phi(ty, &state.var_name()))
.collect()
} else {
SmallVec::new()
};
builder.position_at_end(&loop_body);
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
Thread whether state tracking is enabled into the LLVM backend.
2019-10-23 06:15:05 +00:00
if self.track_state {
if let Some(offset) = opcode_offset {
let mut stackmaps = self.stackmaps.borrow_mut();
emit_stack_map(
&info,
intrinsics,
builder,
self.index,
&mut *stackmaps,
StackmapEntryKind::Loop,
&self.locals,
state,
ctx,
offset,
);
let signal_mem = ctx.signal_mem();
let iv = builder
.build_store(signal_mem, context.i8_type().const_int(0 as u64, false));
// Any 'store' can be made volatile.
iv.set_volatile(true).unwrap();
finalize_opcode_stack_map(
intrinsics,
builder,
self.index,
&mut *stackmaps,
StackmapEntryKind::Loop,
offset,
);
}
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push_loop(loop_body, loop_next, phis);
}
Operator::Br { relative_depth } => {
let frame = state.frame_at_depth(relative_depth)?;
let current_block = builder.get_insert_block().ok_or(BinaryReaderError {
message: "not currently in a block",
offset: -1isize as usize,
})?;
let value_len = if frame.is_loop() {
0
} else {
frame.phis().len()
};
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let values = state.peekn_extra(value_len)?;
let values = values.iter().map(|(v, info)| {
apply_pending_canonicalization(builder, intrinsics, *v, *info)
});
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
// For each result of the block we're branching to,
// pop a value off the value stack and load it into
// the corresponding phi.
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
for (phi, value) in frame.phis().iter().zip(values) {
phi.add_incoming(&[(&value, &current_block)]);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
builder.build_unconditional_branch(frame.br_dest());
state.popn(value_len)?;
state.reachable = false;
}
Operator::BrIf { relative_depth } => {
let cond = state.pop1()?;
let frame = state.frame_at_depth(relative_depth)?;
let current_block = builder.get_insert_block().ok_or(BinaryReaderError {
message: "not currently in a block",
offset: -1isize as usize,
})?;
let value_len = if frame.is_loop() {
0
} else {
frame.phis().len()
};
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let param_stack = state.peekn_extra(value_len)?;
let param_stack = param_stack.iter().map(|(v, info)| {
apply_pending_canonicalization(builder, intrinsics, *v, *info)
});
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
for (phi, value) in frame.phis().iter().zip(param_stack) {
phi.add_incoming(&[(&value, &current_block)]);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
let else_block = context.append_basic_block(&function, "else");
let cond_value = builder.build_int_compare(
IntPredicate::NE,
cond.into_int_value(),
intrinsics.i32_zero,
&state.var_name(),
);
builder.build_conditional_branch(cond_value, frame.br_dest(), &else_block);
builder.position_at_end(&else_block);
}
Operator::BrTable { ref table } => {
let current_block = builder.get_insert_block().ok_or(BinaryReaderError {
message: "not currently in a block",
offset: -1isize as usize,
})?;
let (label_depths, default_depth) = table.read_table()?;
let index = state.pop1()?;
let default_frame = state.frame_at_depth(default_depth)?;
let args = if default_frame.is_loop() {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
Vec::new()
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
} else {
let res_len = default_frame.phis().len();
state.peekn(res_len)?
};
for (phi, value) in default_frame.phis().iter().zip(args.iter()) {
phi.add_incoming(&[(value, &current_block)]);
}
let cases: Vec<_> = label_depths
.iter()
.enumerate()
.map(|(case_index, &depth)| {
Implement feed_local
2019-05-01 01:11:44 +00:00
let frame_result: Result<&ControlFrame, BinaryReaderError> =
state.frame_at_depth(depth);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let frame = match frame_result {
Ok(v) => v,
Err(e) => return Err(e),
};
let case_index_literal =
context.i32_type().const_int(case_index as u64, false);
for (phi, value) in frame.phis().iter().zip(args.iter()) {
phi.add_incoming(&[(value, &current_block)]);
}
Ok((case_index_literal, frame.br_dest()))
})
.collect::<Result<_, _>>()?;
builder.build_switch(index.into_int_value(), default_frame.br_dest(), &cases[..]);
Remove previous LLVM parser code
2019-05-07 04:41:31 +00:00
let args_len = args.len();
state.popn(args_len)?;
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.reachable = false;
}
Operator::If { ty } => {
let current_block = builder.get_insert_block().ok_or(BinaryReaderError {
message: "not currently in a block",
offset: -1isize as usize,
})?;
let if_then_block = context.append_basic_block(&function, "if_then");
let if_else_block = context.append_basic_block(&function, "if_else");
let end_block = context.append_basic_block(&function, "if_end");
let end_phis = {
builder.position_at_end(&end_block);
Update for new wasmparser.rs version.
2019-07-01 23:11:38 +00:00
let phis = if let Ok(wasmer_ty) = blocktype_to_type(ty) {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let llvm_ty = type_to_llvm(intrinsics, wasmer_ty);
[llvm_ty]
.iter()
.map(|&ty| builder.build_phi(ty, &state.var_name()))
.collect()
} else {
SmallVec::new()
};
builder.position_at_end(&current_block);
phis
};
let cond = state.pop1()?;
let cond_value = builder.build_int_compare(
IntPredicate::NE,
cond.into_int_value(),
intrinsics.i32_zero,
&state.var_name(),
);
builder.build_conditional_branch(cond_value, &if_then_block, &if_else_block);
builder.position_at_end(&if_then_block);
state.push_if(if_then_block, if_else_block, end_block, end_phis);
}
Operator::Else => {
if state.reachable {
let frame = state.frame_at_depth(0)?;
let current_block = builder.get_insert_block().ok_or(BinaryReaderError {
message: "not currently in a block",
offset: -1isize as usize,
})?;
for phi in frame.phis().to_vec().iter().rev() {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (value, info) = state.pop1_extra()?;
let value =
apply_pending_canonicalization(builder, intrinsics, value, info);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
phi.add_incoming(&[(&value, &current_block)])
}
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let frame = state.frame_at_depth(0)?;
builder.build_unconditional_branch(frame.code_after());
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
let (if_else_block, if_else_state) = if let ControlFrame::IfElse {
if_else,
if_else_state,
..
} = state.frame_at_depth_mut(0)?
{
(if_else, if_else_state)
} else {
unreachable!()
};
*if_else_state = IfElseState::Else;
builder.position_at_end(if_else_block);
state.reachable = true;
}
Operator::End => {
let frame = state.pop_frame()?;
let current_block = builder.get_insert_block().ok_or(BinaryReaderError {
message: "not currently in a block",
offset: -1isize as usize,
})?;
if state.reachable {
for phi in frame.phis().iter().rev() {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (value, info) = state.pop1_extra()?;
let value =
apply_pending_canonicalization(builder, intrinsics, value, info);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
phi.add_incoming(&[(&value, &current_block)]);
}
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
builder.build_unconditional_branch(frame.code_after());
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
if let ControlFrame::IfElse {
if_else,
next,
if_else_state,
..
} = &frame
{
if let IfElseState::If = if_else_state {
builder.position_at_end(if_else);
builder.build_unconditional_branch(next);
}
}
builder.position_at_end(frame.code_after());
state.reset_stack(&frame);
state.reachable = true;
// Push each phi value to the value stack.
for phi in frame.phis() {
if phi.count_incoming() != 0 {
state.push1(phi.as_basic_value());
} else {
let basic_ty = phi.as_basic_value().get_type();
let placeholder_value = match basic_ty {
BasicTypeEnum::IntType(int_ty) => {
int_ty.const_int(0, false).as_basic_value_enum()
}
BasicTypeEnum::FloatType(float_ty) => {
float_ty.const_float(0.0).as_basic_value_enum()
}
remove panic and unimplemented in llvm-backend and runtime-core
2019-09-17 10:03:03 +00:00
_ => {
return Err(CodegenError {
message: "Operator::End phi type unimplemented".to_string(),
});
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
};
state.push1(placeholder_value);
phi.as_instruction().erase_from_basic_block();
}
}
}
Operator::Return => {
let frame = state.outermost_frame()?;
let current_block = builder.get_insert_block().ok_or(BinaryReaderError {
message: "not currently in a block",
offset: -1isize as usize,
})?;
builder.build_unconditional_branch(frame.br_dest());
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let frame = state.outermost_frame()?;
for phi in frame.phis().to_vec().iter() {
let (arg, info) = state.pop1_extra()?;
let arg = apply_pending_canonicalization(builder, intrinsics, arg, info);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
phi.add_incoming(&[(&arg, &current_block)]);
}
state.reachable = false;
}
Operator::Unreachable => {
// Emit an unreachable instruction.
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// If llvm cannot prove that this is never reached,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
// it will emit a `ud2` instruction on x86_64 arches.
Allow only integers for LLVM function param/return values.
2019-08-16 02:07:03 +00:00
// Comment out this `if` block to allow spectests to pass.
// TODO: fix this
Populating LLVM stack maps into MSM/FSM.
2019-07-22 18:55:43 +00:00
if let Some(offset) = opcode_offset {
Thread whether state tracking is enabled into the LLVM backend.
2019-10-23 06:15:05 +00:00
if self.track_state {
let mut stackmaps = self.stackmaps.borrow_mut();
emit_stack_map(
&info,
intrinsics,
builder,
self.index,
&mut *stackmaps,
StackmapEntryKind::Trappable,
&self.locals,
state,
ctx,
offset,
);
builder.build_call(intrinsics.trap, &[], "trap");
finalize_opcode_stack_map(
intrinsics,
builder,
self.index,
&mut *stackmaps,
StackmapEntryKind::Trappable,
offset,
);
}
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
builder.build_call(
intrinsics.throw_trap,
&[intrinsics.trap_unreachable],
"throw",
);
builder.build_unreachable();
state.reachable = false;
}
/***************************
* Basic instructions.
* https://github.com/sunfishcode/wasm-reference-manual/blob/master/WebAssembly.md#basic-instructions
***************************/
Operator::Nop => {
// Do nothing.
}
Operator::Drop => {
state.pop1()?;
}
// Generate const values.
Operator::I32Const { value } => {
let i = intrinsics.i32_ty.const_int(value as u64, false);
state.push1(i);
}
Operator::I64Const { value } => {
let i = intrinsics.i64_ty.const_int(value as u64, false);
state.push1(i);
}
Operator::F32Const { value } => {
let bits = intrinsics.i32_ty.const_int(value.bits() as u64, false);
Simplify construction of floating point constants.
2019-06-25 23:03:40 +00:00
let f = builder.build_bitcast(bits, intrinsics.f32_ty, "f");
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(f);
}
Operator::F64Const { value } => {
let bits = intrinsics.i64_ty.const_int(value.bits(), false);
Simplify construction of floating point constants.
2019-06-25 23:03:40 +00:00
let f = builder.build_bitcast(bits, intrinsics.f64_ty, "f");
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(f);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::V128Const { value } => {
let mut hi: [u8; 8] = Default::default();
let mut lo: [u8; 8] = Default::default();
hi.copy_from_slice(&value.bytes()[0..8]);
lo.copy_from_slice(&value.bytes()[8..16]);
let packed = [u64::from_le_bytes(hi), u64::from_le_bytes(lo)];
let i = intrinsics.i128_ty.const_int_arbitrary_precision(&packed);
state.push1(i);
}
Operator::I8x16Splat => {
let v = state.pop1()?.into_int_value();
let v = builder.build_int_truncate(v, intrinsics.i8_ty, "");
let res = splat_vector(
builder,
intrinsics,
v.as_basic_value_enum(),
intrinsics.i8x16_ty,
&state.var_name(),
);
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8Splat => {
let v = state.pop1()?.into_int_value();
let v = builder.build_int_truncate(v, intrinsics.i16_ty, "");
let res = splat_vector(
builder,
intrinsics,
v.as_basic_value_enum(),
intrinsics.i16x8_ty,
&state.var_name(),
);
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I32x4Splat => {
let v = state.pop1()?;
let res = splat_vector(
builder,
intrinsics,
v,
intrinsics.i32x4_ty,
&state.var_name(),
);
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I64x2Splat => {
let v = state.pop1()?;
let res = splat_vector(
builder,
intrinsics,
v,
intrinsics.i64x2_ty,
&state.var_name(),
);
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::F32x4Splat => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = splat_vector(
builder,
intrinsics,
v,
intrinsics.f32x4_ty,
&state.var_name(),
);
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// The spec is unclear, we interpret splat as preserving NaN
// payload bits.
state.push1_extra(res, i);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
}
Operator::F64x2Splat => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = splat_vector(
builder,
intrinsics,
v,
intrinsics.f64x2_ty,
&state.var_name(),
);
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// The spec is unclear, we interpret splat as preserving NaN
// payload bits.
state.push1_extra(res, i);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
// Operate on locals.
Operator::GetLocal { local_index } => {
let pointer_value = locals[local_index as usize];
let v = builder.build_load(pointer_value, &state.var_name());
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
v.as_instruction_value()
.unwrap()
.set_metadata(self.locals_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(v);
}
Operator::SetLocal { local_index } => {
let pointer_value = locals[local_index as usize];
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = apply_pending_canonicalization(builder, intrinsics, v, i);
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let store = builder.build_store(pointer_value, v);
let tbaa_kind = context.get_kind_id("tbaa");
store.set_metadata(self.locals_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Operator::TeeLocal { local_index } => {
let pointer_value = locals[local_index as usize];
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.peek1_extra()?;
let v = apply_pending_canonicalization(builder, intrinsics, v, i);
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let store = builder.build_store(pointer_value, v);
let tbaa_kind = context.get_kind_id("tbaa");
store.set_metadata(self.locals_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Operator::GetGlobal { global_index } => {
let index = GlobalIndex::new(global_index as usize);
Remove transmutes.
2019-05-07 11:20:18 +00:00
let global_cache = ctx.global_cache(index, intrinsics);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
match global_cache {
GlobalCache::Const { value } => {
state.push1(value);
}
GlobalCache::Mut { ptr_to_value } => {
let value = builder.build_load(ptr_to_value, "global_value");
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
value
.as_instruction_value()
.unwrap()
.set_metadata(self.locals_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(value);
}
}
}
Operator::SetGlobal { global_index } => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (value, info) = state.pop1_extra()?;
let value = apply_pending_canonicalization(builder, intrinsics, value, info);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let index = GlobalIndex::new(global_index as usize);
Remove transmutes.
2019-05-07 11:20:18 +00:00
let global_cache = ctx.global_cache(index, intrinsics);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
match global_cache {
GlobalCache::Mut { ptr_to_value } => {
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let store = builder.build_store(ptr_to_value, value);
let tbaa_kind = context.get_kind_id("tbaa");
store.set_metadata(self.globals_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
GlobalCache::Const { value: _ } => {
Return compile error (llvm) for setting immutable global
2019-08-13 23:59:04 +00:00
return Err(CodegenError {
message: "global is immutable".to_string(),
});
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
}
}
Operator::Select => {
let (v1, v2, cond) = state.pop3()?;
let cond_value = builder.build_int_compare(
IntPredicate::NE,
cond.into_int_value(),
intrinsics.i32_zero,
&state.var_name(),
);
let res = builder.build_select(cond_value, v1, v2, &state.var_name());
state.push1(res);
}
Operator::Call { function_index } => {
let func_index = FuncIndex::new(function_index as usize);
let sigindex = info.func_assoc[func_index];
let llvm_sig = signatures[sigindex];
let func_sig = &info.signatures[sigindex];
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
let (params, func_ptr) = match func_index.local_or_import(info) {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
LocalOrImport::Local(local_func_index) => {
Allow only integers for LLVM function param/return values.
2019-08-16 02:07:03 +00:00
let params: Vec<_> = std::iter::once(ctx.basic())
.chain(
Cargo fmt
2019-08-16 02:13:00 +00:00
state
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
.peekn_extra(func_sig.params().len())?
Cargo fmt
2019-08-16 02:13:00 +00:00
.iter()
.enumerate()
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
.map(|(i, (v, info))| match func_sig.params()[i] {
Cargo fmt
2019-08-16 02:13:00 +00:00
Type::F32 => builder.build_bitcast(
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
apply_pending_canonicalization(
builder, intrinsics, *v, *info,
),
Cargo fmt
2019-08-16 02:13:00 +00:00
intrinsics.i32_ty,
&state.var_name(),
),
Type::F64 => builder.build_bitcast(
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
apply_pending_canonicalization(
builder, intrinsics, *v, *info,
),
Cargo fmt
2019-08-16 02:13:00 +00:00
intrinsics.i64_ty,
&state.var_name(),
),
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
Type::V128 => apply_pending_canonicalization(
builder, intrinsics, *v, *info,
),
_ => *v,
Cargo fmt
2019-08-16 02:13:00 +00:00
}),
Allow only integers for LLVM function param/return values.
2019-08-16 02:07:03 +00:00
)
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
.collect();
Remove transmutes.
2019-05-07 11:20:18 +00:00
let func_ptr =
ctx.local_func(local_func_index, llvm_sig, intrinsics, builder);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
(params, func_ptr)
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
LocalOrImport::Import(import_func_index) => {
Remove transmutes.
2019-05-07 11:20:18 +00:00
let (func_ptr_untyped, ctx_ptr) =
ctx.imported_func(import_func_index, intrinsics);
Allow only integers for LLVM function param/return values.
2019-08-16 02:07:03 +00:00
let params: Vec<_> = std::iter::once(ctx_ptr.as_basic_value_enum())
.chain(
Cargo fmt
2019-08-16 02:13:00 +00:00
state
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
.peekn_extra(func_sig.params().len())?
Cargo fmt
2019-08-16 02:13:00 +00:00
.iter()
.enumerate()
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
.map(|(i, (v, info))| match func_sig.params()[i] {
Cargo fmt
2019-08-16 02:13:00 +00:00
Type::F32 => builder.build_bitcast(
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
apply_pending_canonicalization(
builder, intrinsics, *v, *info,
),
Cargo fmt
2019-08-16 02:13:00 +00:00
intrinsics.i32_ty,
&state.var_name(),
),
Type::F64 => builder.build_bitcast(
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
apply_pending_canonicalization(
builder, intrinsics, *v, *info,
),
Cargo fmt
2019-08-16 02:13:00 +00:00
intrinsics.i64_ty,
&state.var_name(),
),
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
Type::V128 => apply_pending_canonicalization(
builder, intrinsics, *v, *info,
),
_ => *v,
Cargo fmt
2019-08-16 02:13:00 +00:00
}),
Allow only integers for LLVM function param/return values.
2019-08-16 02:07:03 +00:00
)
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
.collect();
let func_ptr_ty = llvm_sig.ptr_type(AddressSpace::Generic);
let func_ptr = builder.build_pointer_cast(
func_ptr_untyped,
func_ptr_ty,
"typed_func_ptr",
);
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
(params, func_ptr)
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
};
state.popn(func_sig.params().len())?;
Thread whether state tracking is enabled into the LLVM backend.
2019-10-23 06:15:05 +00:00
if self.track_state {
if let Some(offset) = opcode_offset {
let mut stackmaps = self.stackmaps.borrow_mut();
emit_stack_map(
&info,
intrinsics,
builder,
self.index,
&mut *stackmaps,
StackmapEntryKind::Call,
&self.locals,
state,
ctx,
offset,
)
}
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
}
let call_site = builder.build_call(func_ptr, &params, &state.var_name());
Thread whether state tracking is enabled into the LLVM backend.
2019-10-23 06:15:05 +00:00
if self.track_state {
if let Some(offset) = opcode_offset {
let mut stackmaps = self.stackmaps.borrow_mut();
finalize_opcode_stack_map(
intrinsics,
builder,
self.index,
&mut *stackmaps,
StackmapEntryKind::Call,
offset,
)
}
Allow a range of instruction offsets to be used in ip lookup.
2019-07-30 14:25:15 +00:00
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
if let Some(basic_value) = call_site.try_as_basic_value().left() {
match func_sig.returns().len() {
Allow only integers for LLVM function param/return values.
2019-08-16 02:07:03 +00:00
1 => state.push1(match func_sig.returns()[0] {
Cargo fmt
2019-08-16 02:13:00 +00:00
Type::F32 => {
builder.build_bitcast(basic_value, intrinsics.f32_ty, "ret_cast")
}
Type::F64 => {
builder.build_bitcast(basic_value, intrinsics.f64_ty, "ret_cast")
}
Allow only integers for LLVM function param/return values.
2019-08-16 02:07:03 +00:00
_ => basic_value,
}),
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
count @ _ => {
// This is a multi-value return.
let struct_value = basic_value.into_struct_value();
for i in 0..(count as u32) {
let value = builder
.build_extract_value(struct_value, i, &state.var_name())
.unwrap();
state.push1(value);
}
}
}
}
}
Operator::CallIndirect { index, table_index } => {
let sig_index = SigIndex::new(index as usize);
Remove transmutes.
2019-05-07 11:20:18 +00:00
let expected_dynamic_sigindex = ctx.dynamic_sigindex(sig_index, intrinsics);
let (table_base, table_bound) =
ctx.table(TableIndex::new(table_index as usize), intrinsics, builder);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let func_index = state.pop1()?.into_int_value();
// We assume the table has the `anyfunc` element type.
let casted_table_base = builder.build_pointer_cast(
table_base,
intrinsics.anyfunc_ty.ptr_type(AddressSpace::Generic),
"casted_table_base",
);
let anyfunc_struct_ptr = unsafe {
builder.build_in_bounds_gep(
casted_table_base,
&[func_index],
"anyfunc_struct_ptr",
)
};
// Load things from the anyfunc data structure.
let (func_ptr, ctx_ptr, found_dynamic_sigindex) = unsafe {
(
builder
.build_load(
builder.build_struct_gep(anyfunc_struct_ptr, 0, "func_ptr_ptr"),
"func_ptr",
)
.into_pointer_value(),
builder.build_load(
builder.build_struct_gep(anyfunc_struct_ptr, 1, "ctx_ptr_ptr"),
"ctx_ptr",
),
builder
.build_load(
builder.build_struct_gep(anyfunc_struct_ptr, 2, "sigindex_ptr"),
"sigindex",
)
.into_int_value(),
)
};
let truncated_table_bounds = builder.build_int_truncate(
table_bound,
intrinsics.i32_ty,
"truncated_table_bounds",
);
// First, check if the index is outside of the table bounds.
let index_in_bounds = builder.build_int_compare(
IntPredicate::ULT,
func_index,
truncated_table_bounds,
"index_in_bounds",
);
let index_in_bounds = builder
.build_call(
intrinsics.expect_i1,
&[
index_in_bounds.as_basic_value_enum(),
intrinsics.i1_ty.const_int(1, false).as_basic_value_enum(),
],
"index_in_bounds_expect",
)
.try_as_basic_value()
.left()
.unwrap()
.into_int_value();
let in_bounds_continue_block =
context.append_basic_block(&function, "in_bounds_continue_block");
let not_in_bounds_block =
context.append_basic_block(&function, "not_in_bounds_block");
builder.build_conditional_branch(
index_in_bounds,
&in_bounds_continue_block,
&not_in_bounds_block,
);
builder.position_at_end(&not_in_bounds_block);
builder.build_call(
intrinsics.throw_trap,
&[intrinsics.trap_call_indirect_oob],
"throw",
);
builder.build_unreachable();
builder.position_at_end(&in_bounds_continue_block);
// Next, check if the signature id is correct.
let sigindices_equal = builder.build_int_compare(
IntPredicate::EQ,
expected_dynamic_sigindex,
found_dynamic_sigindex,
"sigindices_equal",
);
// Tell llvm that `expected_dynamic_sigindex` should equal `found_dynamic_sigindex`.
let sigindices_equal = builder
.build_call(
intrinsics.expect_i1,
&[
sigindices_equal.as_basic_value_enum(),
intrinsics.i1_ty.const_int(1, false).as_basic_value_enum(),
],
"sigindices_equal_expect",
)
.try_as_basic_value()
.left()
.unwrap()
.into_int_value();
let continue_block = context.append_basic_block(&function, "continue_block");
let sigindices_notequal_block =
context.append_basic_block(&function, "sigindices_notequal_block");
builder.build_conditional_branch(
sigindices_equal,
&continue_block,
&sigindices_notequal_block,
);
builder.position_at_end(&sigindices_notequal_block);
builder.build_call(
intrinsics.throw_trap,
&[intrinsics.trap_call_indirect_sig],
"throw",
);
builder.build_unreachable();
builder.position_at_end(&continue_block);
let wasmer_fn_sig = &info.signatures[sig_index];
let fn_ty = signatures[sig_index];
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let pushed_args = state.popn_save_extra(wasmer_fn_sig.params().len())?;
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let args: Vec<_> = std::iter::once(ctx_ptr)
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
.chain(pushed_args.into_iter().enumerate().map(|(i, (v, info))| {
Cargo fmt
2019-08-16 02:13:00 +00:00
match wasmer_fn_sig.params()[i] {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
Type::F32 => builder.build_bitcast(
apply_pending_canonicalization(builder, intrinsics, v, info),
intrinsics.i32_ty,
&state.var_name(),
),
Type::F64 => builder.build_bitcast(
apply_pending_canonicalization(builder, intrinsics, v, info),
intrinsics.i64_ty,
&state.var_name(),
),
Type::V128 => {
apply_pending_canonicalization(builder, intrinsics, v, info)
Cargo fmt
2019-08-16 02:13:00 +00:00
}
_ => v,
}
}))
.collect();
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let typed_func_ptr = builder.build_pointer_cast(
func_ptr,
fn_ty.ptr_type(AddressSpace::Generic),
"typed_func_ptr",
);
Thread whether state tracking is enabled into the LLVM backend.
2019-10-23 06:15:05 +00:00
if self.track_state {
if let Some(offset) = opcode_offset {
let mut stackmaps = self.stackmaps.borrow_mut();
emit_stack_map(
&info,
intrinsics,
builder,
self.index,
&mut *stackmaps,
StackmapEntryKind::Call,
&self.locals,
state,
ctx,
offset,
)
}
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let call_site = builder.build_call(typed_func_ptr, &args, "indirect_call");
Thread whether state tracking is enabled into the LLVM backend.
2019-10-23 06:15:05 +00:00
if self.track_state {
if let Some(offset) = opcode_offset {
let mut stackmaps = self.stackmaps.borrow_mut();
finalize_opcode_stack_map(
intrinsics,
builder,
self.index,
&mut *stackmaps,
StackmapEntryKind::Call,
offset,
)
}
Allow a range of instruction offsets to be used in ip lookup.
2019-07-30 14:25:15 +00:00
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
match wasmer_fn_sig.returns() {
[] => {}
[_] => {
let value = call_site.try_as_basic_value().left().unwrap();
Allow only integers for LLVM function param/return values.
2019-08-16 02:07:03 +00:00
state.push1(match wasmer_fn_sig.returns()[0] {
Cargo fmt
2019-08-16 02:13:00 +00:00
Type::F32 => {
builder.build_bitcast(value, intrinsics.f32_ty, "ret_cast")
}
Type::F64 => {
builder.build_bitcast(value, intrinsics.f64_ty, "ret_cast")
}
Allow only integers for LLVM function param/return values.
2019-08-16 02:07:03 +00:00
_ => value,
});
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
remove panic and unimplemented in llvm-backend and runtime-core
2019-09-17 10:03:03 +00:00
_ => {
return Err(CodegenError {
message: "Operator::CallIndirect multi-value returns unimplemented"
.to_string(),
});
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
}
/***************************
* Integer Arithmetic instructions.
* https://github.com/sunfishcode/wasm-reference-manual/blob/master/WebAssembly.md#integer-arithmetic-instructions
***************************/
Operator::I32Add | Operator::I64Add => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
let res = builder.build_int_add(v1, v2, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I8x16Add => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i8x16(builder, intrinsics, v1, i1);
let v2 = v128_into_i8x16(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_add(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8Add => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i16x8(builder, intrinsics, v1, i1);
let v2 = v128_into_i16x8(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_add(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I32x4Add => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_i32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_add(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I64x2Add => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i64x2(builder, intrinsics, v1, i1);
let v2 = v128_into_i64x2(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_add(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I8x16AddSaturateS => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i8x16(builder, intrinsics, v1, i1).as_basic_value_enum();
let v2 = v128_into_i8x16(builder, intrinsics, v2, i2).as_basic_value_enum();
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder
Add missing names to LLVM instructions.
2019-07-23 17:15:22 +00:00
.build_call(intrinsics.sadd_sat_i8x16, &[v1, v2], &state.var_name())
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
.try_as_basic_value()
.left()
.unwrap();
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8AddSaturateS => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i16x8(builder, intrinsics, v1, i1).as_basic_value_enum();
let v2 = v128_into_i16x8(builder, intrinsics, v2, i2).as_basic_value_enum();
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder
Add missing names to LLVM instructions.
2019-07-23 17:15:22 +00:00
.build_call(intrinsics.sadd_sat_i16x8, &[v1, v2], &state.var_name())
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
.try_as_basic_value()
.left()
.unwrap();
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I8x16AddSaturateU => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i8x16(builder, intrinsics, v1, i1).as_basic_value_enum();
let v2 = v128_into_i8x16(builder, intrinsics, v2, i2).as_basic_value_enum();
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder
Add missing names to LLVM instructions.
2019-07-23 17:15:22 +00:00
.build_call(intrinsics.uadd_sat_i8x16, &[v1, v2], &state.var_name())
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
.try_as_basic_value()
.left()
.unwrap();
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8AddSaturateU => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i16x8(builder, intrinsics, v1, i1).as_basic_value_enum();
let v2 = v128_into_i16x8(builder, intrinsics, v2, i2).as_basic_value_enum();
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder
Add missing names to LLVM instructions.
2019-07-23 17:15:22 +00:00
.build_call(intrinsics.uadd_sat_i16x8, &[v1, v2], &state.var_name())
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
.try_as_basic_value()
.left()
.unwrap();
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::I32Sub | Operator::I64Sub => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
let res = builder.build_int_sub(v1, v2, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I8x16Sub => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i8x16(builder, intrinsics, v1, i1);
let v2 = v128_into_i8x16(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_sub(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8Sub => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i16x8(builder, intrinsics, v1, i1);
let v2 = v128_into_i16x8(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_sub(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I32x4Sub => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_i32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_sub(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I64x2Sub => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i64x2(builder, intrinsics, v1, i1);
let v2 = v128_into_i64x2(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_sub(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I8x16SubSaturateS => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i8x16(builder, intrinsics, v1, i1).as_basic_value_enum();
let v2 = v128_into_i8x16(builder, intrinsics, v2, i2).as_basic_value_enum();
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder
Add missing names to LLVM instructions.
2019-07-23 17:15:22 +00:00
.build_call(intrinsics.ssub_sat_i8x16, &[v1, v2], &state.var_name())
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
.try_as_basic_value()
.left()
.unwrap();
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8SubSaturateS => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i16x8(builder, intrinsics, v1, i1).as_basic_value_enum();
let v2 = v128_into_i16x8(builder, intrinsics, v2, i2).as_basic_value_enum();
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder
Add missing names to LLVM instructions.
2019-07-23 17:15:22 +00:00
.build_call(intrinsics.ssub_sat_i16x8, &[v1, v2], &state.var_name())
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
.try_as_basic_value()
.left()
.unwrap();
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I8x16SubSaturateU => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i8x16(builder, intrinsics, v1, i1).as_basic_value_enum();
let v2 = v128_into_i8x16(builder, intrinsics, v2, i2).as_basic_value_enum();
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder
Add missing names to LLVM instructions.
2019-07-23 17:15:22 +00:00
.build_call(intrinsics.usub_sat_i8x16, &[v1, v2], &state.var_name())
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
.try_as_basic_value()
.left()
.unwrap();
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8SubSaturateU => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i16x8(builder, intrinsics, v1, i1).as_basic_value_enum();
let v2 = v128_into_i16x8(builder, intrinsics, v2, i2).as_basic_value_enum();
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder
Add missing names to LLVM instructions.
2019-07-23 17:15:22 +00:00
.build_call(intrinsics.usub_sat_i16x8, &[v1, v2], &state.var_name())
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
.try_as_basic_value()
.left()
.unwrap();
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::I32Mul | Operator::I64Mul => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
let res = builder.build_int_mul(v1, v2, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I8x16Mul => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i8x16(builder, intrinsics, v1, i1);
let v2 = v128_into_i8x16(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_mul(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8Mul => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i16x8(builder, intrinsics, v1, i1);
let v2 = v128_into_i16x8(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_mul(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I32x4Mul => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_i32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_mul(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::I32DivS | Operator::I64DivS => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
trap_if_zero_or_overflow(builder, intrinsics, context, &function, v1, v2);
let res = builder.build_int_signed_div(v1, v2, &state.var_name());
state.push1(res);
}
Operator::I32DivU | Operator::I64DivU => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
trap_if_zero(builder, intrinsics, context, &function, v2);
let res = builder.build_int_unsigned_div(v1, v2, &state.var_name());
state.push1(res);
}
Operator::I32RemS | Operator::I64RemS => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
LLVM srem is undefined in cases where i32.rem_s and i64.rem_s are defined.
2019-07-25 00:17:06 +00:00
let int_type = v1.get_type();
let (min_value, neg_one_value) = if int_type == intrinsics.i32_ty {
let min_value = int_type.const_int(i32::min_value() as u64, false);
let neg_one_value = int_type.const_int(-1i32 as u32 as u64, false);
(min_value, neg_one_value)
} else if int_type == intrinsics.i64_ty {
let min_value = int_type.const_int(i64::min_value() as u64, false);
let neg_one_value = int_type.const_int(-1i64 as u64, false);
(min_value, neg_one_value)
} else {
unreachable!()
};
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
trap_if_zero(builder, intrinsics, context, &function, v2);
LLVM srem is undefined in cases where i32.rem_s and i64.rem_s are defined.
2019-07-25 00:17:06 +00:00
// "Overflow also leads to undefined behavior; this is a rare
// case, but can occur, for example, by taking the remainder of
// a 32-bit division of -2147483648 by -1. (The remainder
// doesn’t actually overflow, but this rule lets srem be
// implemented using instructions that return both the result
// of the division and the remainder.)"
// -- https://llvm.org/docs/LangRef.html#srem-instruction
//
// In Wasm, the i32.rem_s i32.const -2147483648 i32.const -1 is
// i32.const 0. We implement this by swapping out the left value
// for 0 in this case.
let will_overflow = builder.build_and(
builder.build_int_compare(IntPredicate::EQ, v1, min_value, "left_is_min"),
builder.build_int_compare(
IntPredicate::EQ,
v2,
neg_one_value,
"right_is_neg_one",
),
"srem_will_overflow",
);
let v1 = builder
.build_select(will_overflow, int_type.const_zero(), v1, "")
.into_int_value();
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let res = builder.build_int_signed_rem(v1, v2, &state.var_name());
state.push1(res);
}
Operator::I32RemU | Operator::I64RemU => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
trap_if_zero(builder, intrinsics, context, &function, v2);
let res = builder.build_int_unsigned_rem(v1, v2, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I32And | Operator::I64And | Operator::V128And => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = apply_pending_canonicalization(builder, intrinsics, v1, i1);
let v2 = apply_pending_canonicalization(builder, intrinsics, v2, i2);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
let res = builder.build_and(v1, v2, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I32Or | Operator::I64Or | Operator::V128Or => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = apply_pending_canonicalization(builder, intrinsics, v1, i1);
let v2 = apply_pending_canonicalization(builder, intrinsics, v2, i2);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
let res = builder.build_or(v1, v2, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I32Xor | Operator::I64Xor | Operator::V128Xor => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = apply_pending_canonicalization(builder, intrinsics, v1, i1);
let v2 = apply_pending_canonicalization(builder, intrinsics, v2, i2);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
let res = builder.build_xor(v1, v2, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::V128Bitselect => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2), (cond, cond_info)) = state.pop3_extra()?;
let v1 = apply_pending_canonicalization(builder, intrinsics, v1, i1);
let v2 = apply_pending_canonicalization(builder, intrinsics, v2, i2);
let cond = apply_pending_canonicalization(builder, intrinsics, cond, cond_info);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let v1 = builder
.build_bitcast(v1, intrinsics.i1x128_ty, "")
.into_vector_value();
let v2 = builder
.build_bitcast(v2, intrinsics.i1x128_ty, "")
.into_vector_value();
let cond = builder
.build_bitcast(cond, intrinsics.i1x128_ty, "")
.into_vector_value();
let res = builder.build_select(cond, v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::I32Shl | Operator::I64Shl => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
// TODO: missing 'and' of v2?
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let res = builder.build_left_shift(v1, v2, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I8x16Shl => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, _)) = state.pop2_extra()?;
let v1 = v128_into_i8x16(builder, intrinsics, v1, i1);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let v2 = v2.into_int_value();
let v2 = builder.build_and(v2, intrinsics.i32_ty.const_int(7, false), "");
let v2 = builder.build_int_truncate(v2, intrinsics.i8_ty, "");
let v2 = splat_vector(
builder,
intrinsics,
v2.as_basic_value_enum(),
intrinsics.i8x16_ty,
"",
);
let res = builder.build_left_shift(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I16x8Shl => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, _)) = state.pop2_extra()?;
let v1 = v128_into_i16x8(builder, intrinsics, v1, i1);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let v2 = v2.into_int_value();
let v2 = builder.build_and(v2, intrinsics.i32_ty.const_int(15, false), "");
let v2 = builder.build_int_truncate(v2, intrinsics.i16_ty, "");
let v2 = splat_vector(
builder,
intrinsics,
v2.as_basic_value_enum(),
intrinsics.i16x8_ty,
"",
);
let res = builder.build_left_shift(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I32x4Shl => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, _)) = state.pop2_extra()?;
let v1 = v128_into_i32x4(builder, intrinsics, v1, i1);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let v2 = v2.into_int_value();
let v2 = builder.build_and(v2, intrinsics.i32_ty.const_int(31, false), "");
let v2 = splat_vector(
builder,
intrinsics,
v2.as_basic_value_enum(),
intrinsics.i32x4_ty,
"",
);
let res = builder.build_left_shift(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I64x2Shl => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, _)) = state.pop2_extra()?;
let v1 = v128_into_i64x2(builder, intrinsics, v1, i1);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let v2 = v2.into_int_value();
let v2 = builder.build_and(v2, intrinsics.i32_ty.const_int(63, false), "");
let v2 = builder.build_int_z_extend(v2, intrinsics.i64_ty, "");
let v2 = splat_vector(
builder,
intrinsics,
v2.as_basic_value_enum(),
intrinsics.i64x2_ty,
"",
);
let res = builder.build_left_shift(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I32ShrS | Operator::I64ShrS => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
// TODO: check wasm spec, is this missing v2 mod LaneBits?
let res = builder.build_right_shift(v1, v2, true, &state.var_name());
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I8x16ShrS => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, _)) = state.pop2_extra()?;
let v1 = v128_into_i8x16(builder, intrinsics, v1, i1);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let v2 = v2.into_int_value();
let v2 = builder.build_and(v2, intrinsics.i32_ty.const_int(7, false), "");
let v2 = builder.build_int_truncate(v2, intrinsics.i8_ty, "");
let v2 = splat_vector(
builder,
intrinsics,
v2.as_basic_value_enum(),
intrinsics.i8x16_ty,
"",
);
let res = builder.build_right_shift(v1, v2, true, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I16x8ShrS => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, _)) = state.pop2_extra()?;
let v1 = v128_into_i16x8(builder, intrinsics, v1, i1);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let v2 = v2.into_int_value();
let v2 = builder.build_and(v2, intrinsics.i32_ty.const_int(15, false), "");
let v2 = builder.build_int_truncate(v2, intrinsics.i16_ty, "");
let v2 = splat_vector(
builder,
intrinsics,
v2.as_basic_value_enum(),
intrinsics.i16x8_ty,
"",
);
let res = builder.build_right_shift(v1, v2, true, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I32x4ShrS => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, _)) = state.pop2_extra()?;
let v1 = v128_into_i32x4(builder, intrinsics, v1, i1);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let v2 = v2.into_int_value();
let v2 = builder.build_and(v2, intrinsics.i32_ty.const_int(31, false), "");
let v2 = splat_vector(
builder,
intrinsics,
v2.as_basic_value_enum(),
intrinsics.i32x4_ty,
"",
);
let res = builder.build_right_shift(v1, v2, true, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I64x2ShrS => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, _)) = state.pop2_extra()?;
let v1 = v128_into_i64x2(builder, intrinsics, v1, i1);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let v2 = v2.into_int_value();
let v2 = builder.build_and(v2, intrinsics.i32_ty.const_int(63, false), "");
let v2 = builder.build_int_z_extend(v2, intrinsics.i64_ty, "");
let v2 = splat_vector(
builder,
intrinsics,
v2.as_basic_value_enum(),
intrinsics.i64x2_ty,
"",
);
let res = builder.build_right_shift(v1, v2, true, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I32ShrU | Operator::I64ShrU => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
let res = builder.build_right_shift(v1, v2, false, &state.var_name());
state.push1(res);
}
Operator::I8x16ShrU => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, _)) = state.pop2_extra()?;
let v1 = v128_into_i8x16(builder, intrinsics, v1, i1);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let v2 = v2.into_int_value();
let v2 = builder.build_and(v2, intrinsics.i32_ty.const_int(7, false), "");
let v2 = builder.build_int_truncate(v2, intrinsics.i8_ty, "");
let v2 = splat_vector(
builder,
intrinsics,
v2.as_basic_value_enum(),
intrinsics.i8x16_ty,
"",
);
let res = builder.build_right_shift(v1, v2, false, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8ShrU => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, _)) = state.pop2_extra()?;
let v1 = v128_into_i16x8(builder, intrinsics, v1, i1);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let v2 = v2.into_int_value();
let v2 = builder.build_and(v2, intrinsics.i32_ty.const_int(15, false), "");
let v2 = builder.build_int_truncate(v2, intrinsics.i16_ty, "");
let v2 = splat_vector(
builder,
intrinsics,
v2.as_basic_value_enum(),
intrinsics.i16x8_ty,
"",
);
let res = builder.build_right_shift(v1, v2, false, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I32x4ShrU => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, _)) = state.pop2_extra()?;
let v1 = v128_into_i32x4(builder, intrinsics, v1, i1);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let v2 = v2.into_int_value();
let v2 = builder.build_and(v2, intrinsics.i32_ty.const_int(31, false), "");
let v2 = splat_vector(
builder,
intrinsics,
v2.as_basic_value_enum(),
intrinsics.i32x4_ty,
"",
);
let res = builder.build_right_shift(v1, v2, false, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I64x2ShrU => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, _)) = state.pop2_extra()?;
let v1 = v128_into_i64x2(builder, intrinsics, v1, i1);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let v2 = v2.into_int_value();
let v2 = builder.build_and(v2, intrinsics.i32_ty.const_int(63, false), "");
let v2 = builder.build_int_z_extend(v2, intrinsics.i64_ty, "");
let v2 = splat_vector(
builder,
intrinsics,
v2.as_basic_value_enum(),
intrinsics.i64x2_ty,
"",
);
let res = builder.build_right_shift(v1, v2, false, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I32Rotl => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
let lhs = builder.build_left_shift(v1, v2, &state.var_name());
let rhs = {
let int_width = intrinsics.i32_ty.const_int(32 as u64, false);
let rhs = builder.build_int_sub(int_width, v2, &state.var_name());
builder.build_right_shift(v1, rhs, false, &state.var_name())
};
let res = builder.build_or(lhs, rhs, &state.var_name());
state.push1(res);
}
Operator::I64Rotl => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
let lhs = builder.build_left_shift(v1, v2, &state.var_name());
let rhs = {
let int_width = intrinsics.i64_ty.const_int(64 as u64, false);
let rhs = builder.build_int_sub(int_width, v2, &state.var_name());
builder.build_right_shift(v1, rhs, false, &state.var_name())
};
let res = builder.build_or(lhs, rhs, &state.var_name());
state.push1(res);
}
Operator::I32Rotr => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
let lhs = builder.build_right_shift(v1, v2, false, &state.var_name());
let rhs = {
let int_width = intrinsics.i32_ty.const_int(32 as u64, false);
let rhs = builder.build_int_sub(int_width, v2, &state.var_name());
builder.build_left_shift(v1, rhs, &state.var_name())
};
let res = builder.build_or(lhs, rhs, &state.var_name());
state.push1(res);
}
Operator::I64Rotr => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
let lhs = builder.build_right_shift(v1, v2, false, &state.var_name());
let rhs = {
let int_width = intrinsics.i64_ty.const_int(64 as u64, false);
let rhs = builder.build_int_sub(int_width, v2, &state.var_name());
builder.build_left_shift(v1, rhs, &state.var_name())
};
let res = builder.build_or(lhs, rhs, &state.var_name());
state.push1(res);
}
Operator::I32Clz => {
let input = state.pop1()?;
The i1 argument is actually named "is_zero_undef" which we want to be false. Fixes the test failures that showed up on mac.
2019-10-08 00:11:59 +00:00
let is_zero_undef = intrinsics.i1_zero.as_basic_value_enum();
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let res = builder
.build_call(
intrinsics.ctlz_i32,
The i1 argument is actually named "is_zero_undef" which we want to be false. Fixes the test failures that showed up on mac.
2019-10-08 00:11:59 +00:00
&[input, is_zero_undef],
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
&state.var_name(),
)
.try_as_basic_value()
.left()
.unwrap();
state.push1(res);
}
Operator::I64Clz => {
let input = state.pop1()?;
The i1 argument is actually named "is_zero_undef" which we want to be false. Fixes the test failures that showed up on mac.
2019-10-08 00:11:59 +00:00
let is_zero_undef = intrinsics.i1_zero.as_basic_value_enum();
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let res = builder
.build_call(
intrinsics.ctlz_i64,
The i1 argument is actually named "is_zero_undef" which we want to be false. Fixes the test failures that showed up on mac.
2019-10-08 00:11:59 +00:00
&[input, is_zero_undef],
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
&state.var_name(),
)
.try_as_basic_value()
.left()
.unwrap();
state.push1(res);
}
Operator::I32Ctz => {
let input = state.pop1()?;
The i1 argument is actually named "is_zero_undef" which we want to be false. Fixes the test failures that showed up on mac.
2019-10-08 00:11:59 +00:00
let is_zero_undef = intrinsics.i1_zero.as_basic_value_enum();
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let res = builder
.build_call(
intrinsics.cttz_i32,
The i1 argument is actually named "is_zero_undef" which we want to be false. Fixes the test failures that showed up on mac.
2019-10-08 00:11:59 +00:00
&[input, is_zero_undef],
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
&state.var_name(),
)
.try_as_basic_value()
.left()
.unwrap();
state.push1(res);
}
Operator::I64Ctz => {
let input = state.pop1()?;
The i1 argument is actually named "is_zero_undef" which we want to be false. Fixes the test failures that showed up on mac.
2019-10-08 00:11:59 +00:00
let is_zero_undef = intrinsics.i1_zero.as_basic_value_enum();
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let res = builder
.build_call(
intrinsics.cttz_i64,
The i1 argument is actually named "is_zero_undef" which we want to be false. Fixes the test failures that showed up on mac.
2019-10-08 00:11:59 +00:00
&[input, is_zero_undef],
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
&state.var_name(),
)
.try_as_basic_value()
.left()
.unwrap();
state.push1(res);
}
Operator::I32Popcnt => {
let input = state.pop1()?;
let res = builder
.build_call(intrinsics.ctpop_i32, &[input], &state.var_name())
.try_as_basic_value()
.left()
.unwrap();
state.push1(res);
}
Operator::I64Popcnt => {
let input = state.pop1()?;
let res = builder
.build_call(intrinsics.ctpop_i64, &[input], &state.var_name())
.try_as_basic_value()
.left()
.unwrap();
state.push1(res);
}
Operator::I32Eqz => {
let input = state.pop1()?.into_int_value();
let cond = builder.build_int_compare(
IntPredicate::EQ,
input,
intrinsics.i32_zero,
&state.var_name(),
);
let res = builder.build_int_z_extend(cond, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Operator::I64Eqz => {
let input = state.pop1()?.into_int_value();
let cond = builder.build_int_compare(
IntPredicate::EQ,
input,
intrinsics.i64_zero,
&state.var_name(),
);
let res = builder.build_int_z_extend(cond, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
/***************************
* Floating-Point Arithmetic instructions.
* https://github.com/sunfishcode/wasm-reference-manual/blob/master/WebAssembly.md#floating-point-arithmetic-instructions
***************************/
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
Operator::F32Add => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
let res = builder.build_float_add(v1, v2, &state.var_name());
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, ExtraInfo::PendingF32NaN);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
Operator::F64Add => {
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let (v1, v2) = state.pop2()?;
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
let res = builder.build_float_add(v1, v2, &state.var_name());
state.push1_extra(res, ExtraInfo::PendingF64NaN);
}
Operator::F32x4Add => {
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_f32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_add(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, ExtraInfo::PendingF32NaN);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
}
Operator::F64x2Add => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f64x2(builder, intrinsics, v1, i1);
let v2 = v128_into_f64x2(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_add(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, ExtraInfo::PendingF64NaN);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
}
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
Operator::F32Sub => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
let res = builder.build_float_sub(v1, v2, &state.var_name());
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, ExtraInfo::PendingF32NaN);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
Operator::F64Sub => {
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let (v1, v2) = state.pop2()?;
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
let res = builder.build_float_sub(v1, v2, &state.var_name());
state.push1_extra(res, ExtraInfo::PendingF64NaN);
}
Operator::F32x4Sub => {
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_f32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_sub(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, ExtraInfo::PendingF32NaN);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
}
Operator::F64x2Sub => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f64x2(builder, intrinsics, v1, i1);
let v2 = v128_into_f64x2(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_sub(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, ExtraInfo::PendingF64NaN);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
}
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
Operator::F32Mul => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
let res = builder.build_float_mul(v1, v2, &state.var_name());
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, ExtraInfo::PendingF32NaN);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
Operator::F64Mul => {
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let (v1, v2) = state.pop2()?;
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
let res = builder.build_float_mul(v1, v2, &state.var_name());
state.push1_extra(res, ExtraInfo::PendingF64NaN);
}
Operator::F32x4Mul => {
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_f32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_mul(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, ExtraInfo::PendingF32NaN);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
}
Operator::F64x2Mul => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f64x2(builder, intrinsics, v1, i1);
let v2 = v128_into_f64x2(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_mul(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, ExtraInfo::PendingF64NaN);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
}
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
Operator::F32Div => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
let res = builder.build_float_div(v1, v2, &state.var_name());
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, ExtraInfo::PendingF32NaN);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
Operator::F64Div => {
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let (v1, v2) = state.pop2()?;
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
let res = builder.build_float_div(v1, v2, &state.var_name());
state.push1_extra(res, ExtraInfo::PendingF64NaN);
}
Operator::F32x4Div => {
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_f32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_div(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, ExtraInfo::PendingF32NaN);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
}
Operator::F64x2Div => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f64x2(builder, intrinsics, v1, i1);
let v2 = v128_into_f64x2(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_div(v1, v2, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, ExtraInfo::PendingF64NaN);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::F32Sqrt => {
let input = state.pop1()?;
let res = builder
.build_call(intrinsics.sqrt_f32, &[input], &state.var_name())
.try_as_basic_value()
.left()
.unwrap();
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, ExtraInfo::PendingF32NaN);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Operator::F64Sqrt => {
let input = state.pop1()?;
let res = builder
.build_call(intrinsics.sqrt_f64, &[input], &state.var_name())
.try_as_basic_value()
.left()
.unwrap();
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, ExtraInfo::PendingF64NaN);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::F32x4Sqrt => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = v128_into_f32x4(builder, intrinsics, v, i);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
.build_call(
intrinsics.sqrt_f32x4,
&[v.as_basic_value_enum()],
&state.var_name(),
)
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
.try_as_basic_value()
.left()
.unwrap();
let bits = builder.build_bitcast(res, intrinsics.i128_ty, "bits");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(bits, ExtraInfo::PendingF32NaN);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
}
Operator::F64x2Sqrt => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = v128_into_f64x2(builder, intrinsics, v, i);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
.build_call(
intrinsics.sqrt_f64x2,
&[v.as_basic_value_enum()],
&state.var_name(),
)
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
.try_as_basic_value()
.left()
.unwrap();
let bits = builder.build_bitcast(res, intrinsics.i128_ty, "bits");
state.push1(bits);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::F32Min => {
Add a comment explaining why we don't use the intrinsics for these.
2019-10-04 18:50:11 +00:00
// This implements the same logic as LLVM's @llvm.minimum
Fix repeated typo in comment.
2019-10-18 23:34:45 +00:00
// intrinsic would, but x86 lowering of that intrinsic
Add a comment explaining why we don't use the intrinsics for these.
2019-10-04 18:50:11 +00:00
// encounters a fatal error in LLVM 8 and LLVM 9.
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let (v1, v2) = state.pop2()?;
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// To detect min(-0.0, 0.0), we check whether the integer
// representations are equal. There's one other case where that
// can happen: non-canonical NaNs. Here we unconditionally
// canonicalize the NaNs.
Rewrite Min/Max to handle all cases correctly. Fixes 545 spectest failures.
2019-10-04 01:19:12 +00:00
let v1 = canonicalize_nans(builder, intrinsics, v1);
let v2 = canonicalize_nans(builder, intrinsics, v2);
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
Rewrite Min/Max to handle all cases correctly. Fixes 545 spectest failures.
2019-10-04 01:19:12 +00:00
let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
let v1_is_nan = builder.build_float_compare(
FloatPredicate::UNO,
v1,
intrinsics.f32_zero,
"nan",
);
let v2_is_not_nan = builder.build_float_compare(
FloatPredicate::ORD,
v2,
intrinsics.f32_zero,
"notnan",
);
let v1_repr = builder
.build_bitcast(v1, intrinsics.i32_ty, "")
.into_int_value();
let v2_repr = builder
.build_bitcast(v2, intrinsics.i32_ty, "")
.into_int_value();
let repr_ne = builder.build_int_compare(IntPredicate::NE, v1_repr, v2_repr, "");
let float_eq = builder.build_float_compare(FloatPredicate::OEQ, v1, v2, "");
let min_cmp = builder.build_float_compare(FloatPredicate::OLT, v1, v2, "");
let negative_zero = intrinsics.f32_ty.const_float(-0.0);
let v2 = builder
.build_select(
builder.build_and(
builder.build_and(float_eq, repr_ne, ""),
v2_is_not_nan,
"",
),
negative_zero,
v2,
"",
)
.into_float_value();
let res =
builder.build_select(builder.build_or(v1_is_nan, min_cmp, ""), v1, v2, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// Because inputs were canonicalized, we always produce
// canonical NaN outputs. No pending NaN cleanup.
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(res);
}
Operator::F64Min => {
Add a comment explaining why we don't use the intrinsics for these.
2019-10-04 18:50:11 +00:00
// This implements the same logic as LLVM's @llvm.minimum
Fix repeated typo in comment.
2019-10-18 23:34:45 +00:00
// intrinsic would, but x86 lowering of that intrinsic
Add a comment explaining why we don't use the intrinsics for these.
2019-10-04 18:50:11 +00:00
// encounters a fatal error in LLVM 8 and LLVM 9.
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let (v1, v2) = state.pop2()?;
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// To detect min(-0.0, 0.0), we check whether the integer
// representations are equal. There's one other case where that
// can happen: non-canonical NaNs. Here we unconditionally
// canonicalize the NaNs.
Rewrite Min/Max to handle all cases correctly. Fixes 545 spectest failures.
2019-10-04 01:19:12 +00:00
let v1 = canonicalize_nans(builder, intrinsics, v1);
let v2 = canonicalize_nans(builder, intrinsics, v2);
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
Rewrite Min/Max to handle all cases correctly. Fixes 545 spectest failures.
2019-10-04 01:19:12 +00:00
let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
let v1_is_nan = builder.build_float_compare(
FloatPredicate::UNO,
v1,
intrinsics.f64_zero,
"nan",
);
let v2_is_not_nan = builder.build_float_compare(
FloatPredicate::ORD,
v2,
intrinsics.f64_zero,
"notnan",
);
let v1_repr = builder
.build_bitcast(v1, intrinsics.i64_ty, "")
.into_int_value();
let v2_repr = builder
.build_bitcast(v2, intrinsics.i64_ty, "")
.into_int_value();
let repr_ne = builder.build_int_compare(IntPredicate::NE, v1_repr, v2_repr, "");
let float_eq = builder.build_float_compare(FloatPredicate::OEQ, v1, v2, "");
let min_cmp = builder.build_float_compare(FloatPredicate::OLT, v1, v2, "");
let negative_zero = intrinsics.f64_ty.const_float(-0.0);
let v2 = builder
.build_select(
builder.build_and(
builder.build_and(float_eq, repr_ne, ""),
v2_is_not_nan,
"",
),
negative_zero,
v2,
"",
)
.into_float_value();
let res =
builder.build_select(builder.build_or(v1_is_nan, min_cmp, ""), v1, v2, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// Because inputs were canonicalized, we always produce
// canonical NaN outputs. No pending NaN cleanup.
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::F32x4Min => {
Add a comment explaining why we don't use the intrinsics for these.
2019-10-04 18:50:11 +00:00
// This implements the same logic as LLVM's @llvm.minimum
Fix repeated typo in comment.
2019-10-18 23:34:45 +00:00
// intrinsic would, but x86 lowering of that intrinsic
Add a comment explaining why we don't use the intrinsics for these.
2019-10-04 18:50:11 +00:00
// encounters a fatal error in LLVM 8 and LLVM 9.
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_f32x4(builder, intrinsics, v2, i2);
// To detect min(-0.0, 0.0), we check whether the integer
// representations are equal. There's one other case where that
// can happen: non-canonical NaNs. Here we unconditionally
// canonicalize the NaNs. Note that this is a different
// canonicalization from that which may be performed in the
// v128_into_f32x4 function. That may canonicalize as F64x2 if
// previous computations may have emitted F64x2 NaNs.
let v1 = canonicalize_nans(builder, intrinsics, v1.as_basic_value_enum());
let v2 = canonicalize_nans(builder, intrinsics, v2.as_basic_value_enum());
Rewrite Min/Max to handle all cases correctly. Fixes 545 spectest failures.
2019-10-04 01:19:12 +00:00
let (v1, v2) = (v1.into_vector_value(), v2.into_vector_value());
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
Rewrite Min/Max to handle all cases correctly. Fixes 545 spectest failures.
2019-10-04 01:19:12 +00:00
let v1_is_nan = builder.build_float_compare(
FloatPredicate::UNO,
v1,
intrinsics.f32x4_zero,
"nan",
);
let v2_is_not_nan = builder.build_float_compare(
FloatPredicate::ORD,
v2,
intrinsics.f32x4_zero,
"notnan",
);
let v1_repr = builder
.build_bitcast(v1, intrinsics.i32x4_ty, "")
.into_vector_value();
let v2_repr = builder
.build_bitcast(v2, intrinsics.i32x4_ty, "")
.into_vector_value();
let repr_ne = builder.build_int_compare(IntPredicate::NE, v1_repr, v2_repr, "");
let float_eq = builder.build_float_compare(FloatPredicate::OEQ, v1, v2, "");
let min_cmp = builder.build_float_compare(FloatPredicate::OLT, v1, v2, "");
let negative_zero = splat_vector(
builder,
intrinsics,
intrinsics.f32_ty.const_float(-0.0).as_basic_value_enum(),
intrinsics.f32x4_ty,
"",
);
let v2 = builder
.build_select(
builder.build_and(
builder.build_and(float_eq, repr_ne, ""),
v2_is_not_nan,
"",
),
negative_zero,
v2,
"",
)
.into_vector_value();
let res =
builder.build_select(builder.build_or(v1_is_nan, min_cmp, ""), v1, v2, "");
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// Because inputs were canonicalized, we always produce
// canonical NaN outputs. No pending NaN cleanup.
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
state.push1(res);
}
Operator::F64x2Min => {
Add a comment explaining why we don't use the intrinsics for these.
2019-10-04 18:50:11 +00:00
// This implements the same logic as LLVM's @llvm.minimum
Fix repeated typo in comment.
2019-10-18 23:34:45 +00:00
// intrinsic would, but x86 lowering of that intrinsic
Add a comment explaining why we don't use the intrinsics for these.
2019-10-04 18:50:11 +00:00
// encounters a fatal error in LLVM 8 and LLVM 9.
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f64x2(builder, intrinsics, v1, i1);
let v2 = v128_into_f64x2(builder, intrinsics, v2, i2);
// To detect min(-0.0, 0.0), we check whether the integer
// representations are equal. There's one other case where that
// can happen: non-canonical NaNs. Here we unconditionally
// canonicalize the NaNs. Note that this is a different
// canonicalization from that which may be performed in the
// v128_into_f32x4 function. That may canonicalize as F64x2 if
// previous computations may have emitted F64x2 NaNs.
let v1 = canonicalize_nans(builder, intrinsics, v1.as_basic_value_enum());
let v2 = canonicalize_nans(builder, intrinsics, v2.as_basic_value_enum());
Rewrite Min/Max to handle all cases correctly. Fixes 545 spectest failures.
2019-10-04 01:19:12 +00:00
let (v1, v2) = (v1.into_vector_value(), v2.into_vector_value());
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
Rewrite Min/Max to handle all cases correctly. Fixes 545 spectest failures.
2019-10-04 01:19:12 +00:00
let v1_is_nan = builder.build_float_compare(
FloatPredicate::UNO,
v1,
intrinsics.f64x2_zero,
"nan",
);
let v2_is_not_nan = builder.build_float_compare(
FloatPredicate::ORD,
v2,
intrinsics.f64x2_zero,
"notnan",
);
let v1_repr = builder
.build_bitcast(v1, intrinsics.i64x2_ty, "")
.into_vector_value();
let v2_repr = builder
.build_bitcast(v2, intrinsics.i64x2_ty, "")
.into_vector_value();
let repr_ne = builder.build_int_compare(IntPredicate::NE, v1_repr, v2_repr, "");
let float_eq = builder.build_float_compare(FloatPredicate::OEQ, v1, v2, "");
let min_cmp = builder.build_float_compare(FloatPredicate::OLT, v1, v2, "");
let negative_zero = splat_vector(
builder,
intrinsics,
intrinsics.f64_ty.const_float(-0.0).as_basic_value_enum(),
intrinsics.f64x2_ty,
"",
);
let v2 = builder
.build_select(
builder.build_and(
builder.build_and(float_eq, repr_ne, ""),
v2_is_not_nan,
"",
),
negative_zero,
v2,
"",
)
.into_vector_value();
let res =
builder.build_select(builder.build_or(v1_is_nan, min_cmp, ""), v1, v2, "");
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// Because inputs were canonicalized, we always produce
// canonical NaN outputs. No pending NaN cleanup.
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::F32Max => {
Add a comment explaining why we don't use the intrinsics for these.
2019-10-04 18:50:11 +00:00
// This implements the same logic as LLVM's @llvm.maximum
Fix repeated typo in comment.
2019-10-18 23:34:45 +00:00
// intrinsic would, but x86 lowering of that intrinsic
Add a comment explaining why we don't use the intrinsics for these.
2019-10-04 18:50:11 +00:00
// encounters a fatal error in LLVM 8 and LLVM 9.
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let (v1, v2) = state.pop2()?;
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// To detect min(-0.0, 0.0), we check whether the integer
// representations are equal. There's one other case where that
// can happen: non-canonical NaNs. Here we unconditionally
// canonicalize the NaNs.
Rewrite Min/Max to handle all cases correctly. Fixes 545 spectest failures.
2019-10-04 01:19:12 +00:00
let v1 = canonicalize_nans(builder, intrinsics, v1);
let v2 = canonicalize_nans(builder, intrinsics, v2);
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
Rewrite Min/Max to handle all cases correctly. Fixes 545 spectest failures.
2019-10-04 01:19:12 +00:00
let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
let v1_is_nan = builder.build_float_compare(
FloatPredicate::UNO,
v1,
intrinsics.f32_zero,
"nan",
);
let v2_is_not_nan = builder.build_float_compare(
FloatPredicate::ORD,
v2,
intrinsics.f32_zero,
"notnan",
);
let v1_repr = builder
.build_bitcast(v1, intrinsics.i32_ty, "")
.into_int_value();
let v2_repr = builder
.build_bitcast(v2, intrinsics.i32_ty, "")
.into_int_value();
let repr_ne = builder.build_int_compare(IntPredicate::NE, v1_repr, v2_repr, "");
let float_eq = builder.build_float_compare(FloatPredicate::OEQ, v1, v2, "");
let min_cmp = builder.build_float_compare(FloatPredicate::OGT, v1, v2, "");
let v2 = builder
.build_select(
builder.build_and(
builder.build_and(float_eq, repr_ne, ""),
v2_is_not_nan,
"",
),
intrinsics.f32_zero,
v2,
"",
)
.into_float_value();
let res =
builder.build_select(builder.build_or(v1_is_nan, min_cmp, ""), v1, v2, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// Because inputs were canonicalized, we always produce
// canonical NaN outputs. No pending NaN cleanup.
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(res);
}
Operator::F64Max => {
Add a comment explaining why we don't use the intrinsics for these.
2019-10-04 18:50:11 +00:00
// This implements the same logic as LLVM's @llvm.maximum
Fix repeated typo in comment.
2019-10-18 23:34:45 +00:00
// intrinsic would, but x86 lowering of that intrinsic
Add a comment explaining why we don't use the intrinsics for these.
2019-10-04 18:50:11 +00:00
// encounters a fatal error in LLVM 8 and LLVM 9.
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let (v1, v2) = state.pop2()?;
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// To detect min(-0.0, 0.0), we check whether the integer
// representations are equal. There's one other case where that
// can happen: non-canonical NaNs. Here we unconditionally
// canonicalize the NaNs.
Rewrite Min/Max to handle all cases correctly. Fixes 545 spectest failures.
2019-10-04 01:19:12 +00:00
let v1 = canonicalize_nans(builder, intrinsics, v1);
let v2 = canonicalize_nans(builder, intrinsics, v2);
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
Rewrite Min/Max to handle all cases correctly. Fixes 545 spectest failures.
2019-10-04 01:19:12 +00:00
let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
let v1_is_nan = builder.build_float_compare(
FloatPredicate::UNO,
v1,
intrinsics.f64_zero,
"nan",
);
let v2_is_not_nan = builder.build_float_compare(
FloatPredicate::ORD,
v2,
intrinsics.f64_zero,
"notnan",
);
let v1_repr = builder
.build_bitcast(v1, intrinsics.i64_ty, "")
.into_int_value();
let v2_repr = builder
.build_bitcast(v2, intrinsics.i64_ty, "")
.into_int_value();
let repr_ne = builder.build_int_compare(IntPredicate::NE, v1_repr, v2_repr, "");
let float_eq = builder.build_float_compare(FloatPredicate::OEQ, v1, v2, "");
let min_cmp = builder.build_float_compare(FloatPredicate::OGT, v1, v2, "");
let v2 = builder
.build_select(
builder.build_and(
builder.build_and(float_eq, repr_ne, ""),
v2_is_not_nan,
"",
),
intrinsics.f64_zero,
v2,
"",
)
.into_float_value();
let res =
builder.build_select(builder.build_or(v1_is_nan, min_cmp, ""), v1, v2, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// Because inputs were canonicalized, we always produce
// canonical NaN outputs. No pending NaN cleanup.
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::F32x4Max => {
Add a comment explaining why we don't use the intrinsics for these.
2019-10-04 18:50:11 +00:00
// This implements the same logic as LLVM's @llvm.maximum
Fix repeated typo in comment.
2019-10-18 23:34:45 +00:00
// intrinsic would, but x86 lowering of that intrinsic
Add a comment explaining why we don't use the intrinsics for these.
2019-10-04 18:50:11 +00:00
// encounters a fatal error in LLVM 8 and LLVM 9.
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_f32x4(builder, intrinsics, v2, i2);
// To detect min(-0.0, 0.0), we check whether the integer
// representations are equal. There's one other case where that
// can happen: non-canonical NaNs. Here we unconditionally
// canonicalize the NaNs. Note that this is a different
// canonicalization from that which may be performed in the
// v128_into_f32x4 function. That may canonicalize as F64x2 if
// previous computations may have emitted F64x2 NaNs.
let v1 = canonicalize_nans(builder, intrinsics, v1.as_basic_value_enum());
let v2 = canonicalize_nans(builder, intrinsics, v2.as_basic_value_enum());
Rewrite Min/Max to handle all cases correctly. Fixes 545 spectest failures.
2019-10-04 01:19:12 +00:00
let (v1, v2) = (v1.into_vector_value(), v2.into_vector_value());
let v1_is_nan = builder.build_float_compare(
FloatPredicate::UNO,
v1,
intrinsics.f32x4_zero,
"nan",
);
let v2_is_not_nan = builder.build_float_compare(
FloatPredicate::ORD,
v2,
intrinsics.f32x4_zero,
"notnan",
);
let v1_repr = builder
.build_bitcast(v1, intrinsics.i32x4_ty, "")
.into_vector_value();
let v2_repr = builder
.build_bitcast(v2, intrinsics.i32x4_ty, "")
.into_vector_value();
let repr_ne = builder.build_int_compare(IntPredicate::NE, v1_repr, v2_repr, "");
let float_eq = builder.build_float_compare(FloatPredicate::OEQ, v1, v2, "");
let min_cmp = builder.build_float_compare(FloatPredicate::OGT, v1, v2, "");
let zero = splat_vector(
builder,
intrinsics,
intrinsics.f32_zero.as_basic_value_enum(),
intrinsics.f32x4_ty,
"",
);
let v2 = builder
.build_select(
builder.build_and(
builder.build_and(float_eq, repr_ne, ""),
v2_is_not_nan,
"",
),
zero,
v2,
"",
)
.into_vector_value();
let res =
builder.build_select(builder.build_or(v1_is_nan, min_cmp, ""), v1, v2, "");
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// Because inputs were canonicalized, we always produce
// canonical NaN outputs. No pending NaN cleanup.
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
state.push1(res);
}
Operator::F64x2Max => {
Add a comment explaining why we don't use the intrinsics for these.
2019-10-04 18:50:11 +00:00
// This implements the same logic as LLVM's @llvm.maximum
Fix repeated typo in comment.
2019-10-18 23:34:45 +00:00
// intrinsic would, but x86 lowering of that intrinsic
Add a comment explaining why we don't use the intrinsics for these.
2019-10-04 18:50:11 +00:00
// encounters a fatal error in LLVM 8 and LLVM 9.
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f64x2(builder, intrinsics, v1, i1);
let v2 = v128_into_f64x2(builder, intrinsics, v2, i2);
// To detect min(-0.0, 0.0), we check whether the integer
// representations are equal. There's one other case where that
// can happen: non-canonical NaNs. Here we unconditionally
// canonicalize the NaNs. Note that this is a different
// canonicalization from that which may be performed in the
// v128_into_f32x4 function. That may canonicalize as F64x2 if
// previous computations may have emitted F64x2 NaNs.
let v1 = canonicalize_nans(builder, intrinsics, v1.as_basic_value_enum());
let v2 = canonicalize_nans(builder, intrinsics, v2.as_basic_value_enum());
Rewrite Min/Max to handle all cases correctly. Fixes 545 spectest failures.
2019-10-04 01:19:12 +00:00
let (v1, v2) = (v1.into_vector_value(), v2.into_vector_value());
let v1_is_nan = builder.build_float_compare(
FloatPredicate::UNO,
v1,
intrinsics.f64x2_zero,
"nan",
);
let v2_is_not_nan = builder.build_float_compare(
FloatPredicate::ORD,
v2,
intrinsics.f64x2_zero,
"notnan",
);
let v1_repr = builder
.build_bitcast(v1, intrinsics.i64x2_ty, "")
.into_vector_value();
let v2_repr = builder
.build_bitcast(v2, intrinsics.i64x2_ty, "")
.into_vector_value();
let repr_ne = builder.build_int_compare(IntPredicate::NE, v1_repr, v2_repr, "");
let float_eq = builder.build_float_compare(FloatPredicate::OEQ, v1, v2, "");
let min_cmp = builder.build_float_compare(FloatPredicate::OGT, v1, v2, "");
let zero = splat_vector(
builder,
intrinsics,
intrinsics.f64_zero.as_basic_value_enum(),
intrinsics.f64x2_ty,
"",
);
let v2 = builder
.build_select(
builder.build_and(
builder.build_and(float_eq, repr_ne, ""),
v2_is_not_nan,
"",
),
zero,
v2,
"",
)
.into_vector_value();
let res =
builder.build_select(builder.build_or(v1_is_nan, min_cmp, ""), v1, v2, "");
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// Because inputs were canonicalized, we always produce
// canonical NaN outputs. No pending NaN cleanup.
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::F32Ceil => {
let input = state.pop1()?;
let res = builder
.build_call(intrinsics.ceil_f32, &[input], &state.var_name())
.try_as_basic_value()
.left()
.unwrap();
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, ExtraInfo::PendingF32NaN);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Operator::F64Ceil => {
let input = state.pop1()?;
let res = builder
.build_call(intrinsics.ceil_f64, &[input], &state.var_name())
.try_as_basic_value()
.left()
.unwrap();
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, ExtraInfo::PendingF64NaN);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Operator::F32Floor => {
let input = state.pop1()?;
let res = builder
.build_call(intrinsics.floor_f32, &[input], &state.var_name())
.try_as_basic_value()
.left()
.unwrap();
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, ExtraInfo::PendingF32NaN);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Operator::F64Floor => {
let input = state.pop1()?;
let res = builder
.build_call(intrinsics.floor_f64, &[input], &state.var_name())
.try_as_basic_value()
.left()
.unwrap();
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, ExtraInfo::PendingF64NaN);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Operator::F32Trunc => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let res = builder
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
.build_call(
intrinsics.trunc_f32,
&[v.as_basic_value_enum()],
&state.var_name(),
)
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
.try_as_basic_value()
.left()
.unwrap();
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, i);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Operator::F64Trunc => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let res = builder
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
.build_call(
intrinsics.trunc_f64,
&[v.as_basic_value_enum()],
&state.var_name(),
)
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
.try_as_basic_value()
.left()
.unwrap();
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, i);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Operator::F32Nearest => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let res = builder
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
.build_call(
intrinsics.nearbyint_f32,
&[v.as_basic_value_enum()],
&state.var_name(),
)
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
.try_as_basic_value()
.left()
.unwrap();
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, i);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Operator::F64Nearest => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let res = builder
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
.build_call(
intrinsics.nearbyint_f64,
&[v.as_basic_value_enum()],
&state.var_name(),
)
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
.try_as_basic_value()
.left()
.unwrap();
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
state.push1_extra(res, i);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Operator::F32Abs => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = apply_pending_canonicalization(builder, intrinsics, v, i);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let res = builder
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
.build_call(
intrinsics.fabs_f32,
&[v.as_basic_value_enum()],
&state.var_name(),
)
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
.try_as_basic_value()
.left()
.unwrap();
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// The exact NaN returned by F32Abs is fully defined. Do not
// adjust.
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(res);
}
Operator::F64Abs => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = apply_pending_canonicalization(builder, intrinsics, v, i);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let res = builder
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
.build_call(
intrinsics.fabs_f64,
&[v.as_basic_value_enum()],
&state.var_name(),
)
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
.try_as_basic_value()
.left()
.unwrap();
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// The exact NaN returned by F64Abs is fully defined. Do not
// adjust.
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::F32x4Abs => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = builder.build_bitcast(v.into_int_value(), intrinsics.f32x4_ty, "");
let v = apply_pending_canonicalization(builder, intrinsics, v, i);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
.build_call(
intrinsics.fabs_f32x4,
&[v.as_basic_value_enum()],
&state.var_name(),
)
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
.try_as_basic_value()
.left()
.unwrap();
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// The exact NaN returned by F32x4Abs is fully defined. Do not
// adjust.
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
state.push1(res);
}
Operator::F64x2Abs => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = builder.build_bitcast(v.into_int_value(), intrinsics.f64x2_ty, "");
let v = apply_pending_canonicalization(builder, intrinsics, v, i);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder
.build_call(intrinsics.fabs_f64x2, &[v], &state.var_name())
.try_as_basic_value()
.left()
.unwrap();
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// The exact NaN returned by F32x4Abs is fully defined. Do not
// adjust.
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
state.push1(res);
}
Operator::F32x4Neg => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = builder.build_bitcast(v.into_int_value(), intrinsics.f32x4_ty, "");
let v =
apply_pending_canonicalization(builder, intrinsics, v, i).into_vector_value();
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_neg(v, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// The exact NaN returned by F32x4Neg is fully defined. Do not
// adjust.
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
state.push1(res);
}
Operator::F64x2Neg => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = builder.build_bitcast(v.into_int_value(), intrinsics.f64x2_ty, "");
let v =
apply_pending_canonicalization(builder, intrinsics, v, i).into_vector_value();
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_neg(v, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// The exact NaN returned by F64x2Neg is fully defined. Do not
// adjust.
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::F32Neg | Operator::F64Neg => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v =
apply_pending_canonicalization(builder, intrinsics, v, i).into_float_value();
let res = builder.build_float_neg(v, &state.var_name());
// The exact NaN returned by F32Neg and F64Neg are fully defined.
// Do not adjust.
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(res);
}
Operator::F32Copysign => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((mag, mag_info), (sgn, sgn_info)) = state.pop2_extra()?;
let mag = apply_pending_canonicalization(builder, intrinsics, mag, mag_info);
let sgn = apply_pending_canonicalization(builder, intrinsics, sgn, sgn_info);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let res = builder
.build_call(intrinsics.copysign_f32, &[mag, sgn], &state.var_name())
.try_as_basic_value()
.left()
.unwrap();
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// The exact NaN returned by F32Copysign is fully defined.
// Do not adjust.
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(res);
}
Operator::F64Copysign => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((mag, mag_info), (sgn, sgn_info)) = state.pop2_extra()?;
let mag = apply_pending_canonicalization(builder, intrinsics, mag, mag_info);
let sgn = apply_pending_canonicalization(builder, intrinsics, sgn, sgn_info);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let res = builder
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
.build_call(intrinsics.copysign_f64, &[mag, sgn], &state.var_name())
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
.try_as_basic_value()
.left()
.unwrap();
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
// The exact NaN returned by F32Copysign is fully defined.
// Do not adjust.
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(res);
}
/***************************
* Integer Comparison instructions.
* https://github.com/sunfishcode/wasm-reference-manual/blob/master/WebAssembly.md#integer-comparison-instructions
***************************/
Operator::I32Eq | Operator::I64Eq => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
let cond = builder.build_int_compare(IntPredicate::EQ, v1, v2, &state.var_name());
let res = builder.build_int_z_extend(cond, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I8x16Eq => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i8x16(builder, intrinsics, v1, i1);
let v2 = v128_into_i8x16(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::EQ, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i8x16_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8Eq => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i16x8(builder, intrinsics, v1, i1);
let v2 = v128_into_i16x8(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::EQ, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i16x8_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I32x4Eq => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_i32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::EQ, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i32x4_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::I32Ne | Operator::I64Ne => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
let cond = builder.build_int_compare(IntPredicate::NE, v1, v2, &state.var_name());
let res = builder.build_int_z_extend(cond, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I8x16Ne => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i8x16(builder, intrinsics, v1, i1);
let v2 = v128_into_i8x16(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::NE, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i8x16_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8Ne => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i16x8(builder, intrinsics, v1, i1);
let v2 = v128_into_i16x8(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::NE, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i16x8_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I32x4Ne => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_i32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::NE, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i32x4_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::I32LtS | Operator::I64LtS => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
let cond = builder.build_int_compare(IntPredicate::SLT, v1, v2, &state.var_name());
let res = builder.build_int_z_extend(cond, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I8x16LtS => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i8x16(builder, intrinsics, v1, i1);
let v2 = v128_into_i8x16(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::SLT, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i8x16_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8LtS => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i16x8(builder, intrinsics, v1, i1);
let v2 = v128_into_i16x8(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::SLT, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i16x8_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I32x4LtS => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_i32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::SLT, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i32x4_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::I32LtU | Operator::I64LtU => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
let cond = builder.build_int_compare(IntPredicate::ULT, v1, v2, &state.var_name());
let res = builder.build_int_z_extend(cond, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I8x16LtU => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i8x16(builder, intrinsics, v1, i1);
let v2 = v128_into_i8x16(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::ULT, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i8x16_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8LtU => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i16x8(builder, intrinsics, v1, i1);
let v2 = v128_into_i16x8(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::ULT, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i16x8_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
Operator::I32x4LtU => {
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_i32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::ULT, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i32x4_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::I32LeS | Operator::I64LeS => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
let cond = builder.build_int_compare(IntPredicate::SLE, v1, v2, &state.var_name());
let res = builder.build_int_z_extend(cond, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I8x16LeS => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i8x16(builder, intrinsics, v1, i1);
let v2 = v128_into_i8x16(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::SLE, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i8x16_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8LeS => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i16x8(builder, intrinsics, v1, i1);
let v2 = v128_into_i16x8(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::SLE, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i16x8_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I32x4LeS => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_i32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::SLE, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i32x4_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::I32LeU | Operator::I64LeU => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
let cond = builder.build_int_compare(IntPredicate::ULE, v1, v2, &state.var_name());
let res = builder.build_int_z_extend(cond, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I8x16LeU => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i8x16(builder, intrinsics, v1, i1);
let v2 = v128_into_i8x16(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::ULE, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i8x16_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8LeU => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i16x8(builder, intrinsics, v1, i1);
let v2 = v128_into_i16x8(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::ULE, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i16x8_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I32x4LeU => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_i32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::ULE, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i32x4_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::I32GtS | Operator::I64GtS => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
let cond = builder.build_int_compare(IntPredicate::SGT, v1, v2, &state.var_name());
let res = builder.build_int_z_extend(cond, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I8x16GtS => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i8x16(builder, intrinsics, v1, i1);
let v2 = v128_into_i8x16(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::SGT, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i8x16_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8GtS => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i16x8(builder, intrinsics, v1, i1);
let v2 = v128_into_i16x8(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::SGT, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i16x8_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I32x4GtS => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_i32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::SGT, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i32x4_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::I32GtU | Operator::I64GtU => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
let cond = builder.build_int_compare(IntPredicate::UGT, v1, v2, &state.var_name());
let res = builder.build_int_z_extend(cond, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I8x16GtU => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i8x16(builder, intrinsics, v1, i1);
let v2 = v128_into_i8x16(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::UGT, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i8x16_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8GtU => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i16x8(builder, intrinsics, v1, i1);
let v2 = v128_into_i16x8(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::UGT, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i16x8_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I32x4GtU => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_i32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::UGT, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i32x4_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::I32GeS | Operator::I64GeS => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
let cond = builder.build_int_compare(IntPredicate::SGE, v1, v2, &state.var_name());
let res = builder.build_int_z_extend(cond, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I8x16GeS => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i8x16(builder, intrinsics, v1, i1);
let v2 = v128_into_i8x16(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::SGE, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i8x16_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8GeS => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i16x8(builder, intrinsics, v1, i1);
let v2 = v128_into_i16x8(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::SGE, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i16x8_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I32x4GeS => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_i32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::SGE, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i32x4_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::I32GeU | Operator::I64GeU => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
let cond = builder.build_int_compare(IntPredicate::UGE, v1, v2, &state.var_name());
let res = builder.build_int_z_extend(cond, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I8x16GeU => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i8x16(builder, intrinsics, v1, i1);
let v2 = v128_into_i8x16(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::UGE, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i8x16_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8GeU => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i16x8(builder, intrinsics, v1, i1);
let v2 = v128_into_i16x8(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::UGE, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i16x8_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I32x4GeU => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_i32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_i32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(IntPredicate::UGE, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i32x4_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
/***************************
* Floating-Point Comparison instructions.
* https://github.com/sunfishcode/wasm-reference-manual/blob/master/WebAssembly.md#floating-point-comparison-instructions
***************************/
Operator::F32Eq | Operator::F64Eq => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
let cond =
builder.build_float_compare(FloatPredicate::OEQ, v1, v2, &state.var_name());
let res = builder.build_int_z_extend(cond, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::F32x4Eq => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_f32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_compare(FloatPredicate::OEQ, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i32x4_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::F64x2Eq => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f64x2(builder, intrinsics, v1, i1);
let v2 = v128_into_f64x2(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_compare(FloatPredicate::OEQ, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i64x2_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::F32Ne | Operator::F64Ne => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
let cond =
builder.build_float_compare(FloatPredicate::UNE, v1, v2, &state.var_name());
let res = builder.build_int_z_extend(cond, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::F32x4Ne => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_f32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_compare(FloatPredicate::UNE, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i32x4_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::F64x2Ne => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f64x2(builder, intrinsics, v1, i1);
let v2 = v128_into_f64x2(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_compare(FloatPredicate::UNE, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i64x2_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::F32Lt | Operator::F64Lt => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
let cond =
builder.build_float_compare(FloatPredicate::OLT, v1, v2, &state.var_name());
let res = builder.build_int_z_extend(cond, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::F32x4Lt => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_f32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_compare(FloatPredicate::OLT, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i32x4_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::F64x2Lt => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f64x2(builder, intrinsics, v1, i1);
let v2 = v128_into_f64x2(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_compare(FloatPredicate::OLT, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i64x2_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::F32Le | Operator::F64Le => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
let cond =
builder.build_float_compare(FloatPredicate::OLE, v1, v2, &state.var_name());
let res = builder.build_int_z_extend(cond, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::F32x4Le => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_f32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_compare(FloatPredicate::OLE, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i32x4_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::F64x2Le => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f64x2(builder, intrinsics, v1, i1);
let v2 = v128_into_f64x2(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_compare(FloatPredicate::OLE, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i64x2_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::F32Gt | Operator::F64Gt => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
let cond =
builder.build_float_compare(FloatPredicate::OGT, v1, v2, &state.var_name());
let res = builder.build_int_z_extend(cond, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::F32x4Gt => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_f32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_compare(FloatPredicate::OGT, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i32x4_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::F64x2Gt => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f64x2(builder, intrinsics, v1, i1);
let v2 = v128_into_f64x2(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_compare(FloatPredicate::OGT, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i64x2_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::F32Ge | Operator::F64Ge => {
let (v1, v2) = state.pop2()?;
let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
let cond =
builder.build_float_compare(FloatPredicate::OGE, v1, v2, &state.var_name());
let res = builder.build_int_z_extend(cond, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::F32x4Ge => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f32x4(builder, intrinsics, v1, i1);
let v2 = v128_into_f32x4(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_compare(FloatPredicate::OGE, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i32x4_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::F64x2Ge => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f64x2(builder, intrinsics, v1, i1);
let v2 = v128_into_f64x2(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_float_compare(FloatPredicate::OGE, v1, v2, "");
let res = builder.build_int_s_extend(res, intrinsics.i64x2_ty, "");
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
/***************************
* Conversion instructions.
* https://github.com/sunfishcode/wasm-reference-manual/blob/master/WebAssembly.md#conversion-instructions
***************************/
Operator::I32WrapI64 => {
let v1 = state.pop1()?.into_int_value();
let res = builder.build_int_truncate(v1, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Operator::I64ExtendSI32 => {
let v1 = state.pop1()?.into_int_value();
let res = builder.build_int_s_extend(v1, intrinsics.i64_ty, &state.var_name());
state.push1(res);
}
Operator::I64ExtendUI32 => {
let v1 = state.pop1()?.into_int_value();
let res = builder.build_int_z_extend(v1, intrinsics.i64_ty, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I32x4TruncSF32x4Sat => {
let v = state.pop1()?.into_int_value();
let res = trunc_sat(
builder,
intrinsics,
intrinsics.f32x4_ty,
intrinsics.i32x4_ty,
Fix bugs in V128 support based on results from testing against simd spec test. These is one test failure remaining with V128 global variables. * Fix trunc_sat. We need both the largest float that can be converted to an int and the largest int, they are not the same number. * Implement calling of functions that take V128 by passing in two i64's. * Improve support for V128 in spectests. Parse binary modules with the same features as the outer spectest. Fix compilation error involving Result in emitted .rs file. Handle V128 in more cases when producing .rs file. Parse the wast script with SIMD enabled. * Adjust the WAVM spectest so that it parses with WABT and mostly passes with wasmer. Wabt is particular about ints not having decimal places and floats having decimal places. Wasmer does not support mutable globals or shared memory. Tests of shuffles are disabled. Some assert_invalid tests that wabt won't even parse are disabled.
2019-07-18 19:52:59 +00:00
-2147480000i32 as u32 as u64,
2147480000,
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
std::i32::MIN as u64,
std::i32::MAX as u64,
v,
&state.var_name(),
);
state.push1(res);
}
Operator::I32x4TruncUF32x4Sat => {
let v = state.pop1()?.into_int_value();
let res = trunc_sat(
builder,
intrinsics,
intrinsics.f32x4_ty,
intrinsics.i32x4_ty,
Fix bugs in V128 support based on results from testing against simd spec test. These is one test failure remaining with V128 global variables. * Fix trunc_sat. We need both the largest float that can be converted to an int and the largest int, they are not the same number. * Implement calling of functions that take V128 by passing in two i64's. * Improve support for V128 in spectests. Parse binary modules with the same features as the outer spectest. Fix compilation error involving Result in emitted .rs file. Handle V128 in more cases when producing .rs file. Parse the wast script with SIMD enabled. * Adjust the WAVM spectest so that it parses with WABT and mostly passes with wasmer. Wabt is particular about ints not having decimal places and floats having decimal places. Wasmer does not support mutable globals or shared memory. Tests of shuffles are disabled. Some assert_invalid tests that wabt won't even parse are disabled.
2019-07-18 19:52:59 +00:00
0,
4294960000,
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
std::u32::MIN as u64,
std::u32::MAX as u64,
v,
&state.var_name(),
);
state.push1(res);
}
Operator::I64x2TruncSF64x2Sat => {
let v = state.pop1()?.into_int_value();
let res = trunc_sat(
builder,
intrinsics,
intrinsics.f64x2_ty,
intrinsics.i64x2_ty,
std::i64::MIN as u64,
std::i64::MAX as u64,
Fix bugs in V128 support based on results from testing against simd spec test. These is one test failure remaining with V128 global variables. * Fix trunc_sat. We need both the largest float that can be converted to an int and the largest int, they are not the same number. * Implement calling of functions that take V128 by passing in two i64's. * Improve support for V128 in spectests. Parse binary modules with the same features as the outer spectest. Fix compilation error involving Result in emitted .rs file. Handle V128 in more cases when producing .rs file. Parse the wast script with SIMD enabled. * Adjust the WAVM spectest so that it parses with WABT and mostly passes with wasmer. Wabt is particular about ints not having decimal places and floats having decimal places. Wasmer does not support mutable globals or shared memory. Tests of shuffles are disabled. Some assert_invalid tests that wabt won't even parse are disabled.
2019-07-18 19:52:59 +00:00
std::i64::MIN as u64,
std::i64::MAX as u64,
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
v,
&state.var_name(),
);
state.push1(res);
}
Operator::I64x2TruncUF64x2Sat => {
let v = state.pop1()?.into_int_value();
let res = trunc_sat(
builder,
intrinsics,
intrinsics.f64x2_ty,
intrinsics.i64x2_ty,
std::u64::MIN,
std::u64::MAX,
Fix bugs in V128 support based on results from testing against simd spec test. These is one test failure remaining with V128 global variables. * Fix trunc_sat. We need both the largest float that can be converted to an int and the largest int, they are not the same number. * Implement calling of functions that take V128 by passing in two i64's. * Improve support for V128 in spectests. Parse binary modules with the same features as the outer spectest. Fix compilation error involving Result in emitted .rs file. Handle V128 in more cases when producing .rs file. Parse the wast script with SIMD enabled. * Adjust the WAVM spectest so that it parses with WABT and mostly passes with wasmer. Wabt is particular about ints not having decimal places and floats having decimal places. Wasmer does not support mutable globals or shared memory. Tests of shuffles are disabled. Some assert_invalid tests that wabt won't even parse are disabled.
2019-07-18 19:52:59 +00:00
std::u64::MIN,
std::u64::MAX,
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
v,
&state.var_name(),
);
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::I32TruncSF32 => {
let v1 = state.pop1()?.into_float_value();
Simplify trap_if_not_representable_as_int. Fix typo in function name. Use two fcmp instructions instead of unpacking the bits of the IEEE float and using integer arithmetic to determine details about its value.
2019-07-11 23:24:09 +00:00
trap_if_not_representable_as_int(
Fix the Trunc[SU] operations, makes conversions.wast pass.
2019-07-29 22:01:00 +00:00
builder, intrinsics, context, &function, 0xcf000000, // -2147483600.0
0x4effffff, // 2147483500.0
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
v1,
);
let res =
builder.build_float_to_signed_int(v1, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Operator::I32TruncSF64 => {
let v1 = state.pop1()?.into_float_value();
Simplify trap_if_not_representable_as_int. Fix typo in function name. Use two fcmp instructions instead of unpacking the bits of the IEEE float and using integer arithmetic to determine details about its value.
2019-07-11 23:24:09 +00:00
trap_if_not_representable_as_int(
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
builder,
intrinsics,
context,
&function,
Fix the Trunc[SU] operations, makes conversions.wast pass.
2019-07-29 22:01:00 +00:00
0xc1e00000001fffff, // -2147483648.9999995
0x41dfffffffffffff, // 2147483647.9999998
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
v1,
);
let res =
builder.build_float_to_signed_int(v1, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Operator::I32TruncSSatF32 | Operator::I32TruncSSatF64 => {
let v1 = state.pop1()?.into_float_value();
let res =
builder.build_float_to_signed_int(v1, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Operator::I64TruncSF32 => {
let v1 = state.pop1()?.into_float_value();
Simplify trap_if_not_representable_as_int. Fix typo in function name. Use two fcmp instructions instead of unpacking the bits of the IEEE float and using integer arithmetic to determine details about its value.
2019-07-11 23:24:09 +00:00
trap_if_not_representable_as_int(
Fix the Trunc[SU] operations, makes conversions.wast pass.
2019-07-29 22:01:00 +00:00
builder, intrinsics, context, &function,
0xdf000000, // -9223372000000000000.0
0x5effffff, // 9223371500000000000.0
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
v1,
);
let res =
builder.build_float_to_signed_int(v1, intrinsics.i64_ty, &state.var_name());
state.push1(res);
}
Operator::I64TruncSF64 => {
let v1 = state.pop1()?.into_float_value();
Simplify trap_if_not_representable_as_int. Fix typo in function name. Use two fcmp instructions instead of unpacking the bits of the IEEE float and using integer arithmetic to determine details about its value.
2019-07-11 23:24:09 +00:00
trap_if_not_representable_as_int(
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
builder,
intrinsics,
context,
&function,
Fix the Trunc[SU] operations, makes conversions.wast pass.
2019-07-29 22:01:00 +00:00
0xc3e0000000000000, // -9223372036854776000.0
0x43dfffffffffffff, // 9223372036854775000.0
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
v1,
);
let res =
builder.build_float_to_signed_int(v1, intrinsics.i64_ty, &state.var_name());
state.push1(res);
}
Operator::I64TruncSSatF32 | Operator::I64TruncSSatF64 => {
let v1 = state.pop1()?.into_float_value();
let res =
builder.build_float_to_signed_int(v1, intrinsics.i64_ty, &state.var_name());
state.push1(res);
}
Operator::I32TruncUF32 => {
let v1 = state.pop1()?.into_float_value();
Simplify trap_if_not_representable_as_int. Fix typo in function name. Use two fcmp instructions instead of unpacking the bits of the IEEE float and using integer arithmetic to determine details about its value.
2019-07-11 23:24:09 +00:00
trap_if_not_representable_as_int(
Fix the Trunc[SU] operations, makes conversions.wast pass.
2019-07-29 22:01:00 +00:00
builder, intrinsics, context, &function, 0xbf7fffff, // -0.99999994
0x4f7fffff, // 4294967000.0
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
v1,
);
let res =
builder.build_float_to_unsigned_int(v1, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Operator::I32TruncUF64 => {
let v1 = state.pop1()?.into_float_value();
Simplify trap_if_not_representable_as_int. Fix typo in function name. Use two fcmp instructions instead of unpacking the bits of the IEEE float and using integer arithmetic to determine details about its value.
2019-07-11 23:24:09 +00:00
trap_if_not_representable_as_int(
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
builder,
intrinsics,
context,
&function,
Fix the Trunc[SU] operations, makes conversions.wast pass.
2019-07-29 22:01:00 +00:00
0xbfefffffffffffff, // -0.9999999999999999
0x41efffffffffffff, // 4294967295.9999995
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
v1,
);
let res =
builder.build_float_to_unsigned_int(v1, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Operator::I32TruncUSatF32 | Operator::I32TruncUSatF64 => {
let v1 = state.pop1()?.into_float_value();
let res =
builder.build_float_to_unsigned_int(v1, intrinsics.i32_ty, &state.var_name());
state.push1(res);
}
Operator::I64TruncUF32 => {
let v1 = state.pop1()?.into_float_value();
Simplify trap_if_not_representable_as_int. Fix typo in function name. Use two fcmp instructions instead of unpacking the bits of the IEEE float and using integer arithmetic to determine details about its value.
2019-07-11 23:24:09 +00:00
trap_if_not_representable_as_int(
Fix the Trunc[SU] operations, makes conversions.wast pass.
2019-07-29 22:01:00 +00:00
builder, intrinsics, context, &function, 0xbf7fffff, // -0.99999994
0x5f7fffff, // 18446743000000000000.0
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
v1,
);
let res =
builder.build_float_to_unsigned_int(v1, intrinsics.i64_ty, &state.var_name());
state.push1(res);
}
Operator::I64TruncUF64 => {
let v1 = state.pop1()?.into_float_value();
Simplify trap_if_not_representable_as_int. Fix typo in function name. Use two fcmp instructions instead of unpacking the bits of the IEEE float and using integer arithmetic to determine details about its value.
2019-07-11 23:24:09 +00:00
trap_if_not_representable_as_int(
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
builder,
intrinsics,
context,
&function,
Fix the Trunc[SU] operations, makes conversions.wast pass.
2019-07-29 22:01:00 +00:00
0xbfefffffffffffff, // -0.9999999999999999
0x43efffffffffffff, // 18446744073709550000.0
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
v1,
);
let res =
builder.build_float_to_unsigned_int(v1, intrinsics.i64_ty, &state.var_name());
state.push1(res);
}
Operator::I64TruncUSatF32 | Operator::I64TruncUSatF64 => {
let v1 = state.pop1()?.into_float_value();
let res =
builder.build_float_to_unsigned_int(v1, intrinsics.i64_ty, &state.var_name());
state.push1(res);
}
Operator::F32DemoteF64 => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let v = state.pop1()?;
let v = v.into_float_value();
let res = builder.build_float_trunc(v, intrinsics.f32_ty, &state.var_name());
state.push1_extra(res, ExtraInfo::PendingF32NaN);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Operator::F64PromoteF32 => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let v = state.pop1()?;
let v = v.into_float_value();
let res = builder.build_float_ext(v, intrinsics.f64_ty, &state.var_name());
state.push1_extra(res, ExtraInfo::PendingF64NaN);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Operator::F32ConvertSI32 | Operator::F32ConvertSI64 => {
let v1 = state.pop1()?.into_int_value();
let res =
builder.build_signed_int_to_float(v1, intrinsics.f32_ty, &state.var_name());
state.push1(res);
}
Operator::F64ConvertSI32 | Operator::F64ConvertSI64 => {
let v1 = state.pop1()?.into_int_value();
let res =
builder.build_signed_int_to_float(v1, intrinsics.f64_ty, &state.var_name());
state.push1(res);
}
Operator::F32ConvertUI32 | Operator::F32ConvertUI64 => {
let v1 = state.pop1()?.into_int_value();
let res =
builder.build_unsigned_int_to_float(v1, intrinsics.f32_ty, &state.var_name());
state.push1(res);
}
Operator::F64ConvertUI32 | Operator::F64ConvertUI64 => {
let v1 = state.pop1()?.into_int_value();
let res =
builder.build_unsigned_int_to_float(v1, intrinsics.f64_ty, &state.var_name());
state.push1(res);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::F32x4ConvertSI32x4 => {
let v = state.pop1()?;
let v = builder
.build_bitcast(v, intrinsics.i32x4_ty, "")
.into_vector_value();
let res =
builder.build_signed_int_to_float(v, intrinsics.f32x4_ty, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::F32x4ConvertUI32x4 => {
let v = state.pop1()?;
let v = builder
.build_bitcast(v, intrinsics.i32x4_ty, "")
.into_vector_value();
let res =
builder.build_unsigned_int_to_float(v, intrinsics.f32x4_ty, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::F64x2ConvertSI64x2 => {
let v = state.pop1()?;
let v = builder
.build_bitcast(v, intrinsics.i64x2_ty, "")
.into_vector_value();
let res =
builder.build_signed_int_to_float(v, intrinsics.f64x2_ty, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::F64x2ConvertUI64x2 => {
let v = state.pop1()?;
let v = builder
.build_bitcast(v, intrinsics.i64x2_ty, "")
.into_vector_value();
let res =
builder.build_unsigned_int_to_float(v, intrinsics.f64x2_ty, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::I32ReinterpretF32 => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = apply_pending_canonicalization(builder, intrinsics, v, i);
Use bitcast instead of alloca+load+ptrcast+store sequence.
2019-07-10 17:24:14 +00:00
let ret = builder.build_bitcast(v, intrinsics.i32_ty, &state.var_name());
state.push1(ret);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Operator::I64ReinterpretF64 => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = apply_pending_canonicalization(builder, intrinsics, v, i);
Use bitcast instead of alloca+load+ptrcast+store sequence.
2019-07-10 17:24:14 +00:00
let ret = builder.build_bitcast(v, intrinsics.i64_ty, &state.var_name());
state.push1(ret);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Operator::F32ReinterpretI32 => {
let v = state.pop1()?;
Use bitcast instead of alloca+load+ptrcast+store sequence.
2019-07-10 17:24:14 +00:00
let ret = builder.build_bitcast(v, intrinsics.f32_ty, &state.var_name());
state.push1(ret);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Operator::F64ReinterpretI64 => {
let v = state.pop1()?;
Use bitcast instead of alloca+load+ptrcast+store sequence.
2019-07-10 17:24:14 +00:00
let ret = builder.build_bitcast(v, intrinsics.f64_ty, &state.var_name());
state.push1(ret);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
/***************************
* Sign-extension operators.
* https://github.com/WebAssembly/sign-extension-ops/blob/master/proposals/sign-extension-ops/Overview.md
***************************/
Operator::I32Extend8S => {
let value = state.pop1()?.into_int_value();
let narrow_value =
builder.build_int_truncate(value, intrinsics.i8_ty, &state.var_name());
let extended_value =
builder.build_int_s_extend(narrow_value, intrinsics.i32_ty, &state.var_name());
state.push1(extended_value);
}
Operator::I32Extend16S => {
let value = state.pop1()?.into_int_value();
let narrow_value =
builder.build_int_truncate(value, intrinsics.i16_ty, &state.var_name());
let extended_value =
builder.build_int_s_extend(narrow_value, intrinsics.i32_ty, &state.var_name());
state.push1(extended_value);
}
Operator::I64Extend8S => {
let value = state.pop1()?.into_int_value();
let narrow_value =
builder.build_int_truncate(value, intrinsics.i8_ty, &state.var_name());
let extended_value =
builder.build_int_s_extend(narrow_value, intrinsics.i64_ty, &state.var_name());
state.push1(extended_value);
}
Operator::I64Extend16S => {
let value = state.pop1()?.into_int_value();
let narrow_value =
builder.build_int_truncate(value, intrinsics.i16_ty, &state.var_name());
let extended_value =
builder.build_int_s_extend(narrow_value, intrinsics.i64_ty, &state.var_name());
state.push1(extended_value);
}
Operator::I64Extend32S => {
let value = state.pop1()?.into_int_value();
let narrow_value =
builder.build_int_truncate(value, intrinsics.i32_ty, &state.var_name());
let extended_value =
builder.build_int_s_extend(narrow_value, intrinsics.i64_ty, &state.var_name());
state.push1(extended_value);
}
/***************************
* Load and Store instructions.
* https://github.com/sunfishcode/wasm-reference-manual/blob/master/WebAssembly.md#load-and-store-instructions
***************************/
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Operator::I32Load { ref memarg } => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.i32_ptr_ty,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
4,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
)?;
let result = builder.build_load(effective_address, &state.var_name());
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
result
.as_instruction_value()
.unwrap()
.set_metadata(self.memory_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(result);
}
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Operator::I64Load { ref memarg } => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.i64_ptr_ty,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
8,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
)?;
let result = builder.build_load(effective_address, &state.var_name());
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
result
.as_instruction_value()
.unwrap()
.set_metadata(self.memory_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(result);
}
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Operator::F32Load { ref memarg } => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.f32_ptr_ty,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
4,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
)?;
let result = builder.build_load(effective_address, &state.var_name());
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
result
.as_instruction_value()
.unwrap()
.set_metadata(self.memory_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(result);
}
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Operator::F64Load { ref memarg } => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.f64_ptr_ty,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
8,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
)?;
let result = builder.build_load(effective_address, &state.var_name());
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
result
.as_instruction_value()
.unwrap()
.set_metadata(self.memory_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(result);
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::V128Load { ref memarg } => {
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.i128_ptr_ty,
16,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
)?;
let result = builder.build_load(effective_address, &state.var_name());
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
result
.as_instruction_value()
.unwrap()
.set_metadata(self.memory_tbaa, tbaa_kind);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
state.push1(result);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Operator::I32Store { ref memarg } => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let value = state.pop1()?;
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.i32_ptr_ty,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
4,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
)?;
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let store = builder.build_store(effective_address, value);
let tbaa_kind = context.get_kind_id("tbaa");
store.set_metadata(self.memory_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Operator::I64Store { ref memarg } => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let value = state.pop1()?;
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.i64_ptr_ty,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
8,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
)?;
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let store = builder.build_store(effective_address, value);
let tbaa_kind = context.get_kind_id("tbaa");
store.set_metadata(self.memory_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Operator::F32Store { ref memarg } => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = apply_pending_canonicalization(builder, intrinsics, v, i);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.f32_ptr_ty,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
4,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
)?;
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let store = builder.build_store(effective_address, v);
let tbaa_kind = context.get_kind_id("tbaa");
store.set_metadata(self.memory_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Operator::F64Store { ref memarg } => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = apply_pending_canonicalization(builder, intrinsics, v, i);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.f64_ptr_ty,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
8,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
)?;
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let store = builder.build_store(effective_address, v);
let tbaa_kind = context.get_kind_id("tbaa");
store.set_metadata(self.memory_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::V128Store { ref memarg } => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = apply_pending_canonicalization(builder, intrinsics, v, i);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.i128_ptr_ty,
16,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
)?;
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let store = builder.build_store(effective_address, v);
let tbaa_kind = context.get_kind_id("tbaa");
store.set_metadata(self.memory_tbaa, tbaa_kind);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
}
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Operator::I32Load8S { ref memarg } => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.i8_ptr_ty,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
1,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
)?;
let narrow_result = builder
.build_load(effective_address, &state.var_name())
.into_int_value();
let result =
builder.build_int_s_extend(narrow_result, intrinsics.i32_ty, &state.var_name());
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
result
.as_instruction_value()
.unwrap()
.set_metadata(self.memory_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(result);
}
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Operator::I32Load16S { ref memarg } => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.i16_ptr_ty,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
2,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
)?;
let narrow_result = builder
.build_load(effective_address, &state.var_name())
.into_int_value();
let result =
builder.build_int_s_extend(narrow_result, intrinsics.i32_ty, &state.var_name());
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
result
.as_instruction_value()
.unwrap()
.set_metadata(self.memory_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(result);
}
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Operator::I64Load8S { ref memarg } => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.i8_ptr_ty,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
1,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
)?;
let narrow_result = builder
.build_load(effective_address, &state.var_name())
.into_int_value();
let result =
builder.build_int_s_extend(narrow_result, intrinsics.i64_ty, &state.var_name());
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
result
.as_instruction_value()
.unwrap()
.set_metadata(self.memory_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(result);
}
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Operator::I64Load16S { ref memarg } => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.i16_ptr_ty,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
2,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
)?;
let narrow_result = builder
.build_load(effective_address, &state.var_name())
.into_int_value();
let result =
builder.build_int_s_extend(narrow_result, intrinsics.i64_ty, &state.var_name());
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
result
.as_instruction_value()
.unwrap()
.set_metadata(self.memory_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(result);
}
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Operator::I64Load32S { ref memarg } => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.i32_ptr_ty,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
4,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
)?;
let narrow_result = builder
.build_load(effective_address, &state.var_name())
.into_int_value();
let result =
builder.build_int_s_extend(narrow_result, intrinsics.i64_ty, &state.var_name());
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
result
.as_instruction_value()
.unwrap()
.set_metadata(self.memory_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(result);
}
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Operator::I32Load8U { ref memarg } => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.i8_ptr_ty,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
1,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
)?;
let narrow_result = builder
.build_load(effective_address, &state.var_name())
.into_int_value();
let result =
builder.build_int_z_extend(narrow_result, intrinsics.i32_ty, &state.var_name());
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
result
.as_instruction_value()
.unwrap()
.set_metadata(self.memory_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(result);
}
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Operator::I32Load16U { ref memarg } => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.i16_ptr_ty,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
2,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
)?;
let narrow_result = builder
.build_load(effective_address, &state.var_name())
.into_int_value();
let result =
builder.build_int_z_extend(narrow_result, intrinsics.i32_ty, &state.var_name());
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
result
.as_instruction_value()
.unwrap()
.set_metadata(self.memory_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(result);
}
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Operator::I64Load8U { ref memarg } => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.i8_ptr_ty,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
1,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
)?;
let narrow_result = builder
.build_load(effective_address, &state.var_name())
.into_int_value();
let result =
builder.build_int_z_extend(narrow_result, intrinsics.i64_ty, &state.var_name());
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
result
.as_instruction_value()
.unwrap()
.set_metadata(self.memory_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(result);
}
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Operator::I64Load16U { ref memarg } => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.i16_ptr_ty,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
2,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
)?;
let narrow_result = builder
.build_load(effective_address, &state.var_name())
.into_int_value();
let result =
builder.build_int_z_extend(narrow_result, intrinsics.i64_ty, &state.var_name());
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
result
.as_instruction_value()
.unwrap()
.set_metadata(self.memory_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(result);
}
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Operator::I64Load32U { ref memarg } => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.i32_ptr_ty,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
4,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
)?;
let narrow_result = builder
.build_load(effective_address, &state.var_name())
.into_int_value();
let result =
builder.build_int_z_extend(narrow_result, intrinsics.i64_ty, &state.var_name());
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
result
.as_instruction_value()
.unwrap()
.set_metadata(self.memory_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
state.push1(result);
}
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Operator::I32Store8 { ref memarg } | Operator::I64Store8 { ref memarg } => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
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,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
1,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
)?;
let narrow_value =
builder.build_int_truncate(value, intrinsics.i8_ty, &state.var_name());
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let store = builder.build_store(effective_address, narrow_value);
let tbaa_kind = context.get_kind_id("tbaa");
store.set_metadata(self.memory_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Operator::I32Store16 { ref memarg } | Operator::I64Store16 { ref memarg } => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
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,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
2,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
)?;
let narrow_value =
builder.build_int_truncate(value, intrinsics.i16_ty, &state.var_name());
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let store = builder.build_store(effective_address, narrow_value);
let tbaa_kind = context.get_kind_id("tbaa");
store.set_metadata(self.memory_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
Operator::I64Store32 { ref memarg } => {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
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,
Fix LLVM backend.
2019-05-14 10:49:02 +00:00
4,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
)?;
let narrow_value =
builder.build_int_truncate(value, intrinsics.i32_ty, &state.var_name());
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let store = builder.build_store(effective_address, narrow_value);
let tbaa_kind = context.get_kind_id("tbaa");
store.set_metadata(self.memory_tbaa, tbaa_kind);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
Operator::I8x16Neg => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = v128_into_i8x16(builder, intrinsics, v, i);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_sub(v.get_type().const_zero(), v, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8Neg => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = v128_into_i16x8(builder, intrinsics, v, i);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_sub(v.get_type().const_zero(), v, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I32x4Neg => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = v128_into_i32x4(builder, intrinsics, v, i);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_sub(v.get_type().const_zero(), v, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I64x2Neg => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = v128_into_i64x2(builder, intrinsics, v, i);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_sub(v.get_type().const_zero(), v, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::V128Not => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = apply_pending_canonicalization(builder, intrinsics, v, i).into_int_value();
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_not(v, &state.var_name());
state.push1(res);
}
Operator::I8x16AnyTrue
| Operator::I16x8AnyTrue
| Operator::I32x4AnyTrue
| Operator::I64x2AnyTrue => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = apply_pending_canonicalization(builder, intrinsics, v, i).into_int_value();
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let res = builder.build_int_compare(
IntPredicate::NE,
v,
v.get_type().const_zero(),
&state.var_name(),
);
let res = builder.build_int_z_extend(res, intrinsics.i32_ty, "");
state.push1(res);
}
Operator::I8x16AllTrue
| Operator::I16x8AllTrue
| Operator::I32x4AllTrue
| Operator::I64x2AllTrue => {
let vec_ty = match *op {
Operator::I8x16AllTrue => intrinsics.i8x16_ty,
Operator::I16x8AllTrue => intrinsics.i16x8_ty,
Operator::I32x4AllTrue => intrinsics.i32x4_ty,
Operator::I64x2AllTrue => intrinsics.i64x2_ty,
Improve panic/unreachable/unimplemented usage. Refactor a little.
2019-07-22 19:15:56 +00:00
_ => unreachable!(),
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
};
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = apply_pending_canonicalization(builder, intrinsics, v, i).into_int_value();
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let lane_int_ty = context.custom_width_int_type(vec_ty.get_size());
let vec = builder.build_bitcast(v, vec_ty, "vec").into_vector_value();
let mask =
builder.build_int_compare(IntPredicate::NE, vec, vec_ty.const_zero(), "mask");
let cmask = builder
.build_bitcast(mask, lane_int_ty, "cmask")
.into_int_value();
let res = builder.build_int_compare(
IntPredicate::EQ,
cmask,
lane_int_ty.const_int(std::u64::MAX, true),
&state.var_name(),
);
let res = builder.build_int_z_extend(res, intrinsics.i32_ty, "");
state.push1(res);
}
Operator::I8x16ExtractLaneS { lane } => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = v128_into_i8x16(builder, intrinsics, v, i);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let idx = intrinsics.i32_ty.const_int(lane.into(), false);
let res = builder
.build_extract_element(v, idx, &state.var_name())
.into_int_value();
let res = builder.build_int_s_extend(res, intrinsics.i32_ty, "");
state.push1(res);
}
Operator::I8x16ExtractLaneU { lane } => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = v128_into_i8x16(builder, intrinsics, v, i);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let idx = intrinsics.i32_ty.const_int(lane.into(), false);
let res = builder
.build_extract_element(v, idx, &state.var_name())
.into_int_value();
let res = builder.build_int_z_extend(res, intrinsics.i32_ty, "");
state.push1(res);
}
Operator::I16x8ExtractLaneS { lane } => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = v128_into_i16x8(builder, intrinsics, v, i);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let idx = intrinsics.i32_ty.const_int(lane.into(), false);
let res = builder
.build_extract_element(v, idx, &state.var_name())
.into_int_value();
let res = builder.build_int_s_extend(res, intrinsics.i32_ty, "");
state.push1(res);
}
Operator::I16x8ExtractLaneU { lane } => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = v128_into_i16x8(builder, intrinsics, v, i);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let idx = intrinsics.i32_ty.const_int(lane.into(), false);
let res = builder
.build_extract_element(v, idx, &state.var_name())
.into_int_value();
let res = builder.build_int_z_extend(res, intrinsics.i32_ty, "");
state.push1(res);
}
Operator::I32x4ExtractLane { lane } => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = v128_into_i32x4(builder, intrinsics, v, i);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let idx = intrinsics.i32_ty.const_int(lane.into(), false);
let res = builder.build_extract_element(v, idx, &state.var_name());
state.push1(res);
}
Operator::I64x2ExtractLane { lane } => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = v128_into_i64x2(builder, intrinsics, v, i);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let idx = intrinsics.i32_ty.const_int(lane.into(), false);
let res = builder.build_extract_element(v, idx, &state.var_name());
state.push1(res);
}
Operator::F32x4ExtractLane { lane } => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = v128_into_f32x4(builder, intrinsics, v, i);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let idx = intrinsics.i32_ty.const_int(lane.into(), false);
let res = builder.build_extract_element(v, idx, &state.var_name());
state.push1(res);
}
Operator::F64x2ExtractLane { lane } => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let (v, i) = state.pop1_extra()?;
let v = v128_into_f64x2(builder, intrinsics, v, i);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let idx = intrinsics.i32_ty.const_int(lane.into(), false);
let res = builder.build_extract_element(v, idx, &state.var_name());
state.push1(res);
}
Operator::I8x16ReplaceLane { lane } => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, _)) = state.pop2_extra()?;
let v1 = v128_into_i8x16(builder, intrinsics, v1, i1);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let v2 = v2.into_int_value();
let v2 = builder.build_int_cast(v2, intrinsics.i8_ty, "");
let idx = intrinsics.i32_ty.const_int(lane.into(), false);
let res = builder.build_insert_element(v1, v2, idx, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8ReplaceLane { lane } => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, _)) = state.pop2_extra()?;
let v1 = v128_into_i16x8(builder, intrinsics, v1, i1);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let v2 = v2.into_int_value();
let v2 = builder.build_int_cast(v2, intrinsics.i16_ty, "");
let idx = intrinsics.i32_ty.const_int(lane.into(), false);
let res = builder.build_insert_element(v1, v2, idx, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I32x4ReplaceLane { lane } => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, _)) = state.pop2_extra()?;
let v1 = v128_into_i32x4(builder, intrinsics, v1, i1);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let v2 = v2.into_int_value();
let idx = intrinsics.i32_ty.const_int(lane.into(), false);
let res = builder.build_insert_element(v1, v2, idx, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I64x2ReplaceLane { lane } => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, _)) = state.pop2_extra()?;
let v1 = v128_into_i64x2(builder, intrinsics, v1, i1);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let v2 = v2.into_int_value();
let idx = intrinsics.i32_ty.const_int(lane.into(), false);
let res = builder.build_insert_element(v1, v2, idx, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::F32x4ReplaceLane { lane } => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f32x4(builder, intrinsics, v1, i1);
let v2 =
apply_pending_canonicalization(builder, intrinsics, v2, i2).into_float_value();
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let idx = intrinsics.i32_ty.const_int(lane.into(), false);
let res = builder.build_insert_element(v1, v2, idx, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::F64x2ReplaceLane { lane } => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = v128_into_f64x2(builder, intrinsics, v1, i1);
let v2 =
apply_pending_canonicalization(builder, intrinsics, v2, i2).into_float_value();
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let idx = intrinsics.i32_ty.const_int(lane.into(), false);
let res = builder.build_insert_element(v1, v2, idx, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Fix shuffle and enable tests. Add support for new load_splat instructions. Updates to wasmparser 0.34.0 and picks up a newer wasmerio/wabt.
2019-07-19 22:19:58 +00:00
Operator::V8x16Swizzle => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = apply_pending_canonicalization(builder, intrinsics, v1, i1);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let v1 = builder
.build_bitcast(v1, intrinsics.i8x16_ty, "")
.into_vector_value();
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let v2 = apply_pending_canonicalization(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let v2 = builder
.build_bitcast(v2, intrinsics.i8x16_ty, "")
.into_vector_value();
Fix shuffle and enable tests. Add support for new load_splat instructions. Updates to wasmparser 0.34.0 and picks up a newer wasmerio/wabt.
2019-07-19 22:19:58 +00:00
let lanes = intrinsics.i8_ty.const_int(16, false);
let lanes = splat_vector(
builder,
intrinsics,
lanes.as_basic_value_enum(),
intrinsics.i8x16_ty,
"",
);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let mut res = intrinsics.i8x16_ty.get_undef();
Fix shuffle and enable tests. Add support for new load_splat instructions. Updates to wasmparser 0.34.0 and picks up a newer wasmerio/wabt.
2019-07-19 22:19:58 +00:00
let idx_out_of_range =
builder.build_int_compare(IntPredicate::UGE, v2, lanes, "idx_out_of_range");
let idx_clamped = builder
.build_select(
idx_out_of_range,
intrinsics.i8x16_ty.const_zero(),
v2,
"idx_clamped",
)
.into_vector_value();
for i in 0..16 {
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let idx = builder
Fix shuffle and enable tests. Add support for new load_splat instructions. Updates to wasmparser 0.34.0 and picks up a newer wasmerio/wabt.
2019-07-19 22:19:58 +00:00
.build_extract_element(
idx_clamped,
intrinsics.i32_ty.const_int(i, false),
"idx",
)
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
.into_int_value();
Fix shuffle and enable tests. Add support for new load_splat instructions. Updates to wasmparser 0.34.0 and picks up a newer wasmerio/wabt.
2019-07-19 22:19:58 +00:00
let replace_with_zero = builder
.build_extract_element(
idx_out_of_range,
intrinsics.i32_ty.const_int(i, false),
"replace_with_zero",
)
Reformat.
2019-07-18 20:40:24 +00:00
.into_int_value();
let elem = builder
Fix shuffle and enable tests. Add support for new load_splat instructions. Updates to wasmparser 0.34.0 and picks up a newer wasmerio/wabt.
2019-07-19 22:19:58 +00:00
.build_extract_element(v1, idx, "elem")
Reformat.
2019-07-18 20:40:24 +00:00
.into_int_value();
let elem_or_zero = builder.build_select(
Fix shuffle and enable tests. Add support for new load_splat instructions. Updates to wasmparser 0.34.0 and picks up a newer wasmerio/wabt.
2019-07-19 22:19:58 +00:00
replace_with_zero,
intrinsics.i8_zero,
Reformat.
2019-07-18 20:40:24 +00:00
elem,
"elem_or_zero",
);
Reformat.
2019-07-10 21:28:07 +00:00
res = builder.build_insert_element(
res,
Fix bugs in V128 support based on results from testing against simd spec test. These is one test failure remaining with V128 global variables. * Fix trunc_sat. We need both the largest float that can be converted to an int and the largest int, they are not the same number. * Implement calling of functions that take V128 by passing in two i64's. * Improve support for V128 in spectests. Parse binary modules with the same features as the outer spectest. Fix compilation error involving Result in emitted .rs file. Handle V128 in more cases when producing .rs file. Parse the wast script with SIMD enabled. * Adjust the WAVM spectest so that it parses with WABT and mostly passes with wasmer. Wabt is particular about ints not having decimal places and floats having decimal places. Wasmer does not support mutable globals or shared memory. Tests of shuffles are disabled. Some assert_invalid tests that wabt won't even parse are disabled.
2019-07-18 19:52:59 +00:00
elem_or_zero,
Reformat.
2019-07-10 21:28:07 +00:00
intrinsics.i32_ty.const_int(i, false),
"",
);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
}
let res = builder.build_bitcast(res, intrinsics.i128_ty, &state.var_name());
state.push1(res);
}
Fix shuffle and enable tests. Add support for new load_splat instructions. Updates to wasmparser 0.34.0 and picks up a newer wasmerio/wabt.
2019-07-19 22:19:58 +00:00
Operator::V8x16Shuffle { lanes } => {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let ((v1, i1), (v2, i2)) = state.pop2_extra()?;
let v1 = apply_pending_canonicalization(builder, intrinsics, v1, i1);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let v1 = builder
.build_bitcast(v1, intrinsics.i8x16_ty, "")
.into_vector_value();
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let v2 = apply_pending_canonicalization(builder, intrinsics, v2, i2);
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
let v2 = builder
.build_bitcast(v2, intrinsics.i8x16_ty, "")
.into_vector_value();
let mask = VectorType::const_vector(
lanes
This .into_iter() call is equivalent to .iter() and will not move the array.
2019-07-02 23:05:10 +00:00
.iter()
Initial implementation of SIMD in the LLVM backend.
2019-07-02 22:50:33 +00:00
.map(|l| intrinsics.i32_ty.const_int((*l).into(), false))
.collect::<Vec<IntValue>>()
.as_slice(),
);
let res = builder.build_shuffle_vector(v1, v2, mask, &state.var_name());
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Fix shuffle and enable tests. Add support for new load_splat instructions. Updates to wasmparser 0.34.0 and picks up a newer wasmerio/wabt.
2019-07-19 22:19:58 +00:00
Operator::I8x16LoadSplat { ref memarg } => {
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.i8_ptr_ty,
1,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Fix shuffle and enable tests. Add support for new load_splat instructions. Updates to wasmparser 0.34.0 and picks up a newer wasmerio/wabt.
2019-07-19 22:19:58 +00:00
)?;
let elem = builder.build_load(effective_address, "").into_int_value();
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
elem.as_instruction_value()
.unwrap()
.set_metadata(self.memory_tbaa, tbaa_kind);
Fix shuffle and enable tests. Add support for new load_splat instructions. Updates to wasmparser 0.34.0 and picks up a newer wasmerio/wabt.
2019-07-19 22:19:58 +00:00
let res = splat_vector(
builder,
intrinsics,
elem.as_basic_value_enum(),
intrinsics.i8x16_ty,
&state.var_name(),
);
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I16x8LoadSplat { ref memarg } => {
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.i16_ptr_ty,
2,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Fix shuffle and enable tests. Add support for new load_splat instructions. Updates to wasmparser 0.34.0 and picks up a newer wasmerio/wabt.
2019-07-19 22:19:58 +00:00
)?;
let elem = builder.build_load(effective_address, "").into_int_value();
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
elem.as_instruction_value()
.unwrap()
.set_metadata(self.memory_tbaa, tbaa_kind);
Fix shuffle and enable tests. Add support for new load_splat instructions. Updates to wasmparser 0.34.0 and picks up a newer wasmerio/wabt.
2019-07-19 22:19:58 +00:00
let res = splat_vector(
builder,
intrinsics,
elem.as_basic_value_enum(),
intrinsics.i16x8_ty,
&state.var_name(),
);
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I32x4LoadSplat { ref memarg } => {
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.i32_ptr_ty,
4,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Fix shuffle and enable tests. Add support for new load_splat instructions. Updates to wasmparser 0.34.0 and picks up a newer wasmerio/wabt.
2019-07-19 22:19:58 +00:00
)?;
let elem = builder.build_load(effective_address, "").into_int_value();
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
elem.as_instruction_value()
.unwrap()
.set_metadata(self.memory_tbaa, tbaa_kind);
Fix shuffle and enable tests. Add support for new load_splat instructions. Updates to wasmparser 0.34.0 and picks up a newer wasmerio/wabt.
2019-07-19 22:19:58 +00:00
let res = splat_vector(
builder,
intrinsics,
elem.as_basic_value_enum(),
intrinsics.i32x4_ty,
&state.var_name(),
);
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Operator::I64x2LoadSplat { ref memarg } => {
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.i64_ptr_ty,
8,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Fix shuffle and enable tests. Add support for new load_splat instructions. Updates to wasmparser 0.34.0 and picks up a newer wasmerio/wabt.
2019-07-19 22:19:58 +00:00
)?;
let elem = builder.build_load(effective_address, "").into_int_value();
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
elem.as_instruction_value()
.unwrap()
.set_metadata(self.memory_tbaa, tbaa_kind);
Fix shuffle and enable tests. Add support for new load_splat instructions. Updates to wasmparser 0.34.0 and picks up a newer wasmerio/wabt.
2019-07-19 22:19:58 +00:00
let res = splat_vector(
builder,
intrinsics,
elem.as_basic_value_enum(),
intrinsics.i64x2_ty,
&state.var_name(),
);
let res = builder.build_bitcast(res, intrinsics.i128_ty, "");
state.push1(res);
}
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
Operator::Fence { flags: _ } => {
Expound upon Fence's empty implementation being correct.
2019-08-16 22:23:40 +00:00
// 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.
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
}
Operator::I32AtomicLoad { ref memarg } => {
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
intrinsics.i32_ptr_ty,
4,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
)?;
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
trap_if_misaligned(
builder,
intrinsics,
context,
&function,
memarg,
effective_address,
);
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
let result = builder.build_load(effective_address, &state.var_name());
Implement atomic load and store instructions with actual atomics in the LLVM backend. Includes a run of `cargo update` to pick up the newer inkwell required.
2019-09-13 06:38:44 +00:00
let load = result.as_instruction_value().unwrap();
load.set_alignment(4).unwrap();
load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
.unwrap();
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
load.set_metadata(self.memory_tbaa, tbaa_kind);
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
)?;
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
trap_if_misaligned(
builder,
intrinsics,
context,
&function,
memarg,
effective_address,
);
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
let result = builder.build_load(effective_address, &state.var_name());
Implement atomic load and store instructions with actual atomics in the LLVM backend. Includes a run of `cargo update` to pick up the newer inkwell required.
2019-09-13 06:38:44 +00:00
let load = result.as_instruction_value().unwrap();
load.set_alignment(8).unwrap();
load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
.unwrap();
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
load.set_metadata(self.memory_tbaa, tbaa_kind);
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
)?;
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
trap_if_misaligned(
builder,
intrinsics,
context,
&function,
memarg,
effective_address,
);
let narrow_result = builder
.build_load(effective_address, &state.var_name())
.into_int_value();
Implement atomic load and store instructions with actual atomics in the LLVM backend. Includes a run of `cargo update` to pick up the newer inkwell required.
2019-09-13 06:38:44 +00:00
let load = narrow_result.as_instruction_value().unwrap();
load.set_alignment(1).unwrap();
load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
.unwrap();
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
load.set_metadata(self.memory_tbaa, tbaa_kind);
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
let result =
builder.build_int_z_extend(narrow_result, intrinsics.i32_ty, &state.var_name());
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
)?;
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
trap_if_misaligned(
builder,
intrinsics,
context,
&function,
memarg,
effective_address,
);
let narrow_result = builder
.build_load(effective_address, &state.var_name())
.into_int_value();
Implement atomic load and store instructions with actual atomics in the LLVM backend. Includes a run of `cargo update` to pick up the newer inkwell required.
2019-09-13 06:38:44 +00:00
let load = narrow_result.as_instruction_value().unwrap();
load.set_alignment(2).unwrap();
load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
.unwrap();
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
load.set_metadata(self.memory_tbaa, tbaa_kind);
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
let result =
builder.build_int_z_extend(narrow_result, intrinsics.i32_ty, &state.var_name());
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
)?;
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
trap_if_misaligned(
builder,
intrinsics,
context,
&function,
memarg,
effective_address,
);
let narrow_result = builder
.build_load(effective_address, &state.var_name())
.into_int_value();
Implement atomic load and store instructions with actual atomics in the LLVM backend. Includes a run of `cargo update` to pick up the newer inkwell required.
2019-09-13 06:38:44 +00:00
let load = narrow_result.as_instruction_value().unwrap();
load.set_alignment(1).unwrap();
load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
.unwrap();
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
load.set_metadata(self.memory_tbaa, tbaa_kind);
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
let result =
builder.build_int_z_extend(narrow_result, intrinsics.i64_ty, &state.var_name());
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
)?;
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
trap_if_misaligned(
builder,
intrinsics,
context,
&function,
memarg,
effective_address,
);
let narrow_result = builder
.build_load(effective_address, &state.var_name())
.into_int_value();
Implement atomic load and store instructions with actual atomics in the LLVM backend. Includes a run of `cargo update` to pick up the newer inkwell required.
2019-09-13 06:38:44 +00:00
let load = narrow_result.as_instruction_value().unwrap();
load.set_alignment(2).unwrap();
load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
.unwrap();
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
load.set_metadata(self.memory_tbaa, tbaa_kind);
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
let result =
builder.build_int_z_extend(narrow_result, intrinsics.i64_ty, &state.var_name());
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
state.push1(result);
}
Operator::I64AtomicLoad32U { ref memarg } => {
let effective_address = resolve_memory_ptr(
builder,
intrinsics,
context,
&function,
&mut state,
&mut ctx,
memarg,
Fix i64.atomic.load32_u and all alignment checks.
2019-08-20 18:03:22 +00:00
intrinsics.i32_ptr_ty,
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
4,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
)?;
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
trap_if_misaligned(
builder,
intrinsics,
context,
&function,
memarg,
effective_address,
);
let narrow_result = builder
.build_load(effective_address, &state.var_name())
.into_int_value();
Implement atomic load and store instructions with actual atomics in the LLVM backend. Includes a run of `cargo update` to pick up the newer inkwell required.
2019-09-13 06:38:44 +00:00
let load = narrow_result.as_instruction_value().unwrap();
load.set_alignment(4).unwrap();
load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
.unwrap();
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
load.set_metadata(self.memory_tbaa, tbaa_kind);
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
let result =
builder.build_int_z_extend(narrow_result, intrinsics.i64_ty, &state.var_name());
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
)?;
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
trap_if_misaligned(
builder,
intrinsics,
context,
&function,
memarg,
effective_address,
);
Implement atomic load and store instructions with actual atomics in the LLVM backend. Includes a run of `cargo update` to pick up the newer inkwell required.
2019-09-13 06:38:44 +00:00
let store = builder.build_store(effective_address, value);
store.set_alignment(4).unwrap();
store
.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
.unwrap();
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
store.set_metadata(self.memory_tbaa, tbaa_kind);
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
}
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
)?;
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
trap_if_misaligned(
builder,
intrinsics,
context,
&function,
memarg,
effective_address,
);
Implement atomic load and store instructions with actual atomics in the LLVM backend. Includes a run of `cargo update` to pick up the newer inkwell required.
2019-09-13 06:38:44 +00:00
let store = builder.build_store(effective_address, value);
store.set_alignment(8).unwrap();
store
.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
.unwrap();
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
store.set_metadata(self.memory_tbaa, tbaa_kind);
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
}
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
)?;
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
trap_if_misaligned(
builder,
intrinsics,
context,
&function,
memarg,
effective_address,
);
let narrow_value =
builder.build_int_truncate(value, intrinsics.i8_ty, &state.var_name());
Implement atomic load and store instructions with actual atomics in the LLVM backend. Includes a run of `cargo update` to pick up the newer inkwell required.
2019-09-13 06:38:44 +00:00
let store = builder.build_store(effective_address, narrow_value);
store.set_alignment(1).unwrap();
store
.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
.unwrap();
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
store.set_metadata(self.memory_tbaa, tbaa_kind);
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
}
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
Operator::I32AtomicStore16 { ref memarg }
| Operator::I64AtomicStore16 { ref memarg } => {
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
)?;
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
trap_if_misaligned(
builder,
intrinsics,
context,
&function,
memarg,
effective_address,
);
let narrow_value =
builder.build_int_truncate(value, intrinsics.i16_ty, &state.var_name());
Implement atomic load and store instructions with actual atomics in the LLVM backend. Includes a run of `cargo update` to pick up the newer inkwell required.
2019-09-13 06:38:44 +00:00
let store = builder.build_store(effective_address, narrow_value);
store.set_alignment(2).unwrap();
store
.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
.unwrap();
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
store.set_metadata(self.memory_tbaa, tbaa_kind);
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
}
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
)?;
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
trap_if_misaligned(
builder,
intrinsics,
context,
&function,
memarg,
effective_address,
);
let narrow_value =
builder.build_int_truncate(value, intrinsics.i32_ty, &state.var_name());
Implement atomic load and store instructions with actual atomics in the LLVM backend. Includes a run of `cargo update` to pick up the newer inkwell required.
2019-09-13 06:38:44 +00:00
let store = builder.build_store(effective_address, narrow_value);
store.set_alignment(4).unwrap();
store
.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
.unwrap();
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
let tbaa_kind = context.get_kind_id("tbaa");
store.set_metadata(self.memory_tbaa, tbaa_kind);
Implement fence correctly, atomic load/store as non-atomic. Adds trap for misaligned accesses.
2019-08-15 23:39:42 +00:00
}
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
self.context_field_ptr_to_base_tbaa,
self.context_field_ptr_to_bounds_tbaa,
Implement atomic.rmw operations including atomic.rmw.cmpxchg.
2019-08-16 22:17:36 +00:00
)?;
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);
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Operator::MemoryGrow { reserved } => {
let memory_index = MemoryIndex::new(reserved as usize);
let func_value = match memory_index.local_or_import(info) {
LocalOrImport::Local(local_mem_index) => {
let mem_desc = &info.memories[local_mem_index];
match mem_desc.memory_type() {
MemoryType::Dynamic => intrinsics.memory_grow_dynamic_local,
MemoryType::Static => intrinsics.memory_grow_static_local,
MemoryType::SharedStatic => intrinsics.memory_grow_shared_local,
}
}
LocalOrImport::Import(import_mem_index) => {
let mem_desc = &info.imported_memories[import_mem_index].1;
match mem_desc.memory_type() {
MemoryType::Dynamic => intrinsics.memory_grow_dynamic_import,
MemoryType::Static => intrinsics.memory_grow_static_import,
MemoryType::SharedStatic => intrinsics.memory_grow_shared_import,
}
}
};
let memory_index_const = intrinsics
.i32_ty
.const_int(reserved as u64, false)
.as_basic_value_enum();
let delta = state.pop1()?;
let result = builder.build_call(
func_value,
&[ctx.basic(), memory_index_const, delta],
&state.var_name(),
);
state.push1(result.try_as_basic_value().left().unwrap());
}
Operator::MemorySize { reserved } => {
let memory_index = MemoryIndex::new(reserved as usize);
let func_value = match memory_index.local_or_import(info) {
LocalOrImport::Local(local_mem_index) => {
let mem_desc = &info.memories[local_mem_index];
match mem_desc.memory_type() {
MemoryType::Dynamic => intrinsics.memory_size_dynamic_local,
MemoryType::Static => intrinsics.memory_size_static_local,
MemoryType::SharedStatic => intrinsics.memory_size_shared_local,
}
}
LocalOrImport::Import(import_mem_index) => {
let mem_desc = &info.imported_memories[import_mem_index].1;
match mem_desc.memory_type() {
MemoryType::Dynamic => intrinsics.memory_size_dynamic_import,
MemoryType::Static => intrinsics.memory_size_static_import,
MemoryType::SharedStatic => intrinsics.memory_size_shared_import,
}
}
};
let memory_index_const = intrinsics
.i32_ty
.const_int(reserved as u64, false)
.as_basic_value_enum();
let result = builder.build_call(
func_value,
&[ctx.basic(), memory_index_const],
&state.var_name(),
);
state.push1(result.try_as_basic_value().left().unwrap());
}
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
_ => {
remove panic and unimplemented in llvm-backend and runtime-core
2019-09-17 10:03:03 +00:00
return Err(CodegenError {
message: format!("Operator {:?} unimplemented", op),
});
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
}
Implement more of next_function and finalize
2019-05-01 04:22:41 +00:00
Ok(())
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
fn finalize(&mut self) -> Result<(), CodegenError> {
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let results = self.state.popn_save_extra(self.func_sig.returns().len())?;
Implement llvm returns in function code generator finalize
2019-05-04 17:07:21 +00:00
match results.as_slice() {
[] => {
Remove transmutes.
2019-05-07 11:20:18 +00:00
self.builder.as_ref().unwrap().build_return(None);
Implement llvm returns in function code generator finalize
2019-05-04 17:07:21 +00:00
}
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
[(one_value, one_value_info)] => {
Allow only integers for LLVM function param/return values.
2019-08-16 02:07:03 +00:00
let builder = self.builder.as_ref().unwrap();
let intrinsics = self.intrinsics.as_ref().unwrap();
For floating point operations, allow inputs to be arbitrary, including SNaNs. Instead of ensuring outputs are arithmetic NaNs on every function, we tag them as pending such a check, so that a sequence of computation can have a single canonicalization step at the end. There's an extra wriggle for SIMD. The Wasm type system only indicates them as V128, so it's possible that we might do computations as F32x4Add, I8x16Add, F64x2Add in a row with no other computations in between. Thus, most SIMD functions apply pending canonicalizations to their inputs, even integer SIMD operations.
2019-10-17 18:55:01 +00:00
let one_value = apply_pending_canonicalization(
builder,
intrinsics,
*one_value,
*one_value_info,
);
Cargo fmt
2019-08-16 02:13:00 +00:00
builder.build_return(Some(&builder.build_bitcast(
one_value.as_basic_value_enum(),
type_to_llvm_int_only(intrinsics, self.func_sig.returns()[0]),
"return",
)));
Implement llvm returns in function code generator finalize
2019-05-04 17:07:21 +00:00
}
remove panic and unimplemented in llvm-backend and runtime-core
2019-09-17 10:03:03 +00:00
_ => {
return Err(CodegenError {
message: "multi-value returns not yet implemented".to_string(),
});
}
Implement llvm returns in function code generator finalize
2019-05-04 17:07:21 +00:00
}
Implement more of next_function and finalize
2019-05-01 04:22:41 +00:00
Ok(())
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
}
impl From<BinaryReaderError> for CodegenError {
fn from(other: BinaryReaderError) -> CodegenError {
Implement feed_local
2019-05-01 01:11:44 +00:00
CodegenError {
message: format!("{:?}", other),
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
}
impl ModuleCodeGenerator<LLVMFunctionCodeGenerator, LLVMBackend, CodegenError>
for LLVMModuleCodeGenerator
{
fn new() -> LLVMModuleCodeGenerator {
Implement feed_local
2019-05-01 01:11:44 +00:00
let context = Context::create();
let module = context.create_module("module");
Set target triple and datalayout when creating the LLVM module.
2019-10-23 23:04:29 +00:00
Target::initialize_x86(&InitializationConfig {
asm_parser: true,
asm_printer: true,
base: true,
disassembler: true,
info: true,
machine_code: true,
});
let triple = TargetMachine::get_default_triple().to_string();
let target = Target::from_triple(&triple).unwrap();
let target_machine = target
.create_target_machine(
&triple,
&TargetMachine::get_host_cpu_name().to_string(),
&TargetMachine::get_host_cpu_features().to_string(),
OptimizationLevel::Aggressive,
RelocMode::Static,
CodeModel::Large,
)
.unwrap();
module.set_target(&target);
module.set_data_layout(&target_machine.get_target_data().get_data_layout());
Implement feed_local
2019-05-01 01:11:44 +00:00
let builder = context.create_builder();
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Implement feed_local
2019-05-01 01:11:44 +00:00
let intrinsics = Intrinsics::declare(&module, &context);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Implement feed_local
2019-05-01 01:11:44 +00:00
let personality_func = module.add_function(
"__gxx_personality_v0",
intrinsics.i32_ty.fn_type(&[], false),
Some(Linkage::External),
);
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
module.add_global_metadata("wasmer_tbaa_root", &MetadataValue::create_node(&[]));
let tbaa_root = module.get_global_metadata("wasmer_tbaa_root")[0];
let memory = context.metadata_string("memory");
module.add_global_metadata(
"memory",
&MetadataValue::create_node(&[memory.into(), tbaa_root.into()]),
);
let memory_tbaa = module.get_global_metadata("memory")[0];
module.add_global_metadata(
"memory_memop",
&MetadataValue::create_node(&[
memory_tbaa.into(),
memory_tbaa.into(),
intrinsics.i64_zero.into(),
]),
);
let memory_tbaa = module.get_global_metadata("memory_memop")[0];
let locals = context.metadata_string("locals");
module.add_global_metadata(
"locals",
&MetadataValue::create_node(&[locals.into(), tbaa_root.into()]),
);
let locals_tbaa = module.get_global_metadata("locals")[0];
module.add_global_metadata(
"locals_memop",
&MetadataValue::create_node(&[
locals_tbaa.into(),
locals_tbaa.into(),
intrinsics.i64_zero.into(),
]),
);
let locals_tbaa = module.get_global_metadata("locals_memop")[0];
let globals = context.metadata_string("globals");
module.add_global_metadata(
"globals",
&MetadataValue::create_node(&[globals.into(), tbaa_root.into()]),
);
let globals_tbaa = module.get_global_metadata("globals")[0];
module.add_global_metadata(
"globals_memop",
&MetadataValue::create_node(&[
globals_tbaa.into(),
globals_tbaa.into(),
intrinsics.i64_zero.into(),
]),
);
let globals_tbaa = module.get_global_metadata("globals_memop")[0];
let context_field_ptr_to_base_tbaa =
context.metadata_string("context_field_ptr_to_base_tbaa");
module.add_global_metadata(
"context_field_ptr_to_base_tbaa",
&MetadataValue::create_node(&[context_field_ptr_to_base_tbaa.into(), tbaa_root.into()]),
);
let context_field_ptr_to_base_tbaa =
module.get_global_metadata("context_field_ptr_to_base_tbaa")[0];
module.add_global_metadata(
"context_field_ptr_to_base_tbaa_memop",
&MetadataValue::create_node(&[
context_field_ptr_to_base_tbaa.into(),
context_field_ptr_to_base_tbaa.into(),
intrinsics.i64_zero.into(),
]),
);
let context_field_ptr_to_base_tbaa =
module.get_global_metadata("context_field_ptr_to_base_tbaa_memop")[0];
let context_field_ptr_to_bounds_tbaa =
context.metadata_string("context_field_ptr_to_bounds_tbaa");
module.add_global_metadata(
"context_field_ptr_to_bounds_tbaa",
&MetadataValue::create_node(&[
context_field_ptr_to_bounds_tbaa.into(),
tbaa_root.into(),
]),
);
let context_field_ptr_to_bounds_tbaa =
module.get_global_metadata("context_field_ptr_to_bounds_tbaa")[0];
module.add_global_metadata(
"context_field_ptr_to_bounds_tbaa_memop",
&MetadataValue::create_node(&[
context_field_ptr_to_bounds_tbaa.into(),
context_field_ptr_to_bounds_tbaa.into(),
intrinsics.i64_zero.into(),
]),
);
let context_field_ptr_to_bounds_tbaa =
module.get_global_metadata("context_field_ptr_to_bounds_tbaa_memop")[0];
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
LLVMModuleCodeGenerator {
Remove transmutes.
2019-05-07 11:20:18 +00:00
context: Some(context),
builder: Some(builder),
intrinsics: Some(intrinsics),
Remove parser refactor commented out code, unused imports and fields
2019-05-05 19:28:40 +00:00
module,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
functions: vec![],
NFC: Fold variable into initializer.
2019-10-29 19:14:14 +00:00
signatures: Map::new(),
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
signatures_raw: Map::new(),
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
function_signatures: None,
func_import_count: 0,
Remove parser refactor commented out code, unused imports and fields
2019-05-05 19:28:40 +00:00
personality_func,
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
stackmaps: Rc::new(RefCell::new(StackmapRegistry::default())),
Thread whether state tracking is enabled into the LLVM backend.
2019-10-23 06:15:05 +00:00
track_state: false,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
target_machine,
memory_tbaa,
locals_tbaa,
globals_tbaa,
context_field_ptr_to_base_tbaa,
context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
}
fn backend_id() -> Backend {
Backend::LLVM
}
Remove parser refactor commented out code, unused imports and fields
2019-05-05 19:28:40 +00:00
fn check_precondition(&mut self, _module_info: &ModuleInfo) -> Result<(), CodegenError> {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Ok(())
}
Implement MCG.next_function in other backends
2019-05-19 16:45:16 +00:00
fn next_function(
&mut self,
Fix compilation errors and warnings
2019-05-26 16:13:37 +00:00
_module_info: Arc<RwLock<ModuleInfo>>,
Implement MCG.next_function in other backends
2019-05-19 16:45:16 +00:00
) -> Result<&mut LLVMFunctionCodeGenerator, CodegenError> {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
// Creates a new function and returns the function-scope code generator for it.
Reset LLVM related code to master
2019-06-03 00:36:26 +00:00
let (context, builder, intrinsics) = match self.functions.last_mut() {
Remove transmutes.
2019-05-07 11:20:18 +00:00
Some(x) => (
x.context.take().unwrap(),
x.builder.take().unwrap(),
x.intrinsics.take().unwrap(),
),
None => (
self.context.take().unwrap(),
self.builder.take().unwrap(),
self.intrinsics.take().unwrap(),
),
};
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Implement feed_local
2019-05-01 01:11:44 +00:00
let sig_id = self.function_signatures.as_ref().unwrap()
[FuncIndex::new(self.func_import_count + self.functions.len())];
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
let func_sig = self.signatures_raw[sig_id].clone();
Implement feed_local
2019-05-01 01:11:44 +00:00
let function = self.module.add_function(
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
&format!("fn{}", self.func_import_count + self.functions.len()),
self.signatures[sig_id],
Some(Linkage::External),
);
Implement feed_local
2019-05-01 01:11:44 +00:00
function.set_personality_function(self.personality_func);
Implement more of next_function and finalize
2019-05-01 04:22:41 +00:00
let mut state = State::new();
Remove transmutes.
2019-05-07 11:20:18 +00:00
let entry_block = context.append_basic_block(&function, "entry");
Insert allocas as a contiguous block at the top of the entry block. This minimizes the chance we accidentally get categorized as having a dynamic alloca.
2019-10-24 02:21:12 +00:00
let alloca_builder = context.create_builder();
alloca_builder.position_at_end(&entry_block);
Implement more of next_function and finalize
2019-05-01 04:22:41 +00:00
Remove transmutes.
2019-05-07 11:20:18 +00:00
let return_block = context.append_basic_block(&function, "return");
builder.position_at_end(&return_block);
Implement more of next_function and finalize
2019-05-01 04:22:41 +00:00
let phis: SmallVec<[PhiValue; 1]> = func_sig
.returns()
.iter()
Remove transmutes.
2019-05-07 11:20:18 +00:00
.map(|&wasmer_ty| type_to_llvm(&intrinsics, wasmer_ty))
.map(|ty| builder.build_phi(ty, &state.var_name()))
Implement more of next_function and finalize
2019-05-01 04:22:41 +00:00
.collect();
state.push_block(return_block, phis);
Remove transmutes.
2019-05-07 11:20:18 +00:00
builder.position_at_end(&entry_block);
Implement more of next_function and finalize
2019-05-01 04:22:41 +00:00
Implement feed_local
2019-05-01 01:11:44 +00:00
let mut locals = Vec::new();
locals.extend(
function
.get_param_iter()
.skip(1)
.enumerate()
.map(|(index, param)| {
Allow only integers for LLVM function param/return values.
2019-08-16 02:07:03 +00:00
let real_ty = func_sig.params()[index];
let real_ty_llvm = type_to_llvm(&intrinsics, real_ty);
Insert allocas as a contiguous block at the top of the entry block. This minimizes the chance we accidentally get categorized as having a dynamic alloca.
2019-10-24 02:21:12 +00:00
let alloca =
alloca_builder.build_alloca(real_ty_llvm, &format!("local{}", index));
Cargo fmt
2019-08-16 02:13:00 +00:00
builder.build_store(
alloca,
builder.build_bitcast(param, real_ty_llvm, &state.var_name()),
);
Insert allocas as a contiguous block at the top of the entry block. This minimizes the chance we accidentally get categorized as having a dynamic alloca.
2019-10-24 02:21:12 +00:00
if index == 0 {
alloca_builder.position_before(
&alloca
.as_instruction()
.unwrap()
.get_next_instruction()
.unwrap(),
);
}
Implement feed_local
2019-05-01 01:11:44 +00:00
alloca
}),
);
let num_params = locals.len();
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
let local_func_index = self.functions.len();
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
let code = LLVMFunctionCodeGenerator {
Implement more of next_function and finalize
2019-05-01 04:22:41 +00:00
state,
Remove transmutes.
2019-05-07 11:20:18 +00:00
context: Some(context),
builder: Some(builder),
Insert allocas as a contiguous block at the top of the entry block. This minimizes the chance we accidentally get categorized as having a dynamic alloca.
2019-10-24 02:21:12 +00:00
alloca_builder: Some(alloca_builder),
Remove transmutes.
2019-05-07 11:20:18 +00:00
intrinsics: Some(intrinsics),
Implement feed_local
2019-05-01 01:11:44 +00:00
function,
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
func_sig: func_sig,
Implement feed_local
2019-05-01 01:11:44 +00:00
locals,
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
signatures: self.signatures.clone(),
Implement feed_local
2019-05-01 01:11:44 +00:00
num_params,
Update LLVM FCG begin_body
2019-05-03 05:14:25 +00:00
ctx: None,
Fix LLVM refactor unreachable depth
2019-05-05 18:56:02 +00:00
unreachable_depth: 0,
Emit stack map at critical points.
2019-07-17 18:43:04 +00:00
stackmaps: self.stackmaps.clone(),
index: local_func_index,
Populating LLVM stack maps into MSM/FSM.
2019-07-22 18:55:43 +00:00
opcode_offset: 0,
Thread whether state tracking is enabled into the LLVM backend.
2019-10-23 06:15:05 +00:00
track_state: self.track_state,
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
memory_tbaa: self.memory_tbaa,
locals_tbaa: self.locals_tbaa,
globals_tbaa: self.globals_tbaa,
context_field_ptr_to_base_tbaa: self.context_field_ptr_to_base_tbaa,
context_field_ptr_to_bounds_tbaa: self.context_field_ptr_to_bounds_tbaa,
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
};
self.functions.push(code);
Ok(self.functions.last_mut().unwrap())
}
Implement caching for parser refactor
2019-05-06 01:11:47 +00:00
fn finalize(
Remove transmutes.
2019-05-07 11:20:18 +00:00
mut self,
Implement caching for parser refactor
2019-05-06 01:11:47 +00:00
module_info: &ModuleInfo,
) -> Result<(LLVMBackend, Box<dyn CacheGen>), CodegenError> {
Reset LLVM related code to master
2019-06-03 00:36:26 +00:00
let (context, builder, intrinsics) = match self.functions.last_mut() {
Remove transmutes.
2019-05-07 11:20:18 +00:00
Some(x) => (
x.context.take().unwrap(),
x.builder.take().unwrap(),
x.intrinsics.take().unwrap(),
),
None => (
self.context.take().unwrap(),
self.builder.take().unwrap(),
self.intrinsics.take().unwrap(),
),
};
self.context = Some(context);
self.builder = Some(builder);
self.intrinsics = Some(intrinsics);
Implement more of next_function and finalize
2019-05-01 04:22:41 +00:00
generate_trampolines(
module_info,
&self.signatures,
&self.module,
Remove transmutes.
2019-05-07 11:20:18 +00:00
self.context.as_ref().unwrap(),
self.builder.as_ref().unwrap(),
self.intrinsics.as_ref().unwrap(),
remove panic and unimplemented in llvm-backend and runtime-core
2019-09-17 10:03:03 +00:00
)
.map_err(|e| CodegenError {
message: format!("trampolines generation error: {:?}", e),
})?;
Implement more of next_function and finalize
2019-05-01 04:22:41 +00:00
Add support for backend flags. Backend flags are opaque to src/bin/wasmer.rs. Use them to implement three features in the LLVM backend, getting a valid ELF object file, the post-optimization LLVM IR and the pre-optimization LLVM IR. Presently they are also global to the backend which is not ideal.
2019-08-08 23:05:17 +00:00
if let Some(path) = unsafe { &crate::GLOBAL_OPTIONS.pre_opt_ir } {
self.module.print_to_file(path).unwrap();
}
Update to LLVM 8.0.
2019-07-08 21:10:37 +00:00
let pass_manager = PassManager::create(());
Clean up commented out code in LLVM codegen
2019-05-08 03:53:48 +00:00
if cfg!(test) {
pass_manager.add_verifier_pass();
}
Try a new list of optimization passes. A few notes: a) the inliner doesn't help because all the calls are indirect and not even opt -O2 can figure out which functions they're actually calling. b) aggressive instruction combining is not a super-set of the instruction combiner. Instcombine is made up of a large number (probably 10,000s) of patterns, and some particularly slow ones were taken out and moved to the aggressive instruction combiner. Aggressive instcombine *only* runs that handful of optimizations, which fired zero times on our example wasm files. c) NewGVN is not ready for production, it has asserts that fire when building sqlite or cowsay. This is why sqlite didn't build with the llvm backend. d) Scalar-replacement-of-aggregates (sroa) is a strict superset of promote-memory-to-registers (mem2reg), and you probably want sroa because it's usually faster. It also fires 10,000s more times than mem2reg on lua.wasm. e) Aggressive-dead-code-elimination was only deleting as much regular dead-code-elimination, but is slower because it depends on a postdominator tree (PDT) analysis that. Other passes don't need PDT so we'll have to build it for just this one pass (as opposed to regular dominator-tree which is reused by many passes). I've replaced this with bit-tracking dead-code-elimination which deletes more code than dce/adce.
2019-07-11 21:48:07 +00:00
pass_manager.add_lower_expect_intrinsic_pass();
pass_manager.add_scalar_repl_aggregates_pass();
pass_manager.add_instruction_combining_pass();
Implement more of next_function and finalize
2019-05-01 04:22:41 +00:00
pass_manager.add_cfg_simplification_pass();
Initial implementation of TBAA for the LLVM backend.
2019-10-30 17:29:51 +00:00
pass_manager.add_type_based_alias_analysis_pass();
Try a new list of optimization passes. A few notes: a) the inliner doesn't help because all the calls are indirect and not even opt -O2 can figure out which functions they're actually calling. b) aggressive instruction combining is not a super-set of the instruction combiner. Instcombine is made up of a large number (probably 10,000s) of patterns, and some particularly slow ones were taken out and moved to the aggressive instruction combiner. Aggressive instcombine *only* runs that handful of optimizations, which fired zero times on our example wasm files. c) NewGVN is not ready for production, it has asserts that fire when building sqlite or cowsay. This is why sqlite didn't build with the llvm backend. d) Scalar-replacement-of-aggregates (sroa) is a strict superset of promote-memory-to-registers (mem2reg), and you probably want sroa because it's usually faster. It also fires 10,000s more times than mem2reg on lua.wasm. e) Aggressive-dead-code-elimination was only deleting as much regular dead-code-elimination, but is slower because it depends on a postdominator tree (PDT) analysis that. Other passes don't need PDT so we'll have to build it for just this one pass (as opposed to regular dominator-tree which is reused by many passes). I've replaced this with bit-tracking dead-code-elimination which deletes more code than dce/adce.
2019-07-11 21:48:07 +00:00
pass_manager.add_gvn_pass();
pass_manager.add_jump_threading_pass();
pass_manager.add_correlated_value_propagation_pass();
pass_manager.add_sccp_pass();
pass_manager.add_instruction_combining_pass();
pass_manager.add_reassociate_pass();
pass_manager.add_cfg_simplification_pass();
pass_manager.add_bit_tracking_dce_pass();
pass_manager.add_slp_vectorize_pass();
Update to LLVM 8.0.
2019-07-08 21:10:37 +00:00
pass_manager.run_on(&self.module);
Implement more of next_function and finalize
2019-05-01 04:22:41 +00:00
Add support for backend flags. Backend flags are opaque to src/bin/wasmer.rs. Use them to implement three features in the LLVM backend, getting a valid ELF object file, the post-optimization LLVM IR and the pre-optimization LLVM IR. Presently they are also global to the backend which is not ideal.
2019-08-08 23:05:17 +00:00
if let Some(path) = unsafe { &crate::GLOBAL_OPTIONS.post_opt_ir } {
self.module.print_to_file(path).unwrap();
}
Implement more of next_function and finalize
2019-05-01 04:22:41 +00:00
Parsing LLVM stackmaps.
2019-07-18 18:02:15 +00:00
let stackmaps = self.stackmaps.borrow();
Allow a range of instruction offsets to be used in ip lookup.
2019-07-30 14:25:15 +00:00
let (backend, cache_gen) = LLVMBackend::new(
self.module,
self.intrinsics.take().unwrap(),
&*stackmaps,
module_info,
Set target triple and datalayout when creating the LLVM module.
2019-10-23 23:04:29 +00:00
&self.target_machine,
Allow a range of instruction offsets to be used in ip lookup.
2019-07-30 14:25:15 +00:00
);
Implement caching for parser refactor
2019-05-06 01:11:47 +00:00
Ok((backend, Box::new(cache_gen)))
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
}
Thread whether state tracking is enabled into the LLVM backend.
2019-10-23 06:15:05 +00:00
fn feed_compiler_config(&mut self, config: &CompilerConfig) -> Result<(), CodegenError> {
self.track_state = config.track_state;
Ok(())
}
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
fn feed_signatures(&mut self, signatures: Map<SigIndex, FuncSig>) -> Result<(), CodegenError> {
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
self.signatures = signatures
.iter()
Remove transmutes.
2019-05-07 11:20:18 +00:00
.map(|(_, sig)| {
func_sig_to_llvm(
self.context.as_ref().unwrap(),
self.intrinsics.as_ref().unwrap(),
sig,
Allow only integers for LLVM function param/return values.
2019-08-16 02:07:03 +00:00
type_to_llvm_int_only,
Remove transmutes.
2019-05-07 11:20:18 +00:00
)
})
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
.collect();
self.signatures_raw = signatures.clone();
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Ok(())
}
Implement feed_local
2019-05-01 01:11:44 +00:00
fn feed_function_signatures(
&mut self,
assoc: Map<FuncIndex, SigIndex>,
) -> Result<(), CodegenError> {
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
self.function_signatures = Some(Arc::new(assoc));
Ok(())
}
fn feed_import_function(&mut self) -> Result<(), CodegenError> {
Fix LLVM backend compilation and segfaults.
2019-04-30 07:52:43 +00:00
self.func_import_count += 1;
Add initial progress to add LLVM to module refactor
2019-04-29 05:13:34 +00:00
Ok(())
}
Implement caching for parser refactor
2019-05-06 01:11:47 +00:00
Reset LLVM related code to master
2019-06-03 00:36:26 +00:00
unsafe fn from_cache(artifact: Artifact, _: Token) -> Result<ModuleInner, CacheError> {
Implement caching for parser refactor
2019-05-06 01:11:47 +00:00
let (info, _, memory) = artifact.consume();
let (backend, cache_gen) =
LLVMBackend::from_buffer(memory).map_err(CacheError::DeserializeError)?;
Ok(ModuleInner {
runnable_module: Box::new(backend),
cache_gen: Box::new(cache_gen),
info,
Reset LLVM related code to master
2019-06-03 00:36:26 +00:00
})
Implement caching for parser refactor
2019-05-06 01:11:47 +00:00
}
Implement feed_local
2019-05-01 01:11:44 +00:00
}
Reference in New Issue Copy Permalink