btfparse: Refactor

alessandrogario · Jan 11, 2024 · 936bf86 · 936bf86
1 parent c0a0624
commit 936bf86
Show file tree

Hide file tree

Showing 23 changed files with 785 additions and 531 deletions.
diff --git a/btfparse/src/btf/array.rs b/btfparse/src/btf/array.rs
@@ -1,14 +1,14 @@
 use crate::btf::{
-    parse_string, Error as BTFError, ErrorKind as BTFErrorKind, FileHeader, Kind,
-    Result as BTFResult, Type, TypeHeader,
+    Error as BTFError, ErrorKind as BTFErrorKind, FileHeader, Header, Kind, Result as BTFResult,
+    Type,
 };
 use crate::utils::Reader;
 use crate::{define_common_type_methods, define_type};
 
 /// The size of the extra data
 const ENUM_VALUE_SIZE: usize = 12;
 
-/// The extra data contained in an array type
+/// Array data
 #[derive(Debug, Clone, Copy)]
 pub struct Data {
     /// The element type id
@@ -23,15 +23,15 @@ pub struct Data {
 
 impl Data {
     /// The size of the extra data
-    pub fn size(type_header: &TypeHeader) -> usize {
+    pub fn size(type_header: &Header) -> usize {
         type_header.vlen() * ENUM_VALUE_SIZE
     }
 
     /// Creates a new `Data` object
     pub fn new(
         reader: &mut Reader,
         _file_header: &FileHeader,
-        _type_header: &TypeHeader,
+        _type_header: &Header,
     ) -> BTFResult<Self> {
         let element_type_id = reader.u32()?;
         let index_type_id = reader.u32()?;
@@ -43,29 +43,18 @@ impl Data {
             element_count,
         })
     }
-
-    /// Returns the element type id
-    pub fn element_type_id(&self) -> u32 {
-        self.element_type_id
-    }
-
-    /// Returns the index type id
-    pub fn index_type_id(&self) -> u32 {
-        self.index_type_id
-    }
-
-    /// Returns the element count
-    pub fn element_count(&self) -> u32 {
-        self.element_count
-    }
 }
 
-define_type!(Array, Data);
+define_type!(Array, Data,
+    element_type_id: u32,
+    index_type_id: u32,
+    element_count: u32
+);
 
 #[cfg(test)]
 mod tests {
     use super::Array;
-    use crate::btf::{FileHeader, TypeHeader};
+    use crate::btf::{FileHeader, Header};
     use crate::utils::{ReadableBuffer, Reader};
 
     #[test]
@@ -100,10 +89,10 @@ mod tests {
 
         let mut reader = Reader::new(&readable_buffer);
         let file_header = FileHeader::new(&mut reader).unwrap();
-        let type_header = TypeHeader::new(&mut reader, &file_header).unwrap();
+        let type_header = Header::new(&mut reader, &file_header).unwrap();
         let array = Array::new(&mut reader, &file_header, type_header).unwrap();
-        assert_eq!(array.data().element_type_id(), 5);
-        assert_eq!(array.data().index_type_id(), 6);
-        assert_eq!(array.data().element_count(), 7);
+        assert_eq!(*array.element_type_id(), 5);
+        assert_eq!(*array.index_type_id(), 6);
+        assert_eq!(*array.element_count(), 7);
     }
 }
diff --git a/btfparse/src/btf/const.rs b/btfparse/src/btf/const.rs
@@ -1,16 +1,41 @@
 use crate::btf::{
-    parse_string, Error as BTFError, ErrorKind as BTFErrorKind, FileHeader, Kind,
-    Result as BTFResult, Type, TypeHeader,
+    Error as BTFError, ErrorKind as BTFErrorKind, FileHeader, Header, Kind, Result as BTFResult,
+    Type,
 };
 use crate::utils::Reader;
 use crate::{define_common_type_methods, define_type};
 
-define_type!(Const);
+/// Const data
+#[derive(Debug, Clone)]
+pub struct Data {
+    /// The const type
+    type_id: u32,
+}
+
+impl Data {
+    /// The size of the extra data
+    pub fn size(_type_header: &Header) -> usize {
+        0
+    }
+
+    /// Creates a new `Data` object
+    pub fn new(
+        _reader: &mut Reader,
+        _file_header: &FileHeader,
+        type_header: &Header,
+    ) -> BTFResult<Self> {
+        Ok(Self {
+            type_id: type_header.size_or_type(),
+        })
+    }
+}
+
+define_type!(Const, Data, type_id: u32);
 
 #[cfg(test)]
 mod tests {
     use super::Const;
-    use crate::btf::{FileHeader, Type, TypeHeader};
+    use crate::btf::{FileHeader, Header};
     use crate::utils::{ReadableBuffer, Reader};
 
     #[test]
@@ -41,8 +66,8 @@ mod tests {
 
         let mut reader = Reader::new(&readable_buffer);
         let file_header = FileHeader::new(&mut reader).unwrap();
-        let type_header = TypeHeader::new(&mut reader, &file_header).unwrap();
+        let type_header = Header::new(&mut reader, &file_header).unwrap();
         let const_type = Const::new(&mut reader, &file_header, type_header).unwrap();
-        assert_eq!(const_type.size_or_type(), 3);
+        assert_eq!(*const_type.type_id(), 3);
     }
 }
diff --git a/btfparse/src/btf/data_sec.rs b/btfparse/src/btf/data_sec.rs
@@ -1,6 +1,6 @@
 use crate::btf::{
-    parse_string, Error as BTFError, ErrorKind as BTFErrorKind, FileHeader, Kind,
-    Result as BTFResult, Type, TypeHeader,
+    parse_string, Error as BTFError, ErrorKind as BTFErrorKind, FileHeader, Header, Kind,
+    Result as BTFResult, Type,
 };
 use crate::utils::Reader;
 use crate::{define_common_type_methods, define_type};
@@ -24,23 +24,30 @@ pub struct Variable {
 /// A list of variables
 pub type VariableList = Vec<Variable>;
 
-/// The extra data contained in an DataSec type
+/// DataSec date
 #[derive(Debug, Clone)]
 pub struct Data {
+    /// The data sec name
+    name: Option<String>,
+
+    /// The data sec size
+    size: usize,
+
+    /// A list of variables defined in this data section
     variable_list: VariableList,
 }
 
 impl Data {
     /// The size of the extra data
-    pub fn size(type_header: &TypeHeader) -> usize {
+    pub fn size(type_header: &Header) -> usize {
         type_header.vlen() * DATA_SEC_VARIABLE_SIZE
     }
 
     /// Creates a new `Data` object
     pub fn new(
         reader: &mut Reader,
-        _file_header: &FileHeader,
-        type_header: &TypeHeader,
+        file_header: &FileHeader,
+        type_header: &Header,
     ) -> BTFResult<Self> {
         let mut variable_list = VariableList::new();
 
@@ -54,21 +61,34 @@ impl Data {
             variable_list.push(variable);
         }
 
-        Ok(Self { variable_list })
-    }
-
-    /// Returns a list of all the variables defined in this data section
-    pub fn variable_list(&self) -> VariableList {
-        self.variable_list.clone()
+        let name = if type_header.name_offset() != 0 {
+            Some(parse_string(
+                reader,
+                file_header,
+                type_header.name_offset(),
+            )?)
+        } else {
+            None
+        };
+
+        Ok(Self {
+            name,
+            size: type_header.size_or_type() as usize,
+            variable_list,
+        })
     }
 }
 
-define_type!(DataSec, Data);
+define_type!(DataSec, Data,
+    name: Option<String>,
+    size: usize,
+    variable_list: VariableList
+);
 
 #[cfg(test)]
 mod tests {
     use super::DataSec;
-    use crate::btf::{FileHeader, Type, TypeHeader};
+    use crate::btf::{FileHeader, Header};
     use crate::utils::{ReadableBuffer, Reader};
 
     #[test]
@@ -107,18 +127,18 @@ mod tests {
 
         let mut reader = Reader::new(&readable_buffer);
         let file_header = FileHeader::new(&mut reader).unwrap();
-        let type_header = TypeHeader::new(&mut reader, &file_header).unwrap();
+        let type_header = Header::new(&mut reader, &file_header).unwrap();
         let data_sec = DataSec::new(&mut reader, &file_header, type_header).unwrap();
         assert_eq!(data_sec.name().as_deref(), Some("var_name"));
-        assert_eq!(data_sec.size_or_type(), 4);
+        assert_eq!(*data_sec.size(), 4);
 
-        assert_eq!(data_sec.data().variable_list().len(), 2);
-        assert_eq!(data_sec.data().variable_list()[0].var_decl_id, 5);
-        assert_eq!(data_sec.data().variable_list()[0].offset, 4);
-        assert_eq!(data_sec.data().variable_list()[0].var_size, 8);
+        assert_eq!(data_sec.variable_list().len(), 2);
+        assert_eq!(data_sec.variable_list()[0].var_decl_id, 5);
+        assert_eq!(data_sec.variable_list()[0].offset, 4);
+        assert_eq!(data_sec.variable_list()[0].var_size, 8);
 
-        assert_eq!(data_sec.data().variable_list()[1].var_decl_id, 5);
-        assert_eq!(data_sec.data().variable_list()[1].offset, 8);
-        assert_eq!(data_sec.data().variable_list()[1].var_size, 8);
+        assert_eq!(data_sec.variable_list()[1].var_decl_id, 5);
+        assert_eq!(data_sec.variable_list()[1].offset, 8);
+        assert_eq!(data_sec.variable_list()[1].var_size, 8);
     }
 }
diff --git a/btfparse/src/btf/decl_tag.rs b/btfparse/src/btf/decl_tag.rs
@@ -1,46 +1,60 @@
 use crate::btf::{
-    parse_string, Error as BTFError, ErrorKind as BTFErrorKind, FileHeader, Kind,
-    Result as BTFResult, Type, TypeHeader,
+    parse_string, Error as BTFError, ErrorKind as BTFErrorKind, FileHeader, Header, Kind,
+    Result as BTFResult, Type,
 };
 use crate::utils::Reader;
 use crate::{define_common_type_methods, define_type};
 
-/// The extra data contained in a DeclTag type
-#[derive(Debug, Clone, Copy)]
+/// DeclTag data
+#[derive(Debug, Clone)]
 pub struct Data {
+    /// Decl tag name
+    name: Option<String>,
+
     /// Component index
     component_index: u32,
 }
 
 impl Data {
     /// The size of the extra data
-    pub fn size(_type_header: &TypeHeader) -> usize {
+    pub fn size(_type_header: &Header) -> usize {
         4
     }
 
     /// Creates a new `Data` object
     pub fn new(
         reader: &mut Reader,
-        _file_header: &FileHeader,
-        _type_header: &TypeHeader,
+        file_header: &FileHeader,
+        type_header: &Header,
     ) -> BTFResult<Self> {
         let component_index = reader.u32()?;
 
-        Ok(Self { component_index })
-    }
+        let name = if type_header.name_offset() != 0 {
+            Some(parse_string(
+                reader,
+                file_header,
+                type_header.name_offset(),
+            )?)
+        } else {
+            None
+        };
 
-    /// Returns the component index
-    pub fn component_index(&self) -> u32 {
-        self.component_index
+        Ok(Self {
+            name,
+            component_index,
+        })
     }
 }
 
-define_type!(DeclTag, Data);
+define_type!(DeclTag, Data,
+    name: Option<String>,
+    component_index: u32
+);
 
 #[cfg(test)]
 mod tests {
     use super::DeclTag;
-    use crate::btf::{FileHeader, Type, TypeHeader};
+    use crate::btf::{FileHeader, Header};
     use crate::utils::{ReadableBuffer, Reader};
 
     #[test]
@@ -74,9 +88,9 @@ mod tests {
 
         let mut reader = Reader::new(&readable_buffer);
         let file_header = FileHeader::new(&mut reader).unwrap();
-        let type_header = TypeHeader::new(&mut reader, &file_header).unwrap();
+        let type_header = Header::new(&mut reader, &file_header).unwrap();
         let decl_tag = DeclTag::new(&mut reader, &file_header, type_header).unwrap();
-        assert_eq!(decl_tag.data().component_index(), 16);
+        assert_eq!(*decl_tag.component_index(), 16);
         assert_eq!(decl_tag.name().as_deref(), Some("decl_tag"));
     }
 }