Refactor unwind generation in Cranelift.

This commit makes the following changes to unwind information generation in
Cranelift:

* Remove frame layout change implementation in favor of processing the prologue
  and epilogue instructions when unwind information is requested.  This also
  means this work is no longer performed for Windows, which didn't utilize it.
  It also helps simplify the prologue and epilogue generation code.

* Remove the unwind sink implementation that required each unwind information
  to be represented in final form. For FDEs, this meant writing a
  complete frame table per function, which wastes 20 bytes or so for each
  function with duplicate CIEs.  This also enables Cranelift users to collect the
  unwind information and write it as a single frame table.

* For System V calling convention, the unwind information is no longer stored
  in code memory (it's only a requirement for Windows ABI to do so).  This allows
  for more compact code memory for modules with a lot of functions.

* Deletes some duplicate code relating to frame table generation.  Users can
  now simply use gimli to create a frame table from each function's unwind
  information.

Fixes #1181.

crates/jit/src/unwind/systemv.rs

@@ -0,0 +1,140 @@
+//! Module for System V ABI unwind registry.
+
+use anyhow::{bail, Result};
+use cranelift_codegen::isa::{unwind::UnwindInfo, TargetIsa};
+use gimli::{
+    write::{Address, EhFrame, EndianVec, FrameTable, Writer},
+    RunTimeEndian,
+};
+
+/// Represents a registry of function unwind information for System V ABI.
+pub struct UnwindRegistry {
+    base_address: usize,
+    functions: Vec<gimli::write::FrameDescriptionEntry>,
+    frame_table: Vec<u8>,
+    registrations: Vec<usize>,
+    published: bool,
+}
+
+extern "C" {
+    // libunwind import
+    fn __register_frame(fde: *const u8);
+    fn __deregister_frame(fde: *const u8);
+}
+
+impl UnwindRegistry {
+    /// Creates a new unwind registry with the given base address.
+    pub fn new(base_address: usize) -> Self {
+        Self {
+            base_address,
+            functions: Vec::new(),
+            frame_table: Vec::new(),
+            registrations: Vec::new(),
+            published: false,
+        }
+    }
+
+    /// Registers a function given the start offset, length, and unwind information.
+    pub fn register(&mut self, func_start: u32, _func_len: u32, info: &UnwindInfo) -> Result<()> {
+        if self.published {
+            bail!("unwind registry has already been published");
+        }
+
+        match info {
+            UnwindInfo::SystemV(info) => {
+                self.functions.push(info.to_fde(Address::Constant(
+                    self.base_address as u64 + func_start as u64,
+                )));
+            }
+            _ => bail!("unsupported unwind information"),
+        }
+
+        Ok(())
+    }
+
+    /// Publishes all registered functions.
+    pub fn publish(&mut self, isa: &dyn TargetIsa) -> Result<()> {
+        if self.published {
+            bail!("unwind registry has already been published");
+        }
+
+        if self.functions.is_empty() {
+            self.published = true;
+            return Ok(());
+        }
+
+        self.set_frame_table(isa)?;
+
+        unsafe {
+            self.register_frames();
+        }
+
+        self.published = true;
+
+        Ok(())
+    }
+
+    fn set_frame_table(&mut self, isa: &dyn TargetIsa) -> Result<()> {
+        let mut table = FrameTable::default();
+        let cie_id = table.add_cie(match isa.create_systemv_cie() {
+            Some(cie) => cie,
+            None => bail!("ISA does not support System V unwind information"),
+        });
+
+        let functions = std::mem::replace(&mut self.functions, Vec::new());
+
+        for func in functions {
+            table.add_fde(cie_id, func);
+        }
+
+        let mut eh_frame = EhFrame(EndianVec::new(RunTimeEndian::default()));
+        table.write_eh_frame(&mut eh_frame).unwrap();
+
+        // GCC expects a terminating "empty" length, so write a 0 length at the end of the table.
+        eh_frame.0.write_u32(0).unwrap();
+
+        self.frame_table = eh_frame.0.into_vec();
+
+        Ok(())
+    }
+
+    unsafe fn register_frames(&mut self) {
+        let start = self.frame_table.as_ptr();
+        let end = start.add(self.frame_table.len());
+        let mut current = start;
+
+        // Walk all of the entries in the frame table and register them
+        while current < end {
+            let len = std::ptr::read::<u32>(current as *const u32) as usize;
+
+            // Skip over the CIE
+            if current != start {
+                __register_frame(current);
+                self.registrations.push(current as usize);
+            }
+
+            // Move to the next table entry (+4 because the length itself is not inclusive)
+            current = current.add(len + 4);
+        }
+    }
+}
+
+impl Drop for UnwindRegistry {
+    fn drop(&mut self) {
+        if self.published {
+            unsafe {
+                // libgcc stores the frame entries as a linked list in decreasing sort order
+                // based on the PC value of the registered entry.
+                //
+                // As we store the registrations in increasing order, it would be O(N^2) to
+                // deregister in that order.
+                //
+                // To ensure that we just pop off the first element in the list upon every
+                // deregistration, walk our list of registrations backwards.
+                for fde in self.registrations.iter().rev() {
+                    __deregister_frame(*fde as *const _);
+                }
+            }
+        }
+    }
+}

crates/jit/src/unwind/winx64.rs

@@ -0,0 +1,91 @@
+//! Module for Windows x64 ABI unwind registry.
+
+use anyhow::{bail, Result};
+use cranelift_codegen::isa::{unwind::UnwindInfo, TargetIsa};
+use winapi::um::winnt;
+
+/// Represents a registry of function unwind information for Windows x64 ABI.
+pub struct UnwindRegistry {
+    base_address: usize,
+    functions: Vec<winnt::RUNTIME_FUNCTION>,
+    published: bool,
+}
+
+impl UnwindRegistry {
+    /// Creates a new unwind registry with the given base address.
+    pub fn new(base_address: usize) -> Self {
+        Self {
+            base_address,
+            functions: Vec::new(),
+            published: false,
+        }
+    }
+
+    /// Registers a function given the start offset, length, and unwind information.
+    pub fn register(&mut self, func_start: u32, func_len: u32, info: &UnwindInfo) -> Result<()> {
+        if self.published {
+            bail!("unwind registry has already been published");
+        }
+
+        match info {
+            UnwindInfo::WindowsX64(_) => {
+                let mut entry = winnt::RUNTIME_FUNCTION::default();
+
+                entry.BeginAddress = func_start;
+                entry.EndAddress = func_start + func_len;
+
+                // The unwind information should be immediately following the function
+                // with padding for 4 byte alignment
+                unsafe {
+                    *entry.u.UnwindInfoAddress_mut() = ((entry.EndAddress + 3) & !3);
+                }
+
+                self.functions.push(entry);
+
+                Ok(())
+            }
+            _ => bail!("unsupported unwind information"),
+        }
+    }
+
+    /// Publishes all registered functions.
+    pub fn publish(&mut self, isa: &dyn TargetIsa) -> Result<()> {
+        if self.published {
+            bail!("unwind registry has already been published");
+        }
+
+        self.published = true;
+
+        if !self.functions.is_empty() {
+            // Windows heap allocations are 32-bit aligned, but assert just in case
+            assert_eq!(
+                (self.functions.as_mut_ptr() as u64) % 4,
+                0,
+                "function table allocation was not aligned"
+            );
+
+            unsafe {
+                if winnt::RtlAddFunctionTable(
+                    self.functions.as_mut_ptr(),
+                    self.functions.len() as u32,
+                    base_address as u64,
+                ) == 0
+                {
+                    bail!("failed to register function table");
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl Drop for UnwindRegistry {
+    fn drop(&mut self) {
+        if self.published {
+            unsafe {
+                winnt::RtlDeleteFunctionTable(self.functions.as_mut_ptr());
+            }
+        }
+    }
+}