Merge branch 'trying-to-fix-reljumps' into implement-stack-map-table

Author: ArtInLines

Diff for: lib/src/codegen/reljumps.rs

@@ -1,4 +1,5 @@
 use crate::codegen::Instruction;
+use std::cmp::{max, min};
 
 fn get_instruction_length(istr: &Instruction) -> u16 {
     match istr {
@@ -21,73 +22,62 @@ fn get_instructions_length(instructions: &[Instruction]) -> u16 {
 pub(crate) fn convert_to_absolute_jumps(instructions: Vec<Instruction>) -> Vec<Instruction> {
     let mut result = vec![];
     for (j, istr) in instructions.iter().enumerate() {
+        let current_offset = get_instructions_length(&instructions[..j]);
         match istr {
+            Instruction::relgoto(target) => {
+                let absolute_addr =
+                    calculate_absolute_addr(*target, current_offset, j, &instructions);
+                result.push(Instruction::goto(absolute_addr, *target));
+            }
             Instruction::reljumpifeq(target) => {
-                let modifier: i32 = if *target < 0 { -1 } else { 1 };
-                result.push(Instruction::ifeq(
-                    (get_instructions_length(
-                        &instructions[j..j.saturating_add_signed(*target as isize)],
-                    ) as i32
-                        * modifier
-                        + j as i32
-                        - 1) as u16,
-                    *target,
-                ))
+                let absolute_addr =
+                    calculate_absolute_addr(*target, current_offset, j, &instructions);
+                result.push(Instruction::ifeq(absolute_addr, *target));
             }
             Instruction::reljumpifge(target) => {
-                let modifier: i32 = if *target < 0 { -1 } else { 1 };
-                result.push(Instruction::ifge(
-                    (get_instructions_length(
-                        &instructions[j..j.saturating_add_signed(*target as isize)],
-                    ) as i32
-                        * modifier
-                        + j as i32
-                        - 1) as u16,
-                    *target,
-                ))
-            }
-            Instruction::relgoto(target) => {
-                let modifier: i32 = if *target < 0 { -1 } else { 1 };
-                result.push(Instruction::goto(
-                    (get_instructions_length(
-                        &instructions[j..j.saturating_add_signed(*target as isize)],
-                    ) as i32
-                        * modifier
-                        + j as i32
-                        - 1) as u16,
-                    *target,
-                ))
+                let absolute_addr =
+                    calculate_absolute_addr(*target, current_offset, j, &instructions);
+                result.push(Instruction::ifge(absolute_addr, *target));
             }
             Instruction::reljumpiflt(target) => {
-                let modifier: i32 = if *target < 0 { -1 } else { 1 };
-                result.push(Instruction::iflt(
-                    (get_instructions_length(
-                        &instructions[j..j.saturating_add_signed(*target as isize)],
-                    ) as i32
-                        * modifier
-                        + j as i32
-                        - 1) as u16,
-                    *target,
-                ))
+                let absolute_addr =
+                    calculate_absolute_addr(*target, current_offset, j, &instructions);
+                result.push(Instruction::iflt(absolute_addr, *target));
             }
             Instruction::reljumpifne(target) => {
-                let modifier: i32 = if *target < 0 { -1 } else { 1 };
-                result.push(Instruction::ifne(
-                    (get_instructions_length(
-                        &instructions[j..j.saturating_add_signed(*target as isize)],
-                    ) as i32
-                        * modifier
-                        + j as i32
-                        - 1) as u16,
-                    *target,
-                ))
+                let absolute_addr =
+                    calculate_absolute_addr(*target, current_offset, j, &instructions);
+                result.push(Instruction::ifne(absolute_addr, *target));
             }
             _ => result.push(*istr),
         }
     }
     result
 }
 
+fn calculate_absolute_addr(
+    target: i16,
+    current_offset: u16,
+    j: usize,
+    instructions: &[Instruction],
+) -> u16 {
+    let modifier: i32 = if target < 0 { -1 } else { 1 };
+    // Too dumb to figure out the formula for this so here is an ugly if statement
+    if modifier > 0 {
+        let min = min(j + 1, j.saturating_add_signed(target as isize));
+        let max = max(j + 1, j.saturating_add_signed(target as isize));
+        let instructions_to_jump_over = &instructions[min..max];
+        let offset = get_instructions_length(instructions_to_jump_over);
+        (offset as i32 * modifier + current_offset as i32) as u16
+    } else {
+        let min = min(j + 1, j.saturating_add_signed(target as isize));
+        let max = max(j + 1, j.saturating_add_signed(target as isize)) - 1;
+        let instructions_to_jump_over = &instructions[min..max];
+        let offset = get_instructions_length(instructions_to_jump_over);
+        (offset as i32 * modifier + current_offset as i32) as u16
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -140,4 +130,9 @@ mod tests {
         ];
         assert_eq!(convert_to_absolute_jumps(instructions), expected);
     }
+    #[test]
+    fn test_calculate_instruction_size() {
+        let instructions = vec![Instruction::reljumpifge(1), Instruction::relgoto(2)];
+        assert_eq!(get_instructions_length(&instructions), 6);
+    }
 }

Diff for: lib/src/lib.rs

@@ -1,3 +1,5 @@
+extern crate core;
+
 pub mod codegen;
 pub mod parser;
 #[cfg(test)]