More notes and minor restructuring for the upcoming works.

Author: sciguyryan

redox-core/src/boot_rom.rs

@@ -55,7 +55,7 @@ impl BootRom {
 
         // Calculate the position of the start of the interrupt vector.
         let mut next_handler_pos =
-            BOOT_MEMORY_START + BootRom::total_size_of_instructions(&boot_instructions);
+            BOOT_MEMORY_START + Instruction::total_size_of_instructions(&boot_instructions);
 
         // NOTE - in the instances where we are building a custom interrupt handler
         // we would need to use the intret instruction to mark the end of the handler subroutine.
@@ -107,7 +107,7 @@ impl BootRom {
             final_instructions.extend_from_slice(&instructions);
 
             // Advance the next handler location.
-            next_handler_pos += BootRom::total_size_of_instructions(&instructions);
+            next_handler_pos += Instruction::total_size_of_instructions(&instructions);
         }
 
         // Add the return instruction from our IVT initialization subroutine and add
@@ -130,13 +130,4 @@ impl BootRom {
         // Return the compiled bytecode.
         Compiler::new().compile(&final_instructions).to_vec()
     }
-
-    /// Compute the total size of an [`Instruction`] slice.
-    fn total_size_of_instructions(instructions: &[Instruction]) -> usize {
-        let mut size = 0;
-        for ins in instructions {
-            size += ins.get_total_instruction_size();
-        }
-        size
-    }
 }

redox-core/src/compiling/compiler.rs

@@ -79,11 +79,13 @@ impl Compiler {
             // TODO - this is because the instructions may have changed, altering the relative positions of the labels.
         }
 
-        // We now need to preemptively compile the core data. This is because we need to know the length
-        // of the code segment.
-        self.compile(&instructions);
-        let code_segment_len = self.bytes.len();
+        // We now need to calculate the length of the instructions.
+        let code_segment_len = Instruction::total_size_of_instructions(&instructions);
+
+        // TODO - this is a placeholder for the moment.
+        self.calculate_data_label_positions(code_segment_len);
 
+        // TODO - do we care enough to do this?
         if optimize {
             // TODO - a second optimization pass should go here to optimize any labels
             // TODO - related to the data section.
@@ -101,6 +103,14 @@ impl Compiler {
         &self.bytes
     }
 
+    /// Calculate the positions of the local data labels within the provided instruction list.
+    ///
+    /// # Arguments
+    ///
+    /// * `instructions` - A slice of [`Instruction`]s that correspond to the instructions to be compiled.
+    #[inline]
+    fn calculate_data_label_positions(&mut self, data_segment_len: usize) {}
+
     /// Calculate the positions of the local labels within the provided instruction list.
     ///
     /// # Arguments

redox-core/src/ins/instruction.rs

@@ -622,4 +622,13 @@ impl Instruction {
         };
         instruction_size + self.get_instruction_arg_size()
     }
+
+    /// Compute the total size of an [`Instruction`] slice.
+    pub fn total_size_of_instructions(instructions: &[Instruction]) -> usize {
+        let mut size = 0;
+        for ins in instructions {
+            size += ins.get_total_instruction_size();
+        }
+        size
+    }
 }