Refactor.

Author: sisshiki1969

monoasm/src/jit_memory.rs

@@ -23,6 +23,28 @@ pub struct JitMemory {
     labels: Labels,
 }
 
+impl JitMemory {
+    fn write_reloc(&mut self, page: Page, pos: Pos, target: TargetType) {
+        let src_ptr = self[page].contents + pos.0;
+        match target {
+            TargetType::Rel { page, offset, pos } => {
+                let target_ptr = self[page].contents + pos.0 + (offset as usize);
+                let disp = (src_ptr as i128) - (target_ptr as i128);
+                match i32::try_from(disp) {
+                    Ok(disp) => self[page].write32(pos, disp),
+                    Err(_) => panic!(
+                        "Relocation overflow. src:{:016x} dest:{:016x}",
+                        src_ptr, target_ptr
+                    ),
+                }
+            }
+            TargetType::Abs { page, pos } => {
+                self[page].write64(pos, src_ptr as _);
+            }
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct Page(pub usize);
 
@@ -377,10 +399,13 @@ impl JitMemory {
     /// Bind the current location to `label`.
     pub fn bind_label(&mut self, label: DestLabel) {
         let page = self.page;
-        self.labels[label].loc = Some((page, self.counter));
+        self.bind_label_with_page(page, label);
     }
 
     pub fn bind_label_with_page(&mut self, page: Page, label: DestLabel) {
+        //for reloc in std::mem::take(&mut self.labels[label].target) {
+        //    self.write_reloc(page, self[page].counter, reloc);
+        //}
         self.labels[label].loc = Some((page, self[page].counter));
     }
 
@@ -411,40 +436,34 @@ impl JitMemory {
     pub fn save_reloc(&mut self, dest: DestLabel, offset: u8) {
         let page = self.page;
         let pos = self.counter;
-        self.labels[dest]
-            .target
-            .push(TargetType::Rel { page, offset, pos });
+        let target = TargetType::Rel { page, offset, pos };
+        if let Some((src_page, src_pos)) = self.labels[dest].loc {
+            self.write_reloc(src_page, src_pos, target);
+        } else {
+            self.labels[dest].target.push(target);
+        }
+        self[page].counter = self[page].counter + 4;
     }
 
     /// Save relocaton slot for `DestLabel`.
     fn save_absolute_reloc(&mut self, page: Page, dest: DestLabel) {
         let pos = self[page].counter;
-        self.labels[dest].target.push(TargetType::Abs { page, pos });
+        let target = TargetType::Abs { page, pos };
+        if let Some((src_page, src_pos)) = self.labels[dest].loc {
+            self.write_reloc(src_page, src_pos, target);
+        } else {
+            self.labels[dest].target.push(target);
+        }
+        self[page].counter = self[page].counter + 8;
     }
 
     /// Resolve and fill all relocations.
     fn fill_relocs(&mut self) {
         let mut reloc = std::mem::take(&mut self.labels);
         for rel in reloc.iter_mut() {
             if let Some((src_page, src_pos)) = rel.loc {
-                let src_ptr = self[src_page].contents + src_pos.0;
                 for target in std::mem::take(&mut rel.target) {
-                    match target {
-                        TargetType::Rel { page, offset, pos } => {
-                            let target_ptr = self[page].contents + pos.0 + (offset as usize);
-                            let disp = (src_ptr as i128) - (target_ptr as i128);
-                            match i32::try_from(disp) {
-                                Ok(disp) => self[page].write32(pos, disp),
-                                Err(_) => panic!(
-                                    "Relocation overflow. src:{:016x} dest:{:016x}",
-                                    src_ptr, target_ptr
-                                ),
-                            }
-                        }
-                        TargetType::Abs { page, pos } => {
-                            self[page].write64(pos, src_ptr as _);
-                        }
-                    }
+                    self.write_reloc(src_page, src_pos, target);
                 }
             }
         }
@@ -478,7 +497,7 @@ impl JitMemory {
                         self[Page(id)].align8();
                         self.bind_label_with_page(Page(id), const_label);
                         self.save_absolute_reloc(Page(id), label);
-                        self[Page(id)].emitq(0);
+                        //self[Page(id)].emitq(0);
                     }
                     DataType::Align8 => {
                         self[Page(id)].align8();
@@ -516,7 +535,7 @@ impl JitMemory {
                         self[DATA_PAGE].align8();
                         self.bind_label_with_page(DATA_PAGE, data_label);
                         self.save_absolute_reloc(DATA_PAGE, label);
-                        self[DATA_PAGE].emitq(0);
+                        //self[DATA_PAGE].emitq(0);
                     }
                     DataType::Align8 => {
                         self[DATA_PAGE].align8();
@@ -650,7 +669,7 @@ impl JitMemory {
     pub fn enc_d(&mut self, op: &[u8], dest: DestLabel) {
         self.emit(op);
         self.save_reloc(dest, 4);
-        self.emitl(0);
+        //self.emitl(0);
     }
 
     /// Encoding: /n  
@@ -871,7 +890,7 @@ impl JitMemory {
             Disp::D32(d) => self.emitl(d as u32),
             Disp::Label(label) => {
                 self.save_reloc(label, 4 + imm.offset());
-                self.emitl(0);
+                //self.emitl(0);
             }
             Disp::None => {}
         }