Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1b2efbc1 authored by Martin Geisler's avatar Martin Geisler
Browse files

pdl: replace helpers with new ‘types’ module 

This replaces a few helpers with a new ‘Integer’ struct. This struct
implements ‘ToTokens’ and gives convenient access to the its width.

Test: atest pdl_tests pdl_inline_tests
Change-Id: Ibe2521367e92207969657f59b1cc5b6f5754a6f1
parent 5371ea12

tools/pdl/src/backends/rust.rs

+15 −52
Original line number Diff line number Diff line
@@ -15,6 +15,7 @@ use std::path::Path; 
use syn::parse_quote;



mod preamble;

mod types;



/// Generate a block of code.

///
@@ -27,32 +28,11 @@ macro_rules! quote_block { 
    }

}



/// Get the Rust integer type for the given bit width.

///

/// This will round up the size to the nearest Rust integer size. PDL

/// supports integers up to 64 bit, so it is an error to call this

/// with a width larger than 64.

fn rust_integer_type(width: usize) -> usize {

    for integer_width in [8, 16, 32, 64] {

        if width <= integer_width {

            return integer_width;

        }

    }

    panic!("unsupported field width: {width}")

}



/// Generate a Rust unsigned integer type large enough to hold

/// integers of the given bit width.

fn type_for_width(width: usize) -> syn::Type {

    let integer_width = rust_integer_type(width);

    syn::parse_str(&format!("u{integer_width}")).unwrap()

}



