Teach propagate optimisation about break/return/block jumping

Author: btzy

Cargo.toml

@@ -14,5 +14,8 @@ default-members = [
     "source-compiler",
 ]
 
+# Code is generally not exception-safe, so we do not want to catch any panics
+
 [profile.release]
 lto = true
+panic = "abort"

lib-ir/src/lib.rs

@@ -220,7 +220,7 @@ pub enum ExprKind {
     }, // jumps to the end of an enclosing Block or the beginning of an enclosing Loop; Break is noreturn
     Block {
         expr: Box<Expr>,
-    }, // Jump target for Break; type must be at least as wide as expr.vartype and all Breaks that target this block
+    }, // Jump landing for Break; type must be at least as wide as expr.vartype and all Breaks that target this block
     Sequence {
         content: Vec<Expr>,
     }, // returns the value of the last expression, or `undefined` if there are zero expressions

lib-ir/src/opt/landing_context.rs

@@ -0,0 +1,46 @@
+use super::union_type;
+use crate::VarType;
+
+// List of current unioned types of return and break
+// the content[0] is for returns (and breaks that end the function)
+pub struct LandingContext {
+    content: Vec<(usize, Option<VarType>)>, // pair(new index, current union)
+    num_new: usize,
+}
+
+impl LandingContext {
+    pub fn for_new_func() -> Self {
+        Self {
+            content: vec![(0, None)],
+            num_new: 1,
+        }
+    }
+    pub fn with_landing<R, F: FnOnce(&mut Self) -> R>(&mut self, f: F) -> (R, Option<VarType>) {
+        self.content.push((self.num_new, None));
+        self.num_new += 1;
+        let ret = f(self);
+        self.num_new -= 1;
+        (ret, self.content.pop().unwrap().1)
+    }
+
+    pub fn skip_new_landing<R, F: FnOnce(&mut Self) -> R>(&mut self, f: F) -> R {
+        self.num_new += 1;
+        let ret = f(self);
+        self.num_new -= 1;
+        ret
+    }
+
+    // will panic if num_frames is out of range
+    // returns new num_frames to use
+    pub fn add_break(&mut self, num_frames: usize, vartype: VarType) -> usize {
+        let idx = self.content.len() - 1 - num_frames;
+        let landing_ref = &mut self.content[idx];
+        landing_ref.1 = union_type(landing_ref.1, Some(vartype));
+        let new_idx = self.num_new - 1 - landing_ref.0;
+        new_idx
+    }
+    pub fn add_return(&mut self, vartype: VarType) {
+        let landing_ref = &mut self.content[0];
+        landing_ref.1 = union_type(landing_ref.1, Some(vartype));
+    }
+}

lib-ir/src/opt/mod.rs

@@ -1,3 +1,4 @@
+mod landing_context;
 mod propagate;
 mod relabeller;
 mod typecast;
@@ -55,3 +56,34 @@ pub fn optimize_all(mut program: Program) -> Program {
     }
     program
 }
+
+/**
+ * Returns the type wide enough to contain both the given two types.
+ */
+fn union_type(first: Option<VarType>, second: Option<VarType>) -> Option<VarType> {
+    if first.is_none() {
+        return second;
+    }
+    if second.is_none() {
+        return first;
+    }
+    // now both first and second are not None
+    let u_first = first.unwrap();
+    let u_second = second.unwrap();
+    if u_first == u_second {
+        return Some(u_first);
+    }
+    Some(VarType::Any)
+}
+
+/**
+ * Helper function that returns true if dest got changed
+ */
+fn useful_update<T: Eq>(dest: &mut T, source: T) -> bool {
+    if *dest == source {
+        false
+    } else {
+        *dest = source;
+        true
+    }
+}