Fmt

binary-banter · Apr 21, 2024 · 3f6afd9 · 3f6afd9
1 parent f68153f
commit 3f6afd9
Show file tree

Hide file tree

Showing 8 changed files with 53 additions and 150 deletions.
diff --git a/compiler/src/passes/conclude/conclude.rs b/compiler/src/passes/conclude/conclude.rs
@@ -6,7 +6,6 @@ use crate::utils::unique_sym::gen_sym;
 use crate::*;
 use std::collections::HashMap;
 
-
 impl<'p> X86Patched<'p> {
     #[must_use]
     pub fn conclude(self) -> X86Concluded<'p> {
@@ -63,12 +62,10 @@ fn fix_stack_space(block: &mut Block<Arg>, stack_space: usize) {
     for instr in &mut block.instrs {
         match instr {
             InstrAssigned::Add {
-                src: Arg::Imm(val),
-                ..
+                src: Arg::Imm(val), ..
             }
             | InstrAssigned::Sub {
-                src: Arg::Imm(val),
-                ..
+                src: Arg::Imm(val), ..
             } => {
                 assert_eq!(*val, 0x1000);
                 *val = stack_space as i32;

diff --git a/compiler/src/passes/emit/binary.rs b/compiler/src/passes/emit/binary.rs
@@ -106,35 +106,32 @@ pub fn encode_binary_instr(op_info: BinaryOpInfo, src: &Arg, dst: &Arg) -> Vec<u
             v
         }
         (Arg::Imm(imm), Arg::Reg(dst)) => {
-                let (d, ddd) = encode_reg(dst);
-
-                let mut v = vec![
-                    0b0100_1000 | d,
-                    op_info.i_rm,
-                    0b11_000_000 | op_info.pad << 3 | ddd,
-                ];
-                v.extend(imm.to_le_bytes());
-                v
+            let (d, ddd) = encode_reg(dst);
 
-        },
+            let mut v = vec![
+                0b0100_1000 | d,
+                op_info.i_rm,
+                0b11_000_000 | op_info.pad << 3 | ddd,
+            ];
+            v.extend(imm.to_le_bytes());
+            v
+        }
         (Arg::Imm(imm), Arg::Deref { reg: dst, off }) => {
+            let (d, ddd) = encode_reg(dst);
+            let off = *off as i32;
 
-                let (d, ddd) = encode_reg(dst);
-                let off = *off as i32;
-
-                let mut v = vec![
-                    0b0100_1000 | d,
-                    op_info.i_rm,
-                    0b10_000_000 | op_info.pad << 3 | ddd,
-                ];
-                if matches!(dst, Reg::RSP | Reg::R12) {
-                    v.push(0x24);
-                }
-                v.extend(off.to_le_bytes());
-                v.extend(imm.to_le_bytes());
-                v
-
-        },
+            let mut v = vec![
+                0b0100_1000 | d,
+                op_info.i_rm,
+                0b10_000_000 | op_info.pad << 3 | ddd,
+            ];
+            if matches!(dst, Reg::RSP | Reg::R12) {
+                v.push(0x24);
+            }
+            v.extend(off.to_le_bytes());
+            v.extend(imm.to_le_bytes());
+            v
+        }
         (Arg::Deref { .. }, Arg::Deref { .. }) => {
             unreachable!("Found binary instruction with 2 derefs.");
         }

diff --git a/compiler/src/passes/emit/push_pop.rs b/compiler/src/passes/emit/push_pop.rs
@@ -1,7 +1,6 @@
 use crate::passes::assign::Arg;
 use crate::passes::emit;
 
-
 pub struct PushPopInfo {
     pub op_reg: u8,
     pub op_deref: u8,
@@ -29,7 +28,7 @@ pub fn encode_push_pop(op_info: PushPopInfo, reg: &Arg) -> Vec<u8> {
             let mut v = vec![op_info.op_imm];
             v.extend(val.to_le_bytes());
             v
-        },
+        }
         Arg::Reg(reg) => {
             let (r, rrr) = emit::encode_reg(reg);
             if r == 0 {

diff --git a/compiler/src/passes/select/macros.rs b/compiler/src/passes/select/macros.rs
@@ -11,7 +11,6 @@ macro_rules! add {
         $crate::passes::select::Instr::Add {
             src: $src,
             dst: $dst,
-
         }
     };
 }
@@ -22,58 +21,42 @@ macro_rules! sub {
         $crate::passes::select::Instr::Sub {
             src: $src,
             dst: $dst,
-
         }
     };
 }
 
 #[macro_export]
 macro_rules! div {
     ($divisor:expr) => {
-        $crate::passes::select::Instr::Div {
-            divisor: $divisor,
-
-        }
+        $crate::passes::select::Instr::Div { divisor: $divisor }
     };
 }
 
 #[macro_export]
 macro_rules! idiv {
     ($divisor:expr) => {
-        $crate::passes::select::Instr::IDiv {
-            divisor: $divisor,
-
-        }
+        $crate::passes::select::Instr::IDiv { divisor: $divisor }
     };
 }
 
 #[macro_export]
 macro_rules! mul {
     ($src:expr) => {
-        $crate::passes::select::Instr::Mul {
-            src: $src,
-
-        }
+        $crate::passes::select::Instr::Mul { src: $src }
     };
 }
 
 #[macro_export]
 macro_rules! imul {
     ($src:expr) => {
-        $crate::passes::select::Instr::IMul {
-            src: $src,
-
-        }
+        $crate::passes::select::Instr::IMul { src: $src }
     };
 }
 
 #[macro_export]
 macro_rules! neg {
     ($dst:expr) => {
-        $crate::passes::select::Instr::Neg {
-            dst: $dst,
-
-        }
+        $crate::passes::select::Instr::Neg { dst: $dst }
     };
 }
 
@@ -83,7 +66,6 @@ macro_rules! mov {
         $crate::passes::select::Instr::Mov {
             src: $src,
             dst: $dst,
-
         }
     };
 }
@@ -94,28 +76,21 @@ macro_rules! movsx {
         $crate::passes::select::Instr::MovSX {
             src: $src,
             dst: $dst,
-
         }
     };
 }
 
 #[macro_export]
 macro_rules! push {
     ($src:expr) => {
-        $crate::passes::select::Instr::Push {
-            src: $src,
-
-        }
+        $crate::passes::select::Instr::Push { src: $src }
     };
 }
 
 #[macro_export]
 macro_rules! pop {
     ($dst:expr) => {
-        $crate::passes::select::Instr::Pop {
-            dst: $dst,
-
-        }
+        $crate::passes::select::Instr::Pop { dst: $dst }
     };
 }
 
