Remove direct llvm-sys dependency, cleanup imports

Should fix any double-linking problems at the cost of a bit of
tech debt

Author: Others

Cargo.lock

@@ -6,7 +6,6 @@ edition = "2018"
 
 [dependencies]
 flexi_logger = "0.14.4"
-llvm-sys = "90.0.0"
 llvm-alt = { git = "https://github.com/Others/llvm-rs.git"}
 log = "0.4.8"
 structopt = "0.3.2"

Cargo.toml

@@ -4,7 +4,7 @@
 import sys
 import timeit
 
-# Note: This is a major configuration option, you probably want to set this if you're doing anything advanced
+# Note: This is a major configuration option, you probably want to set this if you're doing anything non-trivial
 SILVERFISH_TARGET = None
 # SILVERFISH_TARGET = "thumbv7em-none-unknown-eabi"
 # SILVERFISH_TARGET = "x86_64-apple-macosx10.15.0"

code_benches/run.py

@@ -7,19 +7,19 @@ use llvm::Value;
 
 use wasmparser::Type;
 
-use super::super::wasm::Instruction;
+use crate::codegen::ModuleCtx;
 
-use super::ModuleCtx;
+use crate::codegen::breakout::BreakoutTarget;
+use crate::codegen::breakout::WBreakoutTarget;
 
-use super::breakout::BreakoutTarget;
-use super::breakout::WBreakoutTarget;
+use crate::codegen::function::FunctionCtx;
 
-use super::function::FunctionCtx;
+use crate::codegen::runtime_stubs::*;
 
-use super::runtime_stubs::*;
+use crate::codegen::type_conversions::llvm_type_to_wasm_type;
+use crate::codegen::type_conversions::wasm_func_type_to_llvm_type;
 
-use super::type_conversions::llvm_type_to_wasm_type;
-use super::type_conversions::wasm_func_type_to_llvm_type;
+use crate::wasm::Instruction;
 
 // TODO: Double check each instruction to make sure it does the right thing in both the safe and unsafe case
 

src/codegen/block.rs

@@ -8,8 +8,8 @@ use llvm::Value;
 
 use wasmparser::TypeOrFuncType;
 
-use super::type_conversions::llvm_type_to_zeroed_value;
-use super::type_conversions::wasm_type_to_zeroed_value;
+use crate::codegen::type_conversions::llvm_type_to_zeroed_value;
+use crate::codegen::type_conversions::wasm_type_to_zeroed_value;
 
 pub struct BreakoutTarget<'a> {
     pub bb: &'a BasicBlock,

src/codegen/breakout.rs

@@ -1,20 +1,22 @@
 use std::cell::Cell;
 use std::ffi::CString;
 use std::mem;
+use std::sync::atomic::{AtomicBool, Ordering};
 
 use llvm::{BasicBlock, Sub};
 use llvm::Builder;
 use llvm::Function;
 use llvm::Value;
 
-use super::super::wasm::ImplementedFunction;
-
-use super::block::compile_block;
-use super::breakout::BreakoutTarget;
-use super::type_conversions::wasm_type_to_zeroed_value;
-use super::ModuleCtx;
 use wasmparser::TypeOrFuncType;
 
+use crate::codegen::block::compile_block;
+use crate::codegen::breakout::BreakoutTarget;
+use crate::codegen::type_conversions::wasm_type_to_zeroed_value;
+use crate::codegen::ModuleCtx;
+
+use crate::wasm::ImplementedFunction;
+
 pub struct FunctionCtx<'a> {
     pub llvm_f: &'a Function,
     pub builder: &'a Builder,
@@ -31,29 +33,33 @@ impl<'a> FunctionCtx<'a> {
     }
 }
 
-unsafe fn add_string_attr(k: &str, v: &str, v_ref: *mut llvm_sys::LLVMValue, ctx: &ModuleCtx) {
-    let idx = llvm_sys::LLVMAttributeFunctionIndex;
+unsafe fn add_string_attr(k: &str, v: &str, v_ref: *mut llvm::ffi::LLVMValue, ctx: &ModuleCtx) {
+    let idx = crate::llvm_externs::LLVMAttributeFunctionIndex;
 
     let target_features_key = CString::new(k).unwrap();
     let target_features_value = CString::new(v).unwrap();
 
-    let llvm_ctx: *mut llvm_sys::LLVMContext = mem::transmute(ctx.llvm_ctx as &llvm::Context);
-    let attr_ref = llvm_sys::core::LLVMCreateStringAttribute(
+    let llvm_ctx: *mut llvm::ffi::LLVMContext = mem::transmute(ctx.llvm_ctx as &llvm::Context);
+    let attr_ref = crate::llvm_externs::LLVMCreateStringAttribute(
         llvm_ctx,
         target_features_key.as_ptr(),
         target_features_key.as_bytes().len() as u32,
         target_features_value.as_ptr(),
         target_features_value.as_bytes().len() as u32,
     );
 
-    llvm_sys::core::LLVMAddAttributeAtIndex(
+    crate::llvm_externs::LLVMAddAttributeAtIndex(
         v_ref,
         idx,
         attr_ref
     );
 
 }
 
+// HACK: We only want to emit a note about the cortex-m override once
+// TODO: Is this clearer than doing it up a level in the code?
+static CORTEX_OVERRIDE_MESSAGE_SENT: AtomicBool = AtomicBool::new(false);
+
 pub fn compile_function(ctx: &ModuleCtx, f: &ImplementedFunction) {
     let llvm_f = ctx.llvm_module.get_function(&f.generated_name).unwrap();
 
@@ -86,20 +92,25 @@ pub fn compile_function(ctx: &ModuleCtx, f: &ImplementedFunction) {
     };
 
     unsafe {
-        let v_ref: *mut llvm_sys::LLVMValue = mem::transmute(llvm_f.to_super() as &Value);
-        let llvm_ctx: *mut llvm_sys::LLVMContext = mem::transmute(ctx.llvm_ctx as &llvm::Context);
+        let v_ref: *mut llvm::ffi::LLVMValue = mem::transmute(llvm_f.to_super() as &Value);
+        let llvm_ctx: *mut llvm::ffi::LLVMContext = mem::transmute(ctx.llvm_ctx as &llvm::Context);
 
         let nounwind = CString::new("nounwind").unwrap();
-        let kind = llvm_sys::core::LLVMGetEnumAttributeKindForName(nounwind.as_ptr(), nounwind.as_bytes().len());
-        let attr_ref = llvm_sys::core::LLVMCreateEnumAttribute(llvm_ctx, kind, 0);
+        let kind = crate::llvm_externs::LLVMGetEnumAttributeKindForName(nounwind.as_ptr(), nounwind.as_bytes().len());
+        let attr_ref = crate::llvm_externs::LLVMCreateEnumAttribute(llvm_ctx, kind, 0);
 
-        llvm_sys::core::LLVMAddAttributeAtIndex(
+        crate::llvm_externs::LLVMAddAttributeAtIndex(
             v_ref,
-            llvm_sys::LLVMAttributeFunctionIndex,
+            crate::llvm_externs::LLVMAttributeFunctionIndex,
             attr_ref
         );
         if cm_override {
-            info!("engaging cortex-m override");
+            if !CORTEX_OVERRIDE_MESSAGE_SENT.load(Ordering::Relaxed) {
+                info!("engaging cortex-m override");
+
+                // Only send the message once!
+                CORTEX_OVERRIDE_MESSAGE_SENT.store(true, Ordering::Relaxed);
+            }
 
             add_string_attr(
                 "correctly-rounded-divide-sqrt-fp-math",

src/codegen/function.rs

@@ -8,14 +8,14 @@ use llvm::Value;
 
 use wasmparser::Type;
 
-use super::super::wasm::Global;
-use super::super::wasm::Instruction;
-use super::super::Opt;
+use crate::wasm::Global;
+use crate::wasm::Instruction;
+use crate::Opt;
 
-use super::runtime_stubs::*;
-use super::type_conversions::llvm_type_to_wasm_type;
-use super::type_conversions::wasm_type_to_llvm_type;
-use super::ModuleCtx;
+use crate::codegen::ModuleCtx;
+use crate::codegen::runtime_stubs::*;
+use crate::codegen::type_conversions::llvm_type_to_wasm_type;
+use crate::codegen::type_conversions::wasm_type_to_llvm_type;
 
 pub enum GlobalValue<'a> {
     InlinedConstant(&'a Value),

src/codegen/globals.rs

@@ -1,21 +1,19 @@
-use llvm;
 use llvm::Builder;
 use llvm::Compile;
 use llvm::FunctionType;
 use llvm::PointerType;
 use llvm::Sub;
 use llvm::Value;
 
-use wasmparser;
 use wasmparser::ResizableLimits;
 
-use super::super::wasm::DataInitializer;
-use super::super::wasm::ImplementedFunction;
-use super::super::wasm::Instruction;
+use crate::wasm::DataInitializer;
+use crate::wasm::ImplementedFunction;
+use crate::wasm::Instruction;
 
-use super::function::compile_function;
-use super::type_conversions::wasm_func_type_to_llvm_type;
-use super::ModuleCtx;
+use crate::codegen::ModuleCtx;
+use crate::codegen::function::compile_function;
+use crate::codegen::type_conversions::wasm_func_type_to_llvm_type;
 
 // We add in globals to tell the runtime how much memory to allocate and startup
 // (And what the max amount of allocated memory should be)

src/codegen/memory.rs

@@ -6,12 +6,12 @@ use llvm::Module as LLVMModule;
 
 use wasmparser::FuncType;
 
+use crate::Opt;
+
 use crate::wasm::Export;
 use crate::wasm::Function;
 use crate::wasm::WasmModule;
 
-use super::Opt;
-
 mod block;
 
 mod breakout;

src/codegen/mod.rs

@@ -6,8 +6,8 @@ use llvm::Module as LLVMModule;
 use llvm::PointerType;
 use llvm::Sub;
 
-use super::ModuleCtx;
-use super::Opt;
+use crate::codegen::ModuleCtx;
+use crate::codegen::Opt;
 
 // Backing functions for wasm operations
 pub const INITIALIZE_REGION_STUB: &str = "initialize_region";