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