1 // Copyright 2024, Linaro Limited 2 // Author(s): Manos Pitsidianakis <manos.pitsidianakis@linaro.org> 3 // SPDX-License-Identifier: GPL-2.0-or-later 4 5 use proc_macro::TokenStream; 6 use quote::quote; 7 use syn::{ 8 parse_macro_input, parse_quote, punctuated::Punctuated, spanned::Spanned, token::Comma, Data, 9 DeriveInput, Field, Fields, FieldsUnnamed, Ident, Meta, Path, Token, Variant, 10 }; 11 12 mod utils; 13 use utils::MacroError; 14 15 mod bits; 16 use bits::BitsConstInternal; 17 18 fn get_fields<'a>( 19 input: &'a DeriveInput, 20 msg: &str, 21 ) -> Result<&'a Punctuated<Field, Comma>, MacroError> { 22 let Data::Struct(ref s) = &input.data else { 23 return Err(MacroError::Message( 24 format!("Struct required for {msg}"), 25 input.ident.span(), 26 )); 27 }; 28 let Fields::Named(ref fs) = &s.fields else { 29 return Err(MacroError::Message( 30 format!("Named fields required for {msg}"), 31 input.ident.span(), 32 )); 33 }; 34 Ok(&fs.named) 35 } 36 37 fn get_unnamed_field<'a>(input: &'a DeriveInput, msg: &str) -> Result<&'a Field, MacroError> { 38 let Data::Struct(ref s) = &input.data else { 39 return Err(MacroError::Message( 40 format!("Struct required for {msg}"), 41 input.ident.span(), 42 )); 43 }; 44 let Fields::Unnamed(FieldsUnnamed { ref unnamed, .. }) = &s.fields else { 45 return Err(MacroError::Message( 46 format!("Tuple struct required for {msg}"), 47 s.fields.span(), 48 )); 49 }; 50 if unnamed.len() != 1 { 51 return Err(MacroError::Message( 52 format!("A single field is required for {msg}"), 53 s.fields.span(), 54 )); 55 } 56 Ok(&unnamed[0]) 57 } 58 59 fn is_c_repr(input: &DeriveInput, msg: &str) -> Result<(), MacroError> { 60 let expected = parse_quote! { #[repr(C)] }; 61 62 if input.attrs.iter().any(|attr| attr == &expected) { 63 Ok(()) 64 } else { 65 Err(MacroError::Message( 66 format!("#[repr(C)] required for {msg}"), 67 input.ident.span(), 68 )) 69 } 70 } 71 72 fn is_transparent_repr(input: &DeriveInput, msg: &str) -> Result<(), MacroError> { 73 let expected = parse_quote! { #[repr(transparent)] }; 74 75 if input.attrs.iter().any(|attr| attr == &expected) { 76 Ok(()) 77 } else { 78 Err(MacroError::Message( 79 format!("#[repr(transparent)] required for {msg}"), 80 input.ident.span(), 81 )) 82 } 83 } 84 85 fn derive_object_or_error(input: DeriveInput) -> Result<proc_macro2::TokenStream, MacroError> { 86 is_c_repr(&input, "#[derive(Object)]")?; 87 88 let name = &input.ident; 89 let parent = &get_fields(&input, "#[derive(Object)]")?[0].ident; 90 91 Ok(quote! { 92 ::qemu_api::assert_field_type!(#name, #parent, 93 ::qemu_api::qom::ParentField<<#name as ::qemu_api::qom::ObjectImpl>::ParentType>); 94 95 ::qemu_api::module_init! { 96 MODULE_INIT_QOM => unsafe { 97 ::qemu_api::bindings::type_register_static(&<#name as ::qemu_api::qom::ObjectImpl>::TYPE_INFO); 98 } 99 } 100 }) 101 } 102 103 #[proc_macro_derive(Object)] 104 pub fn derive_object(input: TokenStream) -> TokenStream { 105 let input = parse_macro_input!(input as DeriveInput); 106 let expanded = derive_object_or_error(input).unwrap_or_else(Into::into); 107 108 TokenStream::from(expanded) 109 } 110 111 fn derive_opaque_or_error(input: DeriveInput) -> Result<proc_macro2::TokenStream, MacroError> { 112 is_transparent_repr(&input, "#[derive(Wrapper)]")?; 113 114 let name = &input.ident; 115 let field = &get_unnamed_field(&input, "#[derive(Wrapper)]")?; 116 let typ = &field.ty; 117 118 // TODO: how to add "::qemu_api"? For now, this is only used in the 119 // qemu_api crate so it's not a problem. 120 Ok(quote! { 121 unsafe impl crate::cell::Wrapper for #name { 122 type Wrapped = <#typ as crate::cell::Wrapper>::Wrapped; 123 } 124 impl #name { 125 pub unsafe fn from_raw<'a>(ptr: *mut <Self as crate::cell::Wrapper>::Wrapped) -> &'a Self { 126 let ptr = ::std::ptr::NonNull::new(ptr).unwrap().cast::<Self>(); 127 unsafe { ptr.as_ref() } 128 } 129 130 pub const fn as_mut_ptr(&self) -> *mut <Self as crate::cell::Wrapper>::Wrapped { 131 self.0.as_mut_ptr() 132 } 133 134 pub const fn as_ptr(&self) -> *const <Self as crate::cell::Wrapper>::Wrapped { 135 self.0.as_ptr() 136 } 137 138 pub const fn as_void_ptr(&self) -> *mut ::core::ffi::c_void { 139 self.0.as_void_ptr() 140 } 141 142 pub const fn raw_get(slot: *mut Self) -> *mut <Self as crate::cell::Wrapper>::Wrapped { 143 slot.cast() 144 } 145 } 146 }) 147 } 148 149 #[proc_macro_derive(Wrapper)] 150 pub fn derive_opaque(input: TokenStream) -> TokenStream { 151 let input = parse_macro_input!(input as DeriveInput); 152 let expanded = derive_opaque_or_error(input).unwrap_or_else(Into::into); 153 154 TokenStream::from(expanded) 155 } 156 157 #[allow(non_snake_case)] 158 fn get_repr_uN(input: &DeriveInput, msg: &str) -> Result<Path, MacroError> { 159 let repr = input.attrs.iter().find(|attr| attr.path().is_ident("repr")); 160 if let Some(repr) = repr { 161 let nested = repr.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; 162 for meta in nested { 163 match meta { 164 Meta::Path(path) if path.is_ident("u8") => return Ok(path), 165 Meta::Path(path) if path.is_ident("u16") => return Ok(path), 166 Meta::Path(path) if path.is_ident("u32") => return Ok(path), 167 Meta::Path(path) if path.is_ident("u64") => return Ok(path), 168 _ => {} 169 } 170 } 171 } 172 173 Err(MacroError::Message( 174 format!("#[repr(u8/u16/u32/u64) required for {msg}"), 175 input.ident.span(), 176 )) 177 } 178 179 fn get_variants(input: &DeriveInput) -> Result<&Punctuated<Variant, Comma>, MacroError> { 180 let Data::Enum(ref e) = &input.data else { 181 return Err(MacroError::Message( 182 "Cannot derive TryInto for union or struct.".to_string(), 183 input.ident.span(), 184 )); 185 }; 186 if let Some(v) = e.variants.iter().find(|v| v.fields != Fields::Unit) { 187 return Err(MacroError::Message( 188 "Cannot derive TryInto for enum with non-unit variants.".to_string(), 189 v.fields.span(), 190 )); 191 } 192 Ok(&e.variants) 193 } 194 195 #[rustfmt::skip::macros(quote)] 196 fn derive_tryinto_or_error(input: DeriveInput) -> Result<proc_macro2::TokenStream, MacroError> { 197 let repr = get_repr_uN(&input, "#[derive(TryInto)]")?; 198 199 let name = &input.ident; 200 let variants = get_variants(&input)?; 201 let discriminants: Vec<&Ident> = variants.iter().map(|f| &f.ident).collect(); 202 203 Ok(quote! { 204 impl core::convert::TryFrom<#repr> for #name { 205 type Error = #repr; 206 207 fn try_from(value: #repr) -> Result<Self, Self::Error> { 208 #(const #discriminants: #repr = #name::#discriminants as #repr;)*; 209 match value { 210 #(#discriminants => Ok(Self::#discriminants),)* 211 _ => Err(value), 212 } 213 } 214 } 215 }) 216 } 217 218 #[proc_macro_derive(TryInto)] 219 pub fn derive_tryinto(input: TokenStream) -> TokenStream { 220 let input = parse_macro_input!(input as DeriveInput); 221 let expanded = derive_tryinto_or_error(input).unwrap_or_else(Into::into); 222 223 TokenStream::from(expanded) 224 } 225 226 #[proc_macro] 227 pub fn bits_const_internal(ts: TokenStream) -> TokenStream { 228 let ts = proc_macro2::TokenStream::from(ts); 229 let mut it = ts.into_iter(); 230 231 let expanded = BitsConstInternal::parse(&mut it).unwrap_or_else(Into::into); 232 TokenStream::from(expanded) 233 } 234