Remove ancient register allocation (#3401)

cranelift/codegen/src/ir/function.rs

@@ -3,7 +3,6 @@
 //! The `Function` struct defined in this module owns all of its basic blocks and
 //! instructions.
 
-use crate::binemit::CodeOffset;
 use crate::entity::{PrimaryMap, SecondaryMap};
 use crate::ir;
 use crate::ir::{
@@ -11,11 +10,10 @@ use crate::ir::{
     HeapData, Inst, InstructionData, JumpTable, JumpTableData, Opcode, SigRef, StackSlot,
     StackSlotData, Table, TableData,
 };
-use crate::ir::{BlockOffsets, InstEncodings, SourceLocs, StackSlots, ValueLocations};
+use crate::ir::{BlockOffsets, SourceLocs, StackSlots, ValueLocations};
 use crate::ir::{DataFlowGraph, ExternalName, Layout, Signature};
 use crate::ir::{JumpTableOffsets, JumpTables};
-use crate::isa::{CallConv, EncInfo, Encoding, Legalize, TargetIsa};
-use crate::regalloc::{EntryRegDiversions, RegDiversions};
+use crate::isa::{CallConv, TargetIsa};
 use crate::value_label::ValueLabelsRanges;
 use crate::write::write_function;
 #[cfg(feature = "enable-serde")]
@@ -106,19 +104,9 @@ pub struct Function {
     /// Layout of blocks and instructions in the function body.
     pub layout: Layout,
 
-    /// Encoding recipe and bits for the legal instructions.
-    /// Illegal instructions have the `Encoding::default()` value.
-    pub encodings: InstEncodings,
-
     /// Location assigned to every value.
     pub locations: ValueLocations,
 
-    /// Non-default locations assigned to value at the entry of basic blocks.
-    ///
-    /// At the entry of each basic block, we might have values which are not in their default
-    /// ValueLocation. This field records these register-to-register moves as Diversions.
-    pub entry_diversions: EntryRegDiversions,
-
     /// Code offsets of the block headers.
     ///
     /// This information is only transiently available after the `binemit::relax_branches` function
@@ -168,9 +156,7 @@ impl Function {
             jump_tables: PrimaryMap::new(),
             dfg: DataFlowGraph::new(),
             layout: Layout::new(),
-            encodings: SecondaryMap::new(),
             locations: SecondaryMap::new(),
-            entry_diversions: EntryRegDiversions::new(),
             offsets: SecondaryMap::new(),
             jt_offsets: SecondaryMap::new(),
             srclocs: SecondaryMap::new(),
@@ -190,9 +176,7 @@ impl Function {
         self.jump_tables.clear();
         self.dfg.clear();
         self.layout.clear();
-        self.encodings.clear();
         self.locations.clear();
-        self.entry_diversions.clear();
         self.offsets.clear();
         self.jt_offsets.clear();
         self.srclocs.clear();
@@ -268,51 +252,6 @@ impl Function {
             .map(|i| self.dfg.block_params(entry)[i])
     }
 
-    /// Get an iterator over the instructions in `block`, including offsets and encoded instruction
-    /// sizes.
-    ///
-    /// The iterator returns `(offset, inst, size)` tuples, where `offset` if the offset in bytes
-    /// from the beginning of the function to the instruction, and `size` is the size of the
-    /// instruction in bytes, or 0 for unencoded instructions.
-    ///
-    /// This function can only be used after the code layout has been computed by the
-    /// `binemit::relax_branches()` function.
-    pub fn inst_offsets<'a>(&'a self, block: Block, encinfo: &EncInfo) -> InstOffsetIter<'a> {
-        assert!(
-            !self.offsets.is_empty(),
-            "Code layout must be computed first"
-        );
-        let mut divert = RegDiversions::new();
-        divert.at_block(&self.entry_diversions, block);
-        InstOffsetIter {
-            encinfo: encinfo.clone(),
-            func: self,
-            divert,
-            encodings: &self.encodings,
-            offset: self.offsets[block],
-            iter: self.layout.block_insts(block),
-        }
-    }
-
-    /// Wrapper around `encode` which assigns `inst` the resulting encoding.
-    pub fn update_encoding(&mut self, inst: ir::Inst, isa: &dyn TargetIsa) -> Result<(), Legalize> {
-        if isa.get_mach_backend().is_some() {
-            Ok(())
-        } else {
-            self.encode(inst, isa).map(|e| self.encodings[inst] = e)
-        }
-    }
-
-    /// Wrapper around `TargetIsa::encode` for encoding an existing instruction
-    /// in the `Function`.
-    pub fn encode(&self, inst: ir::Inst, isa: &dyn TargetIsa) -> Result<Encoding, Legalize> {
-        if isa.get_mach_backend().is_some() {
-            Ok(Encoding::new(0, 0))
-        } else {
-            isa.encode(&self, &self.dfg[inst], self.dfg.ctrl_typevar(inst))
-        }
-    }
-
     /// Starts collection of debug information.
     pub fn collect_debug_info(&mut self) {
         self.dfg.collect_debug_info();
@@ -469,29 +408,3 @@ impl fmt::Debug for Function {
         write_function(fmt, self, &DisplayFunctionAnnotations::default())
     }
 }
-
-/// Iterator returning instruction offsets and sizes: `(offset, inst, size)`.
-pub struct InstOffsetIter<'a> {
-    encinfo: EncInfo,
-    divert: RegDiversions,
-    func: &'a Function,
-    encodings: &'a InstEncodings,
-    offset: CodeOffset,
-    iter: ir::layout::Insts<'a>,
-}
-
-impl<'a> Iterator for InstOffsetIter<'a> {
-    type Item = (CodeOffset, ir::Inst, CodeOffset);
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.iter.next().map(|inst| {
-            self.divert.apply(&self.func.dfg[inst]);
-            let byte_size =
-                self.encinfo
-                    .byte_size(self.encodings[inst], inst, &self.divert, self.func);
-            let offset = self.offset;
-            self.offset += byte_size;
-            (offset, inst, byte_size)
-        })
-    }
-}