From d9fd7202ff7f9b60f1a65ee73f6349d713580bd6 Mon Sep 17 00:00:00 2001 From: ywxt Date: Fri, 25 Jul 2025 17:24:14 +0800 Subject: [PATCH 1/8] Fix async closures not reproducible --- compiler/rustc_middle/src/mir/mono.rs | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/compiler/rustc_middle/src/mir/mono.rs b/compiler/rustc_middle/src/mir/mono.rs index 105736b9e243e..ae256e74c0441 100644 --- a/compiler/rustc_middle/src/mir/mono.rs +++ b/compiler/rustc_middle/src/mir/mono.rs @@ -12,7 +12,6 @@ use rustc_data_structures::unord::UnordMap; use rustc_hashes::Hash128; use rustc_hir::ItemId; use rustc_hir::def_id::{CrateNum, DefId, DefIdSet, LOCAL_CRATE}; -use rustc_index::Idx; use rustc_macros::{HashStable, TyDecodable, TyEncodable}; use rustc_query_system::ich::StableHashingContext; use rustc_session::config::OptLevel; @@ -527,8 +526,8 @@ impl<'tcx> CodegenUnit<'tcx> { ) -> Vec<(MonoItem<'tcx>, MonoItemData)> { // The codegen tests rely on items being process in the same order as // they appear in the file, so for local items, we sort by node_id first - #[derive(PartialEq, Eq, PartialOrd, Ord)] - struct ItemSortKey<'tcx>(Option, SymbolName<'tcx>); + #[derive(PartialEq, Eq, PartialOrd, Ord, Debug)] + struct ItemSortKey<'tcx>(Option, SymbolName<'tcx>); fn item_sort_key<'tcx>(tcx: TyCtxt<'tcx>, item: MonoItem<'tcx>) -> ItemSortKey<'tcx> { ItemSortKey( @@ -539,7 +538,9 @@ impl<'tcx> CodegenUnit<'tcx> { // instances into account. The others don't matter for // the codegen tests and can even make item order // unstable. - InstanceKind::Item(def) => def.as_local().map(Idx::index), + InstanceKind::Item(def) => { + def.as_local().map(|def_id|tcx.def_span(def_id)) + }, InstanceKind::VTableShim(..) | InstanceKind::ReifyShim(..) | InstanceKind::Intrinsic(..) @@ -556,8 +557,8 @@ impl<'tcx> CodegenUnit<'tcx> { | InstanceKind::AsyncDropGlueCtorShim(..) => None, } } - MonoItem::Static(def_id) => def_id.as_local().map(Idx::index), - MonoItem::GlobalAsm(item_id) => Some(item_id.owner_id.def_id.index()), + MonoItem::Static(def_id) => def_id.as_local().map(|def_id|tcx.def_span(def_id)), + MonoItem::GlobalAsm(item_id) => Some(tcx.def_span(item_id.owner_id.def_id)), }, item.symbol_name(tcx), ) From 7f522ea5d9e846ca9d5cd68d947558681a4621f1 Mon Sep 17 00:00:00 2001 From: ywxt Date: Fri, 25 Jul 2025 17:27:15 +0800 Subject: [PATCH 2/8] Fix fmt --- compiler/rustc_middle/src/mir/mono.rs | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/compiler/rustc_middle/src/mir/mono.rs b/compiler/rustc_middle/src/mir/mono.rs index ae256e74c0441..18a8a7d1d3350 100644 --- a/compiler/rustc_middle/src/mir/mono.rs +++ b/compiler/rustc_middle/src/mir/mono.rs @@ -539,8 +539,8 @@ impl<'tcx> CodegenUnit<'tcx> { // the codegen tests and can even make item order // unstable. InstanceKind::Item(def) => { - def.as_local().map(|def_id|tcx.def_span(def_id)) - }, + def.as_local().map(|def_id| tcx.def_span(def_id)) + } InstanceKind::VTableShim(..) | InstanceKind::ReifyShim(..) | InstanceKind::Intrinsic(..) @@ -557,7 +557,9 @@ impl<'tcx> CodegenUnit<'tcx> { | InstanceKind::AsyncDropGlueCtorShim(..) => None, } } - MonoItem::Static(def_id) => def_id.as_local().map(|def_id|tcx.def_span(def_id)), + MonoItem::Static(def_id) => { + def_id.as_local().map(|def_id| tcx.def_span(def_id)) + } MonoItem::GlobalAsm(item_id) => Some(tcx.def_span(item_id.owner_id.def_id)), }, item.symbol_name(tcx), From af9ad4fc4f8c2e64b7f1be718d43a2c566bb94d2 Mon Sep 17 00:00:00 2001 From: ywxt Date: Sat, 26 Jul 2025 14:21:29 +0800 Subject: [PATCH 3/8] Use the local_span method. --- compiler/rustc_middle/src/mir/mono.rs | 37 ++------------------------- 1 file changed, 2 insertions(+), 35 deletions(-) diff --git a/compiler/rustc_middle/src/mir/mono.rs b/compiler/rustc_middle/src/mir/mono.rs index 18a8a7d1d3350..f60d1cba34c73 100644 --- a/compiler/rustc_middle/src/mir/mono.rs +++ b/compiler/rustc_middle/src/mir/mono.rs @@ -525,45 +525,12 @@ impl<'tcx> CodegenUnit<'tcx> { tcx: TyCtxt<'tcx>, ) -> Vec<(MonoItem<'tcx>, MonoItemData)> { // The codegen tests rely on items being process in the same order as - // they appear in the file, so for local items, we sort by node_id first + // they appear in the file, so for local items, we sort by span first #[derive(PartialEq, Eq, PartialOrd, Ord, Debug)] struct ItemSortKey<'tcx>(Option, SymbolName<'tcx>); fn item_sort_key<'tcx>(tcx: TyCtxt<'tcx>, item: MonoItem<'tcx>) -> ItemSortKey<'tcx> { - ItemSortKey( - match item { - MonoItem::Fn(ref instance) => { - match instance.def { - // We only want to take HirIds of user-defined - // instances into account. The others don't matter for - // the codegen tests and can even make item order - // unstable. - InstanceKind::Item(def) => { - def.as_local().map(|def_id| tcx.def_span(def_id)) - } - InstanceKind::VTableShim(..) - | InstanceKind::ReifyShim(..) - | InstanceKind::Intrinsic(..) - | InstanceKind::FnPtrShim(..) - | InstanceKind::Virtual(..) - | InstanceKind::ClosureOnceShim { .. } - | InstanceKind::ConstructCoroutineInClosureShim { .. } - | InstanceKind::DropGlue(..) - | InstanceKind::CloneShim(..) - | InstanceKind::ThreadLocalShim(..) - | InstanceKind::FnPtrAddrShim(..) - | InstanceKind::AsyncDropGlue(..) - | InstanceKind::FutureDropPollShim(..) - | InstanceKind::AsyncDropGlueCtorShim(..) => None, - } - } - MonoItem::Static(def_id) => { - def_id.as_local().map(|def_id| tcx.def_span(def_id)) - } - MonoItem::GlobalAsm(item_id) => Some(tcx.def_span(item_id.owner_id.def_id)), - }, - item.symbol_name(tcx), - ) + ItemSortKey(item.local_span(tcx), item.symbol_name(tcx)) } let mut items: Vec<_> = self.items().iter().map(|(&i, &data)| (i, data)).collect(); From e24bd7d6926c0c172c67c7d11b9595cbd1aa3941 Mon Sep 17 00:00:00 2001 From: ywxt Date: Sat, 26 Jul 2025 15:10:59 +0800 Subject: [PATCH 4/8] Remove Debug trait for ItemSortKey. --- compiler/rustc_middle/src/mir/mono.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/rustc_middle/src/mir/mono.rs b/compiler/rustc_middle/src/mir/mono.rs index f60d1cba34c73..b62a3fb39f0bb 100644 --- a/compiler/rustc_middle/src/mir/mono.rs +++ b/compiler/rustc_middle/src/mir/mono.rs @@ -526,7 +526,7 @@ impl<'tcx> CodegenUnit<'tcx> { ) -> Vec<(MonoItem<'tcx>, MonoItemData)> { // The codegen tests rely on items being process in the same order as // they appear in the file, so for local items, we sort by span first - #[derive(PartialEq, Eq, PartialOrd, Ord, Debug)] + #[derive(PartialEq, Eq, PartialOrd, Ord)] struct ItemSortKey<'tcx>(Option, SymbolName<'tcx>); fn item_sort_key<'tcx>(tcx: TyCtxt<'tcx>, item: MonoItem<'tcx>) -> ItemSortKey<'tcx> { From 4abc42691b966cd77146831a52a77cff8486a61a Mon Sep 17 00:00:00 2001 From: ywxt Date: Mon, 28 Jul 2025 14:02:44 +0800 Subject: [PATCH 5/8] Using def_path to fix tests. --- compiler/rustc_middle/src/mir/mono.rs | 14 +- src/tools/compiletest/src/runtest/assembly.rs | 1 - tests/assembly-llvm/asm/aarch64-modifiers.rs | 56 +- tests/assembly-llvm/asm/aarch64-types.rs | 348 ++++----- tests/assembly-llvm/asm/arm-modifiers.rs | 53 +- tests/assembly-llvm/asm/arm-types.rs | 441 ++++++----- tests/assembly-llvm/asm/avr-modifiers.rs | 8 +- tests/assembly-llvm/asm/avr-types.rs | 115 ++- tests/assembly-llvm/asm/bpf-types.rs | 56 +- tests/assembly-llvm/asm/hexagon-types.rs | 69 +- tests/assembly-llvm/asm/loongarch-type.rs | 96 +-- tests/assembly-llvm/asm/m68k-types.rs | 24 +- tests/assembly-llvm/asm/mips-types.rs | 129 ++-- tests/assembly-llvm/asm/msp430-types.rs | 104 +-- tests/assembly-llvm/asm/nvptx-types.rs | 36 +- tests/assembly-llvm/asm/powerpc-types.rs | 370 ++++----- tests/assembly-llvm/asm/riscv-types.rs | 98 +-- tests/assembly-llvm/asm/s390x-types.rs | 196 ++--- tests/assembly-llvm/asm/sparc-types.rs | 62 +- tests/assembly-llvm/asm/wasm-types.rs | 50 +- tests/assembly-llvm/asm/x86-modifiers.rs | 83 +- tests/assembly-llvm/asm/x86-types.rs | 706 +++++++++--------- 22 files changed, 1558 insertions(+), 1557 deletions(-) diff --git a/compiler/rustc_middle/src/mir/mono.rs b/compiler/rustc_middle/src/mir/mono.rs index b62a3fb39f0bb..c36efbd45dbac 100644 --- a/compiler/rustc_middle/src/mir/mono.rs +++ b/compiler/rustc_middle/src/mir/mono.rs @@ -525,12 +525,20 @@ impl<'tcx> CodegenUnit<'tcx> { tcx: TyCtxt<'tcx>, ) -> Vec<(MonoItem<'tcx>, MonoItemData)> { // The codegen tests rely on items being process in the same order as - // they appear in the file, so for local items, we sort by span first + // they appear in the file, so for local items, we sort by span and def_path first #[derive(PartialEq, Eq, PartialOrd, Ord)] - struct ItemSortKey<'tcx>(Option, SymbolName<'tcx>); + struct ItemSortKey<'tcx>(Option, Option, SymbolName<'tcx>); fn item_sort_key<'tcx>(tcx: TyCtxt<'tcx>, item: MonoItem<'tcx>) -> ItemSortKey<'tcx> { - ItemSortKey(item.local_span(tcx), item.symbol_name(tcx)) + ItemSortKey( + // For codegen tests purposes, we don't care about non-local items' order, + // so we just sort non-local items by symbol names. + item.local_span(tcx), + item.def_id() + .as_local() + .map(|_| tcx.def_path(item.def_id()).to_string_no_crate_verbose()), + item.symbol_name(tcx), + ) } let mut items: Vec<_> = self.items().iter().map(|(&i, &data)| (i, data)).collect(); diff --git a/src/tools/compiletest/src/runtest/assembly.rs b/src/tools/compiletest/src/runtest/assembly.rs index 91d4f620f7194..398c65eca080f 100644 --- a/src/tools/compiletest/src/runtest/assembly.rs +++ b/src/tools/compiletest/src/runtest/assembly.rs @@ -42,7 +42,6 @@ impl TestCx<'_> { LinkToAux::Yes, Vec::new(), ); - let proc_res = self.compose_and_run_compiler(rustc, None, self.testpaths); (proc_res, output_path) } diff --git a/tests/assembly-llvm/asm/aarch64-modifiers.rs b/tests/assembly-llvm/asm/aarch64-modifiers.rs index 58f7c114d3a60..40ea33315647f 100644 --- a/tests/assembly-llvm/asm/aarch64-modifiers.rs +++ b/tests/assembly-llvm/asm/aarch64-modifiers.rs @@ -55,35 +55,17 @@ check!(vreg vreg "add {0}.4s, {0}.4s, {0}.4s"); // CHECK: //NO_APP check!(vreg_b vreg "ldr {:b}, [x0]"); -// CHECK-LABEL: vreg_h: -// CHECK: //APP -// CHECK: ldr h0, [x0] -// CHECK: //NO_APP -check!(vreg_h vreg "ldr {:h}, [x0]"); - -// CHECK-LABEL: vreg_s: -// CHECK: //APP -// CHECK: ldr s0, [x0] -// CHECK: //NO_APP -check!(vreg_s vreg "ldr {:s}, [x0]"); - // CHECK-LABEL: vreg_d: // CHECK: //APP // CHECK: ldr d0, [x0] // CHECK: //NO_APP check!(vreg_d vreg "ldr {:d}, [x0]"); -// CHECK-LABEL: vreg_q: -// CHECK: //APP -// CHECK: ldr q0, [x0] -// CHECK: //NO_APP -check!(vreg_q vreg "ldr {:q}, [x0]"); - -// CHECK-LABEL: vreg_v: +// CHECK-LABEL: vreg_h: // CHECK: //APP -// CHECK: add v0.4s, v0.4s, v0.4s +// CHECK: ldr h0, [x0] // CHECK: //NO_APP -check!(vreg_v vreg "add {0:v}.4s, {0:v}.4s, {0:v}.4s"); +check!(vreg_h vreg "ldr {:h}, [x0]"); // CHECK-LABEL: vreg_low16: // CHECK: //APP @@ -97,32 +79,50 @@ check!(vreg_low16 vreg_low16 "add {0}.4s, {0}.4s, {0}.4s"); // CHECK: //NO_APP check!(vreg_low16_b vreg_low16 "ldr {:b}, [x0]"); +// CHECK-LABEL: vreg_low16_d: +// CHECK: //APP +// CHECK: ldr d0, [x0] +// CHECK: //NO_APP +check!(vreg_low16_d vreg_low16 "ldr {:d}, [x0]"); + // CHECK-LABEL: vreg_low16_h: // CHECK: //APP // CHECK: ldr h0, [x0] // CHECK: //NO_APP check!(vreg_low16_h vreg_low16 "ldr {:h}, [x0]"); +// CHECK-LABEL: vreg_low16_q: +// CHECK: //APP +// CHECK: ldr q0, [x0] +// CHECK: //NO_APP +check!(vreg_low16_q vreg_low16 "ldr {:q}, [x0]"); + // CHECK-LABEL: vreg_low16_s: // CHECK: //APP // CHECK: ldr s0, [x0] // CHECK: //NO_APP check!(vreg_low16_s vreg_low16 "ldr {:s}, [x0]"); -// CHECK-LABEL: vreg_low16_d: +// CHECK-LABEL: vreg_low16_v: // CHECK: //APP -// CHECK: ldr d0, [x0] +// CHECK: add v0.4s, v0.4s, v0.4s // CHECK: //NO_APP -check!(vreg_low16_d vreg_low16 "ldr {:d}, [x0]"); +check!(vreg_low16_v vreg_low16 "add {0:v}.4s, {0:v}.4s, {0:v}.4s"); -// CHECK-LABEL: vreg_low16_q: +// CHECK-LABEL: vreg_q: // CHECK: //APP // CHECK: ldr q0, [x0] // CHECK: //NO_APP -check!(vreg_low16_q vreg_low16 "ldr {:q}, [x0]"); +check!(vreg_q vreg "ldr {:q}, [x0]"); -// CHECK-LABEL: vreg_low16_v: +// CHECK-LABEL: vreg_s: +// CHECK: //APP +// CHECK: ldr s0, [x0] +// CHECK: //NO_APP +check!(vreg_s vreg "ldr {:s}, [x0]"); + +// CHECK-LABEL: vreg_v: // CHECK: //APP // CHECK: add v0.4s, v0.4s, v0.4s // CHECK: //NO_APP -check!(vreg_low16_v vreg_low16 "add {0:v}.4s, {0:v}.4s, {0:v}.4s"); +check!(vreg_v vreg "add {0:v}.4s, {0:v}.4s, {0:v}.4s"); diff --git a/tests/assembly-llvm/asm/aarch64-types.rs b/tests/assembly-llvm/asm/aarch64-types.rs index b7abeb0229865..b37eb565209ad 100644 --- a/tests/assembly-llvm/asm/aarch64-types.rs +++ b/tests/assembly-llvm/asm/aarch64-types.rs @@ -128,35 +128,35 @@ macro_rules! check_reg { }; } -// CHECK-LABEL: {{("#)?}}reg_i8{{"?}} +// CHECK-LABEL: {{("#)?}}reg_f16{{"?}} // CHECK: //APP // CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} // CHECK: //NO_APP -check!(reg_i8 i8 reg "mov" ""); +check!(reg_f16 f16 reg "mov" ""); -// CHECK-LABEL: {{("#)?}}reg_i16{{"?}} +// CHECK-LABEL: {{("#)?}}reg_f32{{"?}} // CHECK: //APP // CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} // CHECK: //NO_APP -check!(reg_i16 i16 reg "mov" ""); +check!(reg_f32 f32 reg "mov" ""); -// CHECK-LABEL: {{("#)?}}reg_f16{{"?}} +// CHECK-LABEL: {{("#)?}}reg_f64{{"?}} // CHECK: //APP // CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} // CHECK: //NO_APP -check!(reg_f16 f16 reg "mov" ""); +check!(reg_f64 f64 reg "mov" ""); -// CHECK-LABEL: {{("#)?}}reg_i32{{"?}} +// CHECK-LABEL: {{("#)?}}reg_i16{{"?}} // CHECK: //APP // CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} // CHECK: //NO_APP -check!(reg_i32 i32 reg "mov" ""); +check!(reg_i16 i16 reg "mov" ""); -// CHECK-LABEL: {{("#)?}}reg_f32{{"?}} +// CHECK-LABEL: {{("#)?}}reg_i32{{"?}} // CHECK: //APP // CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} // CHECK: //NO_APP -check!(reg_f32 f32 reg "mov" ""); +check!(reg_i32 i32 reg "mov" ""); // CHECK-LABEL: {{("#)?}}reg_i64{{"?}} // CHECK: //APP @@ -164,11 +164,11 @@ check!(reg_f32 f32 reg "mov" ""); // CHECK: //NO_APP check!(reg_i64 i64 reg "mov" ""); -// CHECK-LABEL: {{("#)?}}reg_f64{{"?}} +// CHECK-LABEL: {{("#)?}}reg_i8{{"?}} // CHECK: //APP // CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} // CHECK: //NO_APP -check!(reg_f64 f64 reg "mov" ""); +check!(reg_i8 i8 reg "mov" ""); // CHECK-LABEL: {{("#)?}}reg_ptr{{"?}} // CHECK: //APP @@ -176,29 +176,29 @@ check!(reg_f64 f64 reg "mov" ""); // CHECK: //NO_APP check!(reg_ptr ptr reg "mov" ""); -// CHECK-LABEL: {{("#)?}}vreg_i8{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_f128{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_i8 i8 vreg "fmov" "s"); +check!(vreg_f128 f128 vreg "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_i16{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_f16{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_i16 i16 vreg "fmov" "s"); +check!(vreg_f16 f16 vreg "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_f16{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_f16x4{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_f16 f16 vreg "fmov" "s"); +check!(vreg_f16x4 f16x4 vreg "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_i32{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_f16x8{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_i32 i32 vreg "fmov" "s"); +check!(vreg_f16x8 f16x8 vreg "fmov" "s"); // CHECK-LABEL: {{("#)?}}vreg_f32{{"?}} // CHECK: //APP @@ -206,11 +206,17 @@ check!(vreg_i32 i32 vreg "fmov" "s"); // CHECK: //NO_APP check!(vreg_f32 f32 vreg "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_i64{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_f32x2{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_i64 i64 vreg "fmov" "s"); +check!(vreg_f32x2 f32x2 vreg "fmov" "s"); + +// CHECK-LABEL: {{("#)?}}vreg_f32x4{{"?}} +// CHECK: //APP +// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} +// CHECK: //NO_APP +check!(vreg_f32x4 f32x4 vreg "fmov" "s"); // CHECK-LABEL: {{("#)?}}vreg_f64{{"?}} // CHECK: //APP @@ -218,23 +224,23 @@ check!(vreg_i64 i64 vreg "fmov" "s"); // CHECK: //NO_APP check!(vreg_f64 f64 vreg "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_f128{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_f64x1{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_f128 f128 vreg "fmov" "s"); +check!(vreg_f64x1 f64x1 vreg "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_ptr{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_f64x2{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_ptr ptr vreg "fmov" "s"); +check!(vreg_f64x2 f64x2 vreg "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_i8x8{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_i16{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_i8x8 i8x8 vreg "fmov" "s"); +check!(vreg_i16 i16 vreg "fmov" "s"); // CHECK-LABEL: {{("#)?}}vreg_i16x4{{"?}} // CHECK: //APP @@ -242,107 +248,107 @@ check!(vreg_i8x8 i8x8 vreg "fmov" "s"); // CHECK: //NO_APP check!(vreg_i16x4 i16x4 vreg "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_i32x2{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_i16x8{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_i32x2 i32x2 vreg "fmov" "s"); +check!(vreg_i16x8 i16x8 vreg "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_i64x1{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_i32{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_i64x1 i64x1 vreg "fmov" "s"); +check!(vreg_i32 i32 vreg "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_f16x4{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_i32x2{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_f16x4 f16x4 vreg "fmov" "s"); +check!(vreg_i32x2 i32x2 vreg "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_f32x2{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_i32x4{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_f32x2 f32x2 vreg "fmov" "s"); +check!(vreg_i32x4 i32x4 vreg "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_f64x1{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_i64{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_f64x1 f64x1 vreg "fmov" "s"); +check!(vreg_i64 i64 vreg "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_i8x16{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_i64x1{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_i8x16 i8x16 vreg "fmov" "s"); +check!(vreg_i64x1 i64x1 vreg "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_i16x8{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_i64x2{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_i16x8 i16x8 vreg "fmov" "s"); +check!(vreg_i64x2 i64x2 vreg "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_i32x4{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_i8{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_i32x4 i32x4 vreg "fmov" "s"); +check!(vreg_i8 i8 vreg "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_i64x2{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_i8x16{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_i64x2 i64x2 vreg "fmov" "s"); +check!(vreg_i8x16 i8x16 vreg "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_f16x8{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_i8x8{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_f16x8 f16x8 vreg "fmov" "s"); +check!(vreg_i8x8 i8x8 vreg "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_f32x4{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_low16_f128{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_f32x4 f32x4 vreg "fmov" "s"); +check!(vreg_low16_f128 f128 vreg_low16 "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_f64x2{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_low16_f16{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_f64x2 f64x2 vreg "fmov" "s"); +check!(vreg_low16_f16 f16 vreg_low16 "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_low16_i8{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_low16_f16x4{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_low16_i8 i8 vreg_low16 "fmov" "s"); +check!(vreg_low16_f16x4 f16x4 vreg_low16 "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_low16_i16{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_low16_f16x8{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_low16_i16 i16 vreg_low16 "fmov" "s"); +check!(vreg_low16_f16x8 f16x8 vreg_low16 "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_low16_f16{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_low16_f32{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_low16_f16 f16 vreg_low16 "fmov" "s"); +check!(vreg_low16_f32 f32 vreg_low16 "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_low16_f32{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_low16_f32x2{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_low16_f32 f32 vreg_low16 "fmov" "s"); +check!(vreg_low16_f32x2 f32x2 vreg_low16 "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_low16_i64{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_low16_f32x4{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_low16_i64 i64 vreg_low16 "fmov" "s"); +check!(vreg_low16_f32x4 f32x4 vreg_low16 "fmov" "s"); // CHECK-LABEL: {{("#)?}}vreg_low16_f64{{"?}} // CHECK: //APP @@ -350,23 +356,22 @@ check!(vreg_low16_i64 i64 vreg_low16 "fmov" "s"); // CHECK: //NO_APP check!(vreg_low16_f64 f64 vreg_low16 "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_low16_f128{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_low16_f64x1{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_low16_f128 f128 vreg_low16 "fmov" "s"); +check!(vreg_low16_f64x1 f64x1 vreg_low16 "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_low16_ptr{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_low16_f64x2{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_low16_ptr ptr vreg_low16 "fmov" "s"); - -// CHECK-LABEL: {{("#)?}}vreg_low16_i8x8{{"?}} +check!(vreg_low16_f64x2 f64x2 vreg_low16 "fmov" "s"); +// CHECK-LABEL: {{("#)?}}vreg_low16_i16{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_low16_i8x8 i8x8 vreg_low16 "fmov" "s"); +check!(vreg_low16_i16 i16 vreg_low16 "fmov" "s"); // CHECK-LABEL: {{("#)?}}vreg_low16_i16x4{{"?}} // CHECK: //APP @@ -374,260 +379,255 @@ check!(vreg_low16_i8x8 i8x8 vreg_low16 "fmov" "s"); // CHECK: //NO_APP check!(vreg_low16_i16x4 i16x4 vreg_low16 "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_low16_i32x2{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_low16_i16x8{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_low16_i32x2 i32x2 vreg_low16 "fmov" "s"); +check!(vreg_low16_i16x8 i16x8 vreg_low16 "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_low16_i64x1{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_low16_i32x2{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_low16_i64x1 i64x1 vreg_low16 "fmov" "s"); +check!(vreg_low16_i32x2 i32x2 vreg_low16 "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_low16_f16x4{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_low16_i32x4{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_low16_f16x4 f16x4 vreg_low16 "fmov" "s"); +check!(vreg_low16_i32x4 i32x4 vreg_low16 "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_low16_f32x2{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_low16_i64{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_low16_f32x2 f32x2 vreg_low16 "fmov" "s"); +check!(vreg_low16_i64 i64 vreg_low16 "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_low16_f64x1{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_low16_i64x1{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_low16_f64x1 f64x1 vreg_low16 "fmov" "s"); +check!(vreg_low16_i64x1 i64x1 vreg_low16 "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_low16_i8x16{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_low16_i64x2{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_low16_i8x16 i8x16 vreg_low16 "fmov" "s"); +check!(vreg_low16_i64x2 i64x2 vreg_low16 "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_low16_i16x8{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_low16_i8{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_low16_i16x8 i16x8 vreg_low16 "fmov" "s"); +check!(vreg_low16_i8 i8 vreg_low16 "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_low16_i32x4{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_low16_i8x16{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_low16_i32x4 i32x4 vreg_low16 "fmov" "s"); +check!(vreg_low16_i8x16 i8x16 vreg_low16 "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_low16_i64x2{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_low16_i8x8{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_low16_i64x2 i64x2 vreg_low16 "fmov" "s"); +check!(vreg_low16_i8x8 i8x8 vreg_low16 "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_low16_f16x8{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_low16_ptr{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_low16_f16x8 f16x8 vreg_low16 "fmov" "s"); +check!(vreg_low16_ptr ptr vreg_low16 "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_low16_f32x4{{"?}} +// CHECK-LABEL: {{("#)?}}vreg_ptr{{"?}} // CHECK: //APP // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} // CHECK: //NO_APP -check!(vreg_low16_f32x4 f32x4 vreg_low16 "fmov" "s"); +check!(vreg_ptr ptr vreg "fmov" "s"); -// CHECK-LABEL: {{("#)?}}vreg_low16_f64x2{{"?}} -// CHECK: //APP -// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}} -// CHECK: //NO_APP -check!(vreg_low16_f64x2 f64x2 vreg_low16 "fmov" "s"); -// CHECK-LABEL: {{("#)?}}x0_i8{{"?}} +// CHECK-LABEL: {{("#)?}}v0_f128{{"?}} // CHECK: //APP -// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} +// CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(x0_i8 i8 "x0" "mov"); +check_reg!(v0_f128 f128 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}x0_i16{{"?}} +// CHECK-LABEL: {{("#)?}}v0_f16{{"?}} // CHECK: //APP -// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} +// CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(x0_i16 i16 "x0" "mov"); +check_reg!(v0_f16 f16 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}x0_f16{{"?}} +// CHECK-LABEL: {{("#)?}}v0_f16x4{{"?}} // CHECK: //APP -// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} +// CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(x0_f16 f16 "x0" "mov"); +check_reg!(v0_f16x4 f16x4 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}x0_i32{{"?}} +// CHECK-LABEL: {{("#)?}}v0_f16x8{{"?}} // CHECK: //APP -// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} +// CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(x0_i32 i32 "x0" "mov"); +check_reg!(v0_f16x8 f16x8 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}x0_f32{{"?}} +// CHECK-LABEL: {{("#)?}}v0_f32{{"?}} // CHECK: //APP -// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} +// CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(x0_f32 f32 "x0" "mov"); +check_reg!(v0_f32 f32 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}x0_i64{{"?}} +// CHECK-LABEL: {{("#)?}}v0_f32x2{{"?}} // CHECK: //APP -// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} +// CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(x0_i64 i64 "x0" "mov"); +check_reg!(v0_f32x2 f32x2 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}x0_f64{{"?}} +// CHECK-LABEL: {{("#)?}}v0_f32x4{{"?}} // CHECK: //APP -// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} +// CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(x0_f64 f64 "x0" "mov"); +check_reg!(v0_f32x4 f32x4 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}x0_ptr{{"?}} +// CHECK-LABEL: {{("#)?}}v0_f64{{"?}} // CHECK: //APP -// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} +// CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(x0_ptr ptr "x0" "mov"); +check_reg!(v0_f64 f64 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}v0_i8{{"?}} +// CHECK-LABEL: {{("#)?}}v0_f64x1{{"?}} // CHECK: //APP // CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(v0_i8 i8 "s0" "fmov"); +check_reg!(v0_f64x1 f64x1 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}v0_i16{{"?}} +// CHECK-LABEL: {{("#)?}}v0_f64x2{{"?}} // CHECK: //APP // CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(v0_i16 i16 "s0" "fmov"); +check_reg!(v0_f64x2 f64x2 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}v0_f16{{"?}} +// CHECK-LABEL: {{("#)?}}v0_i16{{"?}} // CHECK: //APP // CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(v0_f16 f16 "s0" "fmov"); +check_reg!(v0_i16 i16 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}v0_i32{{"?}} +// CHECK-LABEL: {{("#)?}}v0_i16x4{{"?}} // CHECK: //APP // CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(v0_i32 i32 "s0" "fmov"); +check_reg!(v0_i16x4 i16x4 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}v0_f32{{"?}} +// CHECK-LABEL: {{("#)?}}v0_i16x8{{"?}} // CHECK: //APP // CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(v0_f32 f32 "s0" "fmov"); +check_reg!(v0_i16x8 i16x8 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}v0_i64{{"?}} +// CHECK-LABEL: {{("#)?}}v0_i32{{"?}} // CHECK: //APP // CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(v0_i64 i64 "s0" "fmov"); +check_reg!(v0_i32 i32 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}v0_f64{{"?}} +// CHECK-LABEL: {{("#)?}}v0_i32x2{{"?}} // CHECK: //APP // CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(v0_f64 f64 "s0" "fmov"); +check_reg!(v0_i32x2 i32x2 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}v0_f128{{"?}} +// CHECK-LABEL: {{("#)?}}v0_i32x4{{"?}} // CHECK: //APP // CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(v0_f128 f128 "s0" "fmov"); +check_reg!(v0_i32x4 i32x4 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}v0_ptr{{"?}} +// CHECK-LABEL: {{("#)?}}v0_i64{{"?}} // CHECK: //APP // CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(v0_ptr ptr "s0" "fmov"); +check_reg!(v0_i64 i64 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}v0_i8x8{{"?}} +// CHECK-LABEL: {{("#)?}}v0_i64x1{{"?}} // CHECK: //APP // CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(v0_i8x8 i8x8 "s0" "fmov"); +check_reg!(v0_i64x1 i64x1 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}v0_i16x4{{"?}} +// CHECK-LABEL: {{("#)?}}v0_i64x2{{"?}} // CHECK: //APP // CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(v0_i16x4 i16x4 "s0" "fmov"); +check_reg!(v0_i64x2 i64x2 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}v0_i32x2{{"?}} +// CHECK-LABEL: {{("#)?}}v0_i8{{"?}} // CHECK: //APP // CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(v0_i32x2 i32x2 "s0" "fmov"); +check_reg!(v0_i8 i8 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}v0_i64x1{{"?}} +// CHECK-LABEL: {{("#)?}}v0_i8x16{{"?}} // CHECK: //APP // CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(v0_i64x1 i64x1 "s0" "fmov"); +check_reg!(v0_i8x16 i8x16 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}v0_f16x4{{"?}} +// CHECK-LABEL: {{("#)?}}v0_i8x8{{"?}} // CHECK: //APP // CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(v0_f16x4 f16x4 "s0" "fmov"); +check_reg!(v0_i8x8 i8x8 "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}v0_f32x2{{"?}} +// CHECK-LABEL: {{("#)?}}v0_ptr{{"?}} // CHECK: //APP // CHECK: fmov s0, s0 // CHECK: //NO_APP -check_reg!(v0_f32x2 f32x2 "s0" "fmov"); +check_reg!(v0_ptr ptr "s0" "fmov"); -// CHECK-LABEL: {{("#)?}}v0_f64x1{{"?}} +// CHECK-LABEL: {{("#)?}}x0_f16{{"?}} // CHECK: //APP -// CHECK: fmov s0, s0 +// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} // CHECK: //NO_APP -check_reg!(v0_f64x1 f64x1 "s0" "fmov"); +check_reg!(x0_f16 f16 "x0" "mov"); -// CHECK-LABEL: {{("#)?}}v0_i8x16{{"?}} +// CHECK-LABEL: {{("#)?}}x0_f32{{"?}} // CHECK: //APP -// CHECK: fmov s0, s0 +// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} // CHECK: //NO_APP -check_reg!(v0_i8x16 i8x16 "s0" "fmov"); +check_reg!(x0_f32 f32 "x0" "mov"); -// CHECK-LABEL: {{("#)?}}v0_i16x8{{"?}} +// CHECK-LABEL: {{("#)?}}x0_f64{{"?}} // CHECK: //APP -// CHECK: fmov s0, s0 +// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} // CHECK: //NO_APP -check_reg!(v0_i16x8 i16x8 "s0" "fmov"); +check_reg!(x0_f64 f64 "x0" "mov"); -// CHECK-LABEL: {{("#)?}}v0_i32x4{{"?}} +// CHECK-LABEL: {{("#)?}}x0_i16{{"?}} // CHECK: //APP -// CHECK: fmov s0, s0 +// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} // CHECK: //NO_APP -check_reg!(v0_i32x4 i32x4 "s0" "fmov"); +check_reg!(x0_i16 i16 "x0" "mov"); -// CHECK-LABEL: {{("#)?}}v0_i64x2{{"?}} +// CHECK-LABEL: {{("#)?}}x0_i32{{"?}} // CHECK: //APP -// CHECK: fmov s0, s0 +// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} // CHECK: //NO_APP -check_reg!(v0_i64x2 i64x2 "s0" "fmov"); +check_reg!(x0_i32 i32 "x0" "mov"); -// CHECK-LABEL: {{("#)?}}v0_f16x8{{"?}} +// CHECK-LABEL: {{("#)?}}x0_i64{{"?}} // CHECK: //APP -// CHECK: fmov s0, s0 +// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} // CHECK: //NO_APP -check_reg!(v0_f16x8 f16x8 "s0" "fmov"); +check_reg!(x0_i64 i64 "x0" "mov"); -// CHECK-LABEL: {{("#)?}}v0_f32x4{{"?}} +// CHECK-LABEL: {{("#)?}}x0_i8{{"?}} // CHECK: //APP -// CHECK: fmov s0, s0 +// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} // CHECK: //NO_APP -check_reg!(v0_f32x4 f32x4 "s0" "fmov"); +check_reg!(x0_i8 i8 "x0" "mov"); -// CHECK-LABEL: {{("#)?}}v0_f64x2{{"?}} +// CHECK-LABEL: {{("#)?}}x0_ptr{{"?}} // CHECK: //APP -// CHECK: fmov s0, s0 +// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}} // CHECK: //NO_APP -check_reg!(v0_f64x2 f64x2 "s0" "fmov"); +check_reg!(x0_ptr ptr "x0" "mov"); diff --git a/tests/assembly-llvm/asm/arm-modifiers.rs b/tests/assembly-llvm/asm/arm-modifiers.rs index 32a368404924a..9867e21a307af 100644 --- a/tests/assembly-llvm/asm/arm-modifiers.rs +++ b/tests/assembly-llvm/asm/arm-modifiers.rs @@ -31,24 +31,6 @@ macro_rules! check { }; } -// CHECK-LABEL: reg: -// CHECK: @APP -// CHECK: mov r0, r0 -// CHECK: @NO_APP -check!(reg "" reg i32 "mov"); - -// CHECK-LABEL: sreg: -// CHECK: @APP -// CHECK: vmov.f32 s0, s0 -// CHECK: @NO_APP -check!(sreg "" sreg f32 "vmov.f32"); - -// CHECK-LABEL: sreg_low16: -// CHECK: @APP -// CHECK: vmov.f32 s0, s0 -// CHECK: @NO_APP -check!(sreg_low16 "" sreg_low16 f32 "vmov.f32"); - // CHECK-LABEL: dreg: // CHECK: @APP // CHECK: vmov.f64 d0, d0 @@ -85,6 +67,23 @@ check!(qreg_e "e" qreg f32x4 "vmov.f64"); // CHECK: @NO_APP check!(qreg_f "f" qreg f32x4 "vmov.f64"); +// CHECK-LABEL: qreg_low4: +// CHECK: @APP +// CHECK: vorr q0, q0, q0 +// CHECK: @NO_APP +check!(qreg_low4 "" qreg_low4 f32x4 "vmov"); + +// CHECK-LABEL: qreg_low4_e: +// CHECK: @APP +// CHECK: vmov.f64 d0, d0 +// CHECK: @NO_APP +check!(qreg_low4_e "e" qreg_low4 f32x4 "vmov.f64"); + +// CHECK-LABEL: qreg_low4_f: +// CHECK: @APP +// CHECK: vmov.f64 d1, d1 +// CHECK: @NO_APP +check!(qreg_low4_f "f" qreg_low4 f32x4 "vmov.f64"); // CHECK-LABEL: qreg_low8: // CHECK: @APP // CHECK: vorr q0, q0, q0 @@ -103,20 +102,20 @@ check!(qreg_low8_e "e" qreg_low8 f32x4 "vmov.f64"); // CHECK: @NO_APP check!(qreg_low8_f "f" qreg_low8 f32x4 "vmov.f64"); -// CHECK-LABEL: qreg_low4: +// CHECK-LABEL: reg: // CHECK: @APP -// CHECK: vorr q0, q0, q0 +// CHECK: mov r0, r0 // CHECK: @NO_APP -check!(qreg_low4 "" qreg_low4 f32x4 "vmov"); +check!(reg "" reg i32 "mov"); -// CHECK-LABEL: qreg_low4_e: +// CHECK-LABEL: sreg: // CHECK: @APP -// CHECK: vmov.f64 d0, d0 +// CHECK: vmov.f32 s0, s0 // CHECK: @NO_APP -check!(qreg_low4_e "e" qreg_low4 f32x4 "vmov.f64"); +check!(sreg "" sreg f32 "vmov.f32"); -// CHECK-LABEL: qreg_low4_f: +// CHECK-LABEL: sreg_low16: // CHECK: @APP -// CHECK: vmov.f64 d1, d1 +// CHECK: vmov.f32 s0, s0 // CHECK: @NO_APP -check!(qreg_low4_f "f" qreg_low4 f32x4 "vmov.f64"); +check!(sreg_low16 "" sreg_low16 f32 "vmov.f32"); diff --git a/tests/assembly-llvm/asm/arm-types.rs b/tests/assembly-llvm/asm/arm-types.rs index fb93f474c20eb..89f1686d78ac5 100644 --- a/tests/assembly-llvm/asm/arm-types.rs +++ b/tests/assembly-llvm/asm/arm-types.rs @@ -111,90 +111,19 @@ macro_rules! check_reg { }; } -// CHECK-LABEL: reg_i8: -// CHECK: @APP -// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}} -// CHECK: @NO_APP -check!(reg_i8 i8 reg "mov"); - -// CHECK-LABEL: reg_i16: -// CHECK: @APP -// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}} -// CHECK: @NO_APP -check!(reg_i16 i16 reg "mov"); - -// CHECK-LABEL: reg_i32: -// CHECK: @APP -// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}} -// CHECK: @NO_APP -check!(reg_i32 i32 reg "mov"); - -// CHECK-LABEL: reg_f16: -// CHECK: @APP -// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}} -// CHECK: @NO_APP -check!(reg_f16 f16 reg "mov"); - -// CHECK-LABEL: reg_f32: -// CHECK: @APP -// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}} -// CHECK: @NO_APP -check!(reg_f32 f32 reg "mov"); - -// CHECK-LABEL: reg_ptr: -// CHECK: @APP -// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}} -// CHECK: @NO_APP -check!(reg_ptr ptr reg "mov"); - -// CHECK-LABEL: sreg_i32: -// CHECK: @APP -// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}} -// CHECK: @NO_APP -check!(sreg_i32 i32 sreg "vmov.f32"); - -// CHECK-LABEL: sreg_f16: -// CHECK: @APP -// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}} -// CHECK: @NO_APP -check!(sreg_f16 f16 sreg "vmov.f32"); - -// CHECK-LABEL: sreg_f32: -// CHECK: @APP -// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}} -// CHECK: @NO_APP -check!(sreg_f32 f32 sreg "vmov.f32"); - -// CHECK-LABEL: sreg_ptr: -// CHECK: @APP -// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}} -// CHECK: @NO_APP -check!(sreg_ptr ptr sreg "vmov.f32"); - -// CHECK-LABEL: sreg_low16_i32: -// CHECK: @APP -// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}} -// CHECK: @NO_APP -check!(sreg_low16_i32 i32 sreg_low16 "vmov.f32"); - -// CHECK-LABEL: sreg_low16_f16: -// CHECK: @APP -// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}} -// CHECK: @NO_APP -check!(sreg_low16_f16 f16 sreg_low16 "vmov.f32"); - -// CHECK-LABEL: sreg_low16_f32: -// CHECK: @APP -// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}} -// CHECK: @NO_APP -check!(sreg_low16_f32 f32 sreg_low16 "vmov.f32"); +// neon-LABEL: dreg_f16x4: +// neon: @APP +// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} +// neon: @NO_APP +#[cfg(neon)] +check!(dreg_f16x4 f16x4 dreg "vmov.f64"); -// d32-LABEL: dreg_i64: -// d32: @APP -// d32: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} -// d32: @NO_APP -#[cfg(d32)] -check!(dreg_i64 i64 dreg "vmov.f64"); +// neon-LABEL: dreg_f32x2: +// neon: @APP +// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} +// neon: @NO_APP +#[cfg(neon)] +check!(dreg_f32x2 f32x2 dreg "vmov.f64"); // d32-LABEL: dreg_f64: // d32: @APP @@ -203,13 +132,6 @@ check!(dreg_i64 i64 dreg "vmov.f64"); #[cfg(d32)] check!(dreg_f64 f64 dreg "vmov.f64"); -// neon-LABEL: dreg_i8x8: -// neon: @APP -// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} -// neon: @NO_APP -#[cfg(neon)] -check!(dreg_i8x8 i8x8 dreg "vmov.f64"); - // neon-LABEL: dreg_i16x4: // neon: @APP // neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} @@ -224,6 +146,13 @@ check!(dreg_i16x4 i16x4 dreg "vmov.f64"); #[cfg(neon)] check!(dreg_i32x2 i32x2 dreg "vmov.f64"); +// d32-LABEL: dreg_i64: +// d32: @APP +// d32: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} +// d32: @NO_APP +#[cfg(d32)] +check!(dreg_i64 i64 dreg "vmov.f64"); + // neon-LABEL: dreg_i64x1: // neon: @APP // neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} @@ -231,25 +160,26 @@ check!(dreg_i32x2 i32x2 dreg "vmov.f64"); #[cfg(neon)] check!(dreg_i64x1 i64x1 dreg "vmov.f64"); -// neon-LABEL: dreg_f16x4: +// neon-LABEL: dreg_i8x8: // neon: @APP // neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} // neon: @NO_APP #[cfg(neon)] -check!(dreg_f16x4 f16x4 dreg "vmov.f64"); +check!(dreg_i8x8 i8x8 dreg "vmov.f64"); -// neon-LABEL: dreg_f32x2: +// neon-LABEL: dreg_low16_f16x4: // neon: @APP // neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} // neon: @NO_APP #[cfg(neon)] -check!(dreg_f32x2 f32x2 dreg "vmov.f64"); +check!(dreg_low16_f16x4 f16x4 dreg_low16 "vmov.f64"); -// CHECK-LABEL: dreg_low16_i64: -// CHECK: @APP -// CHECK: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} -// CHECK: @NO_APP -check!(dreg_low16_i64 i64 dreg_low16 "vmov.f64"); +// neon-LABEL: dreg_low16_f32x2: +// neon: @APP +// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} +// neon: @NO_APP +#[cfg(neon)] +check!(dreg_low16_f32x2 f32x2 dreg_low16 "vmov.f64"); // CHECK-LABEL: dreg_low16_f64: // CHECK: @APP @@ -257,13 +187,6 @@ check!(dreg_low16_i64 i64 dreg_low16 "vmov.f64"); // CHECK: @NO_APP check!(dreg_low16_f64 f64 dreg_low16 "vmov.f64"); -// neon-LABEL: dreg_low16_i8x8: -// neon: @APP -// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} -// neon: @NO_APP -#[cfg(neon)] -check!(dreg_low16_i8x8 i8x8 dreg_low16 "vmov.f64"); - // neon-LABEL: dreg_low16_i16x4: // neon: @APP // neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} @@ -278,6 +201,12 @@ check!(dreg_low16_i16x4 i16x4 dreg_low16 "vmov.f64"); #[cfg(neon)] check!(dreg_low16_i32x2 i32x2 dreg_low16 "vmov.f64"); +// CHECK-LABEL: dreg_low16_i64: +// CHECK: @APP +// CHECK: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} +// CHECK: @NO_APP +check!(dreg_low16_i64 i64 dreg_low16 "vmov.f64"); + // neon-LABEL: dreg_low16_i64x1: // neon: @APP // neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} @@ -285,25 +214,26 @@ check!(dreg_low16_i32x2 i32x2 dreg_low16 "vmov.f64"); #[cfg(neon)] check!(dreg_low16_i64x1 i64x1 dreg_low16 "vmov.f64"); -// neon-LABEL: dreg_low16_f16x4: +// neon-LABEL: dreg_low16_i8x8: // neon: @APP // neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} // neon: @NO_APP #[cfg(neon)] -check!(dreg_low16_f16x4 f16x4 dreg_low16 "vmov.f64"); +check!(dreg_low16_i8x8 i8x8 dreg_low16 "vmov.f64"); -// neon-LABEL: dreg_low16_f32x2: +// neon-LABEL: dreg_low8_f16x4: // neon: @APP // neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} // neon: @NO_APP #[cfg(neon)] -check!(dreg_low16_f32x2 f32x2 dreg_low16 "vmov.f64"); +check!(dreg_low8_f16x4 f16x4 dreg_low8 "vmov.f64"); -// CHECK-LABEL: dreg_low8_i64: -// CHECK: @APP -// CHECK: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} -// CHECK: @NO_APP -check!(dreg_low8_i64 i64 dreg_low8 "vmov.f64"); +// neon-LABEL: dreg_low8_f32x2: +// neon: @APP +// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} +// neon: @NO_APP +#[cfg(neon)] +check!(dreg_low8_f32x2 f32x2 dreg_low8 "vmov.f64"); // CHECK-LABEL: dreg_low8_f64: // CHECK: @APP @@ -311,13 +241,6 @@ check!(dreg_low8_i64 i64 dreg_low8 "vmov.f64"); // CHECK: @NO_APP check!(dreg_low8_f64 f64 dreg_low8 "vmov.f64"); -// neon-LABEL: dreg_low8_i8x8: -// neon: @APP -// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} -// neon: @NO_APP -#[cfg(neon)] -check!(dreg_low8_i8x8 i8x8 dreg_low8 "vmov.f64"); - // neon-LABEL: dreg_low8_i16x4: // neon: @APP // neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} @@ -332,6 +255,12 @@ check!(dreg_low8_i16x4 i16x4 dreg_low8 "vmov.f64"); #[cfg(neon)] check!(dreg_low8_i32x2 i32x2 dreg_low8 "vmov.f64"); +// CHECK-LABEL: dreg_low8_i64: +// CHECK: @APP +// CHECK: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} +// CHECK: @NO_APP +check!(dreg_low8_i64 i64 dreg_low8 "vmov.f64"); + // neon-LABEL: dreg_low8_i64x1: // neon: @APP // neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} @@ -339,26 +268,26 @@ check!(dreg_low8_i32x2 i32x2 dreg_low8 "vmov.f64"); #[cfg(neon)] check!(dreg_low8_i64x1 i64x1 dreg_low8 "vmov.f64"); -// neon-LABEL: dreg_low8_f16x4: +// neon-LABEL: dreg_low8_i8x8: // neon: @APP // neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} // neon: @NO_APP #[cfg(neon)] -check!(dreg_low8_f16x4 f16x4 dreg_low8 "vmov.f64"); +check!(dreg_low8_i8x8 i8x8 dreg_low8 "vmov.f64"); -// neon-LABEL: dreg_low8_f32x2: +// neon-LABEL: qreg_f16x8: // neon: @APP -// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}} +// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} // neon: @NO_APP #[cfg(neon)] -check!(dreg_low8_f32x2 f32x2 dreg_low8 "vmov.f64"); +check!(qreg_f16x8 f16x8 qreg "vmov"); -// neon-LABEL: qreg_i8x16: +// neon-LABEL: qreg_f32x4: // neon: @APP // neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} // neon: @NO_APP #[cfg(neon)] -check!(qreg_i8x16 i8x16 qreg "vmov"); +check!(qreg_f32x4 f32x4 qreg "vmov"); // neon-LABEL: qreg_i16x8: // neon: @APP @@ -381,171 +310,188 @@ check!(qreg_i32x4 i32x4 qreg "vmov"); #[cfg(neon)] check!(qreg_i64x2 i64x2 qreg "vmov"); -// neon-LABEL: qreg_f16x8: +// neon-LABEL: qreg_i8x16: // neon: @APP // neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} // neon: @NO_APP #[cfg(neon)] -check!(qreg_f16x8 f16x8 qreg "vmov"); +check!(qreg_i8x16 i8x16 qreg "vmov"); -// neon-LABEL: qreg_f32x4: +// neon-LABEL: qreg_low4_f16x8: // neon: @APP // neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} // neon: @NO_APP #[cfg(neon)] -check!(qreg_f32x4 f32x4 qreg "vmov"); +check!(qreg_low4_f16x8 f16x8 qreg_low4 "vmov"); -// neon-LABEL: qreg_low8_i8x16: +// neon-LABEL: qreg_low4_f32x4: // neon: @APP // neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} // neon: @NO_APP #[cfg(neon)] -check!(qreg_low8_i8x16 i8x16 qreg_low8 "vmov"); +check!(qreg_low4_f32x4 f32x4 qreg_low4 "vmov"); -// neon-LABEL: qreg_low8_i16x8: +// neon-LABEL: qreg_low4_i16x8: // neon: @APP // neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} // neon: @NO_APP #[cfg(neon)] -check!(qreg_low8_i16x8 i16x8 qreg_low8 "vmov"); +check!(qreg_low4_i16x8 i16x8 qreg_low4 "vmov"); -// neon-LABEL: qreg_low8_i32x4: +// neon-LABEL: qreg_low4_i32x4: // neon: @APP // neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} // neon: @NO_APP #[cfg(neon)] -check!(qreg_low8_i32x4 i32x4 qreg_low8 "vmov"); +check!(qreg_low4_i32x4 i32x4 qreg_low4 "vmov"); -// neon-LABEL: qreg_low8_i64x2: +// neon-LABEL: qreg_low4_i64x2: // neon: @APP // neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} // neon: @NO_APP #[cfg(neon)] -check!(qreg_low8_i64x2 i64x2 qreg_low8 "vmov"); +check!(qreg_low4_i64x2 i64x2 qreg_low4 "vmov"); -// neon-LABEL: qreg_low8_f16x8: +// neon-LABEL: qreg_low4_i8x16: // neon: @APP // neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} // neon: @NO_APP #[cfg(neon)] -check!(qreg_low8_f16x8 f16x8 qreg_low8 "vmov"); +check!(qreg_low4_i8x16 i8x16 qreg_low4 "vmov"); -// neon-LABEL: qreg_low8_f32x4: +// neon-LABEL: qreg_low8_f16x8: // neon: @APP // neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} // neon: @NO_APP #[cfg(neon)] -check!(qreg_low8_f32x4 f32x4 qreg_low8 "vmov"); +check!(qreg_low8_f16x8 f16x8 qreg_low8 "vmov"); -// neon-LABEL: qreg_low4_i8x16: +// neon-LABEL: qreg_low8_f32x4: // neon: @APP // neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} // neon: @NO_APP #[cfg(neon)] -check!(qreg_low4_i8x16 i8x16 qreg_low4 "vmov"); +check!(qreg_low8_f32x4 f32x4 qreg_low8 "vmov"); -// neon-LABEL: qreg_low4_i16x8: +// neon-LABEL: qreg_low8_i16x8: // neon: @APP // neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} // neon: @NO_APP #[cfg(neon)] -check!(qreg_low4_i16x8 i16x8 qreg_low4 "vmov"); +check!(qreg_low8_i16x8 i16x8 qreg_low8 "vmov"); -// neon-LABEL: qreg_low4_i32x4: +// neon-LABEL: qreg_low8_i32x4: // neon: @APP // neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} // neon: @NO_APP #[cfg(neon)] -check!(qreg_low4_i32x4 i32x4 qreg_low4 "vmov"); +check!(qreg_low8_i32x4 i32x4 qreg_low8 "vmov"); -// neon-LABEL: qreg_low4_i64x2: +// neon-LABEL: qreg_low8_i64x2: // neon: @APP // neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} // neon: @NO_APP #[cfg(neon)] -check!(qreg_low4_i64x2 i64x2 qreg_low4 "vmov"); +check!(qreg_low8_i64x2 i64x2 qreg_low8 "vmov"); -// neon-LABEL: qreg_low4_f16x8: +// neon-LABEL: qreg_low8_i8x16: // neon: @APP // neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} // neon: @NO_APP #[cfg(neon)] -check!(qreg_low4_f16x8 f16x8 qreg_low4 "vmov"); +check!(qreg_low8_i8x16 i8x16 qreg_low8 "vmov"); -// neon-LABEL: qreg_low4_f32x4: -// neon: @APP -// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}} -// neon: @NO_APP -#[cfg(neon)] -check!(qreg_low4_f32x4 f32x4 qreg_low4 "vmov"); +// CHECK-LABEL: reg_f16: +// CHECK: @APP +// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}} +// CHECK: @NO_APP +check!(reg_f16 f16 reg "mov"); -// CHECK-LABEL: r0_i8: +// CHECK-LABEL: reg_f32: // CHECK: @APP -// CHECK: mov r0, r0 +// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}} // CHECK: @NO_APP -check_reg!(r0_i8 i8 "r0" "mov"); +check!(reg_f32 f32 reg "mov"); -// CHECK-LABEL: r0_i16: +// CHECK-LABEL: reg_i16: // CHECK: @APP -// CHECK: mov r0, r0 +// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}} // CHECK: @NO_APP -check_reg!(r0_i16 i16 "r0" "mov"); +check!(reg_i16 i16 reg "mov"); -// CHECK-LABEL: r0_i32: +// CHECK-LABEL: reg_i32: // CHECK: @APP -// CHECK: mov r0, r0 +// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}} // CHECK: @NO_APP -check_reg!(r0_i32 i32 "r0" "mov"); +check!(reg_i32 i32 reg "mov"); -// CHECK-LABEL: r0_f16: +// CHECK-LABEL: reg_i8: // CHECK: @APP -// CHECK: mov r0, r0 +// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}} // CHECK: @NO_APP -check_reg!(r0_f16 f16 "r0" "mov"); +check!(reg_i8 i8 reg "mov"); -// CHECK-LABEL: r0_f32: +// CHECK-LABEL: reg_ptr: // CHECK: @APP -// CHECK: mov r0, r0 +// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}} // CHECK: @NO_APP -check_reg!(r0_f32 f32 "r0" "mov"); +check!(reg_ptr ptr reg "mov"); -// CHECK-LABEL: r0_ptr: +// CHECK-LABEL: sreg_f16: // CHECK: @APP -// CHECK: mov r0, r0 +// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}} // CHECK: @NO_APP -check_reg!(r0_ptr ptr "r0" "mov"); +check!(sreg_f16 f16 sreg "vmov.f32"); -// CHECK-LABEL: s0_i32: +// CHECK-LABEL: sreg_f32: // CHECK: @APP -// CHECK: vmov.f32 s0, s0 +// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}} // CHECK: @NO_APP -check_reg!(s0_i32 i32 "s0" "vmov.f32"); +check!(sreg_f32 f32 sreg "vmov.f32"); -// CHECK-LABEL: s0_f16: +// CHECK-LABEL: sreg_i32: // CHECK: @APP -// CHECK: vmov.f32 s0, s0 +// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}} // CHECK: @NO_APP -check_reg!(s0_f16 f16 "s0" "vmov.f32"); +check!(sreg_i32 i32 sreg "vmov.f32"); -// CHECK-LABEL: s0_f32: +// CHECK-LABEL: sreg_low16_f16: // CHECK: @APP -// CHECK: vmov.f32 s0, s0 +// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}} // CHECK: @NO_APP -check_reg!(s0_f32 f32 "s0" "vmov.f32"); +check!(sreg_low16_f16 f16 sreg_low16 "vmov.f32"); -// CHECK-LABEL: s0_ptr: +// CHECK-LABEL: sreg_low16_f32: // CHECK: @APP -// CHECK: vmov.f32 s0, s0 +// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}} // CHECK: @NO_APP -check_reg!(s0_ptr ptr "s0" "vmov.f32"); +check!(sreg_low16_f32 f32 sreg_low16 "vmov.f32"); -// FIXME(#126797): "d0" should work with `i64` and `f64` even when `d32` is disabled. -// d32-LABEL: d0_i64: -// d32: @APP -// d32: vmov.f64 d0, d0 -// d32: @NO_APP -#[cfg(d32)] -check_reg!(d0_i64 i64 "d0" "vmov.f64"); +// CHECK-LABEL: sreg_low16_i32: +// CHECK: @APP +// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}} +// CHECK: @NO_APP +check!(sreg_low16_i32 i32 sreg_low16 "vmov.f32"); + +// CHECK-LABEL: sreg_ptr: +// CHECK: @APP +// CHECK: vmov.f32 s{{[0-9]+}}, s{{[0-9]+}} +// CHECK: @NO_APP +check!(sreg_ptr ptr sreg "vmov.f32"); + +// neon-LABEL: d0_f16x4: +// neon: @APP +// neon: vmov.f64 d0, d0 +// neon: @NO_APP +#[cfg(neon)] +check_reg!(d0_f16x4 f16x4 "d0" "vmov.f64"); + +// neon-LABEL: d0_f32x2: +// neon: @APP +// neon: vmov.f64 d0, d0 +// neon: @NO_APP +#[cfg(neon)] +check_reg!(d0_f32x2 f32x2 "d0" "vmov.f64"); // d32-LABEL: d0_f64: // d32: @APP @@ -554,13 +500,6 @@ check_reg!(d0_i64 i64 "d0" "vmov.f64"); #[cfg(d32)] check_reg!(d0_f64 f64 "d0" "vmov.f64"); -// neon-LABEL: d0_i8x8: -// neon: @APP -// neon: vmov.f64 d0, d0 -// neon: @NO_APP -#[cfg(neon)] -check_reg!(d0_i8x8 i8x8 "d0" "vmov.f64"); - // neon-LABEL: d0_i16x4: // neon: @APP // neon: vmov.f64 d0, d0 @@ -575,6 +514,14 @@ check_reg!(d0_i16x4 i16x4 "d0" "vmov.f64"); #[cfg(neon)] check_reg!(d0_i32x2 i32x2 "d0" "vmov.f64"); +// FIXME(#126797): "d0" should work with `i64` and `f64` even when `d32` is disabled. +// d32-LABEL: d0_i64: +// d32: @APP +// d32: vmov.f64 d0, d0 +// d32: @NO_APP +#[cfg(d32)] +check_reg!(d0_i64 i64 "d0" "vmov.f64"); + // neon-LABEL: d0_i64x1: // neon: @APP // neon: vmov.f64 d0, d0 @@ -582,27 +529,26 @@ check_reg!(d0_i32x2 i32x2 "d0" "vmov.f64"); #[cfg(neon)] check_reg!(d0_i64x1 i64x1 "d0" "vmov.f64"); -// neon-LABEL: d0_f16x4: +// neon-LABEL: d0_i8x8: // neon: @APP // neon: vmov.f64 d0, d0 // neon: @NO_APP #[cfg(neon)] -check_reg!(d0_f16x4 f16x4 "d0" "vmov.f64"); +check_reg!(d0_i8x8 i8x8 "d0" "vmov.f64"); -// neon-LABEL: d0_f32x2: +// neon-LABEL: q0_f16x8: // neon: @APP -// neon: vmov.f64 d0, d0 +// neon: vorr q0, q0, q0 // neon: @NO_APP #[cfg(neon)] -check_reg!(d0_f32x2 f32x2 "d0" "vmov.f64"); +check_reg!(q0_f16x8 f16x8 "q0" "vmov"); -// neon-LABEL: q0_i8x16: +// neon-LABEL: q0_f32x4: // neon: @APP // neon: vorr q0, q0, q0 // neon: @NO_APP #[cfg(neon)] -check_reg!(q0_i8x16 i8x16 "q0" "vmov"); - +check_reg!(q0_f32x4 f32x4 "q0" "vmov"); // neon-LABEL: q0_i16x8: // neon: @APP // neon: vorr q0, q0, q0 @@ -624,16 +570,69 @@ check_reg!(q0_i32x4 i32x4 "q0" "vmov"); #[cfg(neon)] check_reg!(q0_i64x2 i64x2 "q0" "vmov"); -// neon-LABEL: q0_f16x8: +// neon-LABEL: q0_i8x16: // neon: @APP // neon: vorr q0, q0, q0 // neon: @NO_APP #[cfg(neon)] -check_reg!(q0_f16x8 f16x8 "q0" "vmov"); +check_reg!(q0_i8x16 i8x16 "q0" "vmov"); -// neon-LABEL: q0_f32x4: -// neon: @APP -// neon: vorr q0, q0, q0 -// neon: @NO_APP -#[cfg(neon)] -check_reg!(q0_f32x4 f32x4 "q0" "vmov"); +// CHECK-LABEL: r0_f16: +// CHECK: @APP +// CHECK: mov r0, r0 +// CHECK: @NO_APP +check_reg!(r0_f16 f16 "r0" "mov"); + +// CHECK-LABEL: r0_f32: +// CHECK: @APP +// CHECK: mov r0, r0 +// CHECK: @NO_APP +check_reg!(r0_f32 f32 "r0" "mov"); + +// CHECK-LABEL: r0_i16: +// CHECK: @APP +// CHECK: mov r0, r0 +// CHECK: @NO_APP +check_reg!(r0_i16 i16 "r0" "mov"); + +// CHECK-LABEL: r0_i32: +// CHECK: @APP +// CHECK: mov r0, r0 +// CHECK: @NO_APP +check_reg!(r0_i32 i32 "r0" "mov"); + +// CHECK-LABEL: r0_i8: +// CHECK: @APP +// CHECK: mov r0, r0 +// CHECK: @NO_APP +check_reg!(r0_i8 i8 "r0" "mov"); + +// CHECK-LABEL: r0_ptr: +// CHECK: @APP +// CHECK: mov r0, r0 +// CHECK: @NO_APP +check_reg!(r0_ptr ptr "r0" "mov"); + +// CHECK-LABEL: s0_f16: +// CHECK: @APP +// CHECK: vmov.f32 s0, s0 +// CHECK: @NO_APP +check_reg!(s0_f16 f16 "s0" "vmov.f32"); + +// CHECK-LABEL: s0_f32: +// CHECK: @APP +// CHECK: vmov.f32 s0, s0 +// CHECK: @NO_APP +check_reg!(s0_f32 f32 "s0" "vmov.f32"); + +// CHECK-LABEL: s0_i32: +// CHECK: @APP +// CHECK: vmov.f32 s0, s0 +// CHECK: @NO_APP +check_reg!(s0_i32 i32 "s0" "vmov.f32"); + +// CHECK-LABEL: s0_ptr: +// CHECK: @APP +// CHECK: vmov.f32 s0, s0 +// CHECK: @NO_APP +check_reg!(s0_ptr ptr "s0" "vmov.f32"); diff --git a/tests/assembly-llvm/asm/avr-modifiers.rs b/tests/assembly-llvm/asm/avr-modifiers.rs index 124cad9bef6a8..213f19099ef89 100644 --- a/tests/assembly-llvm/asm/avr-modifiers.rs +++ b/tests/assembly-llvm/asm/avr-modifiers.rs @@ -24,17 +24,17 @@ macro_rules! check { }; } -// CHECK-LABEL: reg_pair_modifiers: +// CHECK-LABEL: reg_iw_modifiers: // CHECK: ;APP // CHECK: mov r{{[1-9]?[13579]}}, r{{[1-9]?[24680]}} // CHECK: ;NO_APP -check!(reg_pair_modifiers "h" "l" reg_pair); +check!(reg_iw_modifiers "h" "l" reg_iw); -// CHECK-LABEL: reg_iw_modifiers: +// CHECK-LABEL: reg_pair_modifiers: // CHECK: ;APP // CHECK: mov r{{[1-9]?[13579]}}, r{{[1-9]?[24680]}} // CHECK: ;NO_APP -check!(reg_iw_modifiers "h" "l" reg_iw); +check!(reg_pair_modifiers "h" "l" reg_pair); // CHECK-LABEL: reg_ptr_modifiers: // CHECK: ;APP diff --git a/tests/assembly-llvm/asm/avr-types.rs b/tests/assembly-llvm/asm/avr-types.rs index 309405f4d51e7..cdf6bfdb5ab87 100644 --- a/tests/assembly-llvm/asm/avr-types.rs +++ b/tests/assembly-llvm/asm/avr-types.rs @@ -13,50 +13,6 @@ use minicore::*; type ptr = *const u64; -macro_rules! check { - ($func:ident $ty:ident $class:ident) => { - #[no_mangle] - pub unsafe fn $func(x: $ty) -> $ty { - let y; - asm!("mov {}, {}", lateout($class) y, in($class) x); - y - } - }; -} - -macro_rules! checkw { - ($func:ident $ty:ident $class:ident) => { - #[no_mangle] - pub unsafe fn $func(x: $ty) -> $ty { - let y; - asm!("movw {}, {}", lateout($class) y, in($class) x); - y - } - }; -} - -macro_rules! check_reg { - ($func:ident $ty:ident $reg:tt) => { - #[no_mangle] - pub unsafe fn $func(x: $ty) -> $ty { - let y; - asm!(concat!("mov ", $reg, ", ", $reg), lateout($reg) y, in($reg) x); - y - } - }; -} - -macro_rules! check_regw { - ($func:ident $ty:ident $reg:tt $reg_lit:tt) => { - #[no_mangle] - pub unsafe fn $func(x: $ty) -> $ty { - let y; - asm!(concat!("movw ", $reg_lit, ", ", $reg_lit), lateout($reg) y, in($reg) x); - y - } - }; -} - extern "C" { fn extern_func(); static extern_static: i8; @@ -144,6 +100,50 @@ pub unsafe fn muls_clobber(x: i8, y: i8) -> i16 { z } +macro_rules! check { + ($func:ident $ty:ident $class:ident) => { + #[no_mangle] + pub unsafe fn $func(x: $ty) -> $ty { + let y; + asm!("mov {}, {}", lateout($class) y, in($class) x); + y + } + }; +} + +macro_rules! checkw { + ($func:ident $ty:ident $class:ident) => { + #[no_mangle] + pub unsafe fn $func(x: $ty) -> $ty { + let y; + asm!("movw {}, {}", lateout($class) y, in($class) x); + y + } + }; +} + +macro_rules! check_reg { + ($func:ident $ty:ident $reg:tt) => { + #[no_mangle] + pub unsafe fn $func(x: $ty) -> $ty { + let y; + asm!(concat!("mov ", $reg, ", ", $reg), lateout($reg) y, in($reg) x); + y + } + }; +} + +macro_rules! check_regw { + ($func:ident $ty:ident $reg:tt $reg_lit:tt) => { + #[no_mangle] + pub unsafe fn $func(x: $ty) -> $ty { + let y; + asm!(concat!("movw ", $reg_lit, ", ", $reg_lit), lateout($reg) y, in($reg) x); + y + } + }; +} + // CHECK-LABEL: reg_i8: // CHECK: ;APP // CHECK: mov r{{[0-9]+}}, r{{[0-9]+}} @@ -156,17 +156,17 @@ check!(reg_i8 i8 reg); // CHECK: ;NO_APP check!(reg_upper_i8 i8 reg_upper); -// CHECK-LABEL: reg_pair_i16: +// CHECK-LABEL: reg_iw_i16: // CHECK: ;APP // CHECK: movw r{{[0-9]+}}, r{{[0-9]+}} // CHECK: ;NO_APP -checkw!(reg_pair_i16 i16 reg_pair); +checkw!(reg_iw_i16 i16 reg_iw); -// CHECK-LABEL: reg_iw_i16: +// CHECK-LABEL: reg_pair_i16: // CHECK: ;APP // CHECK: movw r{{[0-9]+}}, r{{[0-9]+}} // CHECK: ;NO_APP -checkw!(reg_iw_i16 i16 reg_iw); +checkw!(reg_pair_i16 i16 reg_pair); // CHECK-LABEL: reg_ptr_i16: // CHECK: ;APP @@ -180,26 +180,25 @@ checkw!(reg_ptr_i16 i16 reg_ptr); // CHECK: ;NO_APP check_reg!(r2_i8 i8 "r2"); -// CHECK-LABEL: xl_i8: -// CHECK: ;APP -// CHECK: mov r26, r26 -// CHECK: ;NO_APP -check_reg!(xl_i8 i8 "XL"); - // CHECK-LABEL: xh_i8: // CHECK: ;APP // CHECK: mov r27, r27 // CHECK: ;NO_APP check_reg!(xh_i8 i8 "XH"); - -// CHECK-LABEL: x_i16: +// CHECK-LABEL: xl_i8: // CHECK: ;APP -// CHECK: movw r26, r26 +// CHECK: mov r26, r26 // CHECK: ;NO_APP -check_regw!(x_i16 i16 "X" "X"); +check_reg!(xl_i8 i8 "XL"); // CHECK-LABEL: r25r24_i16: // CHECK: ;APP // CHECK: movw r24, r24 // CHECK: ;NO_APP check_regw!(r25r24_i16 i16 "r25r24" "r24"); + +// CHECK-LABEL: x_i16: +// CHECK: ;APP +// CHECK: movw r26, r26 +// CHECK: ;NO_APP +check_regw!(x_i16 i16 "X" "X"); \ No newline at end of file diff --git a/tests/assembly-llvm/asm/bpf-types.rs b/tests/assembly-llvm/asm/bpf-types.rs index 07ea7bd5ce055..380b332730a8f 100644 --- a/tests/assembly-llvm/asm/bpf-types.rs +++ b/tests/assembly-llvm/asm/bpf-types.rs @@ -13,6 +13,19 @@ use minicore::*; type ptr = *const u64; +extern "C" { + fn extern_func(); +} + +// CHECK-LABEL: sym_fn +// CHECK: #APP +// CHECK: call extern_func +// CHECK: #NO_APP +#[no_mangle] +pub unsafe fn sym_fn() { + asm!("call {}", sym extern_func); +} + macro_rules! check { ($func:ident $ty:ident $class:ident) => { #[no_mangle] @@ -35,25 +48,6 @@ macro_rules! check_reg { }; } -extern "C" { - fn extern_func(); -} - -// CHECK-LABEL: sym_fn -// CHECK: #APP -// CHECK: call extern_func -// CHECK: #NO_APP -#[no_mangle] -pub unsafe fn sym_fn() { - asm!("call {}", sym extern_func); -} - -// CHECK-LABEL: reg_i8: -// CHECK: #APP -// CHECK: r{{[0-9]+}} = r{{[0-9]+}} -// CHECK: #NO_APP -check!(reg_i8 i8 reg); - // CHECK-LABEL: reg_i16: // CHECK: #APP // CHECK: r{{[0-9]+}} = r{{[0-9]+}} @@ -72,11 +66,11 @@ check!(reg_i32 i32 reg); // CHECK: #NO_APP check!(reg_i64 i64 reg); -// CHECK-LABEL: wreg_i8: +// CHECK-LABEL: reg_i8: // CHECK: #APP -// CHECK: w{{[0-9]+}} = w{{[0-9]+}} +// CHECK: r{{[0-9]+}} = r{{[0-9]+}} // CHECK: #NO_APP -check!(wreg_i8 i8 wreg); +check!(reg_i8 i8 reg); // CHECK-LABEL: wreg_i16: // CHECK: #APP @@ -90,11 +84,11 @@ check!(wreg_i16 i16 wreg); // CHECK: #NO_APP check!(wreg_i32 i32 wreg); -// CHECK-LABEL: r0_i8: +// CHECK-LABEL: wreg_i8: // CHECK: #APP -// CHECK: r0 = r0 +// CHECK: w{{[0-9]+}} = w{{[0-9]+}} // CHECK: #NO_APP -check_reg!(r0_i8 i8 "r0"); +check!(wreg_i8 i8 wreg); // CHECK-LABEL: r0_i16: // CHECK: #APP @@ -114,11 +108,11 @@ check_reg!(r0_i32 i32 "r0"); // CHECK: #NO_APP check_reg!(r0_i64 i64 "r0"); -// CHECK-LABEL: w0_i8: +// CHECK-LABEL: r0_i8: // CHECK: #APP -// CHECK: w0 = w0 +// CHECK: r0 = r0 // CHECK: #NO_APP -check_reg!(w0_i8 i8 "w0"); +check_reg!(r0_i8 i8 "r0"); // CHECK-LABEL: w0_i16: // CHECK: #APP @@ -131,3 +125,9 @@ check_reg!(w0_i16 i16 "w0"); // CHECK: w0 = w0 // CHECK: #NO_APP check_reg!(w0_i32 i32 "w0"); + +// CHECK-LABEL: w0_i8: +// CHECK: #APP +// CHECK: w0 = w0 +// CHECK: #NO_APP +check_reg!(w0_i8 i8 "w0"); diff --git a/tests/assembly-llvm/asm/hexagon-types.rs b/tests/assembly-llvm/asm/hexagon-types.rs index ce80fa75b359b..999c0d686be2e 100644 --- a/tests/assembly-llvm/asm/hexagon-types.rs +++ b/tests/assembly-llvm/asm/hexagon-types.rs @@ -19,28 +19,6 @@ extern "C" { static extern_static: u8; } -macro_rules! check { - ($func:ident $ty:ident $class:ident) => { - #[no_mangle] - pub unsafe fn $func(x: $ty) -> $ty { - let y; - asm!("{} = {}", out($class) y, in($class) x); - y - } - }; -} - -macro_rules! check_reg { - ($func:ident $ty:ident $reg:tt) => { - #[no_mangle] - pub unsafe fn $func(x: $ty) -> $ty { - let y; - asm!(concat!($reg, " = ", $reg), lateout($reg) y, in($reg) x); - y - } - }; -} - // CHECK-LABEL: sym_static: // CHECK: InlineAsm Start // CHECK: r0 = {{#+}}extern_static @@ -78,11 +56,27 @@ pub unsafe fn packet() { }}", out(reg) _, in(reg) &val); } -// CHECK-LABEL: reg_ptr: -// CHECK: InlineAsm Start -// CHECK: r{{[0-9]+}} = r{{[0-9]+}} -// CHECK: InlineAsm End -check!(reg_ptr ptr reg); +macro_rules! check { + ($func:ident $ty:ident $class:ident) => { + #[no_mangle] + pub unsafe fn $func(x: $ty) -> $ty { + let y; + asm!("{} = {}", out($class) y, in($class) x); + y + } + }; +} + +macro_rules! check_reg { + ($func:ident $ty:ident $reg:tt) => { + #[no_mangle] + pub unsafe fn $func(x: $ty) -> $ty { + let y; + asm!(concat!($reg, " = ", $reg), lateout($reg) y, in($reg) x); + y + } + }; +} // CHECK-LABEL: reg_f32: // CHECK: InlineAsm Start @@ -90,6 +84,11 @@ check!(reg_ptr ptr reg); // CHECK: InlineAsm End check!(reg_f32 f32 reg); +// CHECK-LABEL: reg_i16: +// CHECK: InlineAsm Start +// CHECK: r{{[0-9]+}} = r{{[0-9]+}} +// CHECK: InlineAsm End +check!(reg_i16 i16 reg); // CHECK-LABEL: reg_i32: // CHECK: InlineAsm Start // CHECK: r{{[0-9]+}} = r{{[0-9]+}} @@ -102,23 +101,23 @@ check!(reg_i32 i32 reg); // CHECK: InlineAsm End check!(reg_i8 i8 reg); -// CHECK-LABEL: reg_i16: +// CHECK-LABEL: reg_ptr: // CHECK: InlineAsm Start // CHECK: r{{[0-9]+}} = r{{[0-9]+}} // CHECK: InlineAsm End -check!(reg_i16 i16 reg); +check!(reg_ptr ptr reg); -// CHECK-LABEL: r0_ptr: +// CHECK-LABEL: r0_f32: // CHECK: InlineAsm Start // CHECK: r0 = r0 // CHECK: InlineAsm End -check_reg!(r0_ptr ptr "r0"); +check_reg!(r0_f32 f32 "r0"); -// CHECK-LABEL: r0_f32: +// CHECK-LABEL: r0_i16: // CHECK: InlineAsm Start // CHECK: r0 = r0 // CHECK: InlineAsm End -check_reg!(r0_f32 f32 "r0"); +check_reg!(r0_i16 i16 "r0"); // CHECK-LABEL: r0_i32: // CHECK: InlineAsm Start @@ -132,8 +131,8 @@ check_reg!(r0_i32 i32 "r0"); // CHECK: InlineAsm End check_reg!(r0_i8 i8 "r0"); -// CHECK-LABEL: r0_i16: +// CHECK-LABEL: r0_ptr: // CHECK: InlineAsm Start // CHECK: r0 = r0 // CHECK: InlineAsm End -check_reg!(r0_i16 i16 "r0"); +check_reg!(r0_ptr ptr "r0"); diff --git a/tests/assembly-llvm/asm/loongarch-type.rs b/tests/assembly-llvm/asm/loongarch-type.rs index c782be19f1d2a..4f15a09fd7f6c 100644 --- a/tests/assembly-llvm/asm/loongarch-type.rs +++ b/tests/assembly-llvm/asm/loongarch-type.rs @@ -57,17 +57,23 @@ macro_rules! check_reg { ($func:ident, $ty:ty, $reg:tt, $mov:literal) => { } };} -// CHECK-LABEL: reg_i8: +// CHECK-LABEL: freg_f16: // CHECK: #APP -// CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}} +// CHECK: fmov.s $f{{[a-z0-9]+}}, $f{{[a-z0-9]+}} // CHECK: #NO_APP -check!(reg_i8, i8, reg, "move"); +check!(freg_f16, f16, freg, "fmov.s"); -// CHECK-LABEL: reg_i16: +// CHECK-LABEL: freg_f32: // CHECK: #APP -// CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}} +// CHECK: fmov.s $f{{[a-z0-9]+}}, $f{{[a-z0-9]+}} // CHECK: #NO_APP -check!(reg_i16, i16, reg, "move"); +check!(freg_f32, f32, freg, "fmov.s"); + +// CHECK-LABEL: freg_f64: +// CHECK: #APP +// CHECK: fmov.d $f{{[a-z0-9]+}}, $f{{[a-z0-9]+}} +// CHECK: #NO_APP +check!(freg_f64, f64, freg, "fmov.d"); // CHECK-LABEL: reg_f16: // CHECK: #APP @@ -75,17 +81,29 @@ check!(reg_i16, i16, reg, "move"); // CHECK: #NO_APP check!(reg_f16, f16, reg, "move"); -// CHECK-LABEL: reg_i32: +// CHECK-LABEL: reg_f32: // CHECK: #APP // CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}} // CHECK: #NO_APP -check!(reg_i32, i32, reg, "move"); +check!(reg_f32, f32, reg, "move"); -// CHECK-LABEL: reg_f32: +// CHECK-LABEL: reg_f64: // CHECK: #APP // CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}} // CHECK: #NO_APP -check!(reg_f32, f32, reg, "move"); +check!(reg_f64, f64, reg, "move"); + +// CHECK-LABEL: reg_i16: +// CHECK: #APP +// CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}} +// CHECK: #NO_APP +check!(reg_i16, i16, reg, "move"); + +// CHECK-LABEL: reg_i32: +// CHECK: #APP +// CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}} +// CHECK: #NO_APP +check!(reg_i32, i32, reg, "move"); // CHECK-LABEL: reg_i64: // CHECK: #APP @@ -93,11 +111,11 @@ check!(reg_f32, f32, reg, "move"); // CHECK: #NO_APP check!(reg_i64, i64, reg, "move"); -// CHECK-LABEL: reg_f64: +// CHECK-LABEL: reg_i8: // CHECK: #APP // CHECK: move ${{[a-z0-9]+}}, ${{[a-z0-9]+}} // CHECK: #NO_APP -check!(reg_f64, f64, reg, "move"); +check!(reg_i8, i8, reg, "move"); // CHECK-LABEL: reg_ptr: // CHECK: #APP @@ -105,53 +123,53 @@ check!(reg_f64, f64, reg, "move"); // CHECK: #NO_APP check!(reg_ptr, ptr, reg, "move"); -// CHECK-LABEL: freg_f16: +// CHECK-LABEL: f0_f16: // CHECK: #APP // CHECK: fmov.s $f{{[a-z0-9]+}}, $f{{[a-z0-9]+}} // CHECK: #NO_APP -check!(freg_f16, f16, freg, "fmov.s"); +check_reg!(f0_f16, f16, "$f0", "fmov.s"); -// CHECK-LABEL: freg_f32: +// CHECK-LABEL: f0_f32: // CHECK: #APP // CHECK: fmov.s $f{{[a-z0-9]+}}, $f{{[a-z0-9]+}} // CHECK: #NO_APP -check!(freg_f32, f32, freg, "fmov.s"); +check_reg!(f0_f32, f32, "$f0", "fmov.s"); -// CHECK-LABEL: freg_f64: +// CHECK-LABEL: f0_f64: // CHECK: #APP // CHECK: fmov.d $f{{[a-z0-9]+}}, $f{{[a-z0-9]+}} // CHECK: #NO_APP -check!(freg_f64, f64, freg, "fmov.d"); +check_reg!(f0_f64, f64, "$f0", "fmov.d"); -// CHECK-LABEL: r4_i8: +// CHECK-LABEL: r4_f16: // CHECK: #APP // CHECK: move $a0, $a0 // CHECK: #NO_APP -check_reg!(r4_i8, i8, "$r4", "move"); +check_reg!(r4_f16, f16, "$r4", "move"); -// CHECK-LABEL: r4_i16: +// CHECK-LABEL: r4_f32: // CHECK: #APP // CHECK: move $a0, $a0 // CHECK: #NO_APP -check_reg!(r4_i16, i16, "$r4", "move"); +check_reg!(r4_f32, f32, "$r4", "move"); -// CHECK-LABEL: r4_f16: +// CHECK-LABEL: r4_f64: // CHECK: #APP // CHECK: move $a0, $a0 // CHECK: #NO_APP -check_reg!(r4_f16, f16, "$r4", "move"); +check_reg!(r4_f64, f64, "$r4", "move"); -// CHECK-LABEL: r4_i32: +// CHECK-LABEL: r4_i16: // CHECK: #APP // CHECK: move $a0, $a0 // CHECK: #NO_APP -check_reg!(r4_i32, i32, "$r4", "move"); +check_reg!(r4_i16, i16, "$r4", "move"); -// CHECK-LABEL: r4_f32: +// CHECK-LABEL: r4_i32: // CHECK: #APP // CHECK: move $a0, $a0 // CHECK: #NO_APP -check_reg!(r4_f32, f32, "$r4", "move"); +check_reg!(r4_i32, i32, "$r4", "move"); // CHECK-LABEL: r4_i64: // CHECK: #APP @@ -159,32 +177,14 @@ check_reg!(r4_f32, f32, "$r4", "move"); // CHECK: #NO_APP check_reg!(r4_i64, i64, "$r4", "move"); -// CHECK-LABEL: r4_f64: +// CHECK-LABEL: r4_i8: // CHECK: #APP // CHECK: move $a0, $a0 // CHECK: #NO_APP -check_reg!(r4_f64, f64, "$r4", "move"); +check_reg!(r4_i8, i8, "$r4", "move"); // CHECK-LABEL: r4_ptr: // CHECK: #APP // CHECK: move $a0, $a0 // CHECK: #NO_APP check_reg!(r4_ptr, ptr, "$r4", "move"); - -// CHECK-LABEL: f0_f16: -// CHECK: #APP -// CHECK: fmov.s $f{{[a-z0-9]+}}, $f{{[a-z0-9]+}} -// CHECK: #NO_APP -check_reg!(f0_f16, f16, "$f0", "fmov.s"); - -// CHECK-LABEL: f0_f32: -// CHECK: #APP -// CHECK: fmov.s $f{{[a-z0-9]+}}, $f{{[a-z0-9]+}} -// CHECK: #NO_APP -check_reg!(f0_f32, f32, "$f0", "fmov.s"); - -// CHECK-LABEL: f0_f64: -// CHECK: #APP -// CHECK: fmov.d $f{{[a-z0-9]+}}, $f{{[a-z0-9]+}} -// CHECK: #NO_APP -check_reg!(f0_f64, f64, "$f0", "fmov.d"); diff --git a/tests/assembly-llvm/asm/m68k-types.rs b/tests/assembly-llvm/asm/m68k-types.rs index 9e4f6d9a1a9d5..af6cfae7b3f07 100644 --- a/tests/assembly-llvm/asm/m68k-types.rs +++ b/tests/assembly-llvm/asm/m68k-types.rs @@ -24,11 +24,17 @@ macro_rules! check { }; } -// CHECK-LABEL: reg_data_i8: +// CHECK-LABEL: reg_addr_i16: // CHECK: ;APP -// CHECK: move.b %d{{[0-9]}}, %d{{[0-9]}} +// CHECK: move.w %a{{[0-9]}}, %a{{[0-9]}} // CHECK: ;NO_APP -check!(reg_data_i8 i8 reg_data "move.b"); +check!(reg_addr_i16 i16 reg_addr "move.w"); + +// CHECK-LABEL: reg_addr_i32: +// CHECK: ;APP +// CHECK: move.l %a{{[0-9]}}, %a{{[0-9]}} +// CHECK: ;NO_APP +check!(reg_addr_i32 i32 reg_addr "move.l"); // CHECK-LABEL: reg_data_i16: // CHECK: ;APP @@ -42,17 +48,11 @@ check!(reg_data_i16 i16 reg_data "move.w"); // CHECK: ;NO_APP check!(reg_data_i32 i32 reg_data "move.l"); -// CHECK-LABEL: reg_addr_i16: -// CHECK: ;APP -// CHECK: move.w %a{{[0-9]}}, %a{{[0-9]}} -// CHECK: ;NO_APP -check!(reg_addr_i16 i16 reg_addr "move.w"); - -// CHECK-LABEL: reg_addr_i32: +// CHECK-LABEL: reg_data_i8: // CHECK: ;APP -// CHECK: move.l %a{{[0-9]}}, %a{{[0-9]}} +// CHECK: move.b %d{{[0-9]}}, %d{{[0-9]}} // CHECK: ;NO_APP -check!(reg_addr_i32 i32 reg_addr "move.l"); +check!(reg_data_i8 i8 reg_data "move.b"); // CHECK-LABEL: reg_i16: // CHECK: ;APP diff --git a/tests/assembly-llvm/asm/mips-types.rs b/tests/assembly-llvm/asm/mips-types.rs index 00e8ce0b874aa..5a7873e885e56 100644 --- a/tests/assembly-llvm/asm/mips-types.rs +++ b/tests/assembly-llvm/asm/mips-types.rs @@ -22,24 +22,6 @@ extern "C" { static extern_static: u8; } -macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => { - #[no_mangle] - pub unsafe fn $func(x: $ty) -> $ty { - let y; - asm!(concat!($mov," {}, {}"), out($class) y, in($class) x); - y - } -};} - -macro_rules! check_reg { ($func:ident, $ty:ty, $reg:tt, $mov:literal) => { - #[no_mangle] - pub unsafe fn $func(x: $ty) -> $ty { - let y; - asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x); - y - } -};} - // mips32-LABEL: sym_static_32: // mips32: #APP // mips32: lw $3, %got(extern_static)($gp) @@ -84,31 +66,41 @@ pub unsafe fn sym_fn_64() { asm!("ld $v1, {}", sym extern_func); } +macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => { + #[no_mangle] + pub unsafe fn $func(x: $ty) -> $ty { + let y; + asm!(concat!($mov," {}, {}"), out($class) y, in($class) x); + y + } +};} + +macro_rules! check_reg { ($func:ident, $ty:ty, $reg:tt, $mov:literal) => { + #[no_mangle] + pub unsafe fn $func(x: $ty) -> $ty { + let y; + asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x); + y + } +};} + // CHECK-LABEL: reg_f32: // CHECK: #APP // CHECK: mov.s $f{{[0-9]+}}, $f{{[0-9]+}} // CHECK: #NO_APP check!(reg_f32, f32, freg, "mov.s"); -// CHECK-LABEL: f0_f32: -// CHECK: #APP -// CHECK: mov.s $f0, $f0 -// CHECK: #NO_APP -#[no_mangle] -check_reg!(f0_f32, f32, "$f0", "mov.s"); - // CHECK-LABEL: reg_f32_64: // CHECK: #APP // CHECK: mov.d $f{{[0-9]+}}, $f{{[0-9]+}} // CHECK: #NO_APP check!(reg_f32_64, f32, freg, "mov.d"); -// CHECK-LABEL: f0_f32_64: +// CHECK-LABEL: reg_f32_soft: // CHECK: #APP -// CHECK: mov.d $f0, $f0 +// CHECK: move ${{[0-9]+}}, ${{[0-9]+}} // CHECK: #NO_APP -#[no_mangle] -check_reg!(f0_f32_64, f32, "$f0", "mov.d"); +check!(reg_f32_soft, f32, reg, "move"); // CHECK-LABEL: reg_f64: // CHECK: #APP @@ -117,18 +109,18 @@ check_reg!(f0_f32_64, f32, "$f0", "mov.d"); #[no_mangle] check!(reg_f64, f64, freg, "mov.d"); -// CHECK-LABEL: f0_f64: -// CHECK: #APP -// CHECK: mov.d $f0, $f0 -// CHECK: #NO_APP -#[no_mangle] -check_reg!(f0_f64, f64, "$f0", "mov.d"); +// mips64-LABEL: reg_f64_soft: +// mips64: #APP +// mips64: move ${{[0-9]+}}, ${{[0-9]+}} +// mips64: #NO_APP +#[cfg(mips64)] +check!(reg_f64_soft, f64, reg, "move"); -// CHECK-LABEL: reg_ptr: +// CHECK-LABEL: reg_i16: // CHECK: #APP // CHECK: move ${{[0-9]+}}, ${{[0-9]+}} // CHECK: #NO_APP -check!(reg_ptr, ptr, reg, "move"); +check!(reg_i16, i16, reg, "move"); // CHECK-LABEL: reg_i32: // CHECK: #APP @@ -136,18 +128,12 @@ check!(reg_ptr, ptr, reg, "move"); // CHECK: #NO_APP check!(reg_i32, i32, reg, "move"); -// CHECK-LABEL: reg_f32_soft: -// CHECK: #APP -// CHECK: move ${{[0-9]+}}, ${{[0-9]+}} -// CHECK: #NO_APP -check!(reg_f32_soft, f32, reg, "move"); - -// mips64-LABEL: reg_f64_soft: +// mips64-LABEL: reg_i64: // mips64: #APP // mips64: move ${{[0-9]+}}, ${{[0-9]+}} // mips64: #NO_APP #[cfg(mips64)] -check!(reg_f64_soft, f64, reg, "move"); +check!(reg_i64, i64, reg, "move"); // CHECK-LABEL: reg_i8: // CHECK: #APP @@ -155,36 +141,38 @@ check!(reg_f64_soft, f64, reg, "move"); // CHECK: #NO_APP check!(reg_i8, i8, reg, "move"); -// CHECK-LABEL: reg_u8: +// CHECK-LABEL: reg_ptr: // CHECK: #APP // CHECK: move ${{[0-9]+}}, ${{[0-9]+}} // CHECK: #NO_APP -check!(reg_u8, u8, reg, "move"); +check!(reg_ptr, ptr, reg, "move"); -// CHECK-LABEL: reg_i16: +// CHECK-LABEL: reg_u8: // CHECK: #APP // CHECK: move ${{[0-9]+}}, ${{[0-9]+}} // CHECK: #NO_APP -check!(reg_i16, i16, reg, "move"); +check!(reg_u8, u8, reg, "move"); -// mips64-LABEL: reg_i64: -// mips64: #APP -// mips64: move ${{[0-9]+}}, ${{[0-9]+}} -// mips64: #NO_APP -#[cfg(mips64)] -check!(reg_i64, i64, reg, "move"); +// CHECK-LABEL: f0_f32: +// CHECK: #APP +// CHECK: mov.s $f0, $f0 +// CHECK: #NO_APP +#[no_mangle] +check_reg!(f0_f32, f32, "$f0", "mov.s"); -// CHECK-LABEL: r8_ptr: +// CHECK-LABEL: f0_f32_64: // CHECK: #APP -// CHECK: move $8, $8 +// CHECK: mov.d $f0, $f0 // CHECK: #NO_APP -check_reg!(r8_ptr, ptr, "$8", "move"); +#[no_mangle] +check_reg!(f0_f32_64, f32, "$f0", "mov.d"); -// CHECK-LABEL: r8_i32: +// CHECK-LABEL: f0_f64: // CHECK: #APP -// CHECK: move $8, $8 +// CHECK: mov.d $f0, $f0 // CHECK: #NO_APP -check_reg!(r8_i32, i32, "$8", "move"); +#[no_mangle] +check_reg!(f0_f64, f64, "$f0", "mov.d"); // CHECK-LABEL: r8_f32: // CHECK: #APP @@ -192,20 +180,31 @@ check_reg!(r8_i32, i32, "$8", "move"); // CHECK: #NO_APP check_reg!(r8_f32, f32, "$8", "move"); +// CHECK-LABEL: r8_i16: +// CHECK: #APP +// CHECK: move $8, $8 +// CHECK: #NO_APP +check_reg!(r8_i16, i16, "$8", "move"); +// CHECK-LABEL: r8_i32: +// CHECK: #APP +// CHECK: move $8, $8 +// CHECK: #NO_APP +check_reg!(r8_i32, i32, "$8", "move"); + // CHECK-LABEL: r8_i8: // CHECK: #APP // CHECK: move $8, $8 // CHECK: #NO_APP check_reg!(r8_i8, i8, "$8", "move"); -// CHECK-LABEL: r8_u8: +// CHECK-LABEL: r8_ptr: // CHECK: #APP // CHECK: move $8, $8 // CHECK: #NO_APP -check_reg!(r8_u8, u8, "$8", "move"); +check_reg!(r8_ptr, ptr, "$8", "move"); -// CHECK-LABEL: r8_i16: +// CHECK-LABEL: r8_u8: // CHECK: #APP // CHECK: move $8, $8 // CHECK: #NO_APP -check_reg!(r8_i16, i16, "$8", "move"); +check_reg!(r8_u8, u8, "$8", "move"); diff --git a/tests/assembly-llvm/asm/msp430-types.rs b/tests/assembly-llvm/asm/msp430-types.rs index 442dc77999f54..843414591ca87 100644 --- a/tests/assembly-llvm/asm/msp430-types.rs +++ b/tests/assembly-llvm/asm/msp430-types.rs @@ -13,49 +13,6 @@ use minicore::*; type ptr = *const i16; -macro_rules! check { - ($func:ident $ty:ident $class:ident) => { - #[no_mangle] - pub unsafe fn $func(x: $ty) -> $ty { - let y; - asm!("mov {}, {}", lateout($class) y, in($class) x); - y - } - }; -} - -macro_rules! checkb { - ($func:ident $ty:ident $class:ident) => { - #[no_mangle] - pub unsafe fn $func(x: $ty) -> $ty { - let y; - asm!("mov.b {}, {}", lateout($class) y, in($class) x); - y - } - }; -} - -macro_rules! check_reg { - ($func:ident $ty:ident $reg:tt) => { - #[no_mangle] - pub unsafe fn $func(x: $ty) -> $ty { - let y; - asm!(concat!("mov ", $reg, ", ", $reg), lateout($reg) y, in($reg) x); - y - } - }; -} - -macro_rules! check_regb { - ($func:ident $ty:ident $reg:tt) => { - #[no_mangle] - pub unsafe fn $func(x: $ty) -> $ty { - let y; - asm!(concat!("mov.b ", $reg, ", ", $reg), lateout($reg) y, in($reg) x); - y - } - }; -} extern "C" { fn extern_func(); @@ -104,17 +61,61 @@ pub unsafe fn mov_postincrement(mut x: *const i16) -> (i16, *const i16) { (y, x) } -// CHECK-LABEL: reg_i8: +macro_rules! check { + ($func:ident $ty:ident $class:ident) => { + #[no_mangle] + pub unsafe fn $func(x: $ty) -> $ty { + let y; + asm!("mov {}, {}", lateout($class) y, in($class) x); + y + } + }; +} + +macro_rules! checkb { + ($func:ident $ty:ident $class:ident) => { + #[no_mangle] + pub unsafe fn $func(x: $ty) -> $ty { + let y; + asm!("mov.b {}, {}", lateout($class) y, in($class) x); + y + } + }; +} + +macro_rules! check_reg { + ($func:ident $ty:ident $reg:tt) => { + #[no_mangle] + pub unsafe fn $func(x: $ty) -> $ty { + let y; + asm!(concat!("mov ", $reg, ", ", $reg), lateout($reg) y, in($reg) x); + y + } + }; +} + +macro_rules! check_regb { + ($func:ident $ty:ident $reg:tt) => { + #[no_mangle] + pub unsafe fn $func(x: $ty) -> $ty { + let y; + asm!(concat!("mov.b ", $reg, ", ", $reg), lateout($reg) y, in($reg) x); + y + } + }; +} + +// CHECK-LABEL: reg_i16: // CHECK: ;APP // CHECK: mov r{{[0-9]+}}, r{{[0-9]+}} // CHECK: ;NO_APP -check!(reg_i8 i8 reg); +check!(reg_i16 i16 reg); -// CHECK-LABEL: reg_i16: +// CHECK-LABEL: reg_i8: // CHECK: ;APP // CHECK: mov r{{[0-9]+}}, r{{[0-9]+}} // CHECK: ;NO_APP -check!(reg_i16 i16 reg); +check!(reg_i8 i8 reg); // CHECK-LABEL: reg_i8b: // CHECK: ;APP @@ -122,17 +123,16 @@ check!(reg_i16 i16 reg); // CHECK: ;NO_APP checkb!(reg_i8b i8 reg); -// CHECK-LABEL: r5_i8: +// CHECK-LABEL: r5_i16: // CHECK: ;APP // CHECK: mov r5, r5 // CHECK: ;NO_APP -check_reg!(r5_i8 i8 "r5"); - -// CHECK-LABEL: r5_i16: +check_reg!(r5_i16 i16 "r5"); +// CHECK-LABEL: r5_i8: // CHECK: ;APP // CHECK: mov r5, r5 // CHECK: ;NO_APP -check_reg!(r5_i16 i16 "r5"); +check_reg!(r5_i8 i8 "r5"); // CHECK-LABEL: r5_i8b: // CHECK: ;APP diff --git a/tests/assembly-llvm/asm/nvptx-types.rs b/tests/assembly-llvm/asm/nvptx-types.rs index 7e8ebd03024e4..ee10bc5e03136 100644 --- a/tests/assembly-llvm/asm/nvptx-types.rs +++ b/tests/assembly-llvm/asm/nvptx-types.rs @@ -36,23 +36,23 @@ macro_rules! check { }; } -// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg16_i8 +// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg16_i16 // CHECK: // begin inline asm // CHECK: mov.i16 %{{[a-z0-9]+}}, %{{[a-z0-9]+}}; // CHECK: // end inline asm -check!(reg16_i8 i8 reg16 "mov.i16"); +check!(reg16_i16 i16 reg16 "mov.i16"); -// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg16_i16 +// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg16_i8 // CHECK: // begin inline asm // CHECK: mov.i16 %{{[a-z0-9]+}}, %{{[a-z0-9]+}}; // CHECK: // end inline asm -check!(reg16_i16 i16 reg16 "mov.i16"); +check!(reg16_i8 i8 reg16 "mov.i16"); -// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg32_i8 +// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg32_f32 // CHECK: // begin inline asm // CHECK: mov.i32 %{{[a-z0-9]+}}, %{{[a-z0-9]+}}; // CHECK: // end inline asm -check!(reg32_i8 i8 reg32 "mov.i32"); +check!(reg32_f32 f32 reg32 "mov.i32"); // CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg32_i16 // CHECK: // begin inline asm @@ -66,35 +66,35 @@ check!(reg32_i16 i16 reg32 "mov.i32"); // CHECK: // end inline asm check!(reg32_i32 i32 reg32 "mov.i32"); -// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg32_f32 +// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg32_i8 // CHECK: // begin inline asm // CHECK: mov.i32 %{{[a-z0-9]+}}, %{{[a-z0-9]+}}; // CHECK: // end inline asm -check!(reg32_f32 f32 reg32 "mov.i32"); +check!(reg32_i8 i8 reg32 "mov.i32"); -// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg64_i8 +// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg64_f32 // CHECK: // begin inline asm // CHECK: mov.i64 %{{[a-z0-9]+}}, %{{[a-z0-9]+}}; // CHECK: // end inline asm -check!(reg64_i8 i8 reg64 "mov.i64"); +check!(reg64_f32 f32 reg64 "mov.i64"); -// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg64_i16 +// CHECK-LABEL: .visible .func (.param .b64 func_retval0) reg64_f64 // CHECK: // begin inline asm // CHECK: mov.i64 %{{[a-z0-9]+}}, %{{[a-z0-9]+}}; // CHECK: // end inline asm -check!(reg64_i16 i16 reg64 "mov.i64"); +check!(reg64_f64 f64 reg64 "mov.i64"); -// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg64_i32 +// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg64_i16 // CHECK: // begin inline asm // CHECK: mov.i64 %{{[a-z0-9]+}}, %{{[a-z0-9]+}}; // CHECK: // end inline asm -check!(reg64_i32 i32 reg64 "mov.i64"); +check!(reg64_i16 i16 reg64 "mov.i64"); -// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg64_f32 +// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg64_i32 // CHECK: // begin inline asm // CHECK: mov.i64 %{{[a-z0-9]+}}, %{{[a-z0-9]+}}; // CHECK: // end inline asm -check!(reg64_f32 f32 reg64 "mov.i64"); +check!(reg64_i32 i32 reg64 "mov.i64"); // CHECK-LABEL: .visible .func (.param .b64 func_retval0) reg64_i64 // CHECK: // begin inline asm @@ -102,11 +102,11 @@ check!(reg64_f32 f32 reg64 "mov.i64"); // CHECK: // end inline asm check!(reg64_i64 i64 reg64 "mov.i64"); -// CHECK-LABEL: .visible .func (.param .b64 func_retval0) reg64_f64 +// CHECK-LABEL: .visible .func (.param .b32 func_retval0) reg64_i8 // CHECK: // begin inline asm // CHECK: mov.i64 %{{[a-z0-9]+}}, %{{[a-z0-9]+}}; // CHECK: // end inline asm -check!(reg64_f64 f64 reg64 "mov.i64"); +check!(reg64_i8 i8 reg64 "mov.i64"); // CHECK-LABEL: .visible .func (.param .b64 func_retval0) reg64_ptr // CHECK: // begin inline asm diff --git a/tests/assembly-llvm/asm/powerpc-types.rs b/tests/assembly-llvm/asm/powerpc-types.rs index 4291e4c02f3be..55db090c049b3 100644 --- a/tests/assembly-llvm/asm/powerpc-types.rs +++ b/tests/assembly-llvm/asm/powerpc-types.rs @@ -73,42 +73,35 @@ macro_rules! check_reg { ($func:ident, $ty:ty, $rego:tt, $regc:tt, $mov:literal) } };} -// CHECK-LABEL: reg_i8: +// CHECK-LABEL: reg_f32: // CHECK: #APP -// CHECK: mr {{[0-9]+}}, {{[0-9]+}} +// CHECK: fmr {{[0-9]+}}, {{[0-9]+}} // CHECK: #NO_APP -check!(reg_i8, i8, reg, "mr"); +check!(reg_f32, f32, freg, "fmr"); -// CHECK-LABEL: reg_i16: +// CHECK-LABEL: reg_f64: // CHECK: #APP -// CHECK: mr {{[0-9]+}}, {{[0-9]+}} +// CHECK: fmr {{[0-9]+}}, {{[0-9]+}} // CHECK: #NO_APP -check!(reg_i16, i16, reg, "mr"); +check!(reg_f64, f64, freg, "fmr"); -// CHECK-LABEL: reg_i32: +// CHECK-LABEL: reg_i16: // CHECK: #APP // CHECK: mr {{[0-9]+}}, {{[0-9]+}} // CHECK: #NO_APP -check!(reg_i32, i32, reg, "mr"); - -// powerpc64-LABEL: reg_i64: -// powerpc64: #APP -// powerpc64: mr {{[0-9]+}}, {{[0-9]+}} -// powerpc64: #NO_APP -#[cfg(powerpc64)] -check!(reg_i64, i64, reg, "mr"); +check!(reg_i16, i16, reg, "mr"); -// CHECK-LABEL: reg_i8_nz: +// CHECK-LABEL: reg_i16_nz: // CHECK: #APP // CHECK: mr {{[0-9]+}}, {{[0-9]+}} // CHECK: #NO_APP -check!(reg_i8_nz, i8, reg_nonzero, "mr"); +check!(reg_i16_nz, i16, reg_nonzero, "mr"); -// CHECK-LABEL: reg_i16_nz: +// CHECK-LABEL: reg_i32: // CHECK: #APP // CHECK: mr {{[0-9]+}}, {{[0-9]+}} // CHECK: #NO_APP -check!(reg_i16_nz, i16, reg_nonzero, "mr"); +check!(reg_i32, i32, reg, "mr"); // CHECK-LABEL: reg_i32_nz: // CHECK: #APP @@ -116,6 +109,13 @@ check!(reg_i16_nz, i16, reg_nonzero, "mr"); // CHECK: #NO_APP check!(reg_i32_nz, i32, reg_nonzero, "mr"); +// powerpc64-LABEL: reg_i64: +// powerpc64: #APP +// powerpc64: mr {{[0-9]+}}, {{[0-9]+}} +// powerpc64: #NO_APP +#[cfg(powerpc64)] +check!(reg_i64, i64, reg, "mr"); + // powerpc64-LABEL: reg_i64_nz: // powerpc64: #APP // powerpc64: mr {{[0-9]+}}, {{[0-9]+}} @@ -123,28 +123,61 @@ check!(reg_i32_nz, i32, reg_nonzero, "mr"); #[cfg(powerpc64)] check!(reg_i64_nz, i64, reg_nonzero, "mr"); -// CHECK-LABEL: reg_f32: +// CHECK-LABEL: reg_i8: // CHECK: #APP -// CHECK: fmr {{[0-9]+}}, {{[0-9]+}} +// CHECK: mr {{[0-9]+}}, {{[0-9]+}} // CHECK: #NO_APP -check!(reg_f32, f32, freg, "fmr"); +check!(reg_i8, i8, reg, "mr"); -// CHECK-LABEL: reg_f64: +// CHECK-LABEL: reg_i8_nz: // CHECK: #APP -// CHECK: fmr {{[0-9]+}}, {{[0-9]+}} +// CHECK: mr {{[0-9]+}}, {{[0-9]+}} // CHECK: #NO_APP -check!(reg_f64, f64, freg, "fmr"); +check!(reg_i8_nz, i8, reg_nonzero, "mr"); -// powerpc_altivec-LABEL: vreg_i8x16: +// powerpc_vsx-LABEL: vreg_f32: +// powerpc_vsx: #APP +// powerpc_vsx: vmr {{[0-9]+}}, {{[0-9]+}} +// powerpc_vsx: #NO_APP +// powerpc64_vsx-LABEL: vreg_f32: +// powerpc64_vsx: #APP +// powerpc64_vsx: vmr {{[0-9]+}}, {{[0-9]+}} +// powerpc64_vsx: #NO_APP +#[cfg(vsx)] +check!(vreg_f32, f32, vreg, "vmr"); + +// powerpc_altivec-LABEL: vreg_f32x4: // powerpc_altivec: #APP // powerpc_altivec: vmr {{[0-9]+}}, {{[0-9]+}} // powerpc_altivec: #NO_APP -// powerpc64-LABEL: vreg_i8x16: +// powerpc64-LABEL: vreg_f32x4: // powerpc64: #APP // powerpc64: vmr {{[0-9]+}}, {{[0-9]+}} // powerpc64: #NO_APP #[cfg(altivec)] -check!(vreg_i8x16, i8x16, vreg, "vmr"); +check!(vreg_f32x4, f32x4, vreg, "vmr"); + +// powerpc_vsx-LABEL: vreg_f64: +// powerpc_vsx: #APP +// powerpc_vsx: vmr {{[0-9]+}}, {{[0-9]+}} +// powerpc_vsx: #NO_APP +// powerpc64_vsx-LABEL: vreg_f64: +// powerpc64_vsx: #APP +// powerpc64_vsx: vmr {{[0-9]+}}, {{[0-9]+}} +// powerpc64_vsx: #NO_APP +#[cfg(vsx)] +check!(vreg_f64, f64, vreg, "vmr"); + +// powerpc_vsx-LABEL: vreg_f64x2: +// powerpc_vsx: #APP +// powerpc_vsx: vmr {{[0-9]+}}, {{[0-9]+}} +// powerpc_vsx: #NO_APP +// powerpc64_vsx-LABEL: vreg_f64x2: +// powerpc64_vsx: #APP +// powerpc64_vsx: vmr {{[0-9]+}}, {{[0-9]+}} +// powerpc64_vsx: #NO_APP +#[cfg(vsx)] +check!(vreg_f64x2, f64x2, vreg, "vmr"); // powerpc_altivec-LABEL: vreg_i16x8: // powerpc_altivec: #APP @@ -179,80 +212,46 @@ check!(vreg_i32x4, i32x4, vreg, "vmr"); #[cfg(vsx)] check!(vreg_i64x2, i64x2, vreg, "vmr"); -// powerpc_altivec-LABEL: vreg_f32x4: +// powerpc_altivec-LABEL: vreg_i8x16: // powerpc_altivec: #APP // powerpc_altivec: vmr {{[0-9]+}}, {{[0-9]+}} // powerpc_altivec: #NO_APP -// powerpc64-LABEL: vreg_f32x4: +// powerpc64-LABEL: vreg_i8x16: // powerpc64: #APP // powerpc64: vmr {{[0-9]+}}, {{[0-9]+}} // powerpc64: #NO_APP #[cfg(altivec)] -check!(vreg_f32x4, f32x4, vreg, "vmr"); - -// powerpc_vsx-LABEL: vreg_f64x2: -// powerpc_vsx: #APP -// powerpc_vsx: vmr {{[0-9]+}}, {{[0-9]+}} -// powerpc_vsx: #NO_APP -// powerpc64_vsx-LABEL: vreg_f64x2: -// powerpc64_vsx: #APP -// powerpc64_vsx: vmr {{[0-9]+}}, {{[0-9]+}} -// powerpc64_vsx: #NO_APP -#[cfg(vsx)] -check!(vreg_f64x2, f64x2, vreg, "vmr"); - -// powerpc_vsx-LABEL: vreg_f32: -// powerpc_vsx: #APP -// powerpc_vsx: vmr {{[0-9]+}}, {{[0-9]+}} -// powerpc_vsx: #NO_APP -// powerpc64_vsx-LABEL: vreg_f32: -// powerpc64_vsx: #APP -// powerpc64_vsx: vmr {{[0-9]+}}, {{[0-9]+}} -// powerpc64_vsx: #NO_APP -#[cfg(vsx)] -check!(vreg_f32, f32, vreg, "vmr"); - -// powerpc_vsx-LABEL: vreg_f64: -// powerpc_vsx: #APP -// powerpc_vsx: vmr {{[0-9]+}}, {{[0-9]+}} -// powerpc_vsx: #NO_APP -// powerpc64_vsx-LABEL: vreg_f64: -// powerpc64_vsx: #APP -// powerpc64_vsx: vmr {{[0-9]+}}, {{[0-9]+}} -// powerpc64_vsx: #NO_APP -#[cfg(vsx)] -check!(vreg_f64, f64, vreg, "vmr"); +check!(vreg_i8x16, i8x16, vreg, "vmr"); -// CHECK-LABEL: reg_i8_r0: +// CHECK-LABEL: reg_f32_f0: // CHECK: #APP -// CHECK: mr 0, 0 +// CHECK: fmr 0, 0 // CHECK: #NO_APP -check_reg!(reg_i8_r0, i8, "0", "0", "mr"); +check_reg!(reg_f32_f0, f32, "0", "f0", "fmr"); -// CHECK-LABEL: reg_i16_r0: +// CHECK-LABEL: reg_f32_f18: // CHECK: #APP -// CHECK: mr 0, 0 +// CHECK: fmr 18, 18 // CHECK: #NO_APP -check_reg!(reg_i16_r0, i16, "0", "0", "mr"); +check_reg!(reg_f32_f18, f32, "18", "f18", "fmr"); -// CHECK-LABEL: reg_i32_r0: +// CHECK-LABEL: reg_f64_f0: // CHECK: #APP -// CHECK: mr 0, 0 +// CHECK: fmr 0, 0 // CHECK: #NO_APP -check_reg!(reg_i32_r0, i32, "0", "0", "mr"); +check_reg!(reg_f64_f0, f64, "0", "f0", "fmr"); -// powerpc64-LABEL: reg_i64_r0: -// powerpc64: #APP -// powerpc64: mr 0, 0 -// powerpc64: #NO_APP -#[cfg(powerpc64)] -check_reg!(reg_i64_r0, i64, "0", "0", "mr"); +// CHECK-LABEL: reg_f64_f18: +// CHECK: #APP +// CHECK: fmr 18, 18 +// CHECK: #NO_APP +check_reg!(reg_f64_f18, f64, "18", "f18", "fmr"); -// CHECK-LABEL: reg_i8_r18: +// CHECK-LABEL: reg_i16_r0: // CHECK: #APP -// CHECK: mr 18, 18 +// CHECK: mr 0, 0 // CHECK: #NO_APP -check_reg!(reg_i8_r18, i8, "18", "18", "mr"); +check_reg!(reg_i16_r0, i16, "0", "0", "mr"); // CHECK-LABEL: reg_i16_r18: // CHECK: #APP @@ -260,12 +259,25 @@ check_reg!(reg_i8_r18, i8, "18", "18", "mr"); // CHECK: #NO_APP check_reg!(reg_i16_r18, i16, "18", "18", "mr"); +// CHECK-LABEL: reg_i32_r0: +// CHECK: #APP +// CHECK: mr 0, 0 +// CHECK: #NO_APP +check_reg!(reg_i32_r0, i32, "0", "0", "mr"); + // CHECK-LABEL: reg_i32_r18: // CHECK: #APP // CHECK: mr 18, 18 // CHECK: #NO_APP check_reg!(reg_i32_r18, i32, "18", "18", "mr"); +// powerpc64-LABEL: reg_i64_r0: +// powerpc64: #APP +// powerpc64: mr 0, 0 +// powerpc64: #NO_APP +#[cfg(powerpc64)] +check_reg!(reg_i64_r0, i64, "0", "0", "mr"); + // powerpc64-LABEL: reg_i64_r18: // powerpc64: #APP // powerpc64: mr 18, 18 @@ -273,128 +285,116 @@ check_reg!(reg_i32_r18, i32, "18", "18", "mr"); #[cfg(powerpc64)] check_reg!(reg_i64_r18, i64, "18", "18", "mr"); -// CHECK-LABEL: reg_f32_f0: -// CHECK: #APP -// CHECK: fmr 0, 0 -// CHECK: #NO_APP -check_reg!(reg_f32_f0, f32, "0", "f0", "fmr"); - -// CHECK-LABEL: reg_f64_f0: +// CHECK-LABEL: reg_i8_r0: // CHECK: #APP -// CHECK: fmr 0, 0 +// CHECK: mr 0, 0 // CHECK: #NO_APP -check_reg!(reg_f64_f0, f64, "0", "f0", "fmr"); +check_reg!(reg_i8_r0, i8, "0", "0", "mr"); -// CHECK-LABEL: reg_f32_f18: +// CHECK-LABEL: reg_i8_r18: // CHECK: #APP -// CHECK: fmr 18, 18 +// CHECK: mr 18, 18 // CHECK: #NO_APP -check_reg!(reg_f32_f18, f32, "18", "f18", "fmr"); +check_reg!(reg_i8_r18, i8, "18", "18", "mr"); -// CHECK-LABEL: reg_f64_f18: -// CHECK: #APP -// CHECK: fmr 18, 18 -// CHECK: #NO_APP -check_reg!(reg_f64_f18, f64, "18", "f18", "fmr"); +// powerpc_vsx-LABEL: vreg_f32_v0: +// powerpc_vsx: #APP +// powerpc_vsx: vmr 0, 0 +// powerpc_vsx: #NO_APP +// powerpc64_vsx-LABEL: vreg_f32_v0: +// powerpc64_vsx: #APP +// powerpc64_vsx: vmr 0, 0 +// powerpc64_vsx: #NO_APP +#[cfg(vsx)] +check_reg!(vreg_f32_v0, f32, "0", "v0", "vmr"); -// powerpc_altivec-LABEL: vreg_i8x16_v0: -// powerpc_altivec: #APP -// powerpc_altivec: vmr 0, 0 -// powerpc_altivec: #NO_APP -// powerpc64-LABEL: vreg_i8x16_v0: -// powerpc64: #APP -// powerpc64: vmr 0, 0 -// powerpc64: #NO_APP -#[cfg(altivec)] -check_reg!(vreg_i8x16_v0, i8x16, "0", "v0", "vmr"); +// powerpc_vsx-LABEL: vreg_f32_v18: +// powerpc_vsx: #APP +// powerpc_vsx: vmr 18, 18 +// powerpc_vsx: #NO_APP +// powerpc64_vsx-LABEL: vreg_f32_v18: +// powerpc64_vsx: #APP +// powerpc64_vsx: vmr 18, 18 +// powerpc64_vsx: #NO_APP +#[cfg(vsx)] +check_reg!(vreg_f32_v18, f32, "18", "v18", "vmr"); -// powerpc_altivec-LABEL: vreg_i16x8_v0: +// powerpc_altivec-LABEL: vreg_f32x4_v0: // powerpc_altivec: #APP // powerpc_altivec: vmr 0, 0 // powerpc_altivec: #NO_APP -// powerpc64-LABEL: vreg_i16x8_v0: +// powerpc64-LABEL: vreg_f32x4_v0: // powerpc64: #APP // powerpc64: vmr 0, 0 // powerpc64: #NO_APP #[cfg(altivec)] -check_reg!(vreg_i16x8_v0, i16x8, "0", "v0", "vmr"); +check_reg!(vreg_f32x4_v0, f32x4, "0", "v0", "vmr"); -// powerpc_altivec-LABEL: vreg_i32x4_v0: +// powerpc_altivec-LABEL: vreg_f32x4_v18: // powerpc_altivec: #APP -// powerpc_altivec: vmr 0, 0 +// powerpc_altivec: vmr 18, 18 // powerpc_altivec: #NO_APP -// powerpc64-LABEL: vreg_i32x4_v0: +// powerpc64-LABEL: vreg_f32x4_v18: // powerpc64: #APP -// powerpc64: vmr 0, 0 +// powerpc64: vmr 18, 18 // powerpc64: #NO_APP #[cfg(altivec)] -check_reg!(vreg_i32x4_v0, i32x4, "0", "v0", "vmr"); +check_reg!(vreg_f32x4_v18, f32x4, "18", "v18", "vmr"); -// powerpc_vsx-LABEL: vreg_i64x2_v0: +// powerpc_vsx-LABEL: vreg_f64_v0: // powerpc_vsx: #APP // powerpc_vsx: vmr 0, 0 // powerpc_vsx: #NO_APP -// powerpc64_vsx-LABEL: vreg_i64x2_v0: +// powerpc64_vsx-LABEL: vreg_f64_v0: // powerpc64_vsx: #APP // powerpc64_vsx: vmr 0, 0 // powerpc64_vsx: #NO_APP #[cfg(vsx)] -check_reg!(vreg_i64x2_v0, i64x2, "0", "v0", "vmr"); - -// powerpc_altivec-LABEL: vreg_f32x4_v0: -// powerpc_altivec: #APP -// powerpc_altivec: vmr 0, 0 -// powerpc_altivec: #NO_APP -// powerpc64-LABEL: vreg_f32x4_v0: -// powerpc64: #APP -// powerpc64: vmr 0, 0 -// powerpc64: #NO_APP -#[cfg(altivec)] -check_reg!(vreg_f32x4_v0, f32x4, "0", "v0", "vmr"); +check_reg!(vreg_f64_v0, f64, "0", "v0", "vmr"); -// powerpc_vsx-LABEL: vreg_f64x2_v0: +// powerpc_vsx-LABEL: vreg_f64_v18: // powerpc_vsx: #APP -// powerpc_vsx: vmr 0, 0 +// powerpc_vsx: vmr 18, 18 // powerpc_vsx: #NO_APP -// powerpc64_vsx-LABEL: vreg_f64x2_v0: +// powerpc64_vsx-LABEL: vreg_f64_v18: // powerpc64_vsx: #APP -// powerpc64_vsx: vmr 0, 0 +// powerpc64_vsx: vmr 18, 18 // powerpc64_vsx: #NO_APP #[cfg(vsx)] -check_reg!(vreg_f64x2_v0, f64x2, "0", "v0", "vmr"); +check_reg!(vreg_f64_v18, f64, "18", "v18", "vmr"); -// powerpc_vsx-LABEL: vreg_f32_v0: +// powerpc_vsx-LABEL: vreg_f64x2_v0: // powerpc_vsx: #APP // powerpc_vsx: vmr 0, 0 // powerpc_vsx: #NO_APP -// powerpc64_vsx-LABEL: vreg_f32_v0: +// powerpc64_vsx-LABEL: vreg_f64x2_v0: // powerpc64_vsx: #APP // powerpc64_vsx: vmr 0, 0 // powerpc64_vsx: #NO_APP #[cfg(vsx)] -check_reg!(vreg_f32_v0, f32, "0", "v0", "vmr"); +check_reg!(vreg_f64x2_v0, f64x2, "0", "v0", "vmr"); -// powerpc_vsx-LABEL: vreg_f64_v0: +// powerpc_vsx-LABEL: vreg_f64x2_v18: // powerpc_vsx: #APP -// powerpc_vsx: vmr 0, 0 +// powerpc_vsx: vmr 18, 18 // powerpc_vsx: #NO_APP -// powerpc64_vsx-LABEL: vreg_f64_v0: +// powerpc64_vsx-LABEL: vreg_f64x2_v18: // powerpc64_vsx: #APP -// powerpc64_vsx: vmr 0, 0 +// powerpc64_vsx: vmr 18, 18 // powerpc64_vsx: #NO_APP #[cfg(vsx)] -check_reg!(vreg_f64_v0, f64, "0", "v0", "vmr"); +check_reg!(vreg_f64x2_v18, f64x2, "18", "v18", "vmr"); -// powerpc_altivec-LABEL: vreg_i8x16_v18: +// powerpc_altivec-LABEL: vreg_i16x8_v0: // powerpc_altivec: #APP -// powerpc_altivec: vmr 18, 18 +// powerpc_altivec: vmr 0, 0 // powerpc_altivec: #NO_APP -// powerpc64-LABEL: vreg_i8x16_v18: +// powerpc64-LABEL: vreg_i16x8_v0: // powerpc64: #APP -// powerpc64: vmr 18, 18 +// powerpc64: vmr 0, 0 // powerpc64: #NO_APP #[cfg(altivec)] -check_reg!(vreg_i8x16_v18, i8x16, "18", "v18", "vmr"); +check_reg!(vreg_i16x8_v0, i16x8, "0", "v0", "vmr"); // powerpc_altivec-LABEL: vreg_i16x8_v18: // powerpc_altivec: #APP @@ -407,6 +407,17 @@ check_reg!(vreg_i8x16_v18, i8x16, "18", "v18", "vmr"); #[cfg(altivec)] check_reg!(vreg_i16x8_v18, i16x8, "18", "v18", "vmr"); +// powerpc_altivec-LABEL: vreg_i32x4_v0: +// powerpc_altivec: #APP +// powerpc_altivec: vmr 0, 0 +// powerpc_altivec: #NO_APP +// powerpc64-LABEL: vreg_i32x4_v0: +// powerpc64: #APP +// powerpc64: vmr 0, 0 +// powerpc64: #NO_APP +#[cfg(altivec)] +check_reg!(vreg_i32x4_v0, i32x4, "0", "v0", "vmr"); + // powerpc_altivec-LABEL: vreg_i32x4_v18: // powerpc_altivec: #APP // powerpc_altivec: vmr 18, 18 @@ -418,6 +429,17 @@ check_reg!(vreg_i16x8_v18, i16x8, "18", "v18", "vmr"); #[cfg(altivec)] check_reg!(vreg_i32x4_v18, i32x4, "18", "v18", "vmr"); +// powerpc_vsx-LABEL: vreg_i64x2_v0: +// powerpc_vsx: #APP +// powerpc_vsx: vmr 0, 0 +// powerpc_vsx: #NO_APP +// powerpc64_vsx-LABEL: vreg_i64x2_v0: +// powerpc64_vsx: #APP +// powerpc64_vsx: vmr 0, 0 +// powerpc64_vsx: #NO_APP +#[cfg(vsx)] +check_reg!(vreg_i64x2_v0, i64x2, "0", "v0", "vmr"); + // powerpc_vsx-LABEL: vreg_i64x2_v18: // powerpc_vsx: #APP // powerpc_vsx: vmr 18, 18 @@ -429,46 +451,24 @@ check_reg!(vreg_i32x4_v18, i32x4, "18", "v18", "vmr"); #[cfg(vsx)] check_reg!(vreg_i64x2_v18, i64x2, "18", "v18", "vmr"); -// powerpc_altivec-LABEL: vreg_f32x4_v18: +// powerpc_altivec-LABEL: vreg_i8x16_v0: +// powerpc_altivec: #APP +// powerpc_altivec: vmr 0, 0 +// powerpc_altivec: #NO_APP +// powerpc64-LABEL: vreg_i8x16_v0: +// powerpc64: #APP +// powerpc64: vmr 0, 0 +// powerpc64: #NO_APP +#[cfg(altivec)] +check_reg!(vreg_i8x16_v0, i8x16, "0", "v0", "vmr"); + +// powerpc_altivec-LABEL: vreg_i8x16_v18: // powerpc_altivec: #APP // powerpc_altivec: vmr 18, 18 // powerpc_altivec: #NO_APP -// powerpc64-LABEL: vreg_f32x4_v18: +// powerpc64-LABEL: vreg_i8x16_v18: // powerpc64: #APP // powerpc64: vmr 18, 18 // powerpc64: #NO_APP #[cfg(altivec)] -check_reg!(vreg_f32x4_v18, f32x4, "18", "v18", "vmr"); - -// powerpc_vsx-LABEL: vreg_f64x2_v18: -// powerpc_vsx: #APP -// powerpc_vsx: vmr 18, 18 -// powerpc_vsx: #NO_APP -// powerpc64_vsx-LABEL: vreg_f64x2_v18: -// powerpc64_vsx: #APP -// powerpc64_vsx: vmr 18, 18 -// powerpc64_vsx: #NO_APP -#[cfg(vsx)] -check_reg!(vreg_f64x2_v18, f64x2, "18", "v18", "vmr"); - -// powerpc_vsx-LABEL: vreg_f32_v18: -// powerpc_vsx: #APP -// powerpc_vsx: vmr 18, 18 -// powerpc_vsx: #NO_APP -// powerpc64_vsx-LABEL: vreg_f32_v18: -// powerpc64_vsx: #APP -// powerpc64_vsx: vmr 18, 18 -// powerpc64_vsx: #NO_APP -#[cfg(vsx)] -check_reg!(vreg_f32_v18, f32, "18", "v18", "vmr"); - -// powerpc_vsx-LABEL: vreg_f64_v18: -// powerpc_vsx: #APP -// powerpc_vsx: vmr 18, 18 -// powerpc_vsx: #NO_APP -// powerpc64_vsx-LABEL: vreg_f64_v18: -// powerpc64_vsx: #APP -// powerpc64_vsx: vmr 18, 18 -// powerpc64_vsx: #NO_APP -#[cfg(vsx)] -check_reg!(vreg_f64_v18, f64, "18", "v18", "vmr"); +check_reg!(vreg_i8x16_v18, i8x16, "18", "v18", "vmr"); diff --git a/tests/assembly-llvm/asm/riscv-types.rs b/tests/assembly-llvm/asm/riscv-types.rs index 724aa154da8c0..78bb20fa0e373 100644 --- a/tests/assembly-llvm/asm/riscv-types.rs +++ b/tests/assembly-llvm/asm/riscv-types.rs @@ -86,29 +86,31 @@ macro_rules! check_reg { }; } -// CHECK-LABEL: reg_i8: +// CHECK-LABEL: freg_f16: +// zfhmin-NOT: or // CHECK: #APP -// CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}} +// CHECK: fmv.s f{{[a-z0-9]+}}, f{{[a-z0-9]+}} // CHECK: #NO_APP -check!(reg_i8 i8 reg "mv"); +// zfhmin-NOT: or +check!(freg_f16 f16 freg "fmv.s"); -// CHECK-LABEL: reg_f16: +// CHECK-LABEL: freg_f32: // CHECK: #APP -// CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}} +// CHECK: fmv.s f{{[a-z0-9]+}}, f{{[a-z0-9]+}} // CHECK: #NO_APP -check!(reg_f16 f16 reg "mv"); +check!(freg_f32 f32 freg "fmv.s"); -// CHECK-LABEL: reg_i16: +// CHECK-LABEL: freg_f64: // CHECK: #APP -// CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}} +// CHECK: fmv.d f{{[a-z0-9]+}}, f{{[a-z0-9]+}} // CHECK: #NO_APP -check!(reg_i16 i16 reg "mv"); +check!(freg_f64 f64 freg "fmv.d"); -// CHECK-LABEL: reg_i32: +// CHECK-LABEL: reg_f16: // CHECK: #APP // CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}} // CHECK: #NO_APP -check!(reg_i32 i32 reg "mv"); +check!(reg_f16 f16 reg "mv"); // CHECK-LABEL: reg_f32: // CHECK: #APP @@ -116,13 +118,6 @@ check!(reg_i32 i32 reg "mv"); // CHECK: #NO_APP check!(reg_f32 f32 reg "mv"); -// riscv64-LABEL: reg_i64: -// riscv64: #APP -// riscv64: mv {{[a-z0-9]+}}, {{[a-z0-9]+}} -// riscv64: #NO_APP -#[cfg(riscv64)] -check!(reg_i64 i64 reg "mv"); - // riscv64-LABEL: reg_f64: // riscv64: #APP // riscv64: mv {{[a-z0-9]+}}, {{[a-z0-9]+}} @@ -130,49 +125,61 @@ check!(reg_i64 i64 reg "mv"); #[cfg(riscv64)] check!(reg_f64 f64 reg "mv"); -// CHECK-LABEL: reg_ptr: +// CHECK-LABEL: reg_i16: // CHECK: #APP // CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}} // CHECK: #NO_APP -check!(reg_ptr ptr reg "mv"); +check!(reg_i16 i16 reg "mv"); -// CHECK-LABEL: freg_f16: -// zfhmin-NOT: or +// CHECK-LABEL: reg_i32: // CHECK: #APP -// CHECK: fmv.s f{{[a-z0-9]+}}, f{{[a-z0-9]+}} +// CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}} // CHECK: #NO_APP -// zfhmin-NOT: or -check!(freg_f16 f16 freg "fmv.s"); +check!(reg_i32 i32 reg "mv"); -// CHECK-LABEL: freg_f32: +// riscv64-LABEL: reg_i64: +// riscv64: #APP +// riscv64: mv {{[a-z0-9]+}}, {{[a-z0-9]+}} +// riscv64: #NO_APP +#[cfg(riscv64)] +check!(reg_i64 i64 reg "mv"); + +// CHECK-LABEL: reg_i8: // CHECK: #APP -// CHECK: fmv.s f{{[a-z0-9]+}}, f{{[a-z0-9]+}} +// CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}} // CHECK: #NO_APP -check!(freg_f32 f32 freg "fmv.s"); +check!(reg_i8 i8 reg "mv"); -// CHECK-LABEL: freg_f64: +// CHECK-LABEL: reg_ptr: // CHECK: #APP -// CHECK: fmv.d f{{[a-z0-9]+}}, f{{[a-z0-9]+}} +// CHECK: mv {{[a-z0-9]+}}, {{[a-z0-9]+}} // CHECK: #NO_APP -check!(freg_f64 f64 freg "fmv.d"); +check!(reg_ptr ptr reg "mv"); -// CHECK-LABEL: a0_i8: +// CHECK-LABEL: a0_f16: // CHECK: #APP // CHECK: mv a0, a0 // CHECK: #NO_APP -check_reg!(a0_i8 i8 "a0" "mv"); +check_reg!(a0_f16 f16 "a0" "mv"); -// CHECK-LABEL: a0_i16: +// CHECK-LABEL: a0_f32: // CHECK: #APP // CHECK: mv a0, a0 // CHECK: #NO_APP -check_reg!(a0_i16 i16 "a0" "mv"); +check_reg!(a0_f32 f32 "a0" "mv"); -// CHECK-LABEL: a0_f16: +// riscv64-LABEL: a0_f64: +// riscv64: #APP +// riscv64: mv a0, a0 +// riscv64: #NO_APP +#[cfg(riscv64)] +check_reg!(a0_f64 f64 "a0" "mv"); + +// CHECK-LABEL: a0_i16: // CHECK: #APP // CHECK: mv a0, a0 // CHECK: #NO_APP -check_reg!(a0_f16 f16 "a0" "mv"); +check_reg!(a0_i16 i16 "a0" "mv"); // CHECK-LABEL: a0_i32: // CHECK: #APP @@ -180,12 +187,6 @@ check_reg!(a0_f16 f16 "a0" "mv"); // CHECK: #NO_APP check_reg!(a0_i32 i32 "a0" "mv"); -// CHECK-LABEL: a0_f32: -// CHECK: #APP -// CHECK: mv a0, a0 -// CHECK: #NO_APP -check_reg!(a0_f32 f32 "a0" "mv"); - // riscv64-LABEL: a0_i64: // riscv64: #APP // riscv64: mv a0, a0 @@ -193,12 +194,11 @@ check_reg!(a0_f32 f32 "a0" "mv"); #[cfg(riscv64)] check_reg!(a0_i64 i64 "a0" "mv"); -// riscv64-LABEL: a0_f64: -// riscv64: #APP -// riscv64: mv a0, a0 -// riscv64: #NO_APP -#[cfg(riscv64)] -check_reg!(a0_f64 f64 "a0" "mv"); +// CHECK-LABEL: a0_i8: +// CHECK: #APP +// CHECK: mv a0, a0 +// CHECK: #NO_APP +check_reg!(a0_i8 i8 "a0" "mv"); // CHECK-LABEL: a0_ptr: // CHECK: #APP diff --git a/tests/assembly-llvm/asm/s390x-types.rs b/tests/assembly-llvm/asm/s390x-types.rs index e6fe38ecb0df2..e7e253e517718 100644 --- a/tests/assembly-llvm/asm/s390x-types.rs +++ b/tests/assembly-llvm/asm/s390x-types.rs @@ -43,6 +43,24 @@ extern "C" { static extern_static: u8; } +// CHECK-LABEL: sym_fn_32: +// CHECK: #APP +// CHECK: brasl %r14, extern_func +// CHECK: #NO_APP +#[no_mangle] +pub unsafe fn sym_fn_32() { + asm!("brasl %r14, {}", sym extern_func); +} + +// CHECK-LABEL: sym_static: +// CHECK: #APP +// CHECK: brasl %r14, extern_static +// CHECK: #NO_APP +#[no_mangle] +pub unsafe fn sym_static() { + asm!("brasl %r14, {}", sym extern_static); +} + macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => { #[no_mangle] pub unsafe fn $func(x: $ty) -> $ty { @@ -61,29 +79,17 @@ macro_rules! check_reg { ($func:ident, $ty:ty, $reg:tt, $mov:literal) => { } };} -// CHECK-LABEL: sym_fn_32: -// CHECK: #APP -// CHECK: brasl %r14, extern_func -// CHECK: #NO_APP -#[no_mangle] -pub unsafe fn sym_fn_32() { - asm!("brasl %r14, {}", sym extern_func); -} - -// CHECK-LABEL: sym_static: +// CHECK-LABEL: reg_f32: // CHECK: #APP -// CHECK: brasl %r14, extern_static +// CHECK: ler %f{{[0-9]+}}, %f{{[0-9]+}} // CHECK: #NO_APP -#[no_mangle] -pub unsafe fn sym_static() { - asm!("brasl %r14, {}", sym extern_static); -} +check!(reg_f32, f32, freg, "ler"); -// CHECK-LABEL: reg_i8: +// CHECK-LABEL: reg_f64: // CHECK: #APP -// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}} +// CHECK: ldr %f{{[0-9]+}}, %f{{[0-9]+}} // CHECK: #NO_APP -check!(reg_i8, i8, reg, "lgr"); +check!(reg_f64, f64, freg, "ldr"); // CHECK-LABEL: reg_i16: // CHECK: #APP @@ -91,35 +97,29 @@ check!(reg_i8, i8, reg, "lgr"); // CHECK: #NO_APP check!(reg_i16, i16, reg, "lgr"); -// CHECK-LABEL: reg_i32: -// CHECK: #APP -// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}} -// CHECK: #NO_APP -check!(reg_i32, i32, reg, "lgr"); - -// CHECK-LABEL: reg_i64: +// CHECK-LABEL: reg_i16_addr: // CHECK: #APP // CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}} // CHECK: #NO_APP -check!(reg_i64, i64, reg, "lgr"); +check!(reg_i16_addr, i16, reg_addr, "lgr"); -// CHECK-LABEL: reg_i8_addr: +// CHECK-LABEL: reg_i32: // CHECK: #APP // CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}} // CHECK: #NO_APP -check!(reg_i8_addr, i8, reg_addr, "lgr"); +check!(reg_i32, i32, reg, "lgr"); -// CHECK-LABEL: reg_i16_addr: +// CHECK-LABEL: reg_i32_addr: // CHECK: #APP // CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}} // CHECK: #NO_APP -check!(reg_i16_addr, i16, reg_addr, "lgr"); +check!(reg_i32_addr, i32, reg_addr, "lgr"); -// CHECK-LABEL: reg_i32_addr: +// CHECK-LABEL: reg_i64: // CHECK: #APP // CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}} // CHECK: #NO_APP -check!(reg_i32_addr, i32, reg_addr, "lgr"); +check!(reg_i64, i64, reg, "lgr"); // CHECK-LABEL: reg_i64_addr: // CHECK: #APP @@ -127,17 +127,17 @@ check!(reg_i32_addr, i32, reg_addr, "lgr"); // CHECK: #NO_APP check!(reg_i64_addr, i64, reg_addr, "lgr"); -// CHECK-LABEL: reg_f32: +// CHECK-LABEL: reg_i8: // CHECK: #APP -// CHECK: ler %f{{[0-9]+}}, %f{{[0-9]+}} +// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}} // CHECK: #NO_APP -check!(reg_f32, f32, freg, "ler"); +check!(reg_i8, i8, reg, "lgr"); -// CHECK-LABEL: reg_f64: +// CHECK-LABEL: reg_i8_addr: // CHECK: #APP -// CHECK: ldr %f{{[0-9]+}}, %f{{[0-9]+}} +// CHECK: lgr %r{{[0-9]+}}, %r{{[0-9]+}} // CHECK: #NO_APP -check!(reg_f64, f64, freg, "ldr"); +check!(reg_i8_addr, i8, reg_addr, "lgr"); // CHECK-LABEL: reg_ptr: // CHECK: #APP @@ -145,95 +145,101 @@ check!(reg_f64, f64, freg, "ldr"); // CHECK: #NO_APP check!(reg_ptr, ptr, reg, "lgr"); -// s390x_vector-LABEL: vreg_i8x16: +// s390x_vector-LABEL: vreg_f128: // s390x_vector: #APP // s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}} // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check!(vreg_i8x16, i8x16, vreg, "vlr"); +check!(vreg_f128, f128, vreg, "vlr"); -// s390x_vector-LABEL: vreg_i16x8: +// s390x_vector-LABEL: vreg_f32: // s390x_vector: #APP // s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}} // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check!(vreg_i16x8, i16x8, vreg, "vlr"); +check!(vreg_f32, f32, vreg, "vlr"); -// s390x_vector-LABEL: vreg_i32x4: +// s390x_vector-LABEL: vreg_f32x4: // s390x_vector: #APP // s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}} // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check!(vreg_i32x4, i32x4, vreg, "vlr"); +check!(vreg_f32x4, f32x4, vreg, "vlr"); -// s390x_vector-LABEL: vreg_i64x2: +// s390x_vector-LABEL: vreg_f64: // s390x_vector: #APP // s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}} // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check!(vreg_i64x2, i64x2, vreg, "vlr"); +check!(vreg_f64, f64, vreg, "vlr"); -// s390x_vector-LABEL: vreg_f32x4: +// s390x_vector-LABEL: vreg_f64x2: // s390x_vector: #APP // s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}} // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check!(vreg_f32x4, f32x4, vreg, "vlr"); +check!(vreg_f64x2, f64x2, vreg, "vlr"); -// s390x_vector-LABEL: vreg_f64x2: +// s390x_vector-LABEL: vreg_i128: // s390x_vector: #APP // s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}} // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check!(vreg_f64x2, f64x2, vreg, "vlr"); +check!(vreg_i128, i128, vreg, "vlr"); -// s390x_vector-LABEL: vreg_i32: +// s390x_vector-LABEL: vreg_i16x8: // s390x_vector: #APP // s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}} // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check!(vreg_i32, i32, vreg, "vlr"); +check!(vreg_i16x8, i16x8, vreg, "vlr"); -// s390x_vector-LABEL: vreg_i64: +// s390x_vector-LABEL: vreg_i32: // s390x_vector: #APP // s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}} // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check!(vreg_i64, i64, vreg, "vlr"); +check!(vreg_i32, i32, vreg, "vlr"); -// s390x_vector-LABEL: vreg_i128: +// s390x_vector-LABEL: vreg_i32x4: // s390x_vector: #APP // s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}} // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check!(vreg_i128, i128, vreg, "vlr"); +check!(vreg_i32x4, i32x4, vreg, "vlr"); -// s390x_vector-LABEL: vreg_f32: +// s390x_vector-LABEL: vreg_i64: // s390x_vector: #APP // s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}} // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check!(vreg_f32, f32, vreg, "vlr"); +check!(vreg_i64, i64, vreg, "vlr"); -// s390x_vector-LABEL: vreg_f64: +// s390x_vector-LABEL: vreg_i64x2: // s390x_vector: #APP // s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}} // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check!(vreg_f64, f64, vreg, "vlr"); +check!(vreg_i64x2, i64x2, vreg, "vlr"); -// s390x_vector-LABEL: vreg_f128: +// s390x_vector-LABEL: vreg_i8x16: // s390x_vector: #APP // s390x_vector: vlr %v{{[0-9]+}}, %v{{[0-9]+}} // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check!(vreg_f128, f128, vreg, "vlr"); +check!(vreg_i8x16, i8x16, vreg, "vlr"); -// CHECK-LABEL: r0_i8: +// CHECK-LABEL: f0_f32: // CHECK: #APP -// CHECK: lr %r0, %r0 +// CHECK: ler %f0, %f0 // CHECK: #NO_APP -check_reg!(r0_i8, i8, "r0", "lr"); +check_reg!(f0_f32, f32, "f0", "ler"); + +// CHECK-LABEL: f0_f64: +// CHECK: #APP +// CHECK: ldr %f0, %f0 +// CHECK: #NO_APP +check_reg!(f0_f64, f64, "f0", "ldr"); // CHECK-LABEL: r0_i16: // CHECK: #APP @@ -253,98 +259,92 @@ check_reg!(r0_i32, i32, "r0", "lr"); // CHECK: #NO_APP check_reg!(r0_i64, i64, "r0", "lr"); -// CHECK-LABEL: f0_f32: -// CHECK: #APP -// CHECK: ler %f0, %f0 -// CHECK: #NO_APP -check_reg!(f0_f32, f32, "f0", "ler"); - -// CHECK-LABEL: f0_f64: +// CHECK-LABEL: r0_i8: // CHECK: #APP -// CHECK: ldr %f0, %f0 +// CHECK: lr %r0, %r0 // CHECK: #NO_APP -check_reg!(f0_f64, f64, "f0", "ldr"); +check_reg!(r0_i8, i8, "r0", "lr"); -// s390x_vector-LABEL: v0_i8x16: +// s390x_vector-LABEL: v0_f128: // s390x_vector: #APP // s390x_vector: vlr %v0, %v0 // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check_reg!(v0_i8x16, i8x16, "v0", "vlr"); +check_reg!(v0_f128, f128, "v0", "vlr"); -// s390x_vector-LABEL: v0_i16x8: +// s390x_vector-LABEL: v0_f32: // s390x_vector: #APP // s390x_vector: vlr %v0, %v0 // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check_reg!(v0_i16x8, i16x8, "v0", "vlr"); +check_reg!(v0_f32, f32, "v0", "vlr"); -// s390x_vector-LABEL: v0_i32x4: +// s390x_vector-LABEL: v0_f32x4: // s390x_vector: #APP // s390x_vector: vlr %v0, %v0 // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check_reg!(v0_i32x4, i32x4, "v0", "vlr"); +check_reg!(v0_f32x4, f32x4, "v0", "vlr"); -// s390x_vector-LABEL: v0_i64x2: +// s390x_vector-LABEL: v0_f64: // s390x_vector: #APP // s390x_vector: vlr %v0, %v0 // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check_reg!(v0_i64x2, i64x2, "v0", "vlr"); +check_reg!(v0_f64, f64, "v0", "vlr"); -// s390x_vector-LABEL: v0_f32x4: +// s390x_vector-LABEL: v0_f64x2: // s390x_vector: #APP // s390x_vector: vlr %v0, %v0 // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check_reg!(v0_f32x4, f32x4, "v0", "vlr"); +check_reg!(v0_f64x2, f64x2, "v0", "vlr"); -// s390x_vector-LABEL: v0_f64x2: +// s390x_vector-LABEL: v0_i128: // s390x_vector: #APP // s390x_vector: vlr %v0, %v0 // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check_reg!(v0_f64x2, f64x2, "v0", "vlr"); +check_reg!(v0_i128, i128, "v0", "vlr"); -// s390x_vector-LABEL: v0_i32: +// s390x_vector-LABEL: v0_i16x8: // s390x_vector: #APP // s390x_vector: vlr %v0, %v0 // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check_reg!(v0_i32, i32, "v0", "vlr"); +check_reg!(v0_i16x8, i16x8, "v0", "vlr"); -// s390x_vector-LABEL: v0_i64: +// s390x_vector-LABEL: v0_i32: // s390x_vector: #APP // s390x_vector: vlr %v0, %v0 // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check_reg!(v0_i64, i64, "v0", "vlr"); +check_reg!(v0_i32, i32, "v0", "vlr"); -// s390x_vector-LABEL: v0_i128: +// s390x_vector-LABEL: v0_i32x4: // s390x_vector: #APP // s390x_vector: vlr %v0, %v0 // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check_reg!(v0_i128, i128, "v0", "vlr"); +check_reg!(v0_i32x4, i32x4, "v0", "vlr"); -// s390x_vector-LABEL: v0_f32: +// s390x_vector-LABEL: v0_i64: // s390x_vector: #APP // s390x_vector: vlr %v0, %v0 // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check_reg!(v0_f32, f32, "v0", "vlr"); +check_reg!(v0_i64, i64, "v0", "vlr"); -// s390x_vector-LABEL: v0_f64: +// s390x_vector-LABEL: v0_i64x2: // s390x_vector: #APP // s390x_vector: vlr %v0, %v0 // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check_reg!(v0_f64, f64, "v0", "vlr"); +check_reg!(v0_i64x2, i64x2, "v0", "vlr"); -// s390x_vector-LABEL: v0_f128: +// s390x_vector-LABEL: v0_i8x16: // s390x_vector: #APP // s390x_vector: vlr %v0, %v0 // s390x_vector: #NO_APP #[cfg(s390x_vector)] -check_reg!(v0_f128, f128, "v0", "vlr"); +check_reg!(v0_i8x16, i8x16, "v0", "vlr"); diff --git a/tests/assembly-llvm/asm/sparc-types.rs b/tests/assembly-llvm/asm/sparc-types.rs index 49cc377cd9527..292be00777651 100644 --- a/tests/assembly-llvm/asm/sparc-types.rs +++ b/tests/assembly-llvm/asm/sparc-types.rs @@ -24,24 +24,6 @@ extern "C" { static extern_static: u8; } -macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => { - #[no_mangle] - pub unsafe fn $func(x: $ty) -> $ty { - let y; - asm!(concat!($mov," {}, {}"), in($class) x, out($class) y); - y - } -};} - -macro_rules! check_reg { ($func:ident, $ty:ty, $reg:tt, $mov:literal) => { - #[no_mangle] - pub unsafe fn $func(x: $ty) -> $ty { - let y; - asm!(concat!($mov, " %", $reg, ", %", $reg), in($reg) x, lateout($reg) y); - y - } -};} - // CHECK-LABEL: sym_fn_32: // CHECK: !APP // CHECK-NEXT: call extern_func @@ -60,11 +42,23 @@ pub unsafe fn sym_static() { asm!("call {}", sym extern_static); } -// CHECK-LABEL: reg_i8: -// CHECK: !APP -// CHECK-NEXT: mov %{{[goli]}}{{[0-9]+}}, %{{[goli]}}{{[0-9]+}} -// CHECK-NEXT: !NO_APP -check!(reg_i8, i8, reg, "mov"); +macro_rules! check { ($func:ident, $ty:ty, $class:ident, $mov:literal) => { + #[no_mangle] + pub unsafe fn $func(x: $ty) -> $ty { + let y; + asm!(concat!($mov," {}, {}"), in($class) x, out($class) y); + y + } +};} + +macro_rules! check_reg { ($func:ident, $ty:ty, $reg:tt, $mov:literal) => { + #[no_mangle] + pub unsafe fn $func(x: $ty) -> $ty { + let y; + asm!(concat!($mov, " %", $reg, ", %", $reg), in($reg) x, lateout($reg) y); + y + } +};} // CHECK-LABEL: reg_i16: // CHECK: !APP @@ -86,17 +80,17 @@ check!(reg_i32, i32, reg, "mov"); #[cfg(sparc64)] check!(reg_i64, i64, reg, "mov"); -// CHECK-LABEL: reg_ptr: +// CHECK-LABEL: reg_i8: // CHECK: !APP // CHECK-NEXT: mov %{{[goli]}}{{[0-9]+}}, %{{[goli]}}{{[0-9]+}} // CHECK-NEXT: !NO_APP -check!(reg_ptr, ptr, reg, "mov"); +check!(reg_i8, i8, reg, "mov"); -// CHECK-LABEL: o0_i8: +// CHECK-LABEL: reg_ptr: // CHECK: !APP -// CHECK-NEXT: mov %o0, %o0 +// CHECK-NEXT: mov %{{[goli]}}{{[0-9]+}}, %{{[goli]}}{{[0-9]+}} // CHECK-NEXT: !NO_APP -check_reg!(o0_i8, i8, "o0", "mov"); +check!(reg_ptr, ptr, reg, "mov"); // CHECK-LABEL: o0_i16: // CHECK: !APP @@ -118,11 +112,11 @@ check_reg!(o0_i32, i32, "o0", "mov"); #[cfg(sparc64)] check_reg!(o0_i64, i64, "o0", "mov"); -// CHECK-LABEL: r9_i8: +// CHECK-LABEL: o0_i8: // CHECK: !APP -// CHECK-NEXT: mov %o1, %o1 +// CHECK-NEXT: mov %o0, %o0 // CHECK-NEXT: !NO_APP -check_reg!(r9_i8, i8, "r9", "mov"); +check_reg!(o0_i8, i8, "o0", "mov"); // CHECK-LABEL: r9_i16: // CHECK: !APP @@ -143,3 +137,9 @@ check_reg!(r9_i32, i32, "r9", "mov"); // sparc64-NEXT: !NO_APP #[cfg(sparc64)] check_reg!(r9_i64, i64, "r9", "mov"); + +// CHECK-LABEL: r9_i8: +// CHECK: !APP +// CHECK-NEXT: mov %o1, %o1 +// CHECK-NEXT: !NO_APP +check_reg!(r9_i8, i8, "r9", "mov"); diff --git a/tests/assembly-llvm/asm/wasm-types.rs b/tests/assembly-llvm/asm/wasm-types.rs index 78e555c53173a..4c053a5d84fce 100644 --- a/tests/assembly-llvm/asm/wasm-types.rs +++ b/tests/assembly-llvm/asm/wasm-types.rs @@ -50,45 +50,45 @@ macro_rules! check { }; } -// CHECK-LABEL: i8_i32: +// CHECK-LABEL: f32_f32 // CHECK: #APP // CHECK: local.get {{[0-9]}} -// CHECK: i32.clz +// CHECK: f32.abs // CHECK: local.set {{[0-9]}} // CHECK: #NO_APP -check!(i8_i32 i8 "i32.clz"); +check!(f32_f32 f32 "f32.abs"); -// CHECK-LABEL: i16_i32: +// CHECK-LABEL: f64_f64 // CHECK: #APP // CHECK: local.get {{[0-9]}} -// CHECK: i32.clz +// CHECK: f64.abs // CHECK: local.set {{[0-9]}} // CHECK: #NO_APP -check!(i16_i32 i16 "i32.clz"); +check!(f64_f64 f64 "f64.abs"); -// CHECK-LABEL: i32_i32: +// CHECK-LABEL: i16_i32: // CHECK: #APP // CHECK: local.get {{[0-9]}} // CHECK: i32.clz // CHECK: local.set {{[0-9]}} // CHECK: #NO_APP -check!(i32_i32 i32 "i32.clz"); +check!(i16_i32 i16 "i32.clz"); -// CHECK-LABEL: i8_i64 +// CHECK-LABEL: i16_i64 // CHECK: #APP // CHECK: local.get {{[0-9]}} // CHECK: i64.clz // CHECK: local.set {{[0-9]}} // CHECK: #NO_APP -check!(i8_i64 i8 "i64.clz"); +check!(i16_i64 i16 "i64.clz"); -// CHECK-LABEL: i16_i64 +// CHECK-LABEL: i32_i32: // CHECK: #APP // CHECK: local.get {{[0-9]}} -// CHECK: i64.clz +// CHECK: i32.clz // CHECK: local.set {{[0-9]}} // CHECK: #NO_APP -check!(i16_i64 i16 "i64.clz"); +check!(i32_i32 i32 "i32.clz"); // CHECK-LABEL: i32_i64 // CHECK: #APP @@ -98,34 +98,34 @@ check!(i16_i64 i16 "i64.clz"); // CHECK: #NO_APP check!(i32_i64 i32 "i64.clz"); -// CHECK-LABEL: i64_i64 +// CHECK-LABEL: i32_ptr // CHECK: #APP // CHECK: local.get {{[0-9]}} -// CHECK: i64.clz +// CHECK: i32.eqz // CHECK: local.set {{[0-9]}} // CHECK: #NO_APP -check!(i64_i64 i64 "i64.clz"); +check!(i32_ptr ptr "i32.eqz"); -// CHECK-LABEL: f32_f32 +// CHECK-LABEL: i64_i64 // CHECK: #APP // CHECK: local.get {{[0-9]}} -// CHECK: f32.abs +// CHECK: i64.clz // CHECK: local.set {{[0-9]}} // CHECK: #NO_APP -check!(f32_f32 f32 "f32.abs"); +check!(i64_i64 i64 "i64.clz"); -// CHECK-LABEL: f64_f64 +// CHECK-LABEL: i8_i32: // CHECK: #APP // CHECK: local.get {{[0-9]}} -// CHECK: f64.abs +// CHECK: i32.clz // CHECK: local.set {{[0-9]}} // CHECK: #NO_APP -check!(f64_f64 f64 "f64.abs"); +check!(i8_i32 i8 "i32.clz"); -// CHECK-LABEL: i32_ptr +// CHECK-LABEL: i8_i64 // CHECK: #APP // CHECK: local.get {{[0-9]}} -// CHECK: i32.eqz +// CHECK: i64.clz // CHECK: local.set {{[0-9]}} // CHECK: #NO_APP -check!(i32_ptr ptr "i32.eqz"); +check!(i8_i64 i8 "i64.clz"); diff --git a/tests/assembly-llvm/asm/x86-modifiers.rs b/tests/assembly-llvm/asm/x86-modifiers.rs index 5f68e5c7317f3..ef678e75c049e 100644 --- a/tests/assembly-llvm/asm/x86-modifiers.rs +++ b/tests/assembly-llvm/asm/x86-modifiers.rs @@ -30,6 +30,15 @@ macro_rules! check { }; } +// Note: we don't have any way of ensuring that k1 is actually the register +// chosen by the register allocator, so this check may fail if a different +// register is chosen. +// CHECK-LABEL: kreg: +// CHECK: #APP +// CHECK: kmovb k1, k1 +// CHECK: #NO_APP +check!(kreg "" kreg "kmovb"); + // CHECK-LABEL: reg: // CHECK: #APP // x86_64: mov rax, rax @@ -37,38 +46,24 @@ macro_rules! check { // CHECK: #NO_APP check!(reg "" reg "mov"); -// x86_64-LABEL: reg_l: -// x86_64: #APP -// x86_64: mov al, al -// x86_64: #NO_APP -#[cfg(x86_64)] -check!(reg_l "l" reg "mov"); - -// CHECK-LABEL: reg_x: +// CHECK-LABEL: reg_abcd: // CHECK: #APP -// CHECK: mov ax, ax +// x86_64: mov rax, rax +// i686: mov eax, eax // CHECK: #NO_APP -check!(reg_x "x" reg "mov"); +check!(reg_abcd "" reg_abcd "mov"); -// CHECK-LABEL: reg_e: +// CHECK-LABEL: reg_abcd_e: // CHECK: #APP // CHECK: mov eax, eax // CHECK: #NO_APP -check!(reg_e "e" reg "mov"); - -// x86_64-LABEL: reg_r: -// x86_64: #APP -// x86_64: mov rax, rax -// x86_64: #NO_APP -#[cfg(x86_64)] -check!(reg_r "r" reg "mov"); +check!(reg_abcd_e "e" reg_abcd "mov"); -// CHECK-LABEL: reg_abcd: +// CHECK-LABEL: reg_abcd_h: // CHECK: #APP -// x86_64: mov rax, rax -// i686: mov eax, eax +// CHECK: mov ah, ah // CHECK: #NO_APP -check!(reg_abcd "" reg_abcd "mov"); +check!(reg_abcd_h "h" reg_abcd "mov"); // CHECK-LABEL: reg_abcd_l: // CHECK: #APP @@ -76,11 +71,12 @@ check!(reg_abcd "" reg_abcd "mov"); // CHECK: #NO_APP check!(reg_abcd_l "l" reg_abcd "mov"); -// CHECK-LABEL: reg_abcd_h: -// CHECK: #APP -// CHECK: mov ah, ah -// CHECK: #NO_APP -check!(reg_abcd_h "h" reg_abcd "mov"); +// x86_64-LABEL: reg_abcd_r: +// x86_64: #APP +// x86_64: mov rax, rax +// x86_64: #NO_APP +#[cfg(x86_64)] +check!(reg_abcd_r "r" reg_abcd "mov"); // CHECK-LABEL: reg_abcd_x: // CHECK: #APP @@ -88,18 +84,31 @@ check!(reg_abcd_h "h" reg_abcd "mov"); // CHECK: #NO_APP check!(reg_abcd_x "x" reg_abcd "mov"); -// CHECK-LABEL: reg_abcd_e: +// CHECK-LABEL: reg_e: // CHECK: #APP // CHECK: mov eax, eax // CHECK: #NO_APP -check!(reg_abcd_e "e" reg_abcd "mov"); +check!(reg_e "e" reg "mov"); -// x86_64-LABEL: reg_abcd_r: +// x86_64-LABEL: reg_l: +// x86_64: #APP +// x86_64: mov al, al +// x86_64: #NO_APP +#[cfg(x86_64)] +check!(reg_l "l" reg "mov"); + +// x86_64-LABEL: reg_r: // x86_64: #APP // x86_64: mov rax, rax // x86_64: #NO_APP #[cfg(x86_64)] -check!(reg_abcd_r "r" reg_abcd "mov"); +check!(reg_r "r" reg "mov"); + +// CHECK-LABEL: reg_x: +// CHECK: #APP +// CHECK: mov ax, ax +// CHECK: #NO_APP +check!(reg_x "x" reg "mov"); // CHECK-LABEL: xmm_reg // CHECK: #APP @@ -172,13 +181,3 @@ check!(zmm_reg_y "y" zmm_reg "vmovaps"); // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP check!(zmm_reg_z "z" zmm_reg "vmovaps"); - -// Note: we don't have any way of ensuring that k1 is actually the register -// chosen by the register allocator, so this check may fail if a different -// register is chosen. - -// CHECK-LABEL: kreg: -// CHECK: #APP -// CHECK: kmovb k1, k1 -// CHECK: #NO_APP -check!(kreg "" kreg "kmovb"); diff --git a/tests/assembly-llvm/asm/x86-types.rs b/tests/assembly-llvm/asm/x86-types.rs index 6120ed0d53275..b8eea21121664 100644 --- a/tests/assembly-llvm/asm/x86-types.rs +++ b/tests/assembly-llvm/asm/x86-types.rs @@ -123,109 +123,145 @@ macro_rules! check_reg { }; } -// CHECK-LABEL: reg_i16: +// CHECK-LABEL: kreg_i16: // CHECK: #APP -// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}} -// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}} +// CHECK: kmovw k{{[0-9]+}}, k{{[0-9]+}} // CHECK: #NO_APP -check!(reg_i16 i16 reg "mov"); +check!(kreg_i16 i16 kreg "kmovw"); -// CHECK-LABEL: reg_f16: +// CHECK-LABEL: kreg_i32: // CHECK: #APP -// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}} -// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}} +// CHECK: kmovd k{{[0-9]+}}, k{{[0-9]+}} // CHECK: #NO_APP -check!(reg_f16 f16 reg "mov"); +check!(kreg_i32 i32 kreg "kmovd"); -// CHECK-LABEL: reg_i32: +// CHECK-LABEL: kreg_i64: // CHECK: #APP -// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}} -// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}} +// CHECK: kmovq k{{[0-9]+}}, k{{[0-9]+}} // CHECK: #NO_APP -check!(reg_i32 i32 reg "mov"); +check!(kreg_i64 i64 kreg "kmovq"); -// CHECK-LABEL: reg_f32: +// CHECK-LABEL: kreg_i8: +// CHECK: #APP +// CHECK: kmovb k{{[0-9]+}}, k{{[0-9]+}} +// CHECK: #NO_APP +check!(kreg_i8 i8 kreg "kmovb"); + +// CHECK-LABEL: kreg_ptr: +// CHECK: #APP +// CHECK: kmovq k{{[0-9]+}}, k{{[0-9]+}} +// CHECK: #NO_APP +check!(kreg_ptr ptr kreg "kmovq"); + +// CHECK-LABEL: reg_abcd_f16: // CHECK: #APP // x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}} // i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}} // CHECK: #NO_APP -check!(reg_f32 f32 reg "mov"); +check!(reg_abcd_f16 f16 reg_abcd "mov"); -// x86_64-LABEL: reg_i64: -// x86_64: #APP +// CHECK-LABEL: reg_abcd_f32: +// CHECK: #APP // x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}} -// x86_64: #NO_APP -#[cfg(x86_64)] -check!(reg_i64 i64 reg "mov"); +// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}} +// CHECK: #NO_APP +check!(reg_abcd_f32 f32 reg_abcd "mov"); -// x86_64-LABEL: reg_f64: +// x86_64-LABEL: reg_abcd_f64: // x86_64: #APP // x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}} // x86_64: #NO_APP #[cfg(x86_64)] -check!(reg_f64 f64 reg "mov"); +check!(reg_abcd_f64 f64 reg_abcd "mov"); -// CHECK-LABEL: reg_ptr: +// CHECK-LABEL: reg_abcd_i16: // CHECK: #APP // x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}} // i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}} // CHECK: #NO_APP -check!(reg_ptr ptr reg "mov"); +check!(reg_abcd_i16 i16 reg_abcd "mov"); -// CHECK-LABEL: reg_abcd_i16: +// CHECK-LABEL: reg_abcd_i32: // CHECK: #APP // x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}} // i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}} // CHECK: #NO_APP -check!(reg_abcd_i16 i16 reg_abcd "mov"); +check!(reg_abcd_i32 i32 reg_abcd "mov"); -// CHECK-LABEL: reg_abcd_f16: +// x86_64-LABEL: reg_abcd_i64: +// x86_64: #APP +// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}} +// x86_64: #NO_APP +#[cfg(x86_64)] +check!(reg_abcd_i64 i64 reg_abcd "mov"); + +// CHECK-LABEL: reg_abcd_ptr: // CHECK: #APP // x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}} // i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}} // CHECK: #NO_APP -check!(reg_abcd_f16 f16 reg_abcd "mov"); +check!(reg_abcd_ptr ptr reg_abcd "mov"); -// CHECK-LABEL: reg_abcd_i32: +// CHECK-LABEL: reg_byte: +// CHECK: #APP +// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}} +// CHECK: #NO_APP +check!(reg_byte i8 reg_byte "mov"); + +// CHECK-LABEL: reg_f16: // CHECK: #APP // x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}} // i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}} // CHECK: #NO_APP -check!(reg_abcd_i32 i32 reg_abcd "mov"); +check!(reg_f16 f16 reg "mov"); -// CHECK-LABEL: reg_abcd_f32: +// CHECK-LABEL: reg_f32: // CHECK: #APP // x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}} // i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}} // CHECK: #NO_APP -check!(reg_abcd_f32 f32 reg_abcd "mov"); +check!(reg_f32 f32 reg "mov"); -// x86_64-LABEL: reg_abcd_i64: +// x86_64-LABEL: reg_f64: // x86_64: #APP // x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}} // x86_64: #NO_APP #[cfg(x86_64)] -check!(reg_abcd_i64 i64 reg_abcd "mov"); +check!(reg_f64 f64 reg "mov"); -// x86_64-LABEL: reg_abcd_f64: +// CHECK-LABEL: reg_i16: +// CHECK: #APP +// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}} +// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}} +// CHECK: #NO_APP +check!(reg_i16 i16 reg "mov"); + +// CHECK-LABEL: reg_i32: +// CHECK: #APP +// x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}} +// i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}} +// CHECK: #NO_APP +check!(reg_i32 i32 reg "mov"); + +// x86_64-LABEL: reg_i64: // x86_64: #APP // x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}} // x86_64: #NO_APP #[cfg(x86_64)] -check!(reg_abcd_f64 f64 reg_abcd "mov"); +check!(reg_i64 i64 reg "mov"); -// CHECK-LABEL: reg_abcd_ptr: +// CHECK-LABEL: reg_ptr: // CHECK: #APP // x86_64: mov r{{[a-z0-9]+}}, r{{[a-z0-9]+}} // i686: mov e{{[a-z0-9]+}}, e{{[a-z0-9]+}} // CHECK: #NO_APP -check!(reg_abcd_ptr ptr reg_abcd "mov"); +check!(reg_ptr ptr reg "mov"); -// CHECK-LABEL: reg_byte: +// CHECK-LABEL: xmm_reg_f128: // CHECK: #APP -// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}} +// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}} // CHECK: #NO_APP -check!(reg_byte i8 reg_byte "mov"); +check!(xmm_reg_f128 f128 xmm_reg "movaps"); // CHECK-LABEL: xmm_reg_f16: // CHECK: #APP @@ -233,11 +269,11 @@ check!(reg_byte i8 reg_byte "mov"); // CHECK: #NO_APP check!(xmm_reg_f16 f16 xmm_reg "movaps"); -// CHECK-LABEL: xmm_reg_i32: +// CHECK-LABEL: xmm_reg_f16x8: // CHECK: #APP // CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}} // CHECK: #NO_APP -check!(xmm_reg_i32 i32 xmm_reg "movaps"); +check!(xmm_reg_f16x8 f16x8 xmm_reg "movaps"); // CHECK-LABEL: xmm_reg_f32: // CHECK: #APP @@ -245,11 +281,11 @@ check!(xmm_reg_i32 i32 xmm_reg "movaps"); // CHECK: #NO_APP check!(xmm_reg_f32 f32 xmm_reg "movaps"); -// CHECK-LABEL: xmm_reg_i64: +// CHECK-LABEL: xmm_reg_f32x4: // CHECK: #APP // CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}} // CHECK: #NO_APP -check!(xmm_reg_i64 i64 xmm_reg "movaps"); +check!(xmm_reg_f32x4 f32x4 xmm_reg "movaps"); // CHECK-LABEL: xmm_reg_f64: // CHECK: #APP @@ -257,35 +293,35 @@ check!(xmm_reg_i64 i64 xmm_reg "movaps"); // CHECK: #NO_APP check!(xmm_reg_f64 f64 xmm_reg "movaps"); -// CHECK-LABEL: xmm_reg_f128: +// CHECK-LABEL: xmm_reg_f64x2: // CHECK: #APP // CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}} // CHECK: #NO_APP -check!(xmm_reg_f128 f128 xmm_reg "movaps"); +check!(xmm_reg_f64x2 f64x2 xmm_reg "movaps"); -// CHECK-LABEL: xmm_reg_ptr: +// CHECK-LABEL: xmm_reg_i16x8: // CHECK: #APP // CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}} // CHECK: #NO_APP -check!(xmm_reg_ptr ptr xmm_reg "movaps"); +check!(xmm_reg_i16x8 i16x8 xmm_reg "movaps"); -// CHECK-LABEL: xmm_reg_i8x16: +// CHECK-LABEL: xmm_reg_i32: // CHECK: #APP // CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}} // CHECK: #NO_APP -check!(xmm_reg_i8x16 i8x16 xmm_reg "movaps"); +check!(xmm_reg_i32 i32 xmm_reg "movaps"); -// CHECK-LABEL: xmm_reg_i16x8: +// CHECK-LABEL: xmm_reg_i32x4: // CHECK: #APP // CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}} // CHECK: #NO_APP -check!(xmm_reg_i16x8 i16x8 xmm_reg "movaps"); +check!(xmm_reg_i32x4 i32x4 xmm_reg "movaps"); -// CHECK-LABEL: xmm_reg_i32x4: +// CHECK-LABEL: xmm_reg_i64: // CHECK: #APP // CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}} // CHECK: #NO_APP -check!(xmm_reg_i32x4 i32x4 xmm_reg "movaps"); +check!(xmm_reg_i64 i64 xmm_reg "movaps"); // CHECK-LABEL: xmm_reg_i64x2: // CHECK: #APP @@ -293,23 +329,23 @@ check!(xmm_reg_i32x4 i32x4 xmm_reg "movaps"); // CHECK: #NO_APP check!(xmm_reg_i64x2 i64x2 xmm_reg "movaps"); -// CHECK-LABEL: xmm_reg_f16x8: +// CHECK-LABEL: xmm_reg_i8x16: // CHECK: #APP // CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}} // CHECK: #NO_APP -check!(xmm_reg_f16x8 f16x8 xmm_reg "movaps"); +check!(xmm_reg_i8x16 i8x16 xmm_reg "movaps"); -// CHECK-LABEL: xmm_reg_f32x4: +// CHECK-LABEL: xmm_reg_ptr: // CHECK: #APP // CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}} // CHECK: #NO_APP -check!(xmm_reg_f32x4 f32x4 xmm_reg "movaps"); +check!(xmm_reg_ptr ptr xmm_reg "movaps"); -// CHECK-LABEL: xmm_reg_f64x2: +// CHECK-LABEL: ymm_reg_f128: // CHECK: #APP -// CHECK: movaps xmm{{[0-9]+}}, xmm{{[0-9]+}} +// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}} // CHECK: #NO_APP -check!(xmm_reg_f64x2 f64x2 xmm_reg "movaps"); +check!(ymm_reg_f128 f128 ymm_reg "vmovaps"); // CHECK-LABEL: ymm_reg_f16: // CHECK: #APP @@ -317,101 +353,95 @@ check!(xmm_reg_f64x2 f64x2 xmm_reg "movaps"); // CHECK: #NO_APP check!(ymm_reg_f16 f16 ymm_reg "vmovaps"); -// CHECK-LABEL: ymm_reg_i32: -// CHECK: #APP -// CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}} -// CHECK: #NO_APP -check!(ymm_reg_i32 i32 ymm_reg "vmovaps"); - -// CHECK-LABEL: ymm_reg_f32: +// CHECK-LABEL: ymm_reg_f16x16: // CHECK: #APP // CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}} // CHECK: #NO_APP -check!(ymm_reg_f32 f32 ymm_reg "vmovaps"); +check!(ymm_reg_f16x16 f16x16 ymm_reg "vmovaps"); -// CHECK-LABEL: ymm_reg_i64: +// CHECK-LABEL: ymm_reg_f16x8: // CHECK: #APP // CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}} // CHECK: #NO_APP -check!(ymm_reg_i64 i64 ymm_reg "vmovaps"); +check!(ymm_reg_f16x8 f16x8 ymm_reg "vmovaps"); -// CHECK-LABEL: ymm_reg_f64: +// CHECK-LABEL: ymm_reg_f32: // CHECK: #APP // CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}} // CHECK: #NO_APP -check!(ymm_reg_f64 f64 ymm_reg "vmovaps"); +check!(ymm_reg_f32 f32 ymm_reg "vmovaps"); -// CHECK-LABEL: ymm_reg_f128: +// CHECK-LABEL: ymm_reg_f32x4: // CHECK: #APP // CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}} // CHECK: #NO_APP -check!(ymm_reg_f128 f128 ymm_reg "vmovaps"); +check!(ymm_reg_f32x4 f32x4 ymm_reg "vmovaps"); -// CHECK-LABEL: ymm_reg_ptr: +// CHECK-LABEL: ymm_reg_f32x8: // CHECK: #APP // CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}} // CHECK: #NO_APP -check!(ymm_reg_ptr ptr ymm_reg "vmovaps"); +check!(ymm_reg_f32x8 f32x8 ymm_reg "vmovaps"); -// CHECK-LABEL: ymm_reg_i8x16: +// CHECK-LABEL: ymm_reg_f64: // CHECK: #APP // CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}} // CHECK: #NO_APP -check!(ymm_reg_i8x16 i8x16 ymm_reg "vmovaps"); +check!(ymm_reg_f64 f64 ymm_reg "vmovaps"); -// CHECK-LABEL: ymm_reg_i16x8: +// CHECK-LABEL: ymm_reg_f64x2: // CHECK: #APP // CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}} // CHECK: #NO_APP -check!(ymm_reg_i16x8 i16x8 ymm_reg "vmovaps"); +check!(ymm_reg_f64x2 f64x2 ymm_reg "vmovaps"); -// CHECK-LABEL: ymm_reg_i32x4: +// CHECK-LABEL: ymm_reg_f64x4: // CHECK: #APP // CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}} // CHECK: #NO_APP -check!(ymm_reg_i32x4 i32x4 ymm_reg "vmovaps"); +check!(ymm_reg_f64x4 f64x4 ymm_reg "vmovaps"); -// CHECK-LABEL: ymm_reg_i64x2: +// CHECK-LABEL: ymm_reg_i16x16: // CHECK: #APP // CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}} // CHECK: #NO_APP -check!(ymm_reg_i64x2 i64x2 ymm_reg "vmovaps"); +check!(ymm_reg_i16x16 i16x16 ymm_reg "vmovaps"); -// CHECK-LABEL: ymm_reg_f16x8: +// CHECK-LABEL: ymm_reg_i16x8: // CHECK: #APP // CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}} // CHECK: #NO_APP -check!(ymm_reg_f16x8 f16x8 ymm_reg "vmovaps"); +check!(ymm_reg_i16x8 i16x8 ymm_reg "vmovaps"); -// CHECK-LABEL: ymm_reg_f32x4: +// CHECK-LABEL: ymm_reg_i32: // CHECK: #APP // CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}} // CHECK: #NO_APP -check!(ymm_reg_f32x4 f32x4 ymm_reg "vmovaps"); +check!(ymm_reg_i32 i32 ymm_reg "vmovaps"); -// CHECK-LABEL: ymm_reg_f64x2: +// CHECK-LABEL: ymm_reg_i32x4: // CHECK: #APP // CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}} // CHECK: #NO_APP -check!(ymm_reg_f64x2 f64x2 ymm_reg "vmovaps"); +check!(ymm_reg_i32x4 i32x4 ymm_reg "vmovaps"); -// CHECK-LABEL: ymm_reg_i8x32: +// CHECK-LABEL: ymm_reg_i32x8: // CHECK: #APP // CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}} // CHECK: #NO_APP -check!(ymm_reg_i8x32 i8x32 ymm_reg "vmovaps"); +check!(ymm_reg_i32x8 i32x8 ymm_reg "vmovaps"); -// CHECK-LABEL: ymm_reg_i16x16: +// CHECK-LABEL: ymm_reg_i64: // CHECK: #APP // CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}} // CHECK: #NO_APP -check!(ymm_reg_i16x16 i16x16 ymm_reg "vmovaps"); +check!(ymm_reg_i64 i64 ymm_reg "vmovaps"); -// CHECK-LABEL: ymm_reg_i32x8: +// CHECK-LABEL: ymm_reg_i64x2: // CHECK: #APP // CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}} // CHECK: #NO_APP -check!(ymm_reg_i32x8 i32x8 ymm_reg "vmovaps"); +check!(ymm_reg_i64x2 i64x2 ymm_reg "vmovaps"); // CHECK-LABEL: ymm_reg_i64x4: // CHECK: #APP @@ -419,167 +449,161 @@ check!(ymm_reg_i32x8 i32x8 ymm_reg "vmovaps"); // CHECK: #NO_APP check!(ymm_reg_i64x4 i64x4 ymm_reg "vmovaps"); -// CHECK-LABEL: ymm_reg_f16x16: +// CHECK-LABEL: ymm_reg_i8x16: // CHECK: #APP // CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}} // CHECK: #NO_APP -check!(ymm_reg_f16x16 f16x16 ymm_reg "vmovaps"); +check!(ymm_reg_i8x16 i8x16 ymm_reg "vmovaps"); -// CHECK-LABEL: ymm_reg_f32x8: +// CHECK-LABEL: ymm_reg_i8x32: // CHECK: #APP // CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}} // CHECK: #NO_APP -check!(ymm_reg_f32x8 f32x8 ymm_reg "vmovaps"); +check!(ymm_reg_i8x32 i8x32 ymm_reg "vmovaps"); -// CHECK-LABEL: ymm_reg_f64x4: +// CHECK-LABEL: ymm_reg_ptr: // CHECK: #APP // CHECK: vmovaps ymm{{[0-9]+}}, ymm{{[0-9]+}} // CHECK: #NO_APP -check!(ymm_reg_f64x4 f64x4 ymm_reg "vmovaps"); - -// CHECK-LABEL: zmm_reg_f16: -// CHECK: #APP -// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} -// CHECK: #NO_APP -check!(zmm_reg_f16 f16 zmm_reg "vmovaps"); +check!(ymm_reg_ptr ptr ymm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_i32: +// CHECK-LABEL: zmm_reg_f128: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_i32 i32 zmm_reg "vmovaps"); +check!(zmm_reg_f128 f128 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_f32: +// CHECK-LABEL: zmm_reg_f16: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_f32 f32 zmm_reg "vmovaps"); +check!(zmm_reg_f16 f16 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_i64: +// CHECK-LABEL: zmm_reg_f16x16: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_i64 i64 zmm_reg "vmovaps"); +check!(zmm_reg_f16x16 f16x16 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_f64: +// CHECK-LABEL: zmm_reg_f16x32: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_f64 f64 zmm_reg "vmovaps"); +check!(zmm_reg_f16x32 f16x32 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_f128: +// CHECK-LABEL: zmm_reg_f16x8: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_f128 f128 zmm_reg "vmovaps"); +check!(zmm_reg_f16x8 f16x8 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_ptr: +// CHECK-LABEL: zmm_reg_f32: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_ptr ptr zmm_reg "vmovaps"); +check!(zmm_reg_f32 f32 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_i8x16: +// CHECK-LABEL: zmm_reg_f32x16: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_i8x16 i8x16 zmm_reg "vmovaps"); +check!(zmm_reg_f32x16 f32x16 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_i16x8: +// CHECK-LABEL: zmm_reg_f32x4: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_i16x8 i16x8 zmm_reg "vmovaps"); +check!(zmm_reg_f32x4 f32x4 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_i32x4: +// CHECK-LABEL: zmm_reg_f32x8: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_i32x4 i32x4 zmm_reg "vmovaps"); +check!(zmm_reg_f32x8 f32x8 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_i64x2: +// CHECK-LABEL: zmm_reg_f64: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_i64x2 i64x2 zmm_reg "vmovaps"); +check!(zmm_reg_f64 f64 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_f16x8: +// CHECK-LABEL: zmm_reg_f64x2: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_f16x8 f16x8 zmm_reg "vmovaps"); +check!(zmm_reg_f64x2 f64x2 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_f32x4: +// CHECK-LABEL: zmm_reg_f64x4: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_f32x4 f32x4 zmm_reg "vmovaps"); +check!(zmm_reg_f64x4 f64x4 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_f64x2: +// CHECK-LABEL: zmm_reg_f64x8: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_f64x2 f64x2 zmm_reg "vmovaps"); +check!(zmm_reg_f64x8 f64x8 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_i8x32: +// CHECK-LABEL: zmm_reg_i16x16: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_i8x32 i8x32 zmm_reg "vmovaps"); +check!(zmm_reg_i16x16 i16x16 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_i16x16: +// CHECK-LABEL: zmm_reg_i16x32: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_i16x16 i16x16 zmm_reg "vmovaps"); +check!(zmm_reg_i16x32 i16x32 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_i32x8: +// CHECK-LABEL: zmm_reg_i16x8: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_i32x8 i32x8 zmm_reg "vmovaps"); +check!(zmm_reg_i16x8 i16x8 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_i64x4: +// CHECK-LABEL: zmm_reg_i32: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_i64x4 i64x4 zmm_reg "vmovaps"); +check!(zmm_reg_i32 i32 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_f16x16: +// CHECK-LABEL: zmm_reg_i32x16: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_f16x16 f16x16 zmm_reg "vmovaps"); +check!(zmm_reg_i32x16 i32x16 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_f32x8: +// CHECK-LABEL: zmm_reg_i32x4: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_f32x8 f32x8 zmm_reg "vmovaps"); +check!(zmm_reg_i32x4 i32x4 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_f64x4: +// CHECK-LABEL: zmm_reg_i32x8: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_f64x4 f64x4 zmm_reg "vmovaps"); +check!(zmm_reg_i32x8 i32x8 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_i8x64: +// CHECK-LABEL: zmm_reg_i64: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_i8x64 i8x64 zmm_reg "vmovaps"); +check!(zmm_reg_i64 i64 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_i16x32: +// CHECK-LABEL: zmm_reg_i64x2: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_i16x32 i16x32 zmm_reg "vmovaps"); +check!(zmm_reg_i64x2 i64x2 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_i32x16: +// CHECK-LABEL: zmm_reg_i64x4: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_i32x16 i32x16 zmm_reg "vmovaps"); +check!(zmm_reg_i64x4 i64x4 zmm_reg "vmovaps"); // CHECK-LABEL: zmm_reg_i64x8: // CHECK: #APP @@ -587,53 +611,55 @@ check!(zmm_reg_i32x16 i32x16 zmm_reg "vmovaps"); // CHECK: #NO_APP check!(zmm_reg_i64x8 i64x8 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_f16x32: +// CHECK-LABEL: zmm_reg_i8x16: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_f16x32 f16x32 zmm_reg "vmovaps"); +check!(zmm_reg_i8x16 i8x16 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_f32x16: +// CHECK-LABEL: zmm_reg_i8x32: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_f32x16 f32x16 zmm_reg "vmovaps"); +check!(zmm_reg_i8x32 i8x32 zmm_reg "vmovaps"); -// CHECK-LABEL: zmm_reg_f64x8: +// CHECK-LABEL: zmm_reg_i8x64: // CHECK: #APP // CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(zmm_reg_f64x8 f64x8 zmm_reg "vmovaps"); +check!(zmm_reg_i8x64 i8x64 zmm_reg "vmovaps"); -// CHECK-LABEL: kreg_i8: +// CHECK-LABEL: zmm_reg_ptr: // CHECK: #APP -// CHECK: kmovb k{{[0-9]+}}, k{{[0-9]+}} +// CHECK: vmovaps zmm{{[0-9]+}}, zmm{{[0-9]+}} // CHECK: #NO_APP -check!(kreg_i8 i8 kreg "kmovb"); +check!(zmm_reg_ptr ptr zmm_reg "vmovaps"); -// CHECK-LABEL: kreg_i16: -// CHECK: #APP -// CHECK: kmovw k{{[0-9]+}}, k{{[0-9]+}} -// CHECK: #NO_APP -check!(kreg_i16 i16 kreg "kmovw"); +// i686-LABEL: ah_byte: +// i686: #APP +// i686: mov ah, ah +// i686: #NO_APP +#[cfg(i686)] +check_reg!(ah_byte i8 "ah" "mov"); -// CHECK-LABEL: kreg_i32: +// CHECK-LABEL: eax_f16: // CHECK: #APP -// CHECK: kmovd k{{[0-9]+}}, k{{[0-9]+}} +// CHECK: mov eax, eax // CHECK: #NO_APP -check!(kreg_i32 i32 kreg "kmovd"); +check_reg!(eax_f16 f16 "eax" "mov"); -// CHECK-LABEL: kreg_i64: +// CHECK-LABEL: eax_f32: // CHECK: #APP -// CHECK: kmovq k{{[0-9]+}}, k{{[0-9]+}} +// CHECK: mov eax, eax // CHECK: #NO_APP -check!(kreg_i64 i64 kreg "kmovq"); +check_reg!(eax_f32 f32 "eax" "mov"); -// CHECK-LABEL: kreg_ptr: -// CHECK: #APP -// CHECK: kmovq k{{[0-9]+}}, k{{[0-9]+}} -// CHECK: #NO_APP -check!(kreg_ptr ptr kreg "kmovq"); +// x86_64-LABEL: eax_f64: +// x86_64: #APP +// x86_64: mov eax, eax +// x86_64: #NO_APP +#[cfg(x86_64)] +check_reg!(eax_f64 f64 "eax" "mov"); // CHECK-LABEL: eax_i16: // CHECK: #APP @@ -641,24 +667,12 @@ check!(kreg_ptr ptr kreg "kmovq"); // CHECK: #NO_APP check_reg!(eax_i16 i16 "eax" "mov"); -// CHECK-LABEL: eax_f16: -// CHECK: #APP -// CHECK: mov eax, eax -// CHECK: #NO_APP -check_reg!(eax_f16 f16 "eax" "mov"); - // CHECK-LABEL: eax_i32: // CHECK: #APP // CHECK: mov eax, eax // CHECK: #NO_APP check_reg!(eax_i32 i32 "eax" "mov"); -// CHECK-LABEL: eax_f32: -// CHECK: #APP -// CHECK: mov eax, eax -// CHECK: #NO_APP -check_reg!(eax_f32 f32 "eax" "mov"); - // x86_64-LABEL: eax_i64: // x86_64: #APP // x86_64: mov eax, eax @@ -666,25 +680,47 @@ check_reg!(eax_f32 f32 "eax" "mov"); #[cfg(x86_64)] check_reg!(eax_i64 i64 "eax" "mov"); -// x86_64-LABEL: eax_f64: -// x86_64: #APP -// x86_64: mov eax, eax -// x86_64: #NO_APP -#[cfg(x86_64)] -check_reg!(eax_f64 f64 "eax" "mov"); - // CHECK-LABEL: eax_ptr: // CHECK: #APP // CHECK: mov eax, eax // CHECK: #NO_APP check_reg!(eax_ptr ptr "eax" "mov"); -// i686-LABEL: ah_byte: -// i686: #APP -// i686: mov ah, ah -// i686: #NO_APP -#[cfg(i686)] -check_reg!(ah_byte i8 "ah" "mov"); +// CHECK-LABEL: k1_i16: +// CHECK: #APP +// CHECK: kmovw k1, k1 +// CHECK: #NO_APP +check_reg!(k1_i16 i16 "k1" "kmovw"); + +// CHECK-LABEL: k1_i32: +// CHECK: #APP +// CHECK: kmovd k1, k1 +// CHECK: #NO_APP +check_reg!(k1_i32 i32 "k1" "kmovd"); + +// CHECK-LABEL: k1_i64: +// CHECK: #APP +// CHECK: kmovq k1, k1 +// CHECK: #NO_APP +check_reg!(k1_i64 i64 "k1" "kmovq"); + +// CHECK-LABEL: k1_i8: +// CHECK: #APP +// CHECK: kmovb k1, k1 +// CHECK: #NO_APP +check_reg!(k1_i8 i8 "k1" "kmovb"); + +// CHECK-LABEL: k1_ptr: +// CHECK: #APP +// CHECK: kmovq k1, k1 +// CHECK: #NO_APP +check_reg!(k1_ptr ptr "k1" "kmovq"); + +// CHECK-LABEL: xmm0_f128: +// CHECK: #APP +// CHECK: movaps xmm0, xmm0 +// CHECK: #NO_APP +check_reg!(xmm0_f128 f128 "xmm0" "movaps"); // CHECK-LABEL: xmm0_f16: // CHECK: #APP @@ -692,11 +728,11 @@ check_reg!(ah_byte i8 "ah" "mov"); // CHECK: #NO_APP check_reg!(xmm0_f16 f16 "xmm0" "movaps"); -// CHECK-LABEL: xmm0_i32: +// CHECK-LABEL: xmm0_f16x8: // CHECK: #APP // CHECK: movaps xmm0, xmm0 // CHECK: #NO_APP -check_reg!(xmm0_i32 i32 "xmm0" "movaps"); +check_reg!(xmm0_f16x8 f16x8 "xmm0" "movaps"); // CHECK-LABEL: xmm0_f32: // CHECK: #APP @@ -704,11 +740,11 @@ check_reg!(xmm0_i32 i32 "xmm0" "movaps"); // CHECK: #NO_APP check_reg!(xmm0_f32 f32 "xmm0" "movaps"); -// CHECK-LABEL: xmm0_i64: +// CHECK-LABEL: xmm0_f32x4: // CHECK: #APP // CHECK: movaps xmm0, xmm0 // CHECK: #NO_APP -check_reg!(xmm0_i64 i64 "xmm0" "movaps"); +check_reg!(xmm0_f32x4 f32x4 "xmm0" "movaps"); // CHECK-LABEL: xmm0_f64: // CHECK: #APP @@ -716,35 +752,35 @@ check_reg!(xmm0_i64 i64 "xmm0" "movaps"); // CHECK: #NO_APP check_reg!(xmm0_f64 f64 "xmm0" "movaps"); -// CHECK-LABEL: xmm0_f128: +// CHECK-LABEL: xmm0_f64x2: // CHECK: #APP // CHECK: movaps xmm0, xmm0 // CHECK: #NO_APP -check_reg!(xmm0_f128 f128 "xmm0" "movaps"); +check_reg!(xmm0_f64x2 f64x2 "xmm0" "movaps"); -// CHECK-LABEL: xmm0_ptr: +// CHECK-LABEL: xmm0_i16x8: // CHECK: #APP // CHECK: movaps xmm0, xmm0 // CHECK: #NO_APP -check_reg!(xmm0_ptr ptr "xmm0" "movaps"); +check_reg!(xmm0_i16x8 i16x8 "xmm0" "movaps"); -// CHECK-LABEL: xmm0_i8x16: +// CHECK-LABEL: xmm0_i32: // CHECK: #APP // CHECK: movaps xmm0, xmm0 // CHECK: #NO_APP -check_reg!(xmm0_i8x16 i8x16 "xmm0" "movaps"); +check_reg!(xmm0_i32 i32 "xmm0" "movaps"); -// CHECK-LABEL: xmm0_i16x8: +// CHECK-LABEL: xmm0_i32x4: // CHECK: #APP // CHECK: movaps xmm0, xmm0 // CHECK: #NO_APP -check_reg!(xmm0_i16x8 i16x8 "xmm0" "movaps"); +check_reg!(xmm0_i32x4 i32x4 "xmm0" "movaps"); -// CHECK-LABEL: xmm0_i32x4: +// CHECK-LABEL: xmm0_i64: // CHECK: #APP // CHECK: movaps xmm0, xmm0 // CHECK: #NO_APP -check_reg!(xmm0_i32x4 i32x4 "xmm0" "movaps"); +check_reg!(xmm0_i64 i64 "xmm0" "movaps"); // CHECK-LABEL: xmm0_i64x2: // CHECK: #APP @@ -752,23 +788,23 @@ check_reg!(xmm0_i32x4 i32x4 "xmm0" "movaps"); // CHECK: #NO_APP check_reg!(xmm0_i64x2 i64x2 "xmm0" "movaps"); -// CHECK-LABEL: xmm0_f16x8: +// CHECK-LABEL: xmm0_i8x16: // CHECK: #APP // CHECK: movaps xmm0, xmm0 // CHECK: #NO_APP -check_reg!(xmm0_f16x8 f16x8 "xmm0" "movaps"); +check_reg!(xmm0_i8x16 i8x16 "xmm0" "movaps"); -// CHECK-LABEL: xmm0_f32x4: +// CHECK-LABEL: xmm0_ptr: // CHECK: #APP // CHECK: movaps xmm0, xmm0 // CHECK: #NO_APP -check_reg!(xmm0_f32x4 f32x4 "xmm0" "movaps"); +check_reg!(xmm0_ptr ptr "xmm0" "movaps"); -// CHECK-LABEL: xmm0_f64x2: +// CHECK-LABEL: ymm0_f128: // CHECK: #APP -// CHECK: movaps xmm0, xmm0 +// CHECK: vmovaps ymm0, ymm0 // CHECK: #NO_APP -check_reg!(xmm0_f64x2 f64x2 "xmm0" "movaps"); +check_reg!(ymm0_f128 f128 "ymm0" "vmovaps"); // CHECK-LABEL: ymm0_f16: // CHECK: #APP @@ -776,101 +812,95 @@ check_reg!(xmm0_f64x2 f64x2 "xmm0" "movaps"); // CHECK: #NO_APP check_reg!(ymm0_f16 f16 "ymm0" "vmovaps"); -// CHECK-LABEL: ymm0_i32: -// CHECK: #APP -// CHECK: vmovaps ymm0, ymm0 -// CHECK: #NO_APP -check_reg!(ymm0_i32 i32 "ymm0" "vmovaps"); - -// CHECK-LABEL: ymm0_f32: +// CHECK-LABEL: ymm0_f16x16: // CHECK: #APP // CHECK: vmovaps ymm0, ymm0 // CHECK: #NO_APP -check_reg!(ymm0_f32 f32 "ymm0" "vmovaps"); +check_reg!(ymm0_f16x16 f16x16 "ymm0" "vmovaps"); -// CHECK-LABEL: ymm0_i64: +// CHECK-LABEL: ymm0_f16x8: // CHECK: #APP // CHECK: vmovaps ymm0, ymm0 // CHECK: #NO_APP -check_reg!(ymm0_i64 i64 "ymm0" "vmovaps"); +check_reg!(ymm0_f16x8 f16x8 "ymm0" "vmovaps"); -// CHECK-LABEL: ymm0_f64: +// CHECK-LABEL: ymm0_f32: // CHECK: #APP // CHECK: vmovaps ymm0, ymm0 // CHECK: #NO_APP -check_reg!(ymm0_f64 f64 "ymm0" "vmovaps"); +check_reg!(ymm0_f32 f32 "ymm0" "vmovaps"); -// CHECK-LABEL: ymm0_f128: +// CHECK-LABEL: ymm0_f32x4: // CHECK: #APP // CHECK: vmovaps ymm0, ymm0 // CHECK: #NO_APP -check_reg!(ymm0_f128 f128 "ymm0" "vmovaps"); +check_reg!(ymm0_f32x4 f32x4 "ymm0" "vmovaps"); -// CHECK-LABEL: ymm0_ptr: +// CHECK-LABEL: ymm0_f32x8: // CHECK: #APP // CHECK: vmovaps ymm0, ymm0 // CHECK: #NO_APP -check_reg!(ymm0_ptr ptr "ymm0" "vmovaps"); +check_reg!(ymm0_f32x8 f32x8 "ymm0" "vmovaps"); -// CHECK-LABEL: ymm0_i8x16: +// CHECK-LABEL: ymm0_f64: // CHECK: #APP // CHECK: vmovaps ymm0, ymm0 // CHECK: #NO_APP -check_reg!(ymm0_i8x16 i8x16 "ymm0" "vmovaps"); +check_reg!(ymm0_f64 f64 "ymm0" "vmovaps"); -// CHECK-LABEL: ymm0_i16x8: +// CHECK-LABEL: ymm0_f64x2: // CHECK: #APP // CHECK: vmovaps ymm0, ymm0 // CHECK: #NO_APP -check_reg!(ymm0_i16x8 i16x8 "ymm0" "vmovaps"); +check_reg!(ymm0_f64x2 f64x2 "ymm0" "vmovaps"); -// CHECK-LABEL: ymm0_i32x4: +// CHECK-LABEL: ymm0_f64x4: // CHECK: #APP // CHECK: vmovaps ymm0, ymm0 // CHECK: #NO_APP -check_reg!(ymm0_i32x4 i32x4 "ymm0" "vmovaps"); +check_reg!(ymm0_f64x4 f64x4 "ymm0" "vmovaps"); -// CHECK-LABEL: ymm0_i64x2: +// CHECK-LABEL: ymm0_i16x16: // CHECK: #APP // CHECK: vmovaps ymm0, ymm0 // CHECK: #NO_APP -check_reg!(ymm0_i64x2 i64x2 "ymm0" "vmovaps"); +check_reg!(ymm0_i16x16 i16x16 "ymm0" "vmovaps"); -// CHECK-LABEL: ymm0_f16x8: +// CHECK-LABEL: ymm0_i16x8: // CHECK: #APP // CHECK: vmovaps ymm0, ymm0 // CHECK: #NO_APP -check_reg!(ymm0_f16x8 f16x8 "ymm0" "vmovaps"); +check_reg!(ymm0_i16x8 i16x8 "ymm0" "vmovaps"); -// CHECK-LABEL: ymm0_f32x4: +// CHECK-LABEL: ymm0_i32: // CHECK: #APP // CHECK: vmovaps ymm0, ymm0 // CHECK: #NO_APP -check_reg!(ymm0_f32x4 f32x4 "ymm0" "vmovaps"); +check_reg!(ymm0_i32 i32 "ymm0" "vmovaps"); -// CHECK-LABEL: ymm0_f64x2: +// CHECK-LABEL: ymm0_i32x4: // CHECK: #APP // CHECK: vmovaps ymm0, ymm0 // CHECK: #NO_APP -check_reg!(ymm0_f64x2 f64x2 "ymm0" "vmovaps"); +check_reg!(ymm0_i32x4 i32x4 "ymm0" "vmovaps"); -// CHECK-LABEL: ymm0_i8x32: +// CHECK-LABEL: ymm0_i32x8: // CHECK: #APP // CHECK: vmovaps ymm0, ymm0 // CHECK: #NO_APP -check_reg!(ymm0_i8x32 i8x32 "ymm0" "vmovaps"); +check_reg!(ymm0_i32x8 i32x8 "ymm0" "vmovaps"); -// CHECK-LABEL: ymm0_i16x16: +// CHECK-LABEL: ymm0_i64: // CHECK: #APP // CHECK: vmovaps ymm0, ymm0 // CHECK: #NO_APP -check_reg!(ymm0_i16x16 i16x16 "ymm0" "vmovaps"); +check_reg!(ymm0_i64 i64 "ymm0" "vmovaps"); -// CHECK-LABEL: ymm0_i32x8: +// CHECK-LABEL: ymm0_i64x2: // CHECK: #APP // CHECK: vmovaps ymm0, ymm0 // CHECK: #NO_APP -check_reg!(ymm0_i32x8 i32x8 "ymm0" "vmovaps"); +check_reg!(ymm0_i64x2 i64x2 "ymm0" "vmovaps"); // CHECK-LABEL: ymm0_i64x4: // CHECK: #APP @@ -878,167 +908,161 @@ check_reg!(ymm0_i32x8 i32x8 "ymm0" "vmovaps"); // CHECK: #NO_APP check_reg!(ymm0_i64x4 i64x4 "ymm0" "vmovaps"); -// CHECK-LABEL: ymm0_f16x16: +// CHECK-LABEL: ymm0_i8x16: // CHECK: #APP // CHECK: vmovaps ymm0, ymm0 // CHECK: #NO_APP -check_reg!(ymm0_f16x16 f16x16 "ymm0" "vmovaps"); +check_reg!(ymm0_i8x16 i8x16 "ymm0" "vmovaps"); -// CHECK-LABEL: ymm0_f32x8: +// CHECK-LABEL: ymm0_i8x32: // CHECK: #APP // CHECK: vmovaps ymm0, ymm0 // CHECK: #NO_APP -check_reg!(ymm0_f32x8 f32x8 "ymm0" "vmovaps"); +check_reg!(ymm0_i8x32 i8x32 "ymm0" "vmovaps"); -// CHECK-LABEL: ymm0_f64x4: +// CHECK-LABEL: ymm0_ptr: // CHECK: #APP // CHECK: vmovaps ymm0, ymm0 // CHECK: #NO_APP -check_reg!(ymm0_f64x4 f64x4 "ymm0" "vmovaps"); - -// CHECK-LABEL: zmm0_f16: -// CHECK: #APP -// CHECK: vmovaps zmm0, zmm0 -// CHECK: #NO_APP -check_reg!(zmm0_f16 f16 "zmm0" "vmovaps"); +check_reg!(ymm0_ptr ptr "ymm0" "vmovaps"); -// CHECK-LABEL: zmm0_i32: +// CHECK-LABEL: zmm0_f128: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_i32 i32 "zmm0" "vmovaps"); +check_reg!(zmm0_f128 f128 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_f32: +// CHECK-LABEL: zmm0_f16: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_f32 f32 "zmm0" "vmovaps"); +check_reg!(zmm0_f16 f16 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_i64: +// CHECK-LABEL: zmm0_f16x16: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_i64 i64 "zmm0" "vmovaps"); +check_reg!(zmm0_f16x16 f16x16 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_f64: +// CHECK-LABEL: zmm0_f16x32: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_f64 f64 "zmm0" "vmovaps"); +check_reg!(zmm0_f16x32 f16x32 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_f128: +// CHECK-LABEL: zmm0_f16x8: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_f128 f128 "zmm0" "vmovaps"); +check_reg!(zmm0_f16x8 f16x8 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_ptr: +// CHECK-LABEL: zmm0_f32: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_ptr ptr "zmm0" "vmovaps"); +check_reg!(zmm0_f32 f32 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_i8x16: +// CHECK-LABEL: zmm0_f32x16: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_i8x16 i8x16 "zmm0" "vmovaps"); +check_reg!(zmm0_f32x16 f32x16 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_i16x8: +// CHECK-LABEL: zmm0_f32x4: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_i16x8 i16x8 "zmm0" "vmovaps"); +check_reg!(zmm0_f32x4 f32x4 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_i32x4: +// CHECK-LABEL: zmm0_f32x8: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_i32x4 i32x4 "zmm0" "vmovaps"); +check_reg!(zmm0_f32x8 f32x8 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_i64x2: +// CHECK-LABEL: zmm0_f64: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_i64x2 i64x2 "zmm0" "vmovaps"); +check_reg!(zmm0_f64 f64 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_f16x8: +// CHECK-LABEL: zmm0_f64x2: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_f16x8 f16x8 "zmm0" "vmovaps"); +check_reg!(zmm0_f64x2 f64x2 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_f32x4: +// CHECK-LABEL: zmm0_f64x4: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_f32x4 f32x4 "zmm0" "vmovaps"); +check_reg!(zmm0_f64x4 f64x4 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_f64x2: +// CHECK-LABEL: zmm0_f64x8: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_f64x2 f64x2 "zmm0" "vmovaps"); +check_reg!(zmm0_f64x8 f64x8 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_i8x32: +// CHECK-LABEL: zmm0_i16x16: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_i8x32 i8x32 "zmm0" "vmovaps"); +check_reg!(zmm0_i16x16 i16x16 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_i16x16: +// CHECK-LABEL: zmm0_i16x32: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_i16x16 i16x16 "zmm0" "vmovaps"); +check_reg!(zmm0_i16x32 i16x32 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_i32x8: +// CHECK-LABEL: zmm0_i16x8: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_i32x8 i32x8 "zmm0" "vmovaps"); +check_reg!(zmm0_i16x8 i16x8 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_i64x4: +// CHECK-LABEL: zmm0_i32: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_i64x4 i64x4 "zmm0" "vmovaps"); +check_reg!(zmm0_i32 i32 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_f16x16: +// CHECK-LABEL: zmm0_i32x16: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_f16x16 f16x16 "zmm0" "vmovaps"); +check_reg!(zmm0_i32x16 i32x16 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_f32x8: +// CHECK-LABEL: zmm0_i32x4: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_f32x8 f32x8 "zmm0" "vmovaps"); +check_reg!(zmm0_i32x4 i32x4 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_f64x4: +// CHECK-LABEL: zmm0_i32x8: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_f64x4 f64x4 "zmm0" "vmovaps"); +check_reg!(zmm0_i32x8 i32x8 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_i8x64: +// CHECK-LABEL: zmm0_i64: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_i8x64 i8x64 "zmm0" "vmovaps"); +check_reg!(zmm0_i64 i64 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_i16x32: +// CHECK-LABEL: zmm0_i64x2: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_i16x32 i16x32 "zmm0" "vmovaps"); +check_reg!(zmm0_i64x2 i64x2 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_i32x16: +// CHECK-LABEL: zmm0_i64x4: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_i32x16 i32x16 "zmm0" "vmovaps"); +check_reg!(zmm0_i64x4 i64x4 "zmm0" "vmovaps"); // CHECK-LABEL: zmm0_i64x8: // CHECK: #APP @@ -1046,50 +1070,26 @@ check_reg!(zmm0_i32x16 i32x16 "zmm0" "vmovaps"); // CHECK: #NO_APP check_reg!(zmm0_i64x8 i64x8 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_f16x32: +// CHECK-LABEL: zmm0_i8x16: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_f16x32 f16x32 "zmm0" "vmovaps"); +check_reg!(zmm0_i8x16 i8x16 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_f32x16: +// CHECK-LABEL: zmm0_i8x32: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_f32x16 f32x16 "zmm0" "vmovaps"); +check_reg!(zmm0_i8x32 i8x32 "zmm0" "vmovaps"); -// CHECK-LABEL: zmm0_f64x8: +// CHECK-LABEL: zmm0_i8x64: // CHECK: #APP // CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(zmm0_f64x8 f64x8 "zmm0" "vmovaps"); - -// CHECK-LABEL: k1_i8: -// CHECK: #APP -// CHECK: kmovb k1, k1 -// CHECK: #NO_APP -check_reg!(k1_i8 i8 "k1" "kmovb"); - -// CHECK-LABEL: k1_i16: -// CHECK: #APP -// CHECK: kmovw k1, k1 -// CHECK: #NO_APP -check_reg!(k1_i16 i16 "k1" "kmovw"); - -// CHECK-LABEL: k1_i32: -// CHECK: #APP -// CHECK: kmovd k1, k1 -// CHECK: #NO_APP -check_reg!(k1_i32 i32 "k1" "kmovd"); - -// CHECK-LABEL: k1_i64: -// CHECK: #APP -// CHECK: kmovq k1, k1 -// CHECK: #NO_APP -check_reg!(k1_i64 i64 "k1" "kmovq"); +check_reg!(zmm0_i8x64 i8x64 "zmm0" "vmovaps"); -// CHECK-LABEL: k1_ptr: +// CHECK-LABEL: zmm0_ptr: // CHECK: #APP -// CHECK: kmovq k1, k1 +// CHECK: vmovaps zmm0, zmm0 // CHECK: #NO_APP -check_reg!(k1_ptr ptr "k1" "kmovq"); +check_reg!(zmm0_ptr ptr "zmm0" "vmovaps"); From 67f2b7acadf5f06bac45345da32bbbfb0d46f0a6 Mon Sep 17 00:00:00 2001 From: ywxt Date: Mon, 28 Jul 2025 14:11:30 +0800 Subject: [PATCH 6/8] Fix fmt --- tests/assembly-llvm/asm/aarch64-types.rs | 1 - tests/assembly-llvm/asm/avr-types.rs | 2 +- tests/assembly-llvm/asm/msp430-types.rs | 2 +- 3 files changed, 2 insertions(+), 3 deletions(-) diff --git a/tests/assembly-llvm/asm/aarch64-types.rs b/tests/assembly-llvm/asm/aarch64-types.rs index b37eb565209ad..82af3f049407a 100644 --- a/tests/assembly-llvm/asm/aarch64-types.rs +++ b/tests/assembly-llvm/asm/aarch64-types.rs @@ -445,7 +445,6 @@ check!(vreg_low16_ptr ptr vreg_low16 "fmov" "s"); // CHECK: //NO_APP check!(vreg_ptr ptr vreg "fmov" "s"); - // CHECK-LABEL: {{("#)?}}v0_f128{{"?}} // CHECK: //APP // CHECK: fmov s0, s0 diff --git a/tests/assembly-llvm/asm/avr-types.rs b/tests/assembly-llvm/asm/avr-types.rs index cdf6bfdb5ab87..33dee4617c88a 100644 --- a/tests/assembly-llvm/asm/avr-types.rs +++ b/tests/assembly-llvm/asm/avr-types.rs @@ -201,4 +201,4 @@ check_regw!(r25r24_i16 i16 "r25r24" "r24"); // CHECK: ;APP // CHECK: movw r26, r26 // CHECK: ;NO_APP -check_regw!(x_i16 i16 "X" "X"); \ No newline at end of file +check_regw!(x_i16 i16 "X" "X"); diff --git a/tests/assembly-llvm/asm/msp430-types.rs b/tests/assembly-llvm/asm/msp430-types.rs index 843414591ca87..36cd69d0b6b5b 100644 --- a/tests/assembly-llvm/asm/msp430-types.rs +++ b/tests/assembly-llvm/asm/msp430-types.rs @@ -13,7 +13,6 @@ use minicore::*; type ptr = *const i16; - extern "C" { fn extern_func(); static extern_static: i8; @@ -128,6 +127,7 @@ checkb!(reg_i8b i8 reg); // CHECK: mov r5, r5 // CHECK: ;NO_APP check_reg!(r5_i16 i16 "r5"); + // CHECK-LABEL: r5_i8: // CHECK: ;APP // CHECK: mov r5, r5 From 9867c9d4e5a3bfd452ccc4a824055efa5285b88d Mon Sep 17 00:00:00 2001 From: ywxt Date: Mon, 28 Jul 2025 15:12:03 +0800 Subject: [PATCH 7/8] Restore assembly.rs --- src/tools/compiletest/src/runtest/assembly.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/tools/compiletest/src/runtest/assembly.rs b/src/tools/compiletest/src/runtest/assembly.rs index 398c65eca080f..91d4f620f7194 100644 --- a/src/tools/compiletest/src/runtest/assembly.rs +++ b/src/tools/compiletest/src/runtest/assembly.rs @@ -42,6 +42,7 @@ impl TestCx<'_> { LinkToAux::Yes, Vec::new(), ); + let proc_res = self.compose_and_run_compiler(rustc, None, self.testpaths); (proc_res, output_path) } From f7fba9a9c957a847ed4f54c695ddb0922607c4a5 Mon Sep 17 00:00:00 2001 From: ywxt Date: Tue, 29 Jul 2025 20:35:52 +0800 Subject: [PATCH 8/8] Change the implement of the sort function. --- compiler/rustc_middle/src/mir/mono.rs | 85 ++++++++++++++++++++++----- 1 file changed, 70 insertions(+), 15 deletions(-) diff --git a/compiler/rustc_middle/src/mir/mono.rs b/compiler/rustc_middle/src/mir/mono.rs index c36efbd45dbac..326d83bf939fd 100644 --- a/compiler/rustc_middle/src/mir/mono.rs +++ b/compiler/rustc_middle/src/mir/mono.rs @@ -1,4 +1,5 @@ use std::borrow::Cow; +use std::cmp::Ordering; use std::fmt; use std::hash::Hash; @@ -6,7 +7,7 @@ use rustc_ast::expand::autodiff_attrs::AutoDiffItem; use rustc_attr_data_structures::InlineAttr; use rustc_data_structures::base_n::{BaseNString, CASE_INSENSITIVE, ToBaseN}; use rustc_data_structures::fingerprint::Fingerprint; -use rustc_data_structures::fx::FxIndexMap; +use rustc_data_structures::fx::{FxHashMap, FxIndexMap}; use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey}; use rustc_data_structures::unord::UnordMap; use rustc_hashes::Hash128; @@ -526,23 +527,77 @@ impl<'tcx> CodegenUnit<'tcx> { ) -> Vec<(MonoItem<'tcx>, MonoItemData)> { // The codegen tests rely on items being process in the same order as // they appear in the file, so for local items, we sort by span and def_path first - #[derive(PartialEq, Eq, PartialOrd, Ord)] - struct ItemSortKey<'tcx>(Option, Option, SymbolName<'tcx>); - - fn item_sort_key<'tcx>(tcx: TyCtxt<'tcx>, item: MonoItem<'tcx>) -> ItemSortKey<'tcx> { - ItemSortKey( - // For codegen tests purposes, we don't care about non-local items' order, - // so we just sort non-local items by symbol names. - item.local_span(tcx), - item.def_id() - .as_local() - .map(|_| tcx.def_path(item.def_id()).to_string_no_crate_verbose()), - item.symbol_name(tcx), - ) + struct ItemSortKey<'tcx>(Option, Option, Option>); + + // Avoids def_path querying for items that have different spans + fn item_sort<'tcx>( + tcx: TyCtxt<'tcx>, + cached_keys_map: &'_ mut FxHashMap, ItemSortKey<'tcx>>, + item1: MonoItem<'tcx>, + item2: MonoItem<'tcx>, + ) -> Ordering { + let is_local1 = item1.def_id().is_local(); + let is_local2 = item2.def_id().is_local(); + + match (is_local1, is_local2) { + (false, false) => { + cached_keys_map + .entry(item1) + .or_insert_with(|| ItemSortKey(None, None, Some(item1.symbol_name(tcx)))); + cached_keys_map + .entry(item2) + .or_insert_with(|| ItemSortKey(None, None, Some(item2.symbol_name(tcx)))); + let ItemSortKey(_, _, name1) = &cached_keys_map[&item1]; + let ItemSortKey(_, _, name2) = &cached_keys_map[&item2]; + name1.cmp(name2) + } + (false, true) => Ordering::Less, + (true, false) => Ordering::Greater, + (true, true) => { + cached_keys_map + .entry(item1) + .or_insert_with(|| ItemSortKey(item1.local_span(tcx), None, None)); + cached_keys_map + .entry(item2) + .or_insert_with(|| ItemSortKey(item2.local_span(tcx), None, None)); + let ItemSortKey(span1, _, _) = &cached_keys_map[&item1]; + let ItemSortKey(span2, _, _) = &cached_keys_map[&item2]; + let ord = span1.cmp(span2); + if ord != Ordering::Equal { + return ord; + } + + cached_keys_map.entry(item1).and_modify( + |ItemSortKey(_, def_path, symbol_name)| { + def_path.get_or_insert_with(|| { + tcx.def_path(item1.def_id()).to_string_no_crate_verbose() + }); + symbol_name.get_or_insert_with(|| item1.symbol_name(tcx)); + }, + ); + cached_keys_map.entry(item2).and_modify( + |ItemSortKey(_, def_path, symbol_name)| { + def_path.get_or_insert_with(|| { + tcx.def_path(item2.def_id()).to_string_no_crate_verbose() + }); + symbol_name.get_or_insert_with(|| item2.symbol_name(tcx)); + }, + ); + let ItemSortKey(_, def_path1, name1) = &cached_keys_map[&item1]; + let ItemSortKey(_, def_path2, name2) = &cached_keys_map[&item2]; + match def_path1.cmp(def_path2) { + Ordering::Equal => name1.cmp(name2), + other => other, + } + } + } } let mut items: Vec<_> = self.items().iter().map(|(&i, &data)| (i, data)).collect(); - items.sort_by_cached_key(|&(i, _)| item_sort_key(tcx, i)); + let mut cached_keys_map = + FxHashMap::with_capacity_and_hasher(items.len(), Default::default()); + items + .sort_by(|&(item1, _), &(item2, _)| item_sort(tcx, &mut cached_keys_map, item1, item2)); items }