aml: `DefSizeOf` implementation

aml/src/expression.rs

@@ -4,7 +4,7 @@ use crate::{
     opcode::{self, opcode},
     parser::{choice, comment_scope, n_of, take, take_to_end_of_pkglength, try_with_context, Parser, Propagate},
     pkg_length::pkg_length,
-    term_object::{data_ref_object, term_arg, def_cond_ref_of},
+    term_object::{data_ref_object, def_cond_ref_of, term_arg},
     value::{AmlType, AmlValue, Args},
     AmlError,
     DebugVerbosity,
@@ -59,6 +59,7 @@ where
             def_store(),
             def_to_integer(),
             def_cond_ref_of(),
+            def_size_of(),
             method_invocation() // XXX: this must always appear last. See how we have to parse it to see why.
         ),
     )
@@ -758,6 +759,26 @@ where
         })
 }
 
+fn def_size_of<'a, 'c>() -> impl Parser<'a, 'c, AmlValue>
+where
+    'c: 'a,
+{
+    /*
+     * SizeOf := 0x87 SuperName
+     */
+    opcode(opcode::DEF_SIZE_OF_OP)
+        .then(comment_scope(
+            DebugVerbosity::AllScopes,
+            "DefSizeOf",
+            super_name().map_with_context(|target, context| {
+                let value = try_with_context!(context, context.read_target(&target));
+                let size_of = try_with_context!(context, value.size_of());
+                (Ok(AmlValue::Integer(size_of)), context)
+            }),
+        ))
+        .map(|((), value)| Ok(value))
+}
+
 fn method_invocation<'a, 'c>() -> impl Parser<'a, 'c, AmlValue>
 where
     'c: 'a,

aml/src/lib.rs

@@ -796,6 +796,7 @@ pub enum AmlError {
     TypeCannotBeSliced(AmlType),
     TypeCannotBeWrittenToBufferField(AmlType),
     BufferFieldIndexesOutOfBounds,
+    InvalidSizeOfApplication(AmlType),
 
     /// Unimplemented functionality - return error rather than abort
     Unimplemented,

aml/src/opcode.rs

@@ -68,6 +68,7 @@ pub const DEF_SHIFT_LEFT: u8 = 0x79;
 pub const DEF_SHIFT_RIGHT: u8 = 0x7a;
 pub const DEF_AND_OP: u8 = 0x7b;
 pub const DEF_CONCAT_RES_OP: u8 = 0x84;
+pub const DEF_SIZE_OF_OP: u8 = 0x87;
 pub const DEF_OBJECT_TYPE_OP: u8 = 0x8e;
 pub const DEF_L_AND_OP: u8 = 0x90;
 pub const DEF_L_OR_OP: u8 = 0x91;

aml/src/value.rs

@@ -263,6 +263,21 @@ impl AmlValue {
         }
     }
 
+    /// Returns the `SizeOf (x)` application result as specified in ACPI 6.2 §19.6.125
+    pub fn size_of(&self) -> Result<u64, AmlError> {
+        match self {
+            // For a buffer, returns the size in bytes of the data
+            AmlValue::Buffer(value) => Ok(value.lock().len() as u64),
+            // For a string, returns the size in bytes (without NULL)
+            AmlValue::String(value) => Ok(value.len() as u64),
+            // For a package, returns the number of elements
+            AmlValue::Package(value) => Ok(value.len() as u64),
+            // TODO: For an Object Reference, the size of the object is returned
+            // Other data types cause a fatal run-time error
+            _ => Err(AmlError::InvalidSizeOfApplication(self.type_of())),
+        }
+    }
+
     pub fn as_bool(&self) -> Result<bool, AmlError> {
         match self {
             AmlValue::Boolean(value) => Ok(*value),