Handle DerefOf buffer fields

Allow DerefOf to read directly from BufferField objects. This matches AML
patterns emitted by firmware that creates named fields over buffers and then
uses DerefOf(field).

Author: ArthurHeymans

src/aml/mod.rs

@@ -841,6 +841,7 @@ where
                         extract_args!(op => [Argument::Object(object)]);
                         let result = match **object {
                             Object::Reference { kind: _, inner: _ } => object.clone().unwrap_reference(),
+                            Object::BufferField { .. } => object.read_buffer_field(self.integer_size)?.wrap(),
                             Object::String(_) => {
                                 let path = AmlName::from_str(&object.as_string().unwrap())?;
                                 let (_, object) = self.namespace.lock().search(&path, &context.current_scope)?;
@@ -1675,7 +1676,7 @@ where
                 Opcode::FindSetLeftBit | Opcode::FindSetRightBit => {
                     context.start(OpInFlight::new(opcode, &[ResolveBehaviour::TermArg, ResolveBehaviour::Target]))
                 }
-                Opcode::DerefOf => context.start(OpInFlight::new(opcode, &[ResolveBehaviour::TermArg])),
+                Opcode::DerefOf => context.start(OpInFlight::new(opcode, &[ResolveBehaviour::SuperName])),
                 Opcode::ConcatRes => context.start(OpInFlight::new(
                     opcode,
                     &[ResolveBehaviour::TermArg, ResolveBehaviour::TermArg, ResolveBehaviour::Target],

src/aml/object.rs

@@ -261,10 +261,16 @@ impl Object {
 
     pub fn read_buffer_field(&self, integer_size: IntegerSize) -> Result<Object, AmlError> {
         if let Self::BufferField { buffer, offset, length } = self {
-            let buffer = match **buffer {
-                Object::Buffer(ref buffer) => buffer.as_slice(),
-                Object::String(ref string) => string.as_bytes(),
-                _ => panic!(),
+            let buffer = buffer.clone().unwrap_transparent_reference();
+            let buffer = match &*buffer {
+                Object::Buffer(buffer) => buffer.as_slice(),
+                Object::String(string) => string.as_bytes(),
+                typ => {
+                    return Err(AmlError::InvalidOperationOnObject {
+                        op: Operation::ReadBufferField,
+                        typ: typ.typ(),
+                    });
+                }
             };
             if *length <= integer_size as usize {
                 let mut dst = [0u8; 8];
@@ -283,12 +289,18 @@ impl Object {
     pub fn write_buffer_field(&mut self, value: &[u8], token: &ObjectToken) -> Result<(), AmlError> {
         // TODO: bounds check the buffer first to avoid panicking
         if let Self::BufferField { buffer, offset, length } = self {
+            let buffer = buffer.clone().unwrap_transparent_reference();
             let buffer = match unsafe { buffer.gain_mut(token) } {
                 Object::Buffer(buffer) => buffer.as_mut_slice(),
                 // XXX: this unfortunately requires us to trust AML to keep the string as valid
                 // UTF8... maybe there is a better way?
                 Object::String(string) => unsafe { string.as_bytes_mut() },
-                _ => panic!(),
+                typ => {
+                    return Err(AmlError::InvalidOperationOnObject {
+                        op: Operation::WriteBufferField,
+                        typ: typ.typ(),
+                    });
+                }
             };
             copy_bits(value, 0, buffer, *offset, *length);
             Ok(())

tests/de_ref_of.rs

@@ -26,3 +26,37 @@ DefinitionBlock ("", "SSDT", 2, "RSACPI", "DerefOf", 0x00000002) {
     let handler = NullHandler {};
     test_infra::run_aml_test(AML, handler);
 }
+
+#[test]
+fn test_deref_of_direct_buffer_field() {
+    const AML: &str = r#"
+DefinitionBlock ("", "SSDT", 2, "RSACPI", "DerefOf", 0x00000002) {
+    Name (ADAT, Buffer (0x01) { 0xaa })
+    CreateByteField (ADAT, 0x00, BF00)
+
+    Method(MAIN, 0, NotSerialized) {
+        Return (DerefOf(BF00) - 0xaa)
+    }
+}
+"#;
+
+    let handler = NullHandler {};
+    test_infra::run_aml_test(AML, handler);
+}
+
+#[test]
+fn test_deref_of_local_buffer_field_after_store() {
+    const AML: &str = r#"
+DefinitionBlock ("", "SSDT", 2, "RSACPI", "DerefOf", 0x00000002) {
+    Method(MAIN, 0, NotSerialized) {
+        Local0 = Buffer (0x01) { 0x00 }
+        CreateByteField (Local0, 0x00, BF00)
+        BF00 = 0xaa
+        Return (DerefOf(BF00) - 0xaa)
+    }
+}
+"#;
+
+    let handler = NullHandler {};
+    test_infra::run_aml_test(AML, handler);
+}