Add ElfSectionsTag

src/elf_sections.rs

@@ -0,0 +1,64 @@
+
+#[derive(Debug)]
+#[repr(C)]
+pub struct ElfSectionsTag {
+    typ: u32,
+    size: u32,
+    pub number_of_sections: u32,
+    entry_size: u32,
+    shndx: u32,
+    first_section: ElfSection,
+}
+
+impl ElfSectionsTag {
+    pub fn sections(&self) -> ElfSectionIter {
+        let start_section = (&self.first_section) as *const _;
+        ElfSectionIter {
+            current_section: start_section,
+            remaining_sections: self.number_of_sections - 1,
+            entry_size: self.entry_size,
+        }
+    }
+}
+
+#[derive(Clone)]
+#[allow(raw_pointer_derive)]
+pub struct ElfSectionIter {
+    current_section: *const ElfSection,
+    remaining_sections: u32,
+    entry_size: u32,
+}
+
+impl Iterator for ElfSectionIter {
+    type Item = &'static ElfSection;
+    fn next(&mut self) -> Option<&'static ElfSection> {
+        if self.remaining_sections == 0 {
+            None
+        } else {
+            let section = unsafe{&*self.current_section};
+            self.current_section = ((self.current_section as u32) +
+                self.entry_size) as *const ElfSection;
+            self.remaining_sections -= 1;
+			if section.typ == 0 {
+				self.next()
+			} else {
+	            Some(section)
+			}
+        }
+    }
+}
+
+#[derive(Debug)]
+#[repr(C)]
+pub struct ElfSection {
+    name: u32,
+    typ: u32,
+    pub flags: u64,
+    pub addr: u64,
+    offset: u64,
+    pub size: u64,
+    link: u32,
+    info: u32,
+    addralign: u64,
+    entry_size: u64,
+}

src/lib.rs

@@ -1,8 +1,12 @@
 #![feature(no_std)]
 #![no_std]
 
+pub use elf_sections::{ElfSectionsTag, ElfSection, ElfSectionIter};
+
 use core::mem::size_of;
 
+mod elf_sections;
+
 pub unsafe fn load(address: usize) -> &'static Multiboot {
     let multiboot = &*(address as *const Multiboot);
     assert!(multiboot.has_valid_end_tag());
@@ -17,6 +21,10 @@ pub struct Multiboot {
 }
 
 impl Multiboot {
+    pub fn elf_sections_tag(&self) -> Option<&'static ElfSectionsTag> {
+        self.get_tag(9).map(|tag| unsafe{&*(tag as *const Tag as *const ElfSectionsTag)})
+    }
+
     fn has_valid_end_tag(&self) -> bool {
         const END_TAG: Tag = Tag{typ:0, size:8};