move faerie-related code from traps to output

Author: Pat Hickey

lucetc/src/output.rs

@@ -2,14 +2,14 @@ use crate::error::Error;
 use crate::name::Name;
 use crate::stack_probe;
 use crate::table::{link_tables, TABLE_SYM};
-use crate::traps::{trap_sym_for_func, write_trap_tables};
+use crate::traps::{translate_trapcode, trap_sym_for_func};
 use byteorder::{LittleEndian, WriteBytesExt};
 use cranelift_codegen::{ir, isa, binemit::TrapSink};
 use cranelift_faerie::traps::{FaerieTrapManifest, FaerieTrapSink};
 use cranelift_faerie::FaerieProduct;
 use faerie::{Artifact, Decl, Link};
 use lucet_module::{
-    FunctionSpec, SerializedModule, VersionInfo, LUCET_MODULE_SYM, MODULE_DATA_SYM,
+    FunctionSpec, SerializedModule, TrapSite, VersionInfo, LUCET_MODULE_SYM, MODULE_DATA_SYM,
 };
 use std::collections::HashMap;
 use std::fs::File;
@@ -88,7 +88,7 @@ impl ObjectFile {
             }
         }
 
-        write_trap_tables(&trap_manifest, &mut obj.artifact)?;
+        obj.write_trap_tables(&trap_manifest)?;
         obj.write_function_manifest(function_manifest.as_slice())?;
         link_tables(table_manifest.as_slice(), &mut obj.artifact)?;
 
@@ -213,6 +213,44 @@ impl ObjectFile {
         Ok(())
     }
 
+    fn write_trap_tables(&mut self, manifest: &FaerieTrapManifest) -> Result<(), Error> {
+        for sink in manifest.sinks.iter() {
+            let func_sym = &sink.name;
+            let trap_sym = trap_sym_for_func(func_sym);
+
+            self.artifact.declare(&trap_sym, Decl::data()).map_err(|source| {
+                let message = format!("Trap table error declaring {}", trap_sym);
+                Error::ArtifactError(source, message)
+            })?;
+
+            // write the actual function-level trap table
+            let traps: Vec<TrapSite> = sink
+                .sites
+                .iter()
+                .map(|site| TrapSite {
+                    offset: site.offset,
+                    code: translate_trapcode(site.code),
+                })
+                .collect();
+
+            let trap_site_bytes = unsafe {
+                std::slice::from_raw_parts(
+                    traps.as_ptr() as *const u8,
+                    traps.len() * std::mem::size_of::<TrapSite>(),
+                )
+            };
+
+            // and write the function trap table into the object
+            self.artifact.define(&trap_sym, trap_site_bytes.to_vec())
+                .map_err(|source| {
+                    let message = format!("Trap table error defining {}", trap_sym);
+                    Error::ArtifactError(source, message)
+                })?;
+        }
+
+        Ok(())
+    }
+
     pub fn write<P: AsRef<Path>>(&self, path: P) -> Result<(), Error> {
         let _ = path.as_ref().file_name().ok_or(|| {
             let message = format!("Path must be filename {:?}", path.as_ref());

lucetc/src/traps.rs

@@ -1,48 +1,4 @@
-use crate::error::Error;
-
 use cranelift_codegen::ir;
-use cranelift_faerie::traps::FaerieTrapManifest;
-
-use faerie::{Artifact, Decl};
-use lucet_module::TrapSite;
-
-pub fn write_trap_tables(manifest: &FaerieTrapManifest, obj: &mut Artifact) -> Result<(), Error> {
-    for sink in manifest.sinks.iter() {
-        let func_sym = &sink.name;
-        let trap_sym = trap_sym_for_func(func_sym);
-
-        obj.declare(&trap_sym, Decl::data()).map_err(|source| {
-            let message = format!("Trap table error declaring {}", trap_sym);
-            Error::ArtifactError(source, message)
-        })?;
-
-        // write the actual function-level trap table
-        let traps: Vec<TrapSite> = sink
-            .sites
-            .iter()
-            .map(|site| TrapSite {
-                offset: site.offset,
-                code: translate_trapcode(site.code),
-            })
-            .collect();
-
-        let trap_site_bytes = unsafe {
-            std::slice::from_raw_parts(
-                traps.as_ptr() as *const u8,
-                traps.len() * std::mem::size_of::<TrapSite>(),
-            )
-        };
-
-        // and write the function trap table into the object
-        obj.define(&trap_sym, trap_site_bytes.to_vec())
-            .map_err(|source| {
-                let message = format!("Trap table error defining {}", trap_sym);
-                Error::ArtifactError(source, message)
-            })?;
-    }
-
-    Ok(())
-}
 
 pub(crate) fn trap_sym_for_func(sym: &str) -> String {
     return format!("lucet_trap_table_{}", sym);
@@ -55,7 +11,7 @@ pub(crate) fn trap_sym_for_func(sym: &str) -> String {
 //
 // Not all types have subtypes. Currently, only the user User type has a
 // subtype.
-fn translate_trapcode(code: ir::TrapCode) -> lucet_module::TrapCode {
+pub(crate) fn translate_trapcode(code: ir::TrapCode) -> lucet_module::TrapCode {
     match code {
         ir::TrapCode::StackOverflow => lucet_module::TrapCode::StackOverflow,
         ir::TrapCode::HeapOutOfBounds => lucet_module::TrapCode::HeapOutOfBounds,