@@ -139,7 +114,6 @@ macro_rules! cmp {
         $crate::passes::select::Instr::Cmp {
             src: $src,
             dst: $dst,
-
         }
     };
 }
@@ -167,7 +141,6 @@ macro_rules! and {
         $crate::passes::select::Instr::And {
             src: $src,
             dst: $dst,
-
         }
     };
 }
@@ -178,7 +151,6 @@ macro_rules! or {
         $crate::passes::select::Instr::Or {
             src: $src,
             dst: $dst,
-
         }
     };
 }
@@ -189,18 +161,14 @@ macro_rules! xor {
         $crate::passes::select::Instr::Xor {
             src: $src,
             dst: $dst,
-
         }
     };
 }
 
 #[macro_export]
 macro_rules! not {
     ($dst:expr) => {
-        $crate::passes::select::Instr::Not {
-            dst: $dst,
-
-        }
+        $crate::passes::select::Instr::Not { dst: $dst }
     };
 }
 

diff --git a/compiler/src/passes/select/mod.rs b/compiler/src/passes/select/mod.rs
@@ -2,7 +2,6 @@ mod display;
 pub mod macros;
 pub mod select;
 
-
 use crate::utils::unique_sym::UniqueSym;
 use derive_more::Display;
 use functor_derive::Functor;

