Update generator to facilitate big endian

Author: Jamesbarford

Diff for: crates/stdarch-gen-arm/src/big_endian.rs

@@ -0,0 +1,221 @@
+use crate::expression::LetVariant;
+use crate::wildstring::WildStringPart;
+use crate::{
+    expression::{Expression, IdentifierType},
+    typekinds::*,
+    wildstring::WildString,
+};
+
+/// Simplifies creating a string that can be used in an Expression, as Expression
+/// expects all strings to be `WildString`
+fn create_single_wild_string(name: &str) -> WildString {
+    WildString(vec![WildStringPart::String(name.to_string())])
+}
+
+/// Creates an Identifier with name `name` with no wildcards. This, for example,
+/// can be used to create variables, function names or arbitrary input. Is is
+/// extremely flexible.
+pub fn create_symbol_identifier(arbitrary_string: &str) -> Expression {
+    let identifier_name = create_single_wild_string(arbitrary_string);
+    Expression::Identifier(identifier_name, IdentifierType::Symbol)
+}
+
+/// To compose the simd_shuffle! call we need:
+/// - simd_shuffle!(<arg1>, <arg2>, <array>)
+///
+/// Here we are creating a string version of the `<array>` that can be used as an
+/// Expression Identifier
+///
+/// In textual form `a: int32x4_t` which has 4 lanes would generate:
+/// ```
+/// [0, 1, 2, 3]
+/// ```
+fn create_array(lanes: u32, reverse: bool) -> Option<String> {
+    if reverse {
+        match lanes {
+            1 => None, /* Makes no sense to shuffle an array of size 1 */
+            2 => Some("[1, 0]".to_string()),
+            3 => Some("[2, 1, 0]".to_string()),
+            4 => Some("[3, 2, 1, 0]".to_string()),
+            8 => Some("[7, 6, 5, 4, 3, 2, 1, 0]".to_string()),
+            16 => Some("[15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]".to_string()),
+            _ => panic!("Incorrect vector number of vector lanes: {}", lanes),
+        }
+    } else {
+        match lanes {
+            1 => None, /* Makes no sense to shuffle an array of size 1 */
+            2 => Some("[0, 1]".to_string()),
+            3 => Some("[0, 1, 2]".to_string()),
+            4 => Some("[0, 1, 2, 3]".to_string()),
+            8 => Some("[0, 1, 2, 3, 4, 5, 6, 7]".to_string()),
+            16 => Some("[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]".to_string()),
+            _ => panic!("Incorrect vector number of vector lanes: {}", lanes),
+        }
+    }
+}
+
+/// Creates: `let <variable_name>: <type> = <expression>`
+pub fn create_let_variable(
+    variable_name: &str,
+    type_kind: &TypeKind,
+    expression: Expression,
+) -> Expression {
+    let identifier_name = create_single_wild_string(variable_name);
+    Expression::Let(LetVariant::WithType(
+        identifier_name,
+        type_kind.clone(),
+        Box::new(expression),
+    ))
+}
+
+pub fn create_mut_let_variable(
+    variable_name: &str,
+    type_kind: &TypeKind,
+    expression: Expression,
+) -> Expression {
+    let identifier_name = create_single_wild_string(variable_name);
+    Expression::Let(LetVariant::MutWithType(
+        identifier_name,
+        type_kind.clone(),
+        Box::new(expression),
+    ))
+}
+
+pub fn type_has_tuple(type_kind: &TypeKind) -> bool {
+    if let TypeKind::Vector(vector_type) = type_kind {
+        vector_type.tuple_size().is_some()
+    } else {
+        false
+    }
+}
+
+pub fn make_variable_mutable(variable_name: &str, type_kind: &TypeKind) -> Expression {
+    let mut_variable = format!(
+        "let mut {}: {} = {}",
+        variable_name,
+        type_kind.to_string(),
+        variable_name
+    );
+    let identifier_name = create_single_wild_string(&mut_variable);
+    Expression::Identifier(identifier_name, IdentifierType::Symbol)
+}
+
+/// For creating shuffle calls, accepts function pointers for formatting for tuple
+/// types and types without a tuple
+///
+/// Example:
+///
+/// `a: int32x4_t` with formatting function `create_shuffle_call_fmt` creates:
+/// ```
+/// simd_shuffle!(a, a, [0, 1, 2, 3])
+/// ```
+///
+/// `a: int32x4x2_t` creates:
+/// ```
+/// a.0 = simd_shuffle!(a.0, a.0, [0, 1, 2, 3])
+/// a.1 = simd_shuffle!(a.1, a.1, [0, 1, 2, 3])
+/// ```
+fn create_shuffle_internal(
+    variable_name: &String,
+    type_kind: &TypeKind,
+    reverse: bool,
+    fmt_tuple: fn(variable_name: &String, idx: u32, array_lanes: &String) -> String,
+    fmt: fn(variable_name: &String, type_kind: &TypeKind, array_lanes: &String) -> String,
+) -> Option<Expression> {
+    let TypeKind::Vector(vector_type) = type_kind else {
+        return None;
+    };
+
+    let lane_count = vector_type.lanes();
+    let Some(array_lanes) = create_array(lane_count, reverse) else {
+        return None;
+    };
+
+    let tuple_count = vector_type.tuple_size().map_or_else(|| 0, |t| t.to_int());
+
+    if tuple_count > 0 {
+        let capacity_estimate: usize =
+            tuple_count as usize * (lane_count as usize + ((variable_name.len() + 2) * 3));
+        let mut string_builder = String::with_capacity(capacity_estimate);
+
+        /* <var_name>.idx = simd_shuffle!(<var_name>.idx, <var_name>.idx, [<indexes>]) */
+        for idx in 0..tuple_count {
+            let formatted = fmt_tuple(variable_name, idx, &array_lanes);
+            string_builder += formatted.as_str();
+        }
+        Some(create_symbol_identifier(&string_builder))
+    } else {
+        /* Generate a list of shuffles for each tuple */
+        let expression = fmt(variable_name, type_kind, &array_lanes);
+        Some(create_symbol_identifier(&expression))
+    }
+}
+
+fn create_assigned_tuple_shuffle_call_fmt(
+    variable_name: &String,
+    idx: u32,
+    array_lanes: &String,
+) -> String {
+    format!(
+        "{variable_name}.{idx} = simd_shuffle!({variable_name}.{idx}, {variable_name}.{idx}, {array_lanes});\n",
+        variable_name = variable_name,
+        idx = idx,
+        array_lanes = array_lanes
+    )
+}
+
+fn create_assigned_shuffle_call_fmt(
+    variable_name: &String,
+    type_kind: &TypeKind,
+    array_lanes: &String,
+) -> String {
+    format!(
+        "let {variable_name}: {type_kind} = simd_shuffle!({variable_name}, {variable_name}, {array_lanes})",
+        type_kind = type_kind.to_string(),
+        variable_name = variable_name,
+        array_lanes = array_lanes
+    )
+}
+
+fn create_shuffle_call_fmt(
+    variable_name: &String,
+    _type_kind: &TypeKind,
+    array_lanes: &String,
+) -> String {
+    format!(
+        "simd_shuffle!({variable_name}, {variable_name}, {array_lanes})",
+        variable_name = variable_name,
+        array_lanes = array_lanes
+    )
+}
+
+/// Create a `simd_shuffle!(<...>, [...])` call, where the output is stored
+/// in a variable named `variable_name`
+pub fn create_assigned_shuffle_call(
+    variable_name: &String,
+    type_kind: &TypeKind,
+    reverse: bool,
+) -> Option<Expression> {
+    create_shuffle_internal(
+        variable_name,
+        type_kind,
+        reverse,
+        create_assigned_tuple_shuffle_call_fmt,
+        create_assigned_shuffle_call_fmt,
+    )
+}
+
+/// Create a `simd_shuffle!(<...>, [...])` call
+pub fn create_shuffle_call(
+    variable_name: &String,
+    type_kind: &TypeKind,
+    reverse: bool,
+) -> Option<Expression> {
+    create_shuffle_internal(
+        variable_name,
+        type_kind,
+        reverse,
+        create_assigned_tuple_shuffle_call_fmt,
+        create_shuffle_call_fmt,
+    )
+}

