Merging upstream version 1.69.0+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

2 files changed, 156 insertions, 168 deletions

diff --git a/library/stdarch/crates/stdarch-gen/Cargo.toml b/library/stdarch/crates/stdarch-gen/Cargo.toml
index b339672f4..a5d19b199 100644
--- a/library/stdarch/crates/stdarch-gen/Cargo.toml
+++ b/library/stdarch/crates/stdarch-gen/Cargo.toml
@@ -2,7 +2,7 @@
 name = "stdarch-gen"
 version = "0.1.0"
 authors = ["Heinz Gies <heinz@licenser.net>"]
-edition = "2018"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/library/stdarch/crates/stdarch-gen/src/main.rs b/library/stdarch/crates/stdarch-gen/src/main.rs
index d2f865753..750e88091 100644
--- a/library/stdarch/crates/stdarch-gen/src/main.rs
+++ b/library/stdarch/crates/stdarch-gen/src/main.rs
@@ -59,7 +59,7 @@ fn type_len(t: &str) -> usize {
             "4_" => 4,
             "8_" => 8,
             "16" => 16,
-            _ => panic!("unknown type: {}", t),
+            _ => panic!("unknown type: {t}"),
         }
     } else if s.len() == 3 {
         s[1].parse::<usize>().unwrap() * type_sub_len(t)
@@ -77,7 +77,7 @@ fn type_sub_len(t: &str) -> usize {
             "2_t" => 2,
             "3_t" => 3,
             "4_t" => 4,
-            _ => panic!("unknown type len: {}", t),
+            _ => panic!("unknown type len: {t}"),
         }
     }
 }
@@ -92,7 +92,7 @@ fn type_bits(t: &str) -> usize {
         | "float32x4_t" | "f32" => 32,
         "int64x1_t" | "int64x2_t" | "uint64x1_t" | "uint64x2_t" | "poly64x1_t" | "poly64x2_t"
         | "i64" | "u64" | "float64x1_t" | "float64x2_t" | "f64" => 64,
-        _ => panic!("unknown type: {}", t),
+        _ => panic!("unknown type: {t}"),
     }
 }
 
@@ -105,7 +105,7 @@ fn type_exp_len(t: &str, base_len: usize) -> usize {
         4 => 2,
         8 => 3,
         16 => 4,
-        _ => panic!("unknown type: {}", t),
+        _ => panic!("unknown type: {t}"),
     }
 }
 
@@ -118,7 +118,7 @@ fn type_bits_exp_len(t: &str) -> usize {
         "int32x2_t" | "int32x4_t" | "uint32x2_t" | "uint32x4_t" | "i32" | "u32" => 5,
         "int64x1_t" | "int64x2_t" | "uint64x1_t" | "uint64x2_t" | "poly64x1_t" | "poly64x2_t"
         | "i64" | "u64" => 6,
-        _ => panic!("unknown type: {}", t),
+        _ => panic!("unknown type: {t}"),
     }
 }
 
@@ -243,7 +243,7 @@ fn type_to_suffix(t: &str) -> &str {
         "p8" => "b_p8",
         "p16" => "h_p16",
         "p128" => "q_p128",
-        _ => panic!("unknown type: {}", t),
+        _ => panic!("unknown type: {t}"),
     }
 }
 
@@ -297,7 +297,7 @@ fn type_to_n_suffix(t: &str) -> &str {
         "u16" => "h_n_u16",
         "u32" => "s_n_u32",
         "u64" => "d_n_u64",
-        _ => panic!("unknown type: {}", t),
+        _ => panic!("unknown type: {t}"),
     }
 }
 
@@ -325,7 +325,7 @@ fn type_to_noq_n_suffix(t: &str) -> &str {
         "u16" => "h_n_u16",
         "u32" => "s_n_u32",
         "u64" => "d_n_u64",
-        _ => panic!("unknown type: {}", t),
+        _ => panic!("unknown type: {t}"),
     }
 }
 
@@ -354,7 +354,7 @@ fn type_to_rot_suffix(c_name: &str, suf: &str) -> String {
     if suf.starts_with("q") {
         format!("{}q_{}{}", ns[0], ns[1], &suf[1..])
     } else {
-        format!("{}{}", c_name, suf)
+        format!("{c_name}{suf}")
     }
 }
 
@@ -426,7 +426,7 @@ fn type_to_noq_suffix(t: &str) -> &str {
         "poly16x4_t" | "poly16x8_t" => "_p16",
         "poly64x1_t" | "poly64x2_t" | "p64" => "_p64",
         "p128" => "_p128",
-        _ => panic!("unknown type: {}", t),
+        _ => panic!("unknown type: {t}"),
     }
 }
 
@@ -521,7 +521,7 @@ fn type_to_global_type(t: &str) -> &str {
         "p16" => "p16",
         "p64" => "p64",
         "p128" => "p128",
-        _ => panic!("unknown type: {}", t),
+        _ => panic!("unknown type: {t}"),
     }
 }
 
@@ -530,7 +530,7 @@ fn type_to_sub_type(t: &str) -> String {
     match s.len() {
         2 => String::from(t),
         3 => format!("{}x{}_t", s[0], s[1]),
-        _ => panic!("unknown type: {}", t),
+        _ => panic!("unknown type: {t}"),
     }
 }
 
@@ -547,9 +547,9 @@ fn type_to_native_type(t: &str) -> String {
             "uin" => format!("u{}", &s[0][4..]),
             "flo" => format!("f{}", &s[0][5..]),
             "pol" => format!("u{}", &s[0][4..]),
-            _ => panic!("unknown type: {}", t),
+            _ => panic!("unknown type: {t}"),
         },
-        _ => panic!("unknown type: {}", t),
+        _ => panic!("unknown type: {t}"),
     }
 }
 