diff --git a/compiler/src/passes/validate/mod.rs b/compiler/src/passes/validate/mod.rs
@@ -47,4 +47,4 @@ pub type InstrUniquified<'p> = Instr<VarArg<Spanned<UniqueSym<'p>>>, Spanned<Uni
 pub struct MetaConstrained {
     pub span: Span,
     pub index: UnionIndex,
-}
+}
diff --git a/compiler/src/passes/validate/resolve.rs b/compiler/src/passes/validate/resolve.rs
@@ -4,8 +4,8 @@ use crate::passes::select::{Instr, InstrSelected, VarArg};
 use crate::passes::validate::error::TypeError;
 use crate::passes::validate::partial_type::PartialType;
 use crate::passes::validate::{
-    DefConstrained, DefValidated, ExprConstrained, ExprValidated, InstrUniquified,
-    PrgConstrained, PrgValidated,
+    DefConstrained, DefValidated, ExprConstrained, ExprValidated, InstrUniquified, PrgConstrained,
+    PrgValidated,
 };
 use crate::utils::union_find::{UnionFind, UnionIndex};
 use crate::utils::unique_sym::UniqueSym;
@@ -168,11 +168,9 @@ fn resolve_expr<'p>(
                 Lit::Int(val) => match &typ {
                     Some(typ) => {
                         let int = match typ {
-                            Type::Int(_int) => resolve_int_lit(
-                                val,
-                                expr.meta.span,
-                                i64::from_str_radix,
-                            )?,
+                            Type::Int(_int) => {
+                                resolve_int_lit(val, expr.meta.span, i64::from_str_radix)?
+                            }
                             //     match int {
                             //     IntType::I8 => todo!(),
                             //     IntType::U8 => Int::U8({
@@ -326,71 +324,44 @@ pub fn resolve_instr<'p>(
         InstrUniquified::Sub { src, dst } => InstrSelected::Sub {
             src: map(src),
             dst: map(dst),
-
         },
         InstrUniquified::Div { divisor } => InstrSelected::Div {
             divisor: map(divisor),
-
         },
         InstrUniquified::IDiv { divisor } => InstrSelected::IDiv {
             divisor: map(divisor),
-
-        },
-        InstrUniquified::Mul { src } => InstrSelected::Mul {
-            src: map(src),
-
-        },
-        InstrUniquified::IMul { src } => InstrSelected::IMul {
-            src: map(src),
-
-        },
-        InstrUniquified::Neg { dst } => InstrSelected::Neg {
-            dst: map(dst),
-
         },
+        InstrUniquified::Mul { src } => InstrSelected::Mul { src: map(src) },
+        InstrUniquified::IMul { src } => InstrSelected::IMul { src: map(src) },
+        InstrUniquified::Neg { dst } => InstrSelected::Neg { dst: map(dst) },
         InstrUniquified::Mov { src, dst } => InstrSelected::Mov {
             src: map(src),
             dst: map(dst),
-
         },
         InstrUniquified::MovSX { src, dst } => InstrSelected::MovSX {
             src: map(src),
             dst: map(dst),
-
-        },
-        InstrUniquified::Push { src } => InstrSelected::Push {
-            src: map(src),
-
-        },
-        InstrUniquified::Pop { dst } => InstrSelected::Pop {
-            dst: map(dst),
-
         },
+        InstrUniquified::Push { src } => InstrSelected::Push { src: map(src) },
+        InstrUniquified::Pop { dst } => InstrSelected::Pop { dst: map(dst) },
         InstrUniquified::Syscall { arity } => InstrSelected::Syscall { arity },
         InstrUniquified::Cmp { src, dst } => InstrSelected::Cmp {
             src: map(src),
             dst: map(dst),
-
         },
         InstrUniquified::And { src, dst } => InstrSelected::And {
             src: map(src),
             dst: map(dst),
-
         },
         InstrUniquified::Or { src, dst } => InstrSelected::Or {
             src: map(src),
             dst: map(dst),
-
         },
         InstrUniquified::Xor { src, dst } => InstrSelected::Xor {
             src: map(src),
             dst: map(dst),
-
-        },
-        InstrUniquified::Not { dst } => InstrSelected::Not {
-            dst: map(dst),
-
         },
+        InstrUniquified::Not { dst } => InstrSelected::Not { dst: map(dst) },
         InstrUniquified::Setcc { .. }
         | InstrUniquified::Ret { .. }
         | InstrUniquified::Jmp { .. }