fn generate_field(field: &ast::Field, visibility: syn::Visibility) -> proc_macro2::TokenStream {

    match field {

        ast::Field::Scalar { id, width, .. } => {

            let field_name = format_ident!("{id}");

            let field_type = type_for_width(*width);

            let field_type = types::Integer::new(*width);

            quote! {

                #visibility #field_name: #field_type

            }
@@ -67,7 +47,7 @@ fn generate_field_getter(packet_name: &syn::Ident, field: &ast::Field) -> proc_m 
            // TODO(mgeisler): refactor with generate_field above.

            let getter_name = format_ident!("get_{id}");

            let field_name = format_ident!("{id}");

            let field_type = type_for_width(*width);

            let field_type = types::Integer::new(*width);

            quote! {

                pub fn #getter_name(&self) -> #field_type {

                    self.#packet_name.as_ref().#field_name
@@ -112,8 +92,7 @@ fn generate_chunk_read( 
        _ => format_ident!("chunk"),

    };

    let chunk_width = get_chunk_width(chunk);

    let chunk_type = type_for_width(chunk_width);

    let chunk_type_width = rust_integer_type(chunk_width);

    let chunk_type = types::Integer::new(chunk_width);

    assert!(chunk_width % 8 == 0, "Chunks must have a byte size, got width: {chunk_width}");



    let range = get_field_range(offset, chunk_width);
@@ -147,10 +126,10 @@ fn generate_chunk_read( 
        _ => todo!("unsupported field: {:?}", field),

    });



    // When the chunk_type_width is larger than chunk_width (e.g.

    // chunk_width is 24 but chunk_type_width is 32), then we need

    // When the chunk_type.width is larger than chunk_width (e.g.

    // chunk_width is 24 but chunk_type.width is 32), then we need

    // zero padding.

    let zero_padding_len = (chunk_type_width - chunk_width) / 8;

    let zero_padding_len = (chunk_type.width - chunk_width) / 8;

    // We need the padding on the MSB side of the payload, so for

    // big-endian, we need to padding on the left, for little-endian

    // we need it on the right.
@@ -175,7 +154,7 @@ fn generate_chunk_read_field_adjustments(fields: &[ast::Field]) -> proc_macro2:: 
    }



    let chunk_width = get_chunk_width(fields);

    let chunk_type_width = rust_integer_type(chunk_width);

    let chunk_type = types::Integer::new(chunk_width);



    let mut field_parsers = Vec::new();

    let mut field_offset = 0;
@@ -183,8 +162,7 @@ fn generate_chunk_read_field_adjustments(fields: &[ast::Field]) -> proc_macro2:: 
        match field {

            ast::Field::Scalar { id, width, .. } => {

                let field_name = format_ident!("{id}");

                let field_type = type_for_width(*width);

                let field_type_width = rust_integer_type(*width);

                let field_type = types::Integer::new(*width);



                let mut field = quote! {

                    chunk
@@ -197,14 +175,14 @@ fn generate_chunk_read_field_adjustments(fields: &[ast::Field]) -> proc_macro2:: 
                    };

                }



                if *width < field_type_width {

                if *width < field_type.width {

                    let bit_mask = mask_bits(*width);

                    field = quote! {

                        (#field & #bit_mask)

                    };

                }



                if field_type_width < chunk_type_width {

                if field_type.width < chunk_type.width {

                    field = quote! {

                        #field as #field_type;

                    };
@@ -237,8 +215,7 @@ fn generate_chunk_write_field_adjustments(chunk: &[ast::Field]) -> proc_macro2:: 
    }



    let chunk_width = get_chunk_width(chunk);

    let chunk_type = type_for_width(chunk_width);

    let chunk_type_width = rust_integer_type(chunk_width);

    let chunk_type = types::Integer::new(chunk_width);



    let mut field_parsers = Vec::new();

    let mut field_offset = 0;
@@ -246,19 +223,19 @@ fn generate_chunk_write_field_adjustments(chunk: &[ast::Field]) -> proc_macro2:: 
        match field {

            ast::Field::Scalar { id, width, .. } => {

                let field_name = format_ident!("{id}");

                let field_type_width = rust_integer_type(*width);

                let field_type = types::Integer::new(*width);



                let mut field = quote! {

                    self.#field_name

                };



                if field_type_width < chunk_type_width {

                if field_type.width < chunk_type.width {

                    field = quote! {

                        (#field as #chunk_type)

                    };

                }



                if *width < field_type_width {

                if *width < field_type.width {

                    let bit_mask = mask_bits(*width);

                    field = quote! {

                        (#field & #bit_mask)
@@ -745,20 +722,6 @@ mod tests { 
        );

    }



    #[test]

    fn test_rust_integer_type() {

        assert_eq!(rust_integer_type(0), 8);

        assert_eq!(rust_integer_type(8), 8);

        assert_eq!(rust_integer_type(9), 16);

        assert_eq!(rust_integer_type(64), 64);

    }



    #[test]

    #[should_panic]

    fn test_rust_integer_type_panics_on_large_width() {

        rust_integer_type(65);

    }



    #[test]

    fn test_get_field_range() {

        // Zero widths will give you an empty slice iff the offset is

tools/pdl/src/backends/rust/types.rs

0 → 100644
+49 −0
Original line number Diff line number Diff line 
//! Utility functions for dealing with Rust integer types.



/// A Rust integer type such as `u8`.

pub struct Integer {

    pub width: usize,

}



impl Integer {

    /// Get the Rust integer type for the given bit width.

    ///

    /// This will round up the size to the nearest Rust integer size.

    /// PDL supports integers up to 64 bit, so it is an error to call

    /// this with a width larger than 64.

    pub fn new(width: usize) -> Integer {

        for integer_width in [8, 16, 32, 64] {

            if width <= integer_width {

                return Integer { width: integer_width };

            }

        }

        panic!("Cannot construct Integer with width: {width}")

    }

}



impl quote::ToTokens for Integer {

    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {

        let t: syn::Type = syn::parse_str(&format!("u{}", self.width))

            .expect("Could not parse integer, unsupported width?");

        t.to_tokens(tokens);

    }

}



#[cfg(test)]

mod tests {

    use super::*;



    #[test]

    fn test_integer_new() {

        assert_eq!(Integer::new(0).width, 8);

        assert_eq!(Integer::new(8).width, 8);

        assert_eq!(Integer::new(9).width, 16);

        assert_eq!(Integer::new(64).width, 64);

    }



    #[test]

    #[should_panic]

    fn test_integer_new_panics_on_large_width() {

        Integer::new(65);

    }

}