Merge pull request #9 from rbartlensky/lua-ir

SSA intermediate representation

Author: ltratt

.rustfmt.toml

@@ -1,5 +1,2 @@
-indent_style="Block"
-imports_indent="Block"
 use_try_shorthand=true
 use_field_init_shorthand=true
-merge_imports=true

.travis.yml

@@ -1,5 +1,4 @@
 language: rust
-rust: nightly
 before_script:
   - rustup component add rustfmt-preview
 script:

luacompiler/build.rs

@@ -5,7 +5,8 @@ use lrlex::LexerBuilder;
 use lrpar::CTParserBuilder;
 
 fn main() -> Result<(), Box<std::error::Error>> {
-    let lex_rule_ids_map = CTParserBuilder::<u8>::new().process_file_in_src("lua5_3/lua5_3.y")?;
+    let lex_rule_ids_map =
+        CTParserBuilder::<u8>::new_with_storaget().process_file_in_src("lua5_3/lua5_3.y")?;
     LexerBuilder::new()
         .rule_ids_map(lex_rule_ids_map)
         .process_file_in_src("lua5_3/lua5_3.l")?;

luacompiler/src/lib/bytecode/instructions.rs

@@ -25,10 +25,26 @@ pub fn make_instr(opcode: Opcode, arg1: u8, arg2: u8, arg3: u8) -> u32 {
     opcode as u32 + ((arg1 as u32) << 4) + ((arg2 as u32) << 8) + ((arg3 as u32) << 12)
 }
 
+/// Represents a high level instruction whose operands have a size of usize.
+/// This is used by the frontend to create an SSA IR, which later gets translated
+/// into smaller instructions that fit in 32 bits.
+#[derive(PartialEq, Eq, Debug)]
+pub struct HLInstr(pub Opcode, pub usize, pub usize, pub usize);
+
+impl HLInstr {
+    pub fn as_32bit(&self) -> u32 {
+        if self.1 > 255 || self.2 > 255 || self.3 > 255 {
+            panic!("Value is truncated!");
+        }
+        make_instr(self.0, self.1 as u8, self.2 as u8, self.3 as u8)
+    }
+}
+
 /// Represents the supported operations of the bytecode.
 /// Each operation can have at most 3 arguments.
 /// There are 256 available registers, and load operations (LDI, LDF, LDS) can only
 /// refer to at most 256 constants.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
 pub enum Opcode {
     MOV = 0,  // R(1) = R(2)
     LDI = 1,  // R(1) = I(1); load integer from the constant table

luacompiler/src/lib/bytecode/mod.rs

@@ -84,9 +84,9 @@ impl LuaBytecode {
 
 impl fmt::Display for LuaBytecode {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{{\n");
+        write!(f, "{{\n")?;
         for instr in &self.block {
-            write!(f, "  {}\n", instr);
+            write!(f, "  {}\n", instr)?;
         }
         write!(f, "}}")
     }

luacompiler/src/lib/bytecodegen/mod.rs

@@ -0,0 +1,26 @@
+use bytecode::LuaBytecode;
+use irgen::lua_ir::LuaIR;
+
+pub fn compile_to_bytecode(ir: LuaIR) -> LuaBytecode {
+    LuaIRToLuaBc::new(ir).compile()
+}
+
+struct LuaIRToLuaBc {
+    ir: LuaIR,
+}
+
+impl LuaIRToLuaBc {
+    /// Compile the given LuaIR to LuaBytecode.
+    fn new(ir: LuaIR) -> LuaIRToLuaBc {
+        LuaIRToLuaBc { ir }
+    }
+
+    fn compile(self) -> LuaBytecode {
+        assert!(self.ir.lifetimes.len() < 256);
+        LuaBytecode::new(
+            self.ir.instrs.iter().map(|i| i.as_32bit()).collect(),
+            self.ir.const_map,
+            self.ir.lifetimes.len() as u8,
+        )
+    }
+}

luacompiler/src/lib/errors.rs

@@ -1,17 +1,17 @@
-use lrpar::{Node, ParseError};
+use lrpar::{LexParseError, Node, ParseError};
 use std::io;
 
 type ParseErr = (Option<Node<u8>>, Vec<ParseError<u8>>);
 
 #[derive(Debug)]
 pub enum CliError {
     Io(io::Error),
-    LexError(lrpar::LexParseError<u8>),
+    LexError(Vec<LexParseError<u8>>),
     ParseError(ParseErr),
 }
 
-impl From<lrpar::LexParseError<u8>> for CliError {
-    fn from(err: lrpar::LexParseError<u8>) -> CliError {
+impl From<Vec<LexParseError<u8>>> for CliError {
+    fn from(err: Vec<LexParseError<u8>>) -> CliError {
         CliError::LexError(err)
     }
 }

luacompiler/src/lib/irgen/constants_map.rs

@@ -9,9 +9,9 @@ use std::collections::HashMap;
 /// For instance, if '1.0' is used in Lua, then an entry from 1.0 to 0 is created in the
 /// <float_map> member.
 pub struct ConstantsMap {
-    int_map: HashMap<i64, u8>,
-    float_map: HashMap<String, u8>,
-    str_map: HashMap<String, u8>,
+    int_map: HashMap<i64, usize>,
+    float_map: HashMap<String, usize>,
+    str_map: HashMap<String, usize>,
 }
 
 impl ConstantsMap {
@@ -25,8 +25,8 @@ impl ConstantsMap {
     }
 
     /// Get the corresponding index of the given integer in the constant table.
-    pub fn get_int(&mut self, int: i64) -> u8 {
-        let len = self.int_map.len() as u8;
+    pub fn get_int(&mut self, int: i64) -> usize {
+        let len = self.int_map.len();
         *self.int_map.entry(int).or_insert(len)
     }
 
@@ -41,8 +41,8 @@ impl ConstantsMap {
     }
 
     /// Get the corresponding index of the given float in the constant table.
-    pub fn get_float(&mut self, float: String) -> u8 {
-        let len = self.float_map.len() as u8;
+    pub fn get_float(&mut self, float: String) -> usize {
+        let len = self.float_map.len();
         *self.float_map.entry(float).or_insert(len)
     }
 
@@ -57,8 +57,8 @@ impl ConstantsMap {
     }
 
     /// Get the corresponding index of the given string in the constant table.
-    pub fn get_str(&mut self, string: String) -> u8 {
-        let len = self.str_map.len() as u8;
+    pub fn get_str(&mut self, string: String) -> usize {
+        let len = self.str_map.len();
         *self.str_map.entry(string).or_insert(len)
     }
 

luacompiler/src/lib/irgen/lua_ir.rs

@@ -0,0 +1,24 @@
+use bytecode::instructions::HLInstr;
+use irgen::{constants_map::ConstantsMap, register_map::Lifetime};
+
+/// Represents an IR in which all instructions are in SSA form.
+pub struct LuaIR {
+    pub instrs: Vec<HLInstr>,
+    pub const_map: ConstantsMap,
+    pub lifetimes: Vec<Lifetime>,
+}
+
+impl LuaIR {
+    pub fn new(
+        instrs: Vec<HLInstr>,
+        const_map: ConstantsMap,
+        mut lifetimes: Vec<Lifetime>,
+    ) -> LuaIR {
+        lifetimes.sort_by(|x, y| x.start_point().cmp(&y.start_point()));
+        LuaIR {
+            instrs,
+            const_map,
+            lifetimes,
+        }
+    }
+}