Move IntegerSize back to mod.rs

Author: martin-hughes

src/aml/dsdt_info.rs

@@ -16,7 +16,6 @@
  *  - Fuzzing and guarantee panic-free interpretation
  */
 
-pub mod dsdt_info;
 pub mod namespace;
 pub mod object;
 pub mod op_region;
@@ -29,7 +28,6 @@ use crate::{
     Handle,
     Handler,
     PhysicalMapping,
-    aml::dsdt_info::{DsdtInfo, IntegerSize},
     platform::AcpiPlatform,
     registers::{FixedRegisters, Pm1ControlBit},
     sdt::{SdtHeader, facs::Facs, fadt::Fadt},
@@ -108,7 +106,7 @@ where
     pub namespace: Spinlock<Namespace>,
     pub object_token: Spinlock<ObjectToken>,
     context_stack: Spinlock<Vec<MethodContext>>,
-    dsdt_info: DsdtInfo,
+    integer_size: IntegerSize,
     region_handlers: Spinlock<BTreeMap<RegionSpace, Box<dyn RegionHandler>>>,
 
     global_lock_mutex: Handle,
@@ -144,7 +142,7 @@ where
             namespace: Spinlock::new(Namespace::new(global_lock_mutex)),
             object_token: Spinlock::new(unsafe { ObjectToken::create_interpreter_token() }),
             context_stack: Spinlock::new(Vec::new()),
-            dsdt_info: DsdtInfo::from_revision(dsdt_revision),
+            integer_size: IntegerSize::from_revision(dsdt_revision),
             region_handlers: Spinlock::new(BTreeMap::new()),
             global_lock_mutex,
             registers,
@@ -1615,7 +1613,7 @@ where
                                         let value = self.do_field_read(field)?;
                                         context.last_op()?.arguments.push(Argument::Object(value));
                                     } else if let Object::BufferField { .. } = *object {
-                                        let value = object.read_buffer_field(self.dsdt_info.integer_size)?;
+                                        let value = object.read_buffer_field(self.integer_size)?;
                                         context.last_op()?.arguments.push(Argument::Object(value.wrap()));
                                     } else {
                                         context.last_op()?.arguments.push(Argument::Object(object));
@@ -1865,8 +1863,8 @@ where
         extract_args!(op[0..3] => [Argument::Object(left), Argument::Object(right), Argument::Object(target)]);
         let target2 = if op.op == Opcode::Divide { Some(&op.arguments[3]) } else { None };
 
-        let left = left.clone().unwrap_transparent_reference().to_integer(self.dsdt_info.integer_size)?;
-        let right = right.clone().unwrap_transparent_reference().to_integer(self.dsdt_info.integer_size)?;
+        let left = left.clone().unwrap_transparent_reference().to_integer(self.integer_size)?;
+        let right = right.clone().unwrap_transparent_reference().to_integer(self.integer_size)?;
 
         let result = match op.op {
             Opcode::Add => left.wrapping_add(right),
@@ -1909,7 +1907,7 @@ where
                      * This is a particularly important place to respect the integer width as set
                      * by the DSDT revision.
                      */
-                    match self.dsdt_info.integer_size {
+                    match self.integer_size {
                         IntegerSize::FourBytes => ((operand as u32).leading_zeros() + 1) as u64,
                         IntegerSize::EightBytes => (operand.leading_zeros() + 1) as u64,
                     }
@@ -2019,7 +2017,7 @@ where
         let result = match *operand {
             Object::Buffer(ref bytes) => Object::Buffer(bytes.clone()),
             Object::Integer(value) => {
-                if self.dsdt_info.integer_size == IntegerSize::EightBytes {
+                if self.integer_size == IntegerSize::EightBytes {
                     Object::Buffer(value.to_le_bytes().to_vec())
                 } else {
                     Object::Buffer((value as u32).to_le_bytes().to_vec())
@@ -2049,7 +2047,7 @@ where
         extract_args!(op => [Argument::Object(operand), Argument::Object(target)]);
         let operand = operand.clone().unwrap_transparent_reference();
 
-        let result = Object::Integer(operand.to_integer(self.dsdt_info.integer_size)?).wrap();
+        let result = Object::Integer(operand.to_integer(self.integer_size)?).wrap();
         let result = self.do_store(target.clone(), result)?;
         context.contribute_arg(Argument::Object(result));
         context.retire_op(op);
@@ -2190,9 +2188,9 @@ where
         let result = match source1.typ() {
             ObjectType::Integer => {
                 let source1 = source1.as_integer()?;
-                let source2 = source2.to_integer(self.dsdt_info.integer_size)?;
+                let source2 = source2.to_integer(self.integer_size)?;
                 let mut buffer = Vec::new();
-                if self.dsdt_info.integer_size == IntegerSize::EightBytes {
+                if self.integer_size == IntegerSize::EightBytes {
                     buffer.extend_from_slice(&source1.to_le_bytes());
                     buffer.extend_from_slice(&source2.to_le_bytes());
                 } else {
@@ -2203,7 +2201,7 @@ where
             }
             ObjectType::Buffer => {
                 let mut buffer = source1.as_buffer()?.to_vec();
-                buffer.extend(source2.to_buffer(self.dsdt_info.integer_size)?);
+                buffer.extend(source2.to_buffer(self.integer_size)?);
                 Object::Buffer(buffer).wrap()
             }
             _ => {
@@ -2441,7 +2439,7 @@ where
     /// return either an `Integer` or `Buffer` as appropriate, guided by the size of the field
     /// and expected integer size (as per the DSDT revision).
     fn do_field_read(&self, field: &FieldUnit) -> Result<WrappedObject, AmlError> {
-        let needs_buffer = field.bit_length > (self.dsdt_info.integer_size as usize * 8);
+        let needs_buffer = field.bit_length > (self.integer_size as usize * 8);
         let access_width_bits = field.flags.access_type_bytes()? * 8;
 
         trace!("AML field read. Field = {:?}", field);
@@ -3496,3 +3494,15 @@ pub enum AmlError {
     /// state. More information may be given in the contained value.
     InternalError(String),
 }
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum IntegerSize {
+    FourBytes = 4,
+    EightBytes = 8,
+}
+
+impl IntegerSize {
+    pub fn from_revision(revision: u8) -> IntegerSize {
+        if revision >= 2 { IntegerSize::EightBytes } else { IntegerSize::FourBytes }
+    }
+}

src/aml/mod.rs

@@ -1,4 +1,4 @@
-use crate::aml::{AmlError, Handle, Operation, dsdt_info::IntegerSize, op_region::OpRegion};
+use crate::aml::{AmlError, Handle, IntegerSize, Operation, op_region::OpRegion};
 use alloc::{
     borrow::Cow,
     string::{String, ToString},
@@ -242,9 +242,7 @@ impl Object {
                     })?),
                 }
             }
-            Object::BufferField { .. } => {
-                self.read_buffer_field(integer_size)?.to_integer(integer_size)
-            }
+            Object::BufferField { .. } => self.read_buffer_field(integer_size)?.to_integer(integer_size),
             _ => Err(AmlError::InvalidOperationOnObject { op: Operation::ToInteger, typ: self.typ() })?,
         }
     }

src/aml/object.rs

@@ -17,6 +17,7 @@ DefinitionBlock ("", "SSDT", 2, "RSACPI", "DerefOf", 0x00000002) {
         Local0 = (DerefOf(\_SB.ADAT[0x09]))
         // This relies on subtraction rather than equality as logical ops on BufferFields don't work
         // yet.
+        // TODO: Use logical ops for clarity, when available.
         return (Local0 - 0xaa)
     }
 }