mirror of
https://github.com/rust-lang/rust.git
synced 2025-05-14 02:49:40 +00:00
rustc_codegen_ssa: move all set_var_name calls to mir::debuginfo.
This commit is contained in:
Eduard-Mihai Burtescu
parent
c58e6b5752
commit
5f4ee36e03
@ -7,10 +7,12 @@ use rustc::ty::layout::HasTyCtxt;
|
||||
use rustc_target::abi::{Variants, VariantIdx};
|
||||
use crate::traits::*;
|
||||
|
||||
use std::fmt;
|
||||
use syntax_pos::{DUMMY_SP, BytePos, Span};
|
||||
use syntax::symbol::kw;
|
||||
|
||||
use super::{FunctionCx, LocalRef};
|
||||
use super::OperandValue;
|
||||
|
||||
pub enum FunctionDebugContext<D> {
|
||||
RegularContext(FunctionDebugContextData<D>),
|
||||
@ -90,6 +92,29 @@ impl<D> DebugScope<D> {
|
||||
}
|
||||
}
|
||||
|
||||
// HACK(eddyb) helpers for `set_var_name` calls, move elsewhere?
|
||||
enum Either<T, U> {
|
||||
Left(T),
|
||||
Right(U),
|
||||
}
|
||||
|
||||
impl<T: fmt::Display, U: fmt::Display> fmt::Display for Either<T, U> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
Either::Left(x) => x.fmt(f),
|
||||
Either::Right(x) => x.fmt(f),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct DisplayViaDebug<T>(T);
|
||||
|
||||
impl<T: fmt::Debug> fmt::Display for DisplayViaDebug<T> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
self.0.fmt(f)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
|
||||
pub fn set_debug_loc(
|
||||
&mut self,
|
||||
@ -149,54 +174,107 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn debug_declare_locals(&self, bx: &mut Bx) {
|
||||
let tcx = self.cx.tcx();
|
||||
/// Apply debuginfo and/or name, after creating the `alloca` for a local,
|
||||
/// or initializing the local with an operand (whichever applies).
|
||||
// FIXME(eddyb) use `llvm.dbg.value` (which would work for operands),
|
||||
// not just `llvm.dbg.declare` (which requires `alloca`).
|
||||
pub fn debug_introduce_local(&self, bx: &mut Bx, local: mir::Local) {
|
||||
let upvar_debuginfo = &self.mir.__upvar_debuginfo_codegen_only_do_not_use;
|
||||
|
||||
if bx.sess().opts.debuginfo != DebugInfo::Full {
|
||||
// FIXME(eddyb) maybe name the return place as `_0` or `return`?
|
||||
if local == mir::RETURN_PLACE {
|
||||
return;
|
||||
}
|
||||
|
||||
for (local, local_ref) in self.locals.iter_enumerated() {
|
||||
if local == mir::RETURN_PLACE {
|
||||
continue;
|
||||
let decl = &self.mir.local_decls[local];
|
||||
let (name, kind) = if self.mir.local_kind(local) == mir::LocalKind::Arg {
|
||||
let arg_index = local.index() - 1;
|
||||
|
||||
// Add debuginfo even to unnamed arguments.
|
||||
// FIXME(eddyb) is this really needed?
|
||||
let name = if arg_index == 0 && !upvar_debuginfo.is_empty() {
|
||||
// Hide closure environments from debuginfo.
|
||||
// FIXME(eddyb) shouldn't `ArgumentVariable` indices
|
||||
// be offset to account for the hidden environment?
|
||||
None
|
||||
} else {
|
||||
Some(decl.name.unwrap_or(kw::Invalid))
|
||||
};
|
||||
(name, VariableKind::ArgumentVariable(arg_index + 1))
|
||||
} else {
|
||||
(decl.name, VariableKind::LocalVariable)
|
||||
};
|
||||
|
||||
let local_ref = &self.locals[local];
|
||||
|
||||
{
|
||||
let name = match name {
|
||||
Some(name) if name != kw::Invalid => Either::Left(name),
|
||||
_ => Either::Right(DisplayViaDebug(local)),
|
||||
};
|
||||
match local_ref {
|
||||
LocalRef::Place(place) |
|
||||
LocalRef::UnsizedPlace(place) => {
|
||||
bx.set_var_name(place.llval, name);
|
||||
}
|
||||
LocalRef::Operand(Some(operand)) => match operand.val {
|
||||
OperandValue::Ref(x, ..) |
|
||||
OperandValue::Immediate(x) => {
|
||||
bx.set_var_name(x, name);
|
||||
}
|
||||
OperandValue::Pair(a, b) => {
|
||||
// FIXME(eddyb) these are scalar components,
|
||||
// maybe extract the high-level fields?
|
||||
bx.set_var_name(a, format_args!("{}.0", name));
|
||||
bx.set_var_name(b, format_args!("{}.1", name));
|
||||
}
|
||||
}
|
||||
LocalRef::Operand(None) => {}
|
||||
}
|
||||
}
|
||||
|
||||
if let Some(name) = name {
|
||||
if bx.sess().opts.debuginfo != DebugInfo::Full {
|
||||
return;
|
||||
}
|
||||
|
||||
// FIXME(eddyb) add debuginfo for unsized places too.
|
||||
let place = match local_ref {
|
||||
LocalRef::Place(place) => place,
|
||||
_ => continue,
|
||||
_ => return,
|
||||
};
|
||||
|
||||
let decl = &self.mir.local_decls[local];
|
||||
let (name, kind) = if self.mir.local_kind(local) == mir::LocalKind::Arg {
|
||||
let arg_index = local.index() - 1;
|
||||
let (scope, span) = self.debug_loc(mir::SourceInfo {
|
||||
span: decl.source_info.span,
|
||||
scope: decl.visibility_scope,
|
||||
});
|
||||
if let Some(scope) = scope {
|
||||
bx.declare_local(&self.debug_context, name, place.layout.ty, scope,
|
||||
VariableAccess::DirectVariable { alloca: place.llval },
|
||||
kind, span);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Add debuginfo even to unnamed arguments.
|
||||
// FIXME(eddyb) is this really needed?
|
||||
let name = if arg_index == 0 && !upvar_debuginfo.is_empty() {
|
||||
// Hide closure environments from debuginfo.
|
||||
// FIXME(eddyb) shouldn't `ArgumentVariable` indices
|
||||
// be offset to account for the hidden environment?
|
||||
None
|
||||
} else {
|
||||
Some(decl.name.unwrap_or(kw::Invalid))
|
||||
};
|
||||
(name, VariableKind::ArgumentVariable(arg_index + 1))
|
||||
} else {
|
||||
(decl.name, VariableKind::LocalVariable)
|
||||
};
|
||||
if let Some(name) = name {
|
||||
let (scope, span) = self.debug_loc(mir::SourceInfo {
|
||||
span: decl.source_info.span,
|
||||
scope: decl.visibility_scope,
|
||||
});
|
||||
if let Some(scope) = scope {
|
||||
bx.declare_local(&self.debug_context, name, place.layout.ty, scope,
|
||||
VariableAccess::DirectVariable { alloca: place.llval },
|
||||
kind, span);
|
||||
pub fn debug_introduce_locals(&self, bx: &mut Bx) {
|
||||
let tcx = self.cx.tcx();
|
||||
let upvar_debuginfo = &self.mir.__upvar_debuginfo_codegen_only_do_not_use;
|
||||
|
||||
if bx.sess().opts.debuginfo != DebugInfo::Full {
|
||||
// HACK(eddyb) figure out a way to perhaps disentangle
|
||||
// the use of `declare_local` and `set_var_name`.
|
||||
// Or maybe just running this loop always is not that expensive?
|
||||
if !bx.sess().fewer_names() {
|
||||
for local in self.locals.indices() {
|
||||
self.debug_introduce_local(bx, local);
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
for local in self.locals.indices() {
|
||||
self.debug_introduce_local(bx, local);
|
||||
}
|
||||
|
||||
// Declare closure captures as if they were local variables.
|
||||
|
||||
@ -190,31 +190,15 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
|
||||
return LocalRef::Place(PlaceRef::new_sized(llretptr, layout));
|
||||
}
|
||||
|
||||
let decl_name = decl.name.map(|name| name.as_str());
|
||||
let decl_name = decl_name.as_ref().map(|name| &name[..]);
|
||||
let name;
|
||||
let name = if let Some(name) = decl_name {
|
||||
name
|
||||
} else {
|
||||
// FIXME(eddyb) compute something else for the name so no work is done
|
||||
// unless LLVM IR names are turned on (e.g. for `--emit=llvm-ir`).
|
||||
name = format!("{:?}", local);
|
||||
&name
|
||||
};
|
||||
|
||||
if memory_locals.contains(local) {
|
||||
debug!("alloc: {:?} ({}) -> place", local, name);
|
||||
debug!("alloc: {:?} -> place", local);
|
||||
if layout.is_unsized() {
|
||||
let indirect_place = PlaceRef::alloca_unsized_indirect(&mut bx, layout);
|
||||
bx.set_var_name(indirect_place.llval, name);
|
||||
LocalRef::UnsizedPlace(indirect_place)
|
||||
LocalRef::UnsizedPlace(PlaceRef::alloca_unsized_indirect(&mut bx, layout))
|
||||
} else {
|
||||
let place = PlaceRef::alloca(&mut bx, layout);
|
||||
bx.set_var_name(place.llval, name);
|
||||
LocalRef::Place(place)
|
||||
LocalRef::Place(PlaceRef::alloca(&mut bx, layout))
|
||||
}
|
||||
} else {
|
||||
debug!("alloc: {:?} ({}) -> operand", local, name);
|
||||
debug!("alloc: {:?} -> operand", local);
|
||||
LocalRef::new_operand(&mut bx, layout)
|
||||
}
|
||||
};
|
||||
@ -227,7 +211,7 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
|
||||
};
|
||||
|
||||
// Apply debuginfo to the newly allocated locals.
|
||||
fx.debug_declare_locals(&mut bx);
|
||||
fx.debug_introduce_locals(&mut bx);
|
||||
|
||||
// Branch to the START block, if it's not the entry block.
|
||||
if reentrant_start_block {
|
||||
@ -343,13 +327,6 @@ fn arg_local_refs<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
|
||||
mir.args_iter().enumerate().map(|(arg_index, local)| {
|
||||
let arg_decl = &mir.local_decls[local];
|
||||
|
||||
// FIXME(eddyb) don't allocate a `String` unless it gets used.
|
||||
let name = if let Some(name) = arg_decl.name {
|
||||
name.as_str().to_string()
|
||||
} else {
|
||||
format!("{:?}", local)
|
||||
};
|
||||
|
||||
if Some(local) == mir.spread_arg {
|
||||
// This argument (e.g., the last argument in the "rust-call" ABI)
|
||||
// is a tuple that was spread at the ABI level and now we have
|
||||
@ -363,7 +340,6 @@ fn arg_local_refs<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
|
||||
};
|
||||
|
||||
let place = PlaceRef::alloca(bx, bx.layout_of(arg_ty));
|
||||
bx.set_var_name(place.llval, name);
|
||||
for i in 0..tupled_arg_tys.len() {
|
||||
let arg = &fx.fn_ty.args[idx];
|
||||
idx += 1;
|
||||
@ -381,7 +357,6 @@ fn arg_local_refs<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
|
||||
let arg_ty = fx.monomorphize(&arg_decl.ty);
|
||||
|
||||
let va_list = PlaceRef::alloca(bx, bx.layout_of(arg_ty));
|
||||
bx.set_var_name(va_list.llval, name);
|
||||
bx.va_start(va_list.llval);
|
||||
|
||||
return LocalRef::Place(va_list);
|
||||
@ -404,7 +379,6 @@ fn arg_local_refs<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
|
||||
}
|
||||
PassMode::Direct(_) => {
|
||||
let llarg = bx.get_param(llarg_idx);
|
||||
bx.set_var_name(llarg, &name);
|
||||
llarg_idx += 1;
|
||||
return local(
|
||||
OperandRef::from_immediate_or_packed_pair(bx, llarg, arg.layout));
|
||||
@ -413,11 +387,6 @@ fn arg_local_refs<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
|
||||
let (a, b) = (bx.get_param(llarg_idx), bx.get_param(llarg_idx + 1));
|
||||
llarg_idx += 2;
|
||||
|
||||
// FIXME(eddyb) these are scalar components,
|
||||
// maybe extract the high-level fields?
|
||||
bx.set_var_name(a, format_args!("{}.0", name));
|
||||
bx.set_var_name(b, format_args!("{}.1", name));
|
||||
|
||||
return local(OperandRef {
|
||||
val: OperandValue::Pair(a, b),
|
||||
layout: arg.layout
|
||||
@ -432,7 +401,6 @@ fn arg_local_refs<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
|
||||
// already put it in a temporary alloca and gave it up.
|
||||
// FIXME: lifetimes
|
||||
let llarg = bx.get_param(llarg_idx);
|
||||
bx.set_var_name(llarg, &name);
|
||||
llarg_idx += 1;
|
||||
LocalRef::Place(PlaceRef::new_sized(llarg, arg.layout))
|
||||
} else if arg.is_unsized_indirect() {
|
||||
@ -445,12 +413,10 @@ fn arg_local_refs<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
|
||||
let indirect_operand = OperandValue::Pair(llarg, llextra);
|
||||
|
||||
let tmp = PlaceRef::alloca_unsized_indirect(bx, arg.layout);
|
||||
bx.set_var_name(tmp.llval, name);
|
||||
indirect_operand.store(bx, tmp);
|
||||
LocalRef::UnsizedPlace(tmp)
|
||||
} else {
|
||||
let tmp = PlaceRef::alloca(bx, arg.layout);
|
||||
bx.set_var_name(tmp.llval, name);
|
||||
bx.store_fn_arg(arg, &mut llarg_idx, tmp);
|
||||
LocalRef::Place(tmp)
|
||||
}
|
||||
|
||||
@ -27,21 +27,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
|
||||
}
|
||||
LocalRef::Operand(None) => {
|
||||
let (mut bx, operand) = self.codegen_rvalue_operand(bx, rvalue);
|
||||
if let Some(name) = self.mir.local_decls[index].name {
|
||||
match operand.val {
|
||||
OperandValue::Ref(x, ..) |
|
||||
OperandValue::Immediate(x) => {
|
||||
bx.set_var_name(x, name);
|
||||
}
|
||||
OperandValue::Pair(a, b) => {
|
||||
// FIXME(eddyb) these are scalar components,
|
||||
// maybe extract the high-level fields?
|
||||
bx.set_var_name(a, format_args!("{}.0", name));
|
||||
bx.set_var_name(b, format_args!("{}.1", name));
|
||||
}
|
||||
}
|
||||
}
|
||||
self.locals[index] = LocalRef::Operand(Some(operand));
|
||||
self.debug_introduce_local(&mut bx, index);
|
||||
bx
|
||||
}
|
||||
LocalRef::Operand(Some(op)) => {
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
|
||||
// CHECK-LABEL: define i32 @nothing
|
||||
// CHECK-SAME: [[NOTHING_ATTRS:#[0-9]+]]
|
||||
// NO-OPT: ret i32 %1
|
||||
// NO-OPT: ret i32 %_1.0
|
||||
// SIZE-OPT: ret i32 4
|
||||
// SPEEC-OPT: ret i32 4
|
||||
#[no_mangle]
|
||||
@ -18,7 +18,7 @@ pub fn nothing() -> i32 {
|
||||
|
||||
// CHECK-LABEL: define i32 @size
|
||||
// CHECK-SAME: [[SIZE_ATTRS:#[0-9]+]]
|
||||
// NO-OPT: ret i32 %1
|
||||
// NO-OPT: ret i32 %_1.0
|
||||
// SIZE-OPT: ret i32 6
|
||||
// SPEED-OPT: ret i32 6
|
||||
#[optimize(size)]
|
||||
@ -31,7 +31,7 @@ pub fn size() -> i32 {
|
||||
// NO-OPT-SAME: [[NOTHING_ATTRS]]
|
||||
// SPEED-OPT-SAME: [[NOTHING_ATTRS]]
|
||||
// SIZE-OPT-SAME: [[SPEED_ATTRS:#[0-9]+]]
|
||||
// NO-OPT: ret i32 %1
|
||||
// NO-OPT: ret i32 %_1.0
|
||||
// SIZE-OPT: ret i32 8
|
||||
// SPEED-OPT: ret i32 8
|
||||
#[optimize(speed)]
|
||||
|
||||
@ -116,143 +116,150 @@ extern "platform-intrinsic" {
|
||||
fn simd_saturating_sub<T>(x: T, y: T) -> T;
|
||||
}
|
||||
|
||||
// NOTE(eddyb) `%{{x|_3}}` is used because on some targets (e.g. WASM)
|
||||
// SIMD vectors are passed directly, resulting in `%x` being a vector,
|
||||
// while on others they're passed indirectly, resulting in `%x` being
|
||||
// a pointer to a vector, and `%_3` a vector loaded from that pointer.
|
||||
// This is controlled by the target spec option `simd_types_indirect`.
|
||||
// The same applies to `%{{y|_4}}` as well.
|
||||
|
||||
// CHECK-LABEL: @sadd_i8x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn sadd_i8x2(x: i8x2, y: i8x2) -> i8x2 {
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> %{{[0-9a-z]+}}, <2 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i8> @llvm.sadd.sat.v2i8(<2 x i8> %{{x|_3}}, <2 x i8> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @sadd_i8x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn sadd_i8x4(x: i8x4, y: i8x4) -> i8x4 {
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i8> @llvm.sadd.sat.v4i8(<4 x i8> %{{[0-9a-z]+}}, <4 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i8> @llvm.sadd.sat.v4i8(<4 x i8> %{{x|_3}}, <4 x i8> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @sadd_i8x8
|
||||
#[no_mangle]
|
||||
pub unsafe fn sadd_i8x8(x: i8x8, y: i8x8) -> i8x8 {
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i8> @llvm.sadd.sat.v8i8(<8 x i8> %{{[0-9a-z]+}}, <8 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i8> @llvm.sadd.sat.v8i8(<8 x i8> %{{x|_3}}, <8 x i8> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @sadd_i8x16
|
||||
#[no_mangle]
|
||||
pub unsafe fn sadd_i8x16(x: i8x16, y: i8x16) -> i8x16 {
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i8> @llvm.sadd.sat.v16i8(<16 x i8> %{{[0-9a-z]+}}, <16 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i8> @llvm.sadd.sat.v16i8(<16 x i8> %{{x|_3}}, <16 x i8> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @sadd_i8x32
|
||||
#[no_mangle]
|
||||
pub unsafe fn sadd_i8x32(x: i8x32, y: i8x32) -> i8x32 {
|
||||
// CHECK: %{{[0-9]+}} = call <32 x i8> @llvm.sadd.sat.v32i8(<32 x i8> %{{[0-9a-z]+}}, <32 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <32 x i8> @llvm.sadd.sat.v32i8(<32 x i8> %{{x|_3}}, <32 x i8> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @sadd_i8x64
|
||||
#[no_mangle]
|
||||
pub unsafe fn sadd_i8x64(x: i8x64, y: i8x64) -> i8x64 {
|
||||
// CHECK: %{{[0-9]+}} = call <64 x i8> @llvm.sadd.sat.v64i8(<64 x i8> %{{[0-9a-z]+}}, <64 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <64 x i8> @llvm.sadd.sat.v64i8(<64 x i8> %{{x|_3}}, <64 x i8> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @sadd_i16x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn sadd_i16x2(x: i16x2, y: i16x2) -> i16x2 {
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i16> @llvm.sadd.sat.v2i16(<2 x i16> %{{[0-9a-z]+}}, <2 x i16> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i16> @llvm.sadd.sat.v2i16(<2 x i16> %{{x|_3}}, <2 x i16> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @sadd_i16x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn sadd_i16x4(x: i16x4, y: i16x4) -> i16x4 {
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i16> @llvm.sadd.sat.v4i16(<4 x i16> %{{[0-9a-z]+}}, <4 x i16> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i16> @llvm.sadd.sat.v4i16(<4 x i16> %{{x|_3}}, <4 x i16> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @sadd_i16x8
|
||||
#[no_mangle]
|
||||
pub unsafe fn sadd_i16x8(x: i16x8, y: i16x8) -> i16x8 {
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i16> @llvm.sadd.sat.v8i16(<8 x i16> %{{[0-9a-z]+}}, <8 x i16> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i16> @llvm.sadd.sat.v8i16(<8 x i16> %{{x|_3}}, <8 x i16> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @sadd_i16x16
|
||||
#[no_mangle]
|
||||
pub unsafe fn sadd_i16x16(x: i16x16, y: i16x16) -> i16x16 {
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i16> @llvm.sadd.sat.v16i16(<16 x i16> %{{[0-9a-z]+}}, <16 x i16> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i16> @llvm.sadd.sat.v16i16(<16 x i16> %{{x|_3}}, <16 x i16> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @sadd_i16x32
|
||||
#[no_mangle]
|
||||
pub unsafe fn sadd_i16x32(x: i16x32, y: i16x32) -> i16x32 {
|
||||
// CHECK: %{{[0-9]+}} = call <32 x i16> @llvm.sadd.sat.v32i16(<32 x i16> %{{[0-9a-z]+}}, <32 x i16> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <32 x i16> @llvm.sadd.sat.v32i16(<32 x i16> %{{x|_3}}, <32 x i16> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @sadd_i32x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn sadd_i32x2(x: i32x2, y: i32x2) -> i32x2 {
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i32> @llvm.sadd.sat.v2i32(<2 x i32> %{{[0-9a-z]+}}, <2 x i32> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i32> @llvm.sadd.sat.v2i32(<2 x i32> %{{x|_3}}, <2 x i32> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @sadd_i32x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn sadd_i32x4(x: i32x4, y: i32x4) -> i32x4 {
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i32> @llvm.sadd.sat.v4i32(<4 x i32> %{{[0-9a-z]+}}, <4 x i32> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i32> @llvm.sadd.sat.v4i32(<4 x i32> %{{x|_3}}, <4 x i32> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @sadd_i32x8
|
||||
#[no_mangle]
|
||||
pub unsafe fn sadd_i32x8(x: i32x8, y: i32x8) -> i32x8 {
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i32> @llvm.sadd.sat.v8i32(<8 x i32> %{{[0-9a-z]+}}, <8 x i32> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i32> @llvm.sadd.sat.v8i32(<8 x i32> %{{x|_3}}, <8 x i32> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @sadd_i32x16
|
||||
#[no_mangle]
|
||||
pub unsafe fn sadd_i32x16(x: i32x16, y: i32x16) -> i32x16 {
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i32> @llvm.sadd.sat.v16i32(<16 x i32> %{{[0-9a-z]+}}, <16 x i32> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i32> @llvm.sadd.sat.v16i32(<16 x i32> %{{x|_3}}, <16 x i32> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @sadd_i64x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn sadd_i64x2(x: i64x2, y: i64x2) -> i64x2 {
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i64> @llvm.sadd.sat.v2i64(<2 x i64> %{{[0-9a-z]+}}, <2 x i64> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i64> @llvm.sadd.sat.v2i64(<2 x i64> %{{x|_3}}, <2 x i64> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @sadd_i64x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn sadd_i64x4(x: i64x4, y: i64x4) -> i64x4 {
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i64> @llvm.sadd.sat.v4i64(<4 x i64> %{{[0-9a-z]+}}, <4 x i64> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i64> @llvm.sadd.sat.v4i64(<4 x i64> %{{x|_3}}, <4 x i64> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @sadd_i64x8
|
||||
#[no_mangle]
|
||||
pub unsafe fn sadd_i64x8(x: i64x8, y: i64x8) -> i64x8 {
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i64> @llvm.sadd.sat.v8i64(<8 x i64> %{{[0-9a-z]+}}, <8 x i64> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i64> @llvm.sadd.sat.v8i64(<8 x i64> %{{x|_3}}, <8 x i64> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @sadd_i128x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn sadd_i128x2(x: i128x2, y: i128x2) -> i128x2 {
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i128> @llvm.sadd.sat.v2i128(<2 x i128> %{{[0-9a-z]+}}, <2 x i128> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i128> @llvm.sadd.sat.v2i128(<2 x i128> %{{x|_3}}, <2 x i128> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @sadd_i128x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn sadd_i128x4(x: i128x4, y: i128x4) -> i128x4 {
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i128> @llvm.sadd.sat.v4i128(<4 x i128> %{{[0-9a-z]+}}, <4 x i128> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i128> @llvm.sadd.sat.v4i128(<4 x i128> %{{x|_3}}, <4 x i128> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
@ -261,140 +268,140 @@ pub unsafe fn sadd_i128x4(x: i128x4, y: i128x4) -> i128x4 {
|
||||
// CHECK-LABEL: @uadd_u8x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn uadd_u8x2(x: u8x2, y: u8x2) -> u8x2 {
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %{{[0-9a-z]+}}, <2 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i8> @llvm.uadd.sat.v2i8(<2 x i8> %{{x|_3}}, <2 x i8> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @uadd_u8x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn uadd_u8x4(x: u8x4, y: u8x4) -> u8x4 {
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i8> @llvm.uadd.sat.v4i8(<4 x i8> %{{[0-9a-z]+}}, <4 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i8> @llvm.uadd.sat.v4i8(<4 x i8> %{{x|_3}}, <4 x i8> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @uadd_u8x8
|
||||
#[no_mangle]
|
||||
pub unsafe fn uadd_u8x8(x: u8x8, y: u8x8) -> u8x8 {
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i8> @llvm.uadd.sat.v8i8(<8 x i8> %{{[0-9a-z]+}}, <8 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i8> @llvm.uadd.sat.v8i8(<8 x i8> %{{x|_3}}, <8 x i8> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @uadd_u8x16
|
||||
#[no_mangle]
|
||||
pub unsafe fn uadd_u8x16(x: u8x16, y: u8x16) -> u8x16 {
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i8> @llvm.uadd.sat.v16i8(<16 x i8> %{{[0-9a-z]+}}, <16 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i8> @llvm.uadd.sat.v16i8(<16 x i8> %{{x|_3}}, <16 x i8> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @uadd_u8x32
|
||||
#[no_mangle]
|
||||
pub unsafe fn uadd_u8x32(x: u8x32, y: u8x32) -> u8x32 {
|
||||
// CHECK: %{{[0-9]+}} = call <32 x i8> @llvm.uadd.sat.v32i8(<32 x i8> %{{[0-9a-z]+}}, <32 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <32 x i8> @llvm.uadd.sat.v32i8(<32 x i8> %{{x|_3}}, <32 x i8> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @uadd_u8x64
|
||||
#[no_mangle]
|
||||
pub unsafe fn uadd_u8x64(x: u8x64, y: u8x64) -> u8x64 {
|
||||
// CHECK: %{{[0-9]+}} = call <64 x i8> @llvm.uadd.sat.v64i8(<64 x i8> %{{[0-9a-z]+}}, <64 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <64 x i8> @llvm.uadd.sat.v64i8(<64 x i8> %{{x|_3}}, <64 x i8> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @uadd_u16x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn uadd_u16x2(x: u16x2, y: u16x2) -> u16x2 {
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i16> @llvm.uadd.sat.v2i16(<2 x i16> %{{[0-9a-z]+}}, <2 x i16> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i16> @llvm.uadd.sat.v2i16(<2 x i16> %{{x|_3}}, <2 x i16> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @uadd_u16x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn uadd_u16x4(x: u16x4, y: u16x4) -> u16x4 {
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i16> @llvm.uadd.sat.v4i16(<4 x i16> %{{[0-9a-z]+}}, <4 x i16> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i16> @llvm.uadd.sat.v4i16(<4 x i16> %{{x|_3}}, <4 x i16> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @uadd_u16x8
|
||||
#[no_mangle]
|
||||
pub unsafe fn uadd_u16x8(x: u16x8, y: u16x8) -> u16x8 {
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i16> @llvm.uadd.sat.v8i16(<8 x i16> %{{[0-9a-z]+}}, <8 x i16> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i16> @llvm.uadd.sat.v8i16(<8 x i16> %{{x|_3}}, <8 x i16> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @uadd_u16x16
|
||||
#[no_mangle]
|
||||
pub unsafe fn uadd_u16x16(x: u16x16, y: u16x16) -> u16x16 {
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i16> @llvm.uadd.sat.v16i16(<16 x i16> %{{[0-9a-z]+}}, <16 x i16> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i16> @llvm.uadd.sat.v16i16(<16 x i16> %{{x|_3}}, <16 x i16> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @uadd_u16x32
|
||||
#[no_mangle]
|
||||
pub unsafe fn uadd_u16x32(x: u16x32, y: u16x32) -> u16x32 {
|
||||
// CHECK: %{{[0-9]+}} = call <32 x i16> @llvm.uadd.sat.v32i16(<32 x i16> %{{[0-9a-z]+}}, <32 x i16> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <32 x i16> @llvm.uadd.sat.v32i16(<32 x i16> %{{x|_3}}, <32 x i16> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @uadd_u32x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn uadd_u32x2(x: u32x2, y: u32x2) -> u32x2 {
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i32> @llvm.uadd.sat.v2i32(<2 x i32> %{{[0-9a-z]+}}, <2 x i32> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i32> @llvm.uadd.sat.v2i32(<2 x i32> %{{x|_3}}, <2 x i32> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @uadd_u32x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn uadd_u32x4(x: u32x4, y: u32x4) -> u32x4 {
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i32> @llvm.uadd.sat.v4i32(<4 x i32> %{{[0-9a-z]+}}, <4 x i32> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i32> @llvm.uadd.sat.v4i32(<4 x i32> %{{x|_3}}, <4 x i32> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @uadd_u32x8
|
||||
#[no_mangle]
|
||||
pub unsafe fn uadd_u32x8(x: u32x8, y: u32x8) -> u32x8 {
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i32> @llvm.uadd.sat.v8i32(<8 x i32> %{{[0-9a-z]+}}, <8 x i32> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i32> @llvm.uadd.sat.v8i32(<8 x i32> %{{x|_3}}, <8 x i32> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @uadd_u32x16
|
||||
#[no_mangle]
|
||||
pub unsafe fn uadd_u32x16(x: u32x16, y: u32x16) -> u32x16 {
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i32> @llvm.uadd.sat.v16i32(<16 x i32> %{{[0-9a-z]+}}, <16 x i32> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i32> @llvm.uadd.sat.v16i32(<16 x i32> %{{x|_3}}, <16 x i32> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @uadd_u64x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn uadd_u64x2(x: u64x2, y: u64x2) -> u64x2 {
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i64> @llvm.uadd.sat.v2i64(<2 x i64> %{{[0-9a-z]+}}, <2 x i64> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i64> @llvm.uadd.sat.v2i64(<2 x i64> %{{x|_3}}, <2 x i64> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @uadd_u64x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn uadd_u64x4(x: u64x4, y: u64x4) -> u64x4 {
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i64> @llvm.uadd.sat.v4i64(<4 x i64> %{{[0-9a-z]+}}, <4 x i64> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i64> @llvm.uadd.sat.v4i64(<4 x i64> %{{x|_3}}, <4 x i64> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @uadd_u64x8
|
||||
#[no_mangle]
|
||||
pub unsafe fn uadd_u64x8(x: u64x8, y: u64x8) -> u64x8 {
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i64> @llvm.uadd.sat.v8i64(<8 x i64> %{{[0-9a-z]+}}, <8 x i64> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i64> @llvm.uadd.sat.v8i64(<8 x i64> %{{x|_3}}, <8 x i64> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @uadd_u128x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn uadd_u128x2(x: u128x2, y: u128x2) -> u128x2 {
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i128> @llvm.uadd.sat.v2i128(<2 x i128> %{{[0-9a-z]+}}, <2 x i128> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i128> @llvm.uadd.sat.v2i128(<2 x i128> %{{x|_3}}, <2 x i128> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @uadd_u128x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn uadd_u128x4(x: u128x4, y: u128x4) -> u128x4 {
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i128> @llvm.uadd.sat.v4i128(<4 x i128> %{{[0-9a-z]+}}, <4 x i128> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i128> @llvm.uadd.sat.v4i128(<4 x i128> %{{x|_3}}, <4 x i128> %{{y|_4}})
|
||||
simd_saturating_add(x, y)
|
||||
}
|
||||
|
||||
@ -405,140 +412,140 @@ pub unsafe fn uadd_u128x4(x: u128x4, y: u128x4) -> u128x4 {
|
||||
// CHECK-LABEL: @ssub_i8x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn ssub_i8x2(x: i8x2, y: i8x2) -> i8x2 {
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %{{[0-9a-z]+}}, <2 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i8> @llvm.ssub.sat.v2i8(<2 x i8> %{{x|_3}}, <2 x i8> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @ssub_i8x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn ssub_i8x4(x: i8x4, y: i8x4) -> i8x4 {
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i8> @llvm.ssub.sat.v4i8(<4 x i8> %{{[0-9a-z]+}}, <4 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i8> @llvm.ssub.sat.v4i8(<4 x i8> %{{x|_3}}, <4 x i8> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @ssub_i8x8
|
||||
#[no_mangle]
|
||||
pub unsafe fn ssub_i8x8(x: i8x8, y: i8x8) -> i8x8 {
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i8> @llvm.ssub.sat.v8i8(<8 x i8> %{{[0-9a-z]+}}, <8 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i8> @llvm.ssub.sat.v8i8(<8 x i8> %{{x|_3}}, <8 x i8> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @ssub_i8x16
|
||||
#[no_mangle]
|
||||
pub unsafe fn ssub_i8x16(x: i8x16, y: i8x16) -> i8x16 {
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i8> @llvm.ssub.sat.v16i8(<16 x i8> %{{[0-9a-z]+}}, <16 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i8> @llvm.ssub.sat.v16i8(<16 x i8> %{{x|_3}}, <16 x i8> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @ssub_i8x32
|
||||
#[no_mangle]
|
||||
pub unsafe fn ssub_i8x32(x: i8x32, y: i8x32) -> i8x32 {
|
||||
// CHECK: %{{[0-9]+}} = call <32 x i8> @llvm.ssub.sat.v32i8(<32 x i8> %{{[0-9a-z]+}}, <32 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <32 x i8> @llvm.ssub.sat.v32i8(<32 x i8> %{{x|_3}}, <32 x i8> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @ssub_i8x64
|
||||
#[no_mangle]
|
||||
pub unsafe fn ssub_i8x64(x: i8x64, y: i8x64) -> i8x64 {
|
||||
// CHECK: %{{[0-9]+}} = call <64 x i8> @llvm.ssub.sat.v64i8(<64 x i8> %{{[0-9a-z]+}}, <64 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <64 x i8> @llvm.ssub.sat.v64i8(<64 x i8> %{{x|_3}}, <64 x i8> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @ssub_i16x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn ssub_i16x2(x: i16x2, y: i16x2) -> i16x2 {
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i16> @llvm.ssub.sat.v2i16(<2 x i16> %{{[0-9a-z]+}}, <2 x i16> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i16> @llvm.ssub.sat.v2i16(<2 x i16> %{{x|_3}}, <2 x i16> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @ssub_i16x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn ssub_i16x4(x: i16x4, y: i16x4) -> i16x4 {
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i16> @llvm.ssub.sat.v4i16(<4 x i16> %{{[0-9a-z]+}}, <4 x i16> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i16> @llvm.ssub.sat.v4i16(<4 x i16> %{{x|_3}}, <4 x i16> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @ssub_i16x8
|
||||
#[no_mangle]
|
||||
pub unsafe fn ssub_i16x8(x: i16x8, y: i16x8) -> i16x8 {
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i16> @llvm.ssub.sat.v8i16(<8 x i16> %{{[0-9a-z]+}}, <8 x i16> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i16> @llvm.ssub.sat.v8i16(<8 x i16> %{{x|_3}}, <8 x i16> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @ssub_i16x16
|
||||
#[no_mangle]
|
||||
pub unsafe fn ssub_i16x16(x: i16x16, y: i16x16) -> i16x16 {
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i16> @llvm.ssub.sat.v16i16(<16 x i16> %{{[0-9a-z]+}}, <16 x i16> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i16> @llvm.ssub.sat.v16i16(<16 x i16> %{{x|_3}}, <16 x i16> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @ssub_i16x32
|
||||
#[no_mangle]
|
||||
pub unsafe fn ssub_i16x32(x: i16x32, y: i16x32) -> i16x32 {
|
||||
// CHECK: %{{[0-9]+}} = call <32 x i16> @llvm.ssub.sat.v32i16(<32 x i16> %{{[0-9a-z]+}}, <32 x i16> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <32 x i16> @llvm.ssub.sat.v32i16(<32 x i16> %{{x|_3}}, <32 x i16> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @ssub_i32x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn ssub_i32x2(x: i32x2, y: i32x2) -> i32x2 {
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i32> @llvm.ssub.sat.v2i32(<2 x i32> %{{[0-9a-z]+}}, <2 x i32> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i32> @llvm.ssub.sat.v2i32(<2 x i32> %{{x|_3}}, <2 x i32> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @ssub_i32x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn ssub_i32x4(x: i32x4, y: i32x4) -> i32x4 {
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i32> @llvm.ssub.sat.v4i32(<4 x i32> %{{[0-9a-z]+}}, <4 x i32> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i32> @llvm.ssub.sat.v4i32(<4 x i32> %{{x|_3}}, <4 x i32> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @ssub_i32x8
|
||||
#[no_mangle]
|
||||
pub unsafe fn ssub_i32x8(x: i32x8, y: i32x8) -> i32x8 {
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i32> @llvm.ssub.sat.v8i32(<8 x i32> %{{[0-9a-z]+}}, <8 x i32> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i32> @llvm.ssub.sat.v8i32(<8 x i32> %{{x|_3}}, <8 x i32> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @ssub_i32x16
|
||||
#[no_mangle]
|
||||
pub unsafe fn ssub_i32x16(x: i32x16, y: i32x16) -> i32x16 {
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i32> @llvm.ssub.sat.v16i32(<16 x i32> %{{[0-9a-z]+}}, <16 x i32> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i32> @llvm.ssub.sat.v16i32(<16 x i32> %{{x|_3}}, <16 x i32> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @ssub_i64x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn ssub_i64x2(x: i64x2, y: i64x2) -> i64x2 {
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i64> @llvm.ssub.sat.v2i64(<2 x i64> %{{[0-9a-z]+}}, <2 x i64> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i64> @llvm.ssub.sat.v2i64(<2 x i64> %{{x|_3}}, <2 x i64> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @ssub_i64x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn ssub_i64x4(x: i64x4, y: i64x4) -> i64x4 {
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i64> @llvm.ssub.sat.v4i64(<4 x i64> %{{[0-9a-z]+}}, <4 x i64> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i64> @llvm.ssub.sat.v4i64(<4 x i64> %{{x|_3}}, <4 x i64> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @ssub_i64x8
|
||||
#[no_mangle]
|
||||
pub unsafe fn ssub_i64x8(x: i64x8, y: i64x8) -> i64x8 {
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i64> @llvm.ssub.sat.v8i64(<8 x i64> %{{[0-9a-z]+}}, <8 x i64> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i64> @llvm.ssub.sat.v8i64(<8 x i64> %{{x|_3}}, <8 x i64> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @ssub_i128x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn ssub_i128x2(x: i128x2, y: i128x2) -> i128x2 {
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i128> @llvm.ssub.sat.v2i128(<2 x i128> %{{[0-9a-z]+}}, <2 x i128> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i128> @llvm.ssub.sat.v2i128(<2 x i128> %{{x|_3}}, <2 x i128> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @ssub_i128x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn ssub_i128x4(x: i128x4, y: i128x4) -> i128x4 {
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i128> @llvm.ssub.sat.v4i128(<4 x i128> %{{[0-9a-z]+}}, <4 x i128> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i128> @llvm.ssub.sat.v4i128(<4 x i128> %{{x|_3}}, <4 x i128> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
@ -547,139 +554,139 @@ pub unsafe fn ssub_i128x4(x: i128x4, y: i128x4) -> i128x4 {
|
||||
// CHECK-LABEL: @usub_u8x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn usub_u8x2(x: u8x2, y: u8x2) -> u8x2 {
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %{{[0-9a-z]+}}, <2 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i8> @llvm.usub.sat.v2i8(<2 x i8> %{{x|_3}}, <2 x i8> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @usub_u8x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn usub_u8x4(x: u8x4, y: u8x4) -> u8x4 {
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i8> @llvm.usub.sat.v4i8(<4 x i8> %{{[0-9a-z]+}}, <4 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i8> @llvm.usub.sat.v4i8(<4 x i8> %{{x|_3}}, <4 x i8> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @usub_u8x8
|
||||
#[no_mangle]
|
||||
pub unsafe fn usub_u8x8(x: u8x8, y: u8x8) -> u8x8 {
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i8> @llvm.usub.sat.v8i8(<8 x i8> %{{[0-9a-z]+}}, <8 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i8> @llvm.usub.sat.v8i8(<8 x i8> %{{x|_3}}, <8 x i8> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @usub_u8x16
|
||||
#[no_mangle]
|
||||
pub unsafe fn usub_u8x16(x: u8x16, y: u8x16) -> u8x16 {
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i8> @llvm.usub.sat.v16i8(<16 x i8> %{{[0-9a-z]+}}, <16 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i8> @llvm.usub.sat.v16i8(<16 x i8> %{{x|_3}}, <16 x i8> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @usub_u8x32
|
||||
#[no_mangle]
|
||||
pub unsafe fn usub_u8x32(x: u8x32, y: u8x32) -> u8x32 {
|
||||
// CHECK: %{{[0-9]+}} = call <32 x i8> @llvm.usub.sat.v32i8(<32 x i8> %{{[0-9a-z]+}}, <32 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <32 x i8> @llvm.usub.sat.v32i8(<32 x i8> %{{x|_3}}, <32 x i8> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @usub_u8x64
|
||||
#[no_mangle]
|
||||
pub unsafe fn usub_u8x64(x: u8x64, y: u8x64) -> u8x64 {
|
||||
// CHECK: %{{[0-9]+}} = call <64 x i8> @llvm.usub.sat.v64i8(<64 x i8> %{{[0-9a-z]+}}, <64 x i8> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <64 x i8> @llvm.usub.sat.v64i8(<64 x i8> %{{x|_3}}, <64 x i8> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @usub_u16x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn usub_u16x2(x: u16x2, y: u16x2) -> u16x2 {
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i16> @llvm.usub.sat.v2i16(<2 x i16> %{{[0-9a-z]+}}, <2 x i16> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i16> @llvm.usub.sat.v2i16(<2 x i16> %{{x|_3}}, <2 x i16> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @usub_u16x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn usub_u16x4(x: u16x4, y: u16x4) -> u16x4 {
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i16> @llvm.usub.sat.v4i16(<4 x i16> %{{[0-9a-z]+}}, <4 x i16> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i16> @llvm.usub.sat.v4i16(<4 x i16> %{{x|_3}}, <4 x i16> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @usub_u16x8
|
||||
#[no_mangle]
|
||||
pub unsafe fn usub_u16x8(x: u16x8, y: u16x8) -> u16x8 {
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i16> @llvm.usub.sat.v8i16(<8 x i16> %{{[0-9a-z]+}}, <8 x i16> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i16> @llvm.usub.sat.v8i16(<8 x i16> %{{x|_3}}, <8 x i16> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @usub_u16x16
|
||||
#[no_mangle]
|
||||
pub unsafe fn usub_u16x16(x: u16x16, y: u16x16) -> u16x16 {
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i16> @llvm.usub.sat.v16i16(<16 x i16> %{{[0-9a-z]+}}, <16 x i16> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i16> @llvm.usub.sat.v16i16(<16 x i16> %{{x|_3}}, <16 x i16> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @usub_u16x32
|
||||
#[no_mangle]
|
||||
pub unsafe fn usub_u16x32(x: u16x32, y: u16x32) -> u16x32 {
|
||||
// CHECK: %{{[0-9]+}} = call <32 x i16> @llvm.usub.sat.v32i16(<32 x i16> %{{[0-9a-z]+}}, <32 x i16> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <32 x i16> @llvm.usub.sat.v32i16(<32 x i16> %{{x|_3}}, <32 x i16> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @usub_u32x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn usub_u32x2(x: u32x2, y: u32x2) -> u32x2 {
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i32> @llvm.usub.sat.v2i32(<2 x i32> %{{[0-9a-z]+}}, <2 x i32> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i32> @llvm.usub.sat.v2i32(<2 x i32> %{{x|_3}}, <2 x i32> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @usub_u32x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn usub_u32x4(x: u32x4, y: u32x4) -> u32x4 {
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i32> @llvm.usub.sat.v4i32(<4 x i32> %{{[0-9a-z]+}}, <4 x i32> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i32> @llvm.usub.sat.v4i32(<4 x i32> %{{x|_3}}, <4 x i32> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @usub_u32x8
|
||||
#[no_mangle]
|
||||
pub unsafe fn usub_u32x8(x: u32x8, y: u32x8) -> u32x8 {
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i32> @llvm.usub.sat.v8i32(<8 x i32> %{{[0-9a-z]+}}, <8 x i32> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i32> @llvm.usub.sat.v8i32(<8 x i32> %{{x|_3}}, <8 x i32> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @usub_u32x16
|
||||
#[no_mangle]
|
||||
pub unsafe fn usub_u32x16(x: u32x16, y: u32x16) -> u32x16 {
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i32> @llvm.usub.sat.v16i32(<16 x i32> %{{[0-9a-z]+}}, <16 x i32> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <16 x i32> @llvm.usub.sat.v16i32(<16 x i32> %{{x|_3}}, <16 x i32> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @usub_u64x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn usub_u64x2(x: u64x2, y: u64x2) -> u64x2 {
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i64> @llvm.usub.sat.v2i64(<2 x i64> %{{[0-9a-z]+}}, <2 x i64> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i64> @llvm.usub.sat.v2i64(<2 x i64> %{{x|_3}}, <2 x i64> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @usub_u64x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn usub_u64x4(x: u64x4, y: u64x4) -> u64x4 {
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i64> @llvm.usub.sat.v4i64(<4 x i64> %{{[0-9a-z]+}}, <4 x i64> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i64> @llvm.usub.sat.v4i64(<4 x i64> %{{x|_3}}, <4 x i64> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @usub_u64x8
|
||||
#[no_mangle]
|
||||
pub unsafe fn usub_u64x8(x: u64x8, y: u64x8) -> u64x8 {
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i64> @llvm.usub.sat.v8i64(<8 x i64> %{{[0-9a-z]+}}, <8 x i64> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <8 x i64> @llvm.usub.sat.v8i64(<8 x i64> %{{x|_3}}, <8 x i64> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @usub_u128x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn usub_u128x2(x: u128x2, y: u128x2) -> u128x2 {
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i128> @llvm.usub.sat.v2i128(<2 x i128> %{{[0-9a-z]+}}, <2 x i128> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <2 x i128> @llvm.usub.sat.v2i128(<2 x i128> %{{x|_3}}, <2 x i128> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @usub_u128x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn usub_u128x4(x: u128x4, y: u128x4) -> u128x4 {
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i128> @llvm.usub.sat.v4i128(<4 x i128> %{{[0-9a-z]+}}, <4 x i128> %{{[0-9a-z]+}})
|
||||
// CHECK: %{{[0-9]+}} = call <4 x i128> @llvm.usub.sat.v4i128(<4 x i128> %{{x|_3}}, <4 x i128> %{{y|_4}})
|
||||
simd_saturating_sub(x, y)
|
||||
}
|
||||
|
||||
@ -26,10 +26,16 @@ extern "platform-intrinsic" {
|
||||
fn simd_bitmask<T, U>(x: T) -> U;
|
||||
}
|
||||
|
||||
// NOTE(eddyb) `%{{x|_2}}` is used because on some targets (e.g. WASM)
|
||||
// SIMD vectors are passed directly, resulting in `%x` being a vector,
|
||||
// while on others they're passed indirectly, resulting in `%x` being
|
||||
// a pointer to a vector, and `%_2` a vector loaded from that pointer.
|
||||
// This is controlled by the target spec option `simd_types_indirect`.
|
||||
|
||||
// CHECK-LABEL: @bitmask_int
|
||||
#[no_mangle]
|
||||
pub unsafe fn bitmask_int(x: i32x2) -> u8 {
|
||||
// CHECK: [[A:%[0-9]+]] = lshr <2 x i32> %{{[0-9a-z]+}}, <i32 31, i32 31>
|
||||
// CHECK: [[A:%[0-9]+]] = lshr <2 x i32> %{{x|_2}}, <i32 31, i32 31>
|
||||
// CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
|
||||
// CHECK: [[C:%[0-9]+]] = bitcast <2 x i1> [[B]] to i2
|
||||
// CHECK: %{{[0-9]+}} = zext i2 [[C]] to i8
|
||||
@ -39,7 +45,7 @@ pub unsafe fn bitmask_int(x: i32x2) -> u8 {
|
||||
// CHECK-LABEL: @bitmask_uint
|
||||
#[no_mangle]
|
||||
pub unsafe fn bitmask_uint(x: u32x2) -> u8 {
|
||||
// CHECK: [[A:%[0-9]+]] = lshr <2 x i32> %{{[0-9a-z]+}}, <i32 31, i32 31>
|
||||
// CHECK: [[A:%[0-9]+]] = lshr <2 x i32> %{{x|_2}}, <i32 31, i32 31>
|
||||
// CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
|
||||
// CHECK: [[C:%[0-9]+]] = bitcast <2 x i1> [[B]] to i2
|
||||
// CHECK: %{{[0-9]+}} = zext i2 [[C]] to i8
|
||||
@ -49,7 +55,7 @@ pub unsafe fn bitmask_uint(x: u32x2) -> u8 {
|
||||
// CHECK-LABEL: @bitmask_int16
|
||||
#[no_mangle]
|
||||
pub unsafe fn bitmask_int16(x: i8x16) -> u16 {
|
||||
// CHECK: [[A:%[0-9]+]] = lshr <16 x i8> %{{[0-9a-z]+}}, <i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7>
|
||||
// CHECK: [[A:%[0-9]+]] = lshr <16 x i8> %{{x|_2}}, <i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7, i8 7>
|
||||
// CHECK: [[B:%[0-9]+]] = trunc <16 x i8> [[A]] to <16 x i1>
|
||||
// CHECK: %{{[0-9]+}} = bitcast <16 x i1> [[B]] to i16
|
||||
// CHECK-NOT: zext
|
||||
|
||||
Loading…
Reference in New Issue
Block a user