Diff for: crates/stdarch-gen-arm/src/context.rs

@@ -35,6 +35,10 @@ pub struct GlobalContext {
     pub arch_cfgs: Vec<ArchitectureSettings>,
     #[serde(default)]
     pub uses_neon_types: bool,
+
+    /// Should the yaml file automagically generate big endian shuffling
+    #[serde(default)]
+    pub auto_big_endian: Option<bool>,
 }
 
 /// Context of an intrinsic group

Diff for: crates/stdarch-gen-arm/src/expression.rs

@@ -9,6 +9,7 @@ use std::fmt;
 use std::str::FromStr;
 
 use crate::intrinsic::Intrinsic;
+use crate::wildstring::WildStringPart;
 use crate::{
     context::{self, Context, VariableType},
     intrinsic::{Argument, LLVMLink, StaticDefinition},
@@ -29,6 +30,7 @@ pub enum IdentifierType {
 pub enum LetVariant {
     Basic(WildString, Box<Expression>),
     WithType(WildString, TypeKind, Box<Expression>),
+    MutWithType(WildString, TypeKind, Box<Expression>),
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -155,9 +157,11 @@ impl Expression {
                 cl_ptr_ex.pre_build(ctx)?;
                 arg_exs.iter_mut().try_for_each(|ex| ex.pre_build(ctx))
             }
-            Self::Let(LetVariant::Basic(_, ex) | LetVariant::WithType(_, _, ex)) => {
-                ex.pre_build(ctx)
-            }
+            Self::Let(
+                LetVariant::Basic(_, ex)
+                | LetVariant::WithType(_, _, ex)
+                | LetVariant::MutWithType(_, _, ex),
+            ) => ex.pre_build(ctx),
             Self::CastAs(ex, _) => ex.pre_build(ctx),
             Self::Multiply(lhs, rhs) | Self::Xor(lhs, rhs) => {
                 lhs.pre_build(ctx)?;
@@ -214,7 +218,8 @@ impl Expression {
             Self::Let(variant) => {
                 let (var_name, ex, ty) = match variant {
                     LetVariant::Basic(var_name, ex) => (var_name, ex, None),
-                    LetVariant::WithType(var_name, ty, ex) => {
+                    LetVariant::WithType(var_name, ty, ex)
+                    | LetVariant::MutWithType(var_name, ty, ex) => {
                         if let Some(w) = ty.wildcard() {
                             ty.populate_wildcard(ctx.local.provide_type_wildcard(w)?)?;
                         }
@@ -285,9 +290,11 @@ impl Expression {
             // Nested structures that aren't inherently unsafe, but could contain other expressions
             // that might be.
             Self::Assign(_var, exp) => exp.requires_unsafe_wrapper(ctx_fn),
-            Self::Let(LetVariant::Basic(_, exp) | LetVariant::WithType(_, _, exp)) => {
-                exp.requires_unsafe_wrapper(ctx_fn)
-            }
+            Self::Let(
+                LetVariant::Basic(_, exp)
+                | LetVariant::WithType(_, _, exp)
+                | LetVariant::MutWithType(_, _, exp),
+            ) => exp.requires_unsafe_wrapper(ctx_fn),
             Self::Array(exps) => exps.iter().any(|exp| exp.requires_unsafe_wrapper(ctx_fn)),
             Self::Multiply(lhs, rhs) | Self::Xor(lhs, rhs) => {
                 lhs.requires_unsafe_wrapper(ctx_fn) || rhs.requires_unsafe_wrapper(ctx_fn)
@@ -330,6 +337,32 @@ impl Expression {
             }
         }
     }
+
+    /// Determine if an expression is a `static_assert<...>` function call.
+    pub fn is_static_assert(&self) -> bool {
+        match self {
+            Expression::FnCall(fn_call) => match fn_call.0.as_ref() {
+                Expression::Identifier(wild_string, _) => {
+                    if let WildStringPart::String(function_name) = &wild_string.0[0] {
+                        function_name.starts_with("static_assert")
+                    } else {
+                        false
+                    }
+                }
+                _ => panic!("Badly defined function call: {:?}", fn_call),
+            },
+            _ => false,
+        }
+    }
+
+    /// Determine if an espression is a LLVM binding
+    pub fn is_llvm_link(&self) -> bool {
+        if let Expression::LLVMLink(_) = self {
+            true
+        } else {
+            false
+        }
+    }
 }
 
 impl FromStr for Expression {
@@ -422,6 +455,10 @@ impl ToTokens for Expression {
                 let var_ident = format_ident!("{}", var_name.to_string());
                 tokens.append_all(quote! { let #var_ident: #ty = #exp })
             }
+            Self::Let(LetVariant::MutWithType(var_name, ty, exp)) => {
+                let var_ident = format_ident!("{}", var_name.to_string());
+                tokens.append_all(quote! { let mut #var_ident: #ty = #exp })
+            }
             Self::Assign(var_name, exp) => {
                 /* If we are dereferencing a variable to assign a value \
                  * the 'format_ident!' macro does not like the asterix */