@@ -566,7 +566,7 @@ fn native_type_to_type(t: &str) -> &str {
         "f16" => "float16x4_t",
         "f32" => "float32x2_t",
         "f64" => "float64x1_t",
-        _ => panic!("unknown type: {}", t),
+        _ => panic!("unknown type: {t}"),
     }
 }
 
@@ -583,7 +583,7 @@ fn native_type_to_long_type(t: &str) -> &str {
         "f16" => "float16x8_t",
         "f32" => "float32x4_t",
         "f64" => "float64x2_t",
-        _ => panic!("unknown type: {}", t),
+        _ => panic!("unknown type: {t}"),
     }
 }
 
@@ -601,7 +601,7 @@ fn type_to_half(t: &str) -> &str {
         "poly16x8_t" => "poly16x4_t",
         "float32x4_t" => "float32x2_t",
         "float64x2_t" => "float64x1_t",
-        _ => panic!("unknown half type for {}", t),
+        _ => panic!("unknown half type for {t}"),
     }
 }
 
@@ -624,7 +624,7 @@ fn transpose1(x: usize) -> &'static str {
         4 => "[0, 4, 2, 6]",
         8 => "[0, 8, 2, 10, 4, 12, 6, 14]",
         16 => "[0, 16, 2, 18, 4, 20, 6, 22, 8, 24, 10, 26, 12, 28, 14, 30]",
-        _ => panic!("unknown transpose order of len {}", x),
+        _ => panic!("unknown transpose order of len {x}"),
     }
 }
 
@@ -634,7 +634,7 @@ fn transpose2(x: usize) -> &'static str {
         4 => "[1, 5, 3, 7]",
         8 => "[1, 9, 3, 11, 5, 13, 7, 15]",
         16 => "[1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31]",
-        _ => panic!("unknown transpose order of len {}", x),
+        _ => panic!("unknown transpose order of len {x}"),
     }
 }
 
@@ -644,7 +644,7 @@ fn zip1(x: usize) -> &'static str {
         4 => "[0, 4, 1, 5]",
         8 => "[0, 8, 1, 9, 2, 10, 3, 11]",
         16 => "[0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23]",
-        _ => panic!("unknown zip order of len {}", x),
+        _ => panic!("unknown zip order of len {x}"),
     }
 }
 
@@ -654,7 +654,7 @@ fn zip2(x: usize) -> &'static str {
         4 => "[2, 6, 3, 7]",
         8 => "[4, 12, 5, 13, 6, 14, 7, 15]",
         16 => "[8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31]",
-        _ => panic!("unknown zip order of len {}", x),
+        _ => panic!("unknown zip order of len {x}"),
     }
 }
 
@@ -664,7 +664,7 @@ fn unzip1(x: usize) -> &'static str {
         4 => "[0, 2, 4, 6]",
         8 => "[0, 2, 4, 6, 8, 10, 12, 14]",
         16 => "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30]",
-        _ => panic!("unknown unzip order of len {}", x),
+        _ => panic!("unknown unzip order of len {x}"),
     }
 }
 
@@ -674,13 +674,13 @@ fn unzip2(x: usize) -> &'static str {
         4 => "[1, 3, 5, 7]",
         8 => "[1, 3, 5, 7, 9, 11, 13, 15]",
         16 => "[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31]",
-        _ => panic!("unknown unzip order of len {}", x),
+        _ => panic!("unknown unzip order of len {x}"),
     }
 }
 
 fn values(t: &str, vs: &[String]) -> String {
     if vs.len() == 1 && !t.contains('x') {
-        format!(": {} = {}", t, vs[0])
+        format!(": {t} = {}", vs[0])
     } else if vs.len() == 1 && type_to_global_type(t) == "f64" {
         format!(": {} = {}", type_to_global_type(t), vs[0])
     } else {
@@ -723,7 +723,7 @@ fn max_val(t: &str) -> &'static str {
         "i64" => "0x7F_FF_FF_FF_FF_FF_FF_FF",
         "f32" => "3.40282347e+38",
         "f64" => "1.7976931348623157e+308",
-        _ => panic!("No TRUE for type {}", t),
+        _ => panic!("No TRUE for type {t}"),
     }
 }
 
@@ -739,7 +739,7 @@ fn min_val(t: &str) -> &'static str {
         "i64" => "-9223372036854775808",
         "f32" => "-3.40282347e+38",
         "f64" => "-1.7976931348623157e+308",
-        _ => panic!("No TRUE for type {}", t),
+        _ => panic!("No TRUE for type {t}"),
     }
 }
 
@@ -749,7 +749,7 @@ fn true_val(t: &str) -> &'static str {
         "u16" => "0xFF_FF",
         "u32" => "0xFF_FF_FF_FF",
         "u64" => "0xFF_FF_FF_FF_FF_FF_FF_FF",
-        _ => panic!("No TRUE for type {}", t),
+        _ => panic!("No TRUE for type {t}"),
     }
 }
 
@@ -763,7 +763,7 @@ fn ff_val(t: &str) -> &'static str {
         "i16" => "0xFF_FF",
         "i32" => "0xFF_FF_FF_FF",
         "i64" => "0xFF_FF_FF_FF_FF_FF_FF_FF",
-        _ => panic!("No TRUE for type {}", t),
+        _ => panic!("No TRUE for type {t}"),
     }
 }
 
@@ -784,7 +784,7 @@ fn bits(t: &str) -> &'static str {
         "p8x" => "8",
         "p16" => "16",
         "p64" => "64",
-        _ => panic!("Unknown bits for type {}", t),
+        _ => panic!("Unknown bits for type {t}"),
     }
 }
 
@@ -801,7 +801,7 @@ fn bits_minus_one(t: &str) -> &'static str {
         "p8x" => "7",
         "p16" => "15",
         "p64" => "63",
-        _ => panic!("Unknown bits for type {}", t),
+        _ => panic!("Unknown bits for type {t}"),
     }
 }
 
