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, Error, Field, Fields, FieldsUnnamed, Ident, Meta, Path, Token, Variant, 10 }; 11 mod bits; 12 use bits::BitsConstInternal; 13 14 #[cfg(test)] 15 mod tests; 16 17 fn get_fields<'a>( 18 input: &'a DeriveInput, 19 msg: &str, 20 ) -> Result<&'a Punctuated<Field, Comma>, Error> { 21 let Data::Struct(ref s) = &input.data else { 22 return Err(Error::new( 23 input.ident.span(), 24 format!("Struct required for {msg}"), 25 )); 26 }; 27 let Fields::Named(ref fs) = &s.fields else { 28 return Err(Error::new( 29 input.ident.span(), 30 format!("Named fields required for {msg}"), 31 )); 32 }; 33 Ok(&fs.named) 34 } 35 36 fn get_unnamed_field<'a>(input: &'a DeriveInput, msg: &str) -> Result<&'a Field, Error> { 37 let Data::Struct(ref s) = &input.data else { 38 return Err(Error::new( 39 input.ident.span(), 40 format!("Struct required for {msg}"), 41 )); 42 }; 43 let Fields::Unnamed(FieldsUnnamed { ref unnamed, .. }) = &s.fields else { 44 return Err(Error::new( 45 s.fields.span(), 46 format!("Tuple struct required for {msg}"), 47 )); 48 }; 49 if unnamed.len() != 1 { 50 return Err(Error::new( 51 s.fields.span(), 52 format!("A single field is required for {msg}"), 53 )); 54 } 55 Ok(&unnamed[0]) 56 } 57 58 fn is_c_repr(input: &DeriveInput, msg: &str) -> Result<(), Error> { 59 let expected = parse_quote! { #[repr(C)] }; 60 61 if input.attrs.iter().any(|attr| attr == &expected) { 62 Ok(()) 63 } else { 64 Err(Error::new( 65 input.ident.span(), 66 format!("#[repr(C)] required for {msg}"), 67 )) 68 } 69 } 70 71 fn is_transparent_repr(input: &DeriveInput, msg: &str) -> Result<(), Error> { 72 let expected = parse_quote! { #[repr(transparent)] }; 73 74 if input.attrs.iter().any(|attr| attr == &expected) { 75 Ok(()) 76 } else { 77 Err(Error::new( 78 input.ident.span(), 79 format!("#[repr(transparent)] required for {msg}"), 80 )) 81 } 82 } 83 84 fn derive_object_or_error(input: DeriveInput) -> Result<proc_macro2::TokenStream, Error> { 85 is_c_repr(&input, "#[derive(Object)]")?; 86 87 let name = &input.ident; 88 let parent = &get_fields(&input, "#[derive(Object)]")?[0].ident; 89 90 Ok(quote! { 91 ::qemu_api::assert_field_type!(#name, #parent, 92 ::qemu_api::qom::ParentField<<#name as ::qemu_api::qom::ObjectImpl>::ParentType>); 93 94 ::qemu_api::module_init! { 95 MODULE_INIT_QOM => unsafe { 96 ::qemu_api::bindings::type_register_static(&<#name as ::qemu_api::qom::ObjectImpl>::TYPE_INFO); 97 } 98 } 99 }) 100 } 101 102 #[proc_macro_derive(Object)] 103 pub fn derive_object(input: TokenStream) -> TokenStream { 104 let input = parse_macro_input!(input as DeriveInput); 105 106 derive_object_or_error(input) 107 .unwrap_or_else(syn::Error::into_compile_error) 108 .into() 109 } 110 111 fn derive_opaque_or_error(input: DeriveInput) -> Result<proc_macro2::TokenStream, Error> { 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 153 derive_opaque_or_error(input) 154 .unwrap_or_else(syn::Error::into_compile_error) 155 .into() 156 } 157 158 #[allow(non_snake_case)] 159 fn get_repr_uN(input: &DeriveInput, msg: &str) -> Result<Path, Error> { 160 let repr = input.attrs.iter().find(|attr| attr.path().is_ident("repr")); 161 if let Some(repr) = repr { 162 let nested = repr.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?; 163 for meta in nested { 164 match meta { 165 Meta::Path(path) if path.is_ident("u8") => return Ok(path), 166 Meta::Path(path) if path.is_ident("u16") => return Ok(path), 167 Meta::Path(path) if path.is_ident("u32") => return Ok(path), 168 Meta::Path(path) if path.is_ident("u64") => return Ok(path), 169 _ => {} 170 } 171 } 172 } 173 174 Err(Error::new( 175 input.ident.span(), 176 format!("#[repr(u8/u16/u32/u64) required for {msg}"), 177 )) 178 } 179 180 fn get_variants(input: &DeriveInput) -> Result<&Punctuated<Variant, Comma>, Error> { 181 let Data::Enum(ref e) = &input.data else { 182 return Err(Error::new( 183 input.ident.span(), 184 "Cannot derive TryInto for union or struct.", 185 )); 186 }; 187 if let Some(v) = e.variants.iter().find(|v| v.fields != Fields::Unit) { 188 return Err(Error::new( 189 v.fields.span(), 190 "Cannot derive TryInto for enum with non-unit variants.", 191 )); 192 } 193 Ok(&e.variants) 194 } 195 196 #[rustfmt::skip::macros(quote)] 197 fn derive_tryinto_body( 198 name: &Ident, 199 variants: &Punctuated<Variant, Comma>, 200 repr: &Path, 201 ) -> Result<proc_macro2::TokenStream, Error> { 202 let discriminants: Vec<&Ident> = variants.iter().map(|f| &f.ident).collect(); 203 204 Ok(quote! { 205 #(const #discriminants: #repr = #name::#discriminants as #repr;)* 206 match value { 207 #(#discriminants => core::result::Result::Ok(#name::#discriminants),)* 208 _ => core::result::Result::Err(value), 209 } 210 }) 211 } 212 213 #[rustfmt::skip::macros(quote)] 214 fn derive_tryinto_or_error(input: DeriveInput) -> Result<proc_macro2::TokenStream, Error> { 215 let repr = get_repr_uN(&input, "#[derive(TryInto)]")?; 216 let name = &input.ident; 217 let body = derive_tryinto_body(name, get_variants(&input)?, &repr)?; 218 let errmsg = format!("invalid value for {name}"); 219 220 Ok(quote! { 221 impl #name { 222 #[allow(dead_code)] 223 pub const fn into_bits(self) -> #repr { 224 self as #repr 225 } 226 227 #[allow(dead_code)] 228 pub const fn from_bits(value: #repr) -> Self { 229 match ({ 230 #body 231 }) { 232 Ok(x) => x, 233 Err(_) => panic!(#errmsg), 234 } 235 } 236 } 237 impl core::convert::TryFrom<#repr> for #name { 238 type Error = #repr; 239 240 #[allow(ambiguous_associated_items)] 241 fn try_from(value: #repr) -> Result<Self, #repr> { 242 #body 243 } 244 } 245 }) 246 } 247 248 #[proc_macro_derive(TryInto)] 249 pub fn derive_tryinto(input: TokenStream) -> TokenStream { 250 let input = parse_macro_input!(input as DeriveInput); 251 252 derive_tryinto_or_error(input) 253 .unwrap_or_else(syn::Error::into_compile_error) 254 .into() 255 } 256 257 #[proc_macro] 258 pub fn bits_const_internal(ts: TokenStream) -> TokenStream { 259 let ts = proc_macro2::TokenStream::from(ts); 260 let mut it = ts.into_iter(); 261 262 BitsConstInternal::parse(&mut it) 263 .unwrap_or_else(syn::Error::into_compile_error) 264 .into() 265 } 266