aml: implement DefIndex

Author: IsaacWoods

aml/src/lib.rs

@@ -384,6 +384,7 @@ where
                         context.contribute_arg(Argument::Object(Arc::new(Object::Integer(typ))));
                     }
                     Opcode::SizeOf => self.do_size_of(&mut context, op)?,
+                    Opcode::Index => self.do_index(&mut context, op)?,
                     Opcode::BankField => {
                         let [
                             Argument::TrackedPc(start_pc),
@@ -826,7 +827,7 @@ where
                 Opcode::ConcatRes => todo!(),
                 Opcode::Notify => todo!(),
                 Opcode::SizeOf => context.start_in_flight_op(OpInFlight::new(opcode, 1)),
-                Opcode::Index => todo!(),
+                Opcode::Index => context.start_in_flight_op(OpInFlight::new(opcode, 3)),
                 Opcode::Match => todo!(),
 
                 Opcode::CreateBitField
@@ -1104,6 +1105,55 @@ where
         context.contribute_arg(Argument::Object(Arc::new(Object::Integer(result as u64))));
         Ok(())
     }
+
+    fn do_index(&self, context: &mut MethodContext, op: OpInFlight) -> Result<(), AmlError> {
+        let [Argument::Object(object), Argument::Object(index_value), target] = &op.arguments[..] else {
+            panic!()
+        };
+        let Object::Integer(index_value) = **index_value else {
+            Err(AmlError::ObjectNotOfExpectedType { expected: ObjectType::Integer, got: index_value.typ() })?
+        };
+
+        let result = Arc::new(match **object {
+            Object::Buffer(ref buffer) => {
+                if index_value as usize >= buffer.len() {
+                    Err(AmlError::IndexOutOfBounds)?
+                }
+
+                Object::Reference {
+                    kind: ReferenceKind::RefOf,
+                    inner: Arc::new(Object::BufferField {
+                        buffer: object.clone(),
+                        offset: index_value as usize * 8,
+                        length: 8,
+                    }),
+                }
+            }
+            Object::String(ref string) => {
+                if index_value as usize >= string.len() {
+                    Err(AmlError::IndexOutOfBounds)?
+                }
+
+                Object::Reference {
+                    kind: ReferenceKind::RefOf,
+                    inner: Arc::new(Object::BufferField {
+                        buffer: object.clone(),
+                        offset: index_value as usize * 8,
+                        length: 8,
+                    }),
+                }
+            }
+            Object::Package(ref package) => {
+                let Some(element) = package.get(index_value as usize) else { Err(AmlError::IndexOutOfBounds)? };
+                Object::Reference { kind: ReferenceKind::RefOf, inner: element.clone() }
+            }
+            _ => Err(AmlError::IndexOutOfBounds)?,
+        });
+
+        self.do_store(context, target, result.clone())?;
+        context.contribute_arg(Argument::Object(result));
+        Ok(())
+    }
     fn do_store(
         &self,
         context: &mut MethodContext,
@@ -1703,6 +1753,8 @@ pub enum AmlError {
     MethodArgCountIncorrect,
 
     InvalidOperationOnObject,
+    IndexOutOfBounds,
+    ObjectNotOfExpectedType { expected: ObjectType, got: ObjectType },
 
     InvalidResourceDescriptor,
     UnexpectedResourceType,

aml/src/object.rs

@@ -46,19 +46,30 @@ impl Object {
 
     pub fn read_buffer_field(&self, dst: &mut [u8]) -> Result<(), AmlError> {
         if let Self::BufferField { buffer, offset, length } = self {
-            let Object::Buffer(ref buffer) = **buffer else { panic!() };
-            // TODO: assert length of buffer is sufficient
-            copy_bits(buffer.as_slice(), *offset, dst, 0, *length);
+            let buffer = match **buffer {
+                Object::Buffer(ref buffer) => buffer.as_slice(),
+                Object::String(ref string) => string.as_bytes(),
+                _ => panic!(),
+            };
+            // TODO: bounds check the buffer first to avoid panicking
+            copy_bits(buffer, *offset, dst, 0, *length);
             Ok(())
         } else {
             Err(AmlError::InvalidOperationOnObject)
         }
     }
 
     pub fn write_buffer_field(&mut self, value: &[u8]) -> Result<(), AmlError> {
+        // TODO: bounds check the buffer first to avoid panicking
         if let Self::BufferField { buffer, offset, length } = self {
-            let Object::Buffer(buffer) = buffer.gain_mut() else { panic!() };
-            copy_bits(value, 0, buffer.as_mut_slice(), *offset, *length);
+            let buffer = match buffer.gain_mut() {
+                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!(),
+            };
+            copy_bits(value, 0, buffer, *offset, *length);
             Ok(())
         } else {
             Err(AmlError::InvalidOperationOnObject)
@@ -157,6 +168,7 @@ impl MethodFlags {
 
 #[derive(Clone, Copy, PartialEq, Debug)]
 pub enum ReferenceKind {
+    RefOf,
     LocalOrArg,
     Unresolved,
 }