@@ -818,7 +818,7 @@ fn half_bits(t: &str) -> &'static str {
         "p8x" => "4",
         "p16" => "8",
         "p64" => "32",
-        _ => panic!("Unknown bits for type {}", t),
+        _ => panic!("Unknown bits for type {t}"),
     }
 }
 
@@ -852,7 +852,7 @@ fn type_len_str(t: &str) -> &'static str {
         "poly16x8_t" => "8",
         "poly64x1_t" => "1",
         "poly64x2_t" => "2",
-        _ => panic!("unknown type: {}", t),
+        _ => panic!("unknown type: {t}"),
     }
 }
 
@@ -886,7 +886,7 @@ fn type_len_minus_one_str(t: &str) -> &'static str {
         "poly16x8_t" => "7",
         "poly64x1_t" => "0",
         "poly64x2_t" => "1",
-        _ => panic!("unknown type: {}", t),
+        _ => panic!("unknown type: {t}"),
     }
 }
 
@@ -920,7 +920,7 @@ fn type_half_len_str(t: &str) -> &'static str {
         "poly16x8_t" => "4",
         "poly64x1_t" => "0",
         "poly64x2_t" => "1",
-        _ => panic!("unknown type: {}", t),
+        _ => panic!("unknown type: {t}"),
     }
 }
 
@@ -954,12 +954,12 @@ fn type_to_ext(t: &str, v: bool, r: bool, pi8: bool) -> String {
             native
         ),
         _ if pi8 => format!(".p0i8"),
-        _ => format!(".p0{}", native),
+        _ => format!(".p0{native}"),
     };
     let sub_type = match &native[0..1] {
         "i" | "f" => native,
         "u" => native.replace("u", "i"),
-        _ => panic!("unknown type: {}", t),
+        _ => panic!("unknown type: {t}"),
     };
     let ext = format!(
         "v{}{}{}",
@@ -1041,8 +1041,8 @@ fn gen_aarch64(
     fn_type: Fntype,
 ) -> (String, String) {
     let name = match suffix {
-        Normal => format!("{}{}", current_name, type_to_suffix(in_t[1])),
-        NoQ => format!("{}{}", current_name, type_to_noq_suffix(in_t[1])),
+        Normal => format!("{current_name}{}", type_to_suffix(in_t[1])),
+        NoQ => format!("{current_name}{}", type_to_noq_suffix(in_t[1])),
         Double => format!(
             "{}{}",
             current_name,
@@ -1053,15 +1053,15 @@ fn gen_aarch64(
             current_name,
             type_to_noq_double_suffixes(out_t, in_t[1])
         ),
-        NSuffix => format!("{}{}", current_name, type_to_n_suffix(in_t[1])),
+        NSuffix => format!("{current_name}{}", type_to_n_suffix(in_t[1])),
         DoubleN => format!(
             "{}{}",
             current_name,
             type_to_double_n_suffixes(out_t, in_t[1])
         ),
-        NoQNSuffix => format!("{}{}", current_name, type_to_noq_n_suffix(in_t[1])),
-        OutSuffix => format!("{}{}", current_name, type_to_suffix(out_t)),
-        OutNSuffix => format!("{}{}", current_name, type_to_n_suffix(out_t)),
+        NoQNSuffix => format!("{current_name}{}", type_to_noq_n_suffix(in_t[1])),
+        OutSuffix => format!("{current_name}{}", type_to_suffix(out_t)),
+        OutNSuffix => format!("{current_name}{}", type_to_n_suffix(out_t)),
         OutNox => format!(
             "{}{}",
             current_name,
@@ -1092,7 +1092,7 @@ fn gen_aarch64(
             current_name,
             type_to_lane_suffixes(out_t, in_t[1], false)
         ),
-        In2 => format!("{}{}", current_name, type_to_suffix(in_t[2])),
+        In2 => format!("{current_name}{}", type_to_suffix(in_t[2])),
         In2Lane => format!(
             "{}{}",
             current_name,
@@ -1122,11 +1122,11 @@ fn gen_aarch64(
     };
     let current_fn = if let Some(current_fn) = current_fn.clone() {
         if link_aarch64.is_some() {
-            panic!("[{}] Can't specify link and fn at the same time.", name)
+            panic!("[{name}] Can't specify link and fn at the same time.")
         }
         current_fn
     } else if link_aarch64.is_some() {
-        format!("{}_", name)
+        format!("{name}_")
     } else {
         if multi_fn.is_empty() {
             panic!(
@@ -1174,8 +1174,8 @@ fn gen_aarch64(
                     let sub = type_to_sub_type(in_t[1]);
                     (
                         match type_sub_len(in_t[1]) {
-                            1 => format!("a: {}, n: i64, ptr: {}", sub, ptr_type),
-                            2 => format!("a: {}, b: {}, n: i64, ptr: {}", sub, sub, ptr_type),
+                            1 => format!("a: {sub}, n: i64, ptr: {ptr_type}"),
+                            2 => format!("a: {sub}, b: {sub}, n: i64, ptr: {ptr_type}"),
                             3 => format!(
                                 "a: {}, b: {}, c: {}, n: i64, ptr: {}",
                                 sub, sub, sub, ptr_type
@@ -1187,7 +1187,7 @@ fn gen_aarch64(
                             _ => panic!("unsupported type: {}", in_t[1]),
                         },
                         if out_t != "void" {
-                            format!(" -> {}", out_t)
+                            format!(" -> {out_t}")
                         } else {
                             String::new()
                         },
@@ -1200,7 +1200,7 @@ fn gen_aarch64(
                             3 => format!("a: {}, b: {}, c: {}, n: i32", in_t[0], in_t[1], in_t[2]),
                             _ => unimplemented!("unknown para_num"),
                         },
-                        format!(" -> {}", out_t),
+                        format!(" -> {out_t}"),
                     )
                 }
             } else if matches!(fn_type, Fntype::Store) {
@@ -1211,23 +1211,20 @@ fn gen_aarch64(
                     type_to_native_type(in_t[1])
                 };
                 let subs = match type_sub_len(in_t[1]) {
-                    1 => format!("a: {}", sub),
-                    2 => format!("a: {}, b: {}", sub, sub),
-                    3 => format!("a: {}, b: {}, c: {}", sub, sub, sub),
-                    4 => format!("a: {}, b: {}, c: {}, d: {}", sub, sub, sub, sub),
+                    1 => format!("a: {sub}"),
+                    2 => format!("a: {sub}, b: {sub}"),
+                    3 => format!("a: {sub}, b: {sub}, c: {sub}"),
+                    4 => format!("a: {sub}, b: {sub}, c: {sub}, d: {sub}"),
                     _ => panic!("unsupported type: {}", in_t[1]),
                 };
-                (format!("{}, ptr: *mut {}", subs, ptr_type), String::new())
+                (format!("{subs}, ptr: *mut {ptr_type}"), String::new())
             } else if is_vldx(&name) {
                 let ptr_type = if name.contains("dup") {
                     type_to_native_type(out_t)
                 } else {
                     type_to_sub_type(out_t)
                 };
-                (
-                    format!("ptr: *const {}", ptr_type),
-                    format!(" -> {}", out_t),
-                )
+                (format!("ptr: *const {ptr_type}"), format!(" -> {out_t}"))
             } else {
                 (
                     match para_num {
@@ -1256,7 +1253,7 @@ fn gen_aarch64(
             assert_eq!(constns.len(), 2);
             format!(r#"<const {}: i32, const {}: i32>"#, constns[0], constns[1])
         } else {
-            format!(r#"<const {}: i32>"#, constn)
+            format!(r#"<const {constn}: i32>"#)
         }
     } else {
         String::new()
@@ -1314,7 +1311,7 @@ fn gen_aarch64(
                 para_num + 1
             )
         } else {
-            format!("\n#[rustc_legacy_const_generics({})]", para_num)
+            format!("\n#[rustc_legacy_const_generics({para_num})]")
         }
     } else {
         String::new()
@@ -1323,7 +1320,7 @@ fn gen_aarch64(
         let fn_output = if out_t == "void" {
             String::new()
         } else {
-            format!("-> {} ", out_t)
+            format!("-> {out_t} ")
         };
         let fn_inputs = match para_num {
             1 => format!("(a: {})", in_t[0]),
@@ -1373,14 +1370,14 @@ fn gen_aarch64(
         } else if link_aarch64.is_some() && matches!(fn_type, Fntype::Store) {
             let cast = if is_vstx(&name) { " as _" } else { "" };
             match type_sub_len(in_t[1]) {
-                1 => format!(r#"{}{}(b, a{})"#, ext_c, current_fn, cast),
-                2 => format!(r#"{}{}(b.0, b.1, a{})"#, ext_c, current_fn, cast),
-                3 => format!(r#"{}{}(b.0, b.1, b.2, a{})"#, ext_c, current_fn, cast),
-                4 => format!(r#"{}{}(b.0, b.1, b.2, b.3, a{})"#, ext_c, current_fn, cast),
+                1 => format!(r#"{ext_c}{current_fn}(b, a{cast})"#),
+                2 => format!(r#"{ext_c}{current_fn}(b.0, b.1, a{cast})"#),
+                3 => format!(r#"{ext_c}{current_fn}(b.0, b.1, b.2, a{cast})"#),
+                4 => format!(r#"{ext_c}{current_fn}(b.0, b.1, b.2, b.3, a{cast})"#),
                 _ => panic!("unsupported type: {}", in_t[1]),
             }
         } else if link_aarch64.is_some() && is_vldx(&name) {
-            format!(r#"{}{}(a as _)"#, ext_c, current_fn,)
+            format!(r#"{ext_c}{current_fn}(a as _)"#,)
         } else {
             let trans: [&str; 2] = if link_t[3] != out_t {
                 ["transmute(", ")"]
@@ -1388,7 +1385,7 @@ fn gen_aarch64(
                 ["", ""]
             };
             match (multi_calls.len(), para_num, fixed.len()) {
-                (0, 1, 0) => format!(r#"{}{}{}(a){}"#, ext_c, trans[0], current_fn, trans[1]),
+                (0, 1, 0) => format!(r#"{ext_c}{}{current_fn}(a){}"#, trans[0], trans[1]),
                 (0, 1, _) => {
                     let fixed: Vec<String> =
                         fixed.iter().take(type_len(in_t[0])).cloned().collect();
@@ -1402,11 +1399,11 @@ fn gen_aarch64(
                         trans[1],
                     )
                 }
-                (0, 2, _) => format!(r#"{}{}{}(a, b){}"#, ext_c, trans[0], current_fn, trans[1],),
-                (0, 3, _) => format!(r#"{}{}(a, b, c)"#, ext_c, current_fn,),
-                (_, 1, _) => format!(r#"{}{}"#, ext_c, multi_calls,),
-                (_, 2, _) => format!(r#"{}{}"#, ext_c, multi_calls,),
-                (_, 3, _) => format!(r#"{}{}"#, ext_c, multi_calls,),
+                (0, 2, _) => format!(r#"{ext_c}{}{current_fn}(a, b){}"#, trans[0], trans[1],),
+                (0, 3, _) => format!(r#"{ext_c}{current_fn}(a, b, c)"#,),
+                (_, 1, _) => format!(r#"{ext_c}{multi_calls}"#,),
+                (_, 2, _) => format!(r#"{ext_c}{multi_calls}"#,),
+                (_, 3, _) => format!(r#"{ext_c}{multi_calls}"#,),
                 (_, _, _) => String::new(),
             }
         }
@@ -1768,8 +1765,8 @@ fn gen_arm(
     separate: bool,
 ) -> (String, String) {
     let name = match suffix {
-        Normal => format!("{}{}", current_name, type_to_suffix(in_t[1])),
-        NoQ => format!("{}{}", current_name, type_to_noq_suffix(in_t[1])),
+        Normal => format!("{current_name}{}", type_to_suffix(in_t[1])),
+        NoQ => format!("{current_name}{}", type_to_noq_suffix(in_t[1])),
         Double => format!(
             "{}{}",
             current_name,
@@ -1780,15 +1777,15 @@ fn gen_arm(
             current_name,
             type_to_noq_double_suffixes(out_t, in_t[1])
         ),
-        NSuffix => format!("{}{}", current_name, type_to_n_suffix(in_t[1])),
+        NSuffix => format!("{current_name}{}", type_to_n_suffix(in_t[1])),
         DoubleN => format!(
             "{}{}",
             current_name,
             type_to_double_n_suffixes(out_t, in_t[1])
         ),
-        NoQNSuffix => format!("{}{}", current_name, type_to_noq_n_suffix(in_t[1])),
-        OutSuffix => format!("{}{}", current_name, type_to_suffix(out_t)),
-        OutNSuffix => format!("{}{}", current_name, type_to_n_suffix(out_t)),
+        NoQNSuffix => format!("{current_name}{}", type_to_noq_n_suffix(in_t[1])),
+        OutSuffix => format!("{current_name}{}", type_to_suffix(out_t)),
+        OutNSuffix => format!("{current_name}{}", type_to_n_suffix(out_t)),
         OutNox => format!(
             "{}{}",
             current_name,
@@ -1819,7 +1816,7 @@ fn gen_arm(
             current_name,
             type_to_lane_suffixes(out_t, in_t[1], false)
         ),
-        In2 => format!("{}{}", current_name, type_to_suffix(in_t[2])),
+        In2 => format!("{current_name}{}", type_to_suffix(in_t[2])),
         In2Lane => format!(
             "{}{}",
             current_name,
@@ -1873,7 +1870,7 @@ fn gen_arm(
         }
         current_fn
     } else if link_aarch64.is_some() || link_arm.is_some() {
-        format!("{}_", name)
+        format!("{name}_")
     } else {
         if multi_fn.is_empty() {
             panic!(
@@ -1980,9 +1977,9 @@ fn gen_arm(
                     };
                     let sub_type = type_to_sub_type(in_t[1]);
                     let inputs = match type_sub_len(in_t[1]) {
-                        1 => format!("a: {}", sub_type),
-                        2 => format!("a: {}, b: {}", sub_type, sub_type,),
-                        3 => format!("a: {}, b: {}, c: {}", sub_type, sub_type, sub_type,),
+                        1 => format!("a: {sub_type}"),
+                        2 => format!("a: {sub_type}, b: {sub_type}",),
+                        3 => format!("a: {sub_type}, b: {sub_type}, c: {sub_type}",),
                         4 => format!(
                             "a: {}, b: {}, c: {}, d: {}",
                             sub_type, sub_type, sub_type, sub_type,
@@ -1992,12 +1989,9 @@ fn gen_arm(
                     let out = if out_t == "void" {
                         String::new()
                     } else {
-                        format!(" -> {}", out_t)
+                        format!(" -> {out_t}")
                     };
-                    (
-                        format!("ptr: {}, {}, n: i32, size: i32", ptr_type, inputs),
-                        out,
-                    )
+                    (format!("ptr: {ptr_type}, {inputs}, n: i32, size: i32"), out)
                 } else {
                     let (_, const_type) = if const_arm.contains(":") {
                         let consts: Vec<_> =
@@ -2011,15 +2005,15 @@ fn gen_arm(
                     };
                     (
                         match para_num {
-                            1 => format!("a: {}, n: {}", in_t[0], const_type),
-                            2 => format!("a: {}, b: {}, n: {}", in_t[0], in_t[1], const_type),
+                            1 => format!("a: {}, n: {const_type}", in_t[0]),
+                            2 => format!("a: {}, b: {}, n: {const_type}", in_t[0], in_t[1]),
                             3 => format!(
-                                "a: {}, b: {}, c: {}, n: {}",
-                                in_t[0], in_t[1], in_t[2], const_type
+                                "a: {}, b: {}, c: {}, n: {const_type}",
+                                in_t[0], in_t[1], in_t[2]
                             ),
                             _ => unimplemented!("unknown para_num"),
                         },
-                        format!(" -> {}", out_t),
+                        format!(" -> {out_t}"),
                     )
                 }
             } else if out_t != link_arm_t[3] {
@@ -2038,9 +2032,9 @@ fn gen_arm(
             } else if matches!(fn_type, Fntype::Store) {
                 let sub_type = type_to_sub_type(in_t[1]);
                 let inputs = match type_sub_len(in_t[1]) {
-                    1 => format!("a: {}", sub_type),
-                    2 => format!("a: {}, b: {}", sub_type, sub_type,),
-                    3 => format!("a: {}, b: {}, c: {}", sub_type, sub_type, sub_type,),
+                    1 => format!("a: {sub_type}"),
+                    2 => format!("a: {sub_type}, b: {sub_type}",),
+                    3 => format!("a: {sub_type}, b: {sub_type}, c: {sub_type}",),
                     4 => format!(
                         "a: {}, b: {}, c: {}, d: {}",
                         sub_type, sub_type, sub_type, sub_type,
@@ -2053,14 +2047,11 @@ fn gen_arm(
                     (type_to_native_type(in_t[1]), "")
                 };
                 (
-                    format!("ptr: *mut {}, {}{}", ptr_type, inputs, size),
+                    format!("ptr: *mut {ptr_type}, {inputs}{size}"),
                     String::new(),
                 )
             } else if is_vldx(&name) {
-                (
-                    format!("ptr: *const i8, size: i32"),
-                    format!(" -> {}", out_t),
-                )
+                (format!("ptr: *const i8, size: i32"), format!(" -> {out_t}"))
             } else {
                 (String::new(), String::new())
             }
@@ -2084,20 +2075,20 @@ fn gen_arm(
                     };
                     let sub_type = type_to_sub_type(in_t[1]);
                     let mut inputs = match type_sub_len(in_t[1]) {
-                        1 => format!("a: {}", sub_type,),
-                        2 => format!("a: {}, b: {}", sub_type, sub_type,),
-                        3 => format!("a: {}, b: {}, c: {}", sub_type, sub_type, sub_type,),
+                        1 => format!("a: {sub_type}",),
+                        2 => format!("a: {sub_type}, b: {sub_type}",),
+                        3 => format!("a: {sub_type}, b: {sub_type}, c: {sub_type}",),
                         4 => format!(
                             "a: {}, b: {}, c: {}, d: {}",
                             sub_type, sub_type, sub_type, sub_type,
                         ),
                         _ => panic!("unknown type: {}", in_t[1]),
                     };
-                    inputs.push_str(&format!(", n: i64, ptr: {}", ptr_type));
+                    inputs.push_str(&format!(", n: i64, ptr: {ptr_type}"));
                     let out = if out_t == "void" {
                         String::new()
                     } else {
-                        format!(" -> {}", out_t)
+                        format!(" -> {out_t}")
                     };
                     (inputs, out)
                 } else if const_aarch64.contains("dup-in_len-N as ttn") {
@@ -2111,7 +2102,7 @@ fn gen_arm(
                             ),
                             _ => unimplemented!("unknown para_num"),
                         },
-                        format!(" -> {}", out_t),
+                        format!(" -> {out_t}"),
                     )
                 } else {
                     (
@@ -2121,7 +2112,7 @@ fn gen_arm(
                             3 => format!("a: {}, b: {}, c: {}, n: i32", in_t[0], in_t[1], in_t[2]),
                             _ => unimplemented!("unknown para_num"),
                         },
-                        format!(" -> {}", out_t),
+                        format!(" -> {out_t}"),
                     )
                 }
             } else if out_t != link_aarch64_t[3] {
@@ -2140,9 +2131,9 @@ fn gen_arm(
             } else if matches!(fn_type, Fntype::Store) {
                 let sub_type = type_to_sub_type(in_t[1]);
                 let mut inputs = match type_sub_len(in_t[1]) {
-                    1 => format!("a: {}", sub_type,),
-                    2 => format!("a: {}, b: {}", sub_type, sub_type,),
-                    3 => format!("a: {}, b: {}, c: {}", sub_type, sub_type, sub_type,),
+                    1 => format!("a: {sub_type}",),
+                    2 => format!("a: {sub_type}, b: {sub_type}",),
+                    3 => format!("a: {sub_type}, b: {sub_type}, c: {sub_type}",),
                     4 => format!(
                         "a: {}, b: {}, c: {}, d: {}",
                         sub_type, sub_type, sub_type, sub_type,
@@ -2154,7 +2145,7 @@ fn gen_arm(
                 } else {
                     type_to_native_type(in_t[1])
                 };
-                inputs.push_str(&format!(", ptr: *mut {}", ptr_type));
+                inputs.push_str(&format!(", ptr: *mut {ptr_type}"));
                 (inputs, String::new())
             } else if is_vldx(&name) {
                 let ptr_type = if name.contains("dup") {
@@ -2162,10 +2153,7 @@ fn gen_arm(
                 } else {
                     type_to_sub_type(out_t)
                 };
-                (
-                    format!("ptr: *const {}", ptr_type),
-                    format!(" -> {}", out_t),
-                )
+                (format!("ptr: *const {ptr_type}"), format!(" -> {out_t}"))
             } else {
                 (String::new(), String::new())
             }
@@ -2181,7 +2169,7 @@ fn gen_arm(
         ));
     };
     let const_declare = if let Some(constn) = constn {
-        format!(r#"<const {}: i32>"#, constn)
+        format!(r#"<const {constn}: i32>"#)
     } else {
         String::new()
     };
@@ -2216,7 +2204,7 @@ fn gen_arm(
         String::new()
     };
     let const_legacy = if constn.is_some() {
-        format!("\n#[rustc_legacy_const_generics({})]", para_num)
+        format!("\n#[rustc_legacy_const_generics({para_num})]")
     } else {
         String::new()
     };
@@ -2224,7 +2212,7 @@ fn gen_arm(
         let fn_output = if out_t == "void" {
             String::new()
         } else {
-            format!("-> {} ", out_t)
+            format!("-> {out_t} ")
         };
         let fn_inputs = match para_num {
             1 => format!("(a: {})", in_t[0]),
@@ -2274,15 +2262,15 @@ fn gen_arm(
                         cnt
                     };
                     match para_num {
-                        1 => format!("{}(a, {})", current_fn, cnt),
-                        2 => format!("{}(a, b, {})", current_fn, cnt),
+                        1 => format!("{current_fn}(a, {cnt})"),
+                        2 => format!("{current_fn}(a, b, {cnt})"),
                         _ => String::new(),
                     }
                 }
             } else if out_t != link_arm_t[3] {
                 match para_num {
-                    1 => format!("transmute({}(a))", current_fn,),
-                    2 => format!("transmute({}(transmute(a), transmute(b)))", current_fn,),
+                    1 => format!("transmute({current_fn}(a))",),
+                    2 => format!("transmute({current_fn}(transmute(a), transmute(b)))",),
                     _ => String::new(),
                 }
             } else if matches!(fn_type, Fntype::Store) {
@@ -2295,10 +2283,10 @@ fn gen_arm(
                     ("", String::new())
                 };
                 match type_sub_len(in_t[1]) {
-                    1 => format!("{}(a{}, b{})", current_fn, cast, size),
-                    2 => format!("{}(a{}, b.0, b.1{})", current_fn, cast, size),
-                    3 => format!("{}(a{}, b.0, b.1, b.2{})", current_fn, cast, size),
-                    4 => format!("{}(a{}, b.0, b.1, b.2, b.3{})", current_fn, cast, size),
+                    1 => format!("{current_fn}(a{cast}, b{size})"),
+                    2 => format!("{current_fn}(a{cast}, b.0, b.1{size})"),
+                    3 => format!("{current_fn}(a{cast}, b.0, b.1, b.2{size})"),
+                    4 => format!("{current_fn}(a{cast}, b.0, b.1, b.2, b.3{size})"),
                     _ => String::new(),
                 }
             } else if link_arm.is_some() && is_vldx(&name) {
@@ -2345,31 +2333,31 @@ fn gen_arm(
                             cnt.push_str(&const_aarch64);
                         }
                         cnt.push_str(")");
-                        format!("{}(a, {})", current_fn, cnt)
+                        format!("{current_fn}(a, {cnt})")
                     } else {
                         match para_num {
-                            1 => format!("{}(a, {})", current_fn, const_aarch64),
-                            2 => format!("{}(a, b, {})", current_fn, const_aarch64),
+                            1 => format!("{current_fn}(a, {const_aarch64})"),
+                            2 => format!("{current_fn}(a, b, {const_aarch64})"),
                             _ => String::new(),
                         }
                     }
                 } else if out_t != link_aarch64_t[3] {
                     match para_num {
-                        1 => format!("transmute({}(a))", current_fn,),
-                        2 => format!("transmute({}(a, b))", current_fn,),
+                        1 => format!("transmute({current_fn}(a))",),
+                        2 => format!("transmute({current_fn}(a, b))",),
                         _ => String::new(),
                     }
                 } else if matches!(fn_type, Fntype::Store) {
                     let cast = if is_vstx(&name) { " as _" } else { "" };
                     match type_sub_len(in_t[1]) {
-                        1 => format!("{}(b, a{})", current_fn, cast),
-                        2 => format!("{}(b.0, b.1, a{})", current_fn, cast),
-                        3 => format!("{}(b.0, b.1, b.2, a{})", current_fn, cast),
-                        4 => format!("{}(b.0, b.1, b.2, b.3, a{})", current_fn, cast),
+                        1 => format!("{current_fn}(b, a{cast})"),
+                        2 => format!("{current_fn}(b.0, b.1, a{cast})"),
+                        3 => format!("{current_fn}(b.0, b.1, b.2, a{cast})"),
+                        4 => format!("{current_fn}(b.0, b.1, b.2, b.3, a{cast})"),
                         _ => String::new(),
                     }
                 } else if link_aarch64.is_some() && is_vldx(&name) {
-                    format!("{}(a as _)", current_fn)
+                    format!("{current_fn}(a as _)")
                 } else {
                     String::new()
                 };
@@ -2421,7 +2409,7 @@ fn gen_arm(
     } else {
         let call = {
             let stmts = match (multi_calls.len(), para_num, fixed.len()) {
-                (0, 1, 0) => format!(r#"{}{}(a)"#, ext_c, current_fn,),
+                (0, 1, 0) => format!(r#"{ext_c}{current_fn}(a)"#,),
                 (0, 1, _) => {
                     let fixed: Vec<String> =
                         fixed.iter().take(type_len(in_t[0])).cloned().collect();
@@ -2433,11 +2421,11 @@ fn gen_arm(
                         current_fn,
                     )
                 }
-                (0, 2, _) => format!(r#"{}{}(a, b)"#, ext_c, current_fn,),
-                (0, 3, _) => format!(r#"{}{}(a, b, c)"#, ext_c, current_fn,),
-                (_, 1, _) => format!(r#"{}{}"#, ext_c, multi_calls,),
-                (_, 2, _) => format!(r#"{}{}"#, ext_c, multi_calls,),
-                (_, 3, _) => format!(r#"{}{}"#, ext_c, multi_calls,),
+                (0, 2, _) => format!(r#"{ext_c}{current_fn}(a, b)"#,),
+                (0, 3, _) => format!(r#"{ext_c}{current_fn}(a, b, c)"#,),
+                (_, 1, _) => format!(r#"{ext_c}{multi_calls}"#,),
+                (_, 2, _) => format!(r#"{ext_c}{multi_calls}"#,),
+                (_, 3, _) => format!(r#"{ext_c}{multi_calls}"#,),
                 (_, _, _) => String::new(),
             };
             if stmts != String::new() {
@@ -2452,8 +2440,8 @@ fn gen_arm(
             }
         };
         let stable_aarch64 = match target {
-            Default | ArmV7 | Vfp4 | FPArmV8 | AES => String::from("\n#[cfg_attr(target_arch = \"aarch64\", stable(feature = \"neon_intrinsics\", since = \"1.59.0\"))]"),
-            RDM => String::from("\n#[cfg_attr(target_arch = \"aarch64\", stable(feature = \"rdm_intrinsics\", since = \"1.62.0\"))]"),
+            Default | ArmV7 | Vfp4 | FPArmV8 | AES => String::from("\n#[cfg_attr(not(target_arch = \"arm\"), stable(feature = \"neon_intrinsics\", since = \"1.59.0\"))]"),
+            RDM => String::from("\n#[cfg_attr(not(target_arch = \"arm\"), stable(feature = \"rdm_intrinsics\", since = \"1.62.0\"))]"),
             _ => String::new(),
         };
         let function_doc = create_doc_string(current_comment, &name);
@@ -2536,9 +2524,9 @@ fn expand_intrinsic(intr: &str, t: &str) -> String {
             "poly64x1_t" => "i64x1",
             "poly64x2_t" => "i64x2",
             */
-            _ => panic!("unknown type for extension: {}", t),
+            _ => panic!("unknown type for extension: {t}"),
         };
-        format!(r#""{}{}""#, intr, ext)
+        format!(r#""{intr}{ext}""#)
     } else if intr.ends_with(".s") {
         let ext = match t {
             "int8x8_t" => "s8",
@@ -2571,9 +2559,9 @@ fn expand_intrinsic(intr: &str, t: &str) -> String {
             "poly64x1_t" => "i64x1",
             "poly64x2_t" => "i64x2",
             */
-            _ => panic!("unknown type for extension: {}", t),
+            _ => panic!("unknown type for extension: {t}"),
         };
-        format!(r#""{}{}""#, &intr[..intr.len() - 1], ext)
+        format!(r#""{}{ext}""#, &intr[..intr.len() - 1])
     } else if intr.ends_with(".l") {
         let ext = match t {
             "int8x8_t" => "8",
@@ -2604,9 +2592,9 @@ fn expand_intrinsic(intr: &str, t: &str) -> String {
             "float64x2_t" => "64",
             "poly64x1_t" => "64",
             "poly64x2_t" => "64",
-            _ => panic!("unknown type for extension: {}", t),
+            _ => panic!("unknown type for extension: {t}"),
         };
-        format!(r#""{}{}""#, &intr[..intr.len() - 1], ext)
+        format!(r#""{}{ext}""#, &intr[..intr.len() - 1])
     } else {
         intr.to_string()
     }
@@ -2655,7 +2643,7 @@ fn get_call(
             "halflen" => type_len(in_t[1]) / 2,
             _ => 0,
         };
-        let mut s = format!("{} [", const_declare);
+        let mut s = format!("{const_declare} [");
         for i in 0..len {
             if i != 0 {
                 s.push_str(", ");
@@ -2693,9 +2681,9 @@ fn get_call(
                 if i != 0 || j != 0 {
                     s.push_str(", ");
                 }
-                s.push_str(&format!("{} * {} as u32", base_len, &fn_format[2]));
+                s.push_str(&format!("{base_len} * {} as u32", &fn_format[2]));
                 if j != 0 {
-                    s.push_str(&format!(" + {}", j));
+                    s.push_str(&format!(" + {j}"));
                 }
             }
         }
@@ -2709,7 +2697,7 @@ fn get_call(
             "in_ttn" => type_to_native_type(in_t[1]),
             _ => String::new(),
         };
-        return format!("{} as {}", &fn_format[1], t);
+        return format!("{} as {t}", &fn_format[1]);
     }
     if fn_name.starts_with("ins") {
         let fn_format: Vec<_> = fn_name.split('-').map(|v| v.to_string()).collect();
@@ -2726,7 +2714,7 @@ fn get_call(
             "in0_len" => type_len(in_t[0]),
             _ => 0,
         };
-        let mut s = format!("{} [", const_declare);
+        let mut s = format!("{const_declare} [");
         for i in 0..len {
             if i != 0 {
                 s.push_str(", ");
@@ -2760,7 +2748,7 @@ fn get_call(
                 fn_format[2], fn_format[2]
             );
         } else {
-            return format!(r#"static_assert_imm{}!({});"#, len, fn_format[2]);
+            return format!(r#"static_assert_imm{len}!({});"#, fn_format[2]);
         }
     }
     if fn_name.starts_with("static_assert") {
@@ -2781,13 +2769,13 @@ fn get_call(
         };
         if lim1 == lim2 {
             return format!(
-                r#"static_assert!({} : i32 where {} == {});"#,
-                fn_format[1], fn_format[1], lim1
+                r#"static_assert!({} : i32 where {} == {lim1});"#,
+                fn_format[1], fn_format[1]
             );
         } else {
             return format!(
-                r#"static_assert!({} : i32 where {} >= {} && {} <= {});"#,
-                fn_format[1], fn_format[1], lim1, fn_format[1], lim2
+                r#"static_assert!({} : i32 where {} >= {lim1} && {} <= {lim2});"#,
+                fn_format[1], fn_format[1], fn_format[1]
             );
         }
     }
@@ -2945,7 +2933,7 @@ fn get_call(
     if fn_name == "fixed" {
         let (re_name, re_type) = re.unwrap();
         let fixed: Vec<String> = fixed.iter().take(type_len(in_t[1])).cloned().collect();
-        return format!(r#"let {}{};"#, re_name, values(&re_type, &fixed));
+        return format!(r#"let {re_name}{};"#, values(&re_type, &fixed));
     }
     if fn_name == "fixed-half-right" {
         let fixed: Vec<String> = fixed.iter().take(type_len(in_t[1])).cloned().collect();
@@ -3083,9 +3071,9 @@ fn get_call(
             re_name, re_type, fn_name, param_str
         )
     } else if fn_name.starts_with("*") {
-        format!(r#"{} = {};"#, fn_name, param_str)
+        format!(r#"{fn_name} = {param_str};"#)
     } else {
-        format!(r#"{}({})"#, fn_name, param_str)
+        format!(r#"{fn_name}({param_str})"#)
     };
     return fn_str;
 }
@@ -3337,7 +3325,7 @@ mod test {
                     in_t = [spec[0], spec[1], spec[2]];
                     out_t = spec[3];
                 } else {
-                    panic!("Bad spec: {}", line)
+                    panic!("Bad spec: {line}")
                 }
                 if b.len() == 0 {
                     if matches!(fn_type, Fntype::Store) {
@@ -3430,8 +3418,8 @@ mod test {
         .arg(&arm_out_path)
         .arg(&aarch64_out_path)
         .status() {
-            eprintln!("Could not format `{}`: {}", arm_out_path.to_str().unwrap(), e);
-            eprintln!("Could not format `{}`: {}", aarch64_out_path.to_str().unwrap(), e);
+            eprintln!("Could not format `{}`: {e}", arm_out_path.to_str().unwrap());
+            eprintln!("Could not format `{}`: {e}", aarch64_out_path.to_str().unwrap());
     };
     */
     Ok(())