Added first inline function

Robert-M-Lucas · Jun 6, 2024 · f415fc4 · f415fc4
1 parent aad9441
commit f415fc4
Show file tree

Hide file tree

Showing 8 changed files with 92 additions and 74 deletions.
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
diff --git a/src/root/builtin/int/add.rs b/src/root/builtin/int/add.rs
@@ -28,8 +28,14 @@ impl BuiltinInlineFunction for IntAdd {
     }
 
     fn inline(&self) -> InlineFunctionGenerator {
-        |args: &[LocalAddress], return_addr: Option<LocalAddress>| -> Result<String, WErr> {
-            todo!()
+        |args: &[LocalAddress], return_into: Option<LocalAddress>| -> String {
+            let lhs = args[0];
+            let rhs = args[1];
+            let return_into = return_into.unwrap();
+            format!(
+"    mov rax, qword {lhs}
+    add rax, qword {rhs}
+    mov qword {return_into}, rax")
         }
     }
 

diff --git a/src/root/builtin/int/mod.rs b/src/root/builtin/int/mod.rs
@@ -3,7 +3,6 @@ mod add;
 use b_box::b;
 use unique_type_id::UniqueTypeId;
 use crate::root::builtin::int::add::IntAdd;
-use crate::root::compiler::assembly::utils::get_qword_stack_pointer;
 use crate::root::errors::WErr;
 use crate::root::name_resolver::name_resolvers::GlobalDefinitionTable;
 use crate::root::parser::parse_function::parse_literal::{LiteralToken, LiteralTokens};
@@ -33,18 +32,17 @@ impl Type for IntType {
     }
 
     fn instantiate_from_literal(&self, location: &LocalAddress, literal: &LiteralToken) -> Result<String, WErr> {
-        let location = get_qword_stack_pointer(location);
         Ok(match literal.literal() {
             LiteralTokens::Bool(value) => {
                 if *value {
-                    format!("\tmov {location}, 0")
+                    format!("    mov qword {location}, 0")
                 }
                 else {
-                    format!("\tmov {location}, 1")
+                    format!("    mov qword {location}, 1")
                 }
             }
             LiteralTokens::Int(value) => {
-                format!("\tmov {location}, {value}")
+                format!("    mov qword {location}, {value}")
             }
         })
     }

diff --git a/src/root/builtin/mod.rs b/src/root/builtin/mod.rs
@@ -11,7 +11,7 @@ pub fn register_builtin(global_table: &mut GlobalDefinitionTable) {
     register_int(global_table);
 }
 
-pub type InlineFunctionGenerator = fn(&[LocalAddress], Option<LocalAddress>) -> Result<String, WErr>;
+pub type InlineFunctionGenerator = fn(&[LocalAddress], Option<LocalAddress>) -> String;
 
 pub trait BuiltinInlineFunction {
     fn id(&self) -> FunctionID;

diff --git a/src/root/compiler/assembly/utils.rs b/src/root/compiler/assembly/utils.rs
@@ -47,45 +47,45 @@ pub fn align_16_bytes_plus_8(bytes: ByteSize) -> ByteSize {
     }
 }
 
-pub fn get_qword_stack_pointer(address: &LocalAddress) -> String {
-    let address = address.0;
-
-    if address >= 0 {
-        format!("qword [rbp+{address}]")
-    } else {
-        format!("qword [rbp{address}]")
-    }
-}
-
-pub fn get_dword_stack_pointer(address: &LocalAddress) -> String {
-    let address = address.0;
-
-    if address >= 0 {
-        format!("dword [rbp+{address}]")
-    } else {
-        format!("dword [rbp{address}]")
-    }
-}
-
-pub fn get_word_stack_pointer(address: &LocalAddress) -> String {
-    let address = address.0;
-
-    if address >= 0 {
-        format!("word [rbp+{address}]")
-    } else {
-        format!("word [rbp{address}]")
-    }
-}
-
-pub fn get_byte_stack_pointer(address: &LocalAddress) -> String {
-    let address = address.0;
-
-    if address >= 0 {
-        format!("byte [rbp+{address}]")
-    } else {
-        format!("byte [rbp{address}]")
-    }
-}
+// pub fn get_qword_stack_pointer(address: &LocalAddress) -> String {
+//     let address = address.0;
+//
+//     if address >= 0 {
+//         format!("qword [rbp+{address}]")
+//     } else {
+//         format!("qword [rbp{address}]")
+//     }
+// }
+//
+// pub fn get_dword_stack_pointer(address: &LocalAddress) -> String {
+//     let address = address.0;
+//
+//     if address >= 0 {
+//         format!("dword [rbp+{address}]")
+//     } else {
+//         format!("dword [rbp{address}]")
+//     }
+// }
+//
+// pub fn get_word_stack_pointer(address: &LocalAddress) -> String {
+//     let address = address.0;
+//
+//     if address >= 0 {
+//         format!("word [rbp+{address}]")
+//     } else {
+//         format!("word [rbp{address}]")
+//     }
+// }
+//
+// pub fn get_byte_stack_pointer(address: &LocalAddress) -> String {
+//     let address = address.0;
+//
+//     if address >= 0 {
+//         format!("byte [rbp+{address}]")
+//     } else {
+//         format!("byte [rbp{address}]")
+//     }
+// }
 
 pub fn copy(from: LocalAddress, to: LocalAddress, amount: ByteSize) -> String {
     if amount == ByteSize(0) { return String::new(); }
@@ -99,23 +99,23 @@ pub fn copy(from: LocalAddress, to: LocalAddress, amount: ByteSize) -> String {
     loop {
         let to_write = amount.0 - written;
         if to_write >= 8 {
-            output += &format!("    mov rax, {}\n", get_qword_stack_pointer(&LocalAddress(from + written as isize)));
-            output += &format!("    mov {}, rax", get_qword_stack_pointer(&LocalAddress(to + written as isize)));
+            output += &format!("    mov rax, qword {}\n", LocalAddress(from + written as isize));
+            output += &format!("    mov qword {}, rax", &LocalAddress(to + written as isize));
             written += 8;
         }
         else if to_write >= 4 {
-            output += &format!("    mov eax, {}\n", get_dword_stack_pointer(&LocalAddress(from + written as isize)));
-            output += &format!("    mov {}, eax", get_dword_stack_pointer(&LocalAddress(to + written as isize)));
+            output += &format!("    mov rax, dword {}\n", LocalAddress(from + written as isize));
+            output += &format!("    mov dword {}, rax", &LocalAddress(to + written as isize));
             written += 4;
         }
         else if to_write >= 2 {
-            output += &format!("    mov ax, {}\n", get_word_stack_pointer(&LocalAddress(from + written as isize)));
-            output += &format!("    mov {}, ax", get_word_stack_pointer(&LocalAddress(to + written as isize)));
+            output += &format!("    mov rax, word {}\n", LocalAddress(from + written as isize));
+            output += &format!("    mov word {}, rax", &LocalAddress(to + written as isize));
             written += 2;
         }
         else if to_write >= 1 {
-            output += &format!("    mov ah, {}\n", get_byte_stack_pointer(&LocalAddress(from + written as isize)));
-            output += &format!("    mov {}, ah", get_byte_stack_pointer(&LocalAddress(to + written as isize)));
+            output += &format!("    mov rax, byte {}\n", LocalAddress(from + written as isize));
+            output += &format!("    mov byte {}, rax", &LocalAddress(to + written as isize));
             written += 1;
         }
         else {

diff --git a/src/root/compiler/compile_function.rs b/src/root/compiler/compile_function.rs
@@ -1,6 +1,6 @@
 use std::collections::HashSet;
 use crate::root::builtin::int::IntType;
-use crate::root::compiler::assembly::utils::{align_16_bytes, align_16_bytes_plus_8, get_function_tag, get_qword_stack_pointer};
+use crate::root::compiler::assembly::utils::{align_16_bytes, align_16_bytes_plus_8, get_function_tag};
 use crate::root::compiler::compile_evaluable::{compile_evaluable, compile_evaluable_into, compile_evaluable_reference};
 use crate::root::compiler::local_variable_table::LocalVariableTable;
 use crate::root::errors::WErr;
@@ -86,7 +86,7 @@ fn recursively_compile_lines(fid: FunctionID, lines: &[LineTokens], return_varia
                     let code = compile_evaluable_into(fid, rt.return_value(), address.clone(), &mut local_variables, global_table, function_calls)?;
                     contents += "\n";
                     contents += &code;
-                    contents += &format!("\n\tmov rax, {}", get_qword_stack_pointer(address.local_address()));
+                    contents += &format!("\n\tmov rax, qword {}", address.local_address());
                 }
                 else {
                     todo!()

diff --git a/src/root/name_resolver/name_resolvers.rs b/src/root/name_resolver/name_resolvers.rs
@@ -299,7 +299,7 @@ impl GlobalDefinitionTable {
 
     pub fn call_function(&self, function: FunctionID, arguments: &[LocalAddress], return_address: Option<LocalAddress>) -> Result<String, WErr> {
         if let Some(inline) = self.inline_functions.get(&function) {
-            return inline(arguments, return_address);
+            return Ok(inline(arguments, return_address));
         }
 
         call_function(function, arguments, return_address)

diff --git a/src/root/shared/common.rs b/src/root/shared/common.rs
@@ -1,3 +1,4 @@
+use std::fmt::{Display, Formatter, write};
 use derive_more::{Add, AddAssign, Display, Sub, SubAssign};
 use derive_getters::{Dissolve, Getters};
 
@@ -41,11 +42,21 @@ impl Indirection {
 #[display(fmt = "ByteSize: {}", .0)]
 pub struct ByteSize(pub usize);
 
-#[derive(Debug, PartialEq, Eq, Hash, Display, Copy, Clone)]
+#[derive(Debug, PartialEq, Eq, Hash, Copy, Clone)]
 #[derive(Add, AddAssign, Sub, SubAssign)]
-#[display(fmt = "LocalAddress: {}", .0)]
 pub struct LocalAddress(pub isize);
 
+impl Display for LocalAddress {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        if self.0 >= 0 {
+            write!(f, "[rbp+{}]", self.0)
+        }
+        else {
+            write!(f, "[rbp{}]", self.0)
+        }
+    }
+}
+
 #[derive(Getters, Clone, PartialEq)]
 pub struct TypeRef {
     type_id: TypeID,