Merge remote-tracking branch 'origin/feature/clif-cgapi' into feature/metering

lib/runtime-core/src/codegen.rs

@@ -11,6 +11,8 @@ use smallvec::SmallVec;
 use std::fmt;
 use std::fmt::Debug;
 use std::marker::PhantomData;
+use std::sync::{Arc, RwLock};
+use wasmparser::{self, WasmDecoder};
 use wasmparser::{Operator, Type as WpType};
 
 #[derive(Debug)]
@@ -57,13 +59,14 @@ pub trait ModuleCodeGenerator<FCG: FunctionCodeGenerator<E>, RM: RunnableModule,
     }
     /// Adds an import function.
     fn feed_import_function(&mut self) -> Result<(), E>;
+
     fn feed_signatures(&mut self, signatures: Map<SigIndex, FuncSig>) -> Result<(), E>;
     /// Sets function signatures.
     fn feed_function_signatures(&mut self, assoc: Map<FuncIndex, SigIndex>) -> Result<(), E>;
     /// Checks the precondition for a module.
     fn check_precondition(&mut self, module_info: &ModuleInfo) -> Result<(), E>;
     /// Creates a new function and returns the function-scope code generator for it.
-    fn next_function(&mut self) -> Result<&mut FCG, E>;
+    fn next_function(&mut self, module_info: Arc<RwLock<ModuleInfo>>) -> Result<&mut FCG, E>;
     /// Finalizes this module.
     fn finalize(self, module_info: &ModuleInfo) -> Result<(RM, Box<dyn CacheGen>), E>;
 
@@ -128,6 +131,20 @@ impl<
     }
 }
 
+fn validate(bytes: &[u8]) -> CompileResult<()> {
+    let mut parser = wasmparser::ValidatingParser::new(bytes, None);
+    loop {
+        let state = parser.read();
+        match *state {
+            wasmparser::ParserState::EndWasm => break Ok(()),
+            wasmparser::ParserState::Error(err) => Err(CompileError::ValidationError {
+                msg: err.message.to_string(),
+            })?,
+            _ => {}
+        }
+    }
+}
+
 impl<
         MCG: ModuleCodeGenerator<FCG, RM, E>,
         FCG: FunctionCodeGenerator<E>,
@@ -142,6 +159,10 @@ impl<
         compiler_config: CompilerConfig,
         _: Token,
     ) -> CompileResult<ModuleInner> {
+        if requires_pre_validation(MCG::backend_id()) {
+            validate(wasm)?;
+        }
+
         let mut mcg = MCG::new();
         let mut chain = (self.middleware_chain_generator)();
         let info = crate::parse::read_module(
@@ -152,14 +173,14 @@ impl<
             &compiler_config,
         )?;
         let (exec_context, cache_gen) =
-            mcg.finalize(&info)
+            mcg.finalize(&info.read().unwrap())
                 .map_err(|x| CompileError::InternalError {
                     msg: format!("{:?}", x),
                 })?;
         Ok(ModuleInner {
             cache_gen,
             runnable_module: Box::new(exec_context),
-            info,
+            info: Arc::try_unwrap(info).unwrap().into_inner().unwrap(),
         })
     }
 
@@ -172,6 +193,14 @@ impl<
     }
 }
 
+fn requires_pre_validation(backend: Backend) -> bool {
+    match backend {
+        Backend::Cranelift => true,
+        Backend::LLVM => false,
+        Backend::Singlepass => false,
+    }
+}
+
 pub struct EventSink<'a, 'b> {
     buffer: SmallVec<[Event<'a, 'b>; 2]>,
 }