From a30afec0cdbadbe395ac743e371b3f33b9f952e4 Mon Sep 17 00:00:00 2001 From: Wei Tang Date: Tue, 15 May 2018 08:22:29 +0800 Subject: [PATCH] Port core util lib to support no_std --- src/ext.rs | 6 +++++- src/gas.rs | 2 ++ src/lib.rs | 17 +++++++++++++++++ src/optimizer.rs | 11 ++++++++--- src/pack.rs | 3 +++ src/rules.rs | 14 +++++++++----- src/stack_height/max_height.rs | 2 ++ src/stack_height/mod.rs | 3 +++ src/stack_height/thunk.rs | 12 ++++++++---- src/symbols.rs | 31 ++++++++++++++++++------------- 10 files changed, 75 insertions(+), 26 deletions(-) diff --git a/src/ext.rs b/src/ext.rs index 24eec02..5983785 100644 --- a/src/ext.rs +++ b/src/ext.rs @@ -1,3 +1,7 @@ +use std::string::String; +use std::vec::Vec; +use std::borrow::ToOwned; + use parity_wasm::{elements, builder}; use optimizer::{import_section, export_section}; use byteorder::{LittleEndian, ByteOrder}; @@ -200,4 +204,4 @@ pub fn externalize( module -} \ No newline at end of file +} diff --git a/src/gas.rs b/src/gas.rs index 99bcc6b..730e703 100644 --- a/src/gas.rs +++ b/src/gas.rs @@ -1,3 +1,5 @@ +use std::vec::Vec; + use parity_wasm::{elements, builder}; use rules; diff --git a/src/lib.rs b/src/lib.rs index 50d6e79..f1dc516 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,3 +1,10 @@ +#![cfg_attr(not(feature = "std"), no_std)] +#![cfg_attr(not(feature = "std"), feature(alloc))] + +#[cfg(not(feature = "std"))] +#[macro_use] +extern crate alloc; + extern crate parity_wasm; extern crate byteorder; #[macro_use] extern crate log; @@ -22,3 +29,13 @@ pub use gas::inject_gas_counter; pub use ext::{externalize, externalize_mem, underscore_funcs, ununderscore_funcs, shrink_unknown_stack}; pub use pack::{pack_instance, Error as PackingError}; pub use runtime_type::inject_runtime_type; + +#[cfg(not(feature = "std"))] +mod std { + pub use core::*; + pub use alloc::{vec, string, boxed, borrow}; + + pub mod collections { + pub use alloc::{BTreeMap, BTreeSet}; + } +} diff --git a/src/optimizer.rs b/src/optimizer.rs index 9d2f6bb..890aab0 100644 --- a/src/optimizer.rs +++ b/src/optimizer.rs @@ -1,4 +1,9 @@ -use std::collections::HashSet; +#[cfg(features = "std")] +use std::collections::{HashSet as Set}; +#[cfg(not(features = "std"))] +use std::collections::{BTreeSet as Set}; +use std::vec::Vec; + use parity_wasm::elements; use symbols::{Symbol, expand_symbols, push_code_symbols, resolve_function}; @@ -19,7 +24,7 @@ pub fn optimize( // which in turn compile in unused imports and leaves unused functions // Algo starts from the top, listing all items that should stay - let mut stay = HashSet::new(); + let mut stay = Set::new(); for (index, entry) in module.export_section().ok_or(Error::NoExportSection)?.entries().iter().enumerate() { if used_exports.iter().find(|e| **e == entry.field()).is_some() { stay.insert(Symbol::Export(index)); @@ -615,4 +620,4 @@ mod tests { } } -} \ No newline at end of file +} diff --git a/src/pack.rs b/src/pack.rs index 96e6746..79dd52e 100644 --- a/src/pack.rs +++ b/src/pack.rs @@ -1,4 +1,7 @@ use std::fmt; +use std::vec::Vec; +use std::borrow::ToOwned; + use parity_wasm::elements::{ self, Section, DataSection, Opcode, DataSegment, InitExpr, Internal, External, ImportCountType, diff --git a/src/rules.rs b/src/rules.rs index 50d85cd..f5a254c 100644 --- a/src/rules.rs +++ b/src/rules.rs @@ -1,4 +1,8 @@ -use std::collections::HashMap; +#[cfg(features = "std")] +use std::collections::{HashMap as Map}; +#[cfg(not(features = "std"))] +use std::collections::{BTreeMap as Map}; + use parity_wasm::elements; pub struct UnknownInstruction; @@ -10,7 +14,7 @@ pub enum Metering { Fixed(u32), } -#[derive(Debug, Hash, PartialEq, Eq, Copy, Clone)] +#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Copy, Clone)] pub enum InstructionType { Bit, Add, @@ -265,7 +269,7 @@ impl InstructionType { #[derive(Debug)] pub struct Set { regular: u32, - entries: HashMap, + entries: Map, grow: u32, } @@ -273,14 +277,14 @@ impl Default for Set { fn default() -> Self { Set { regular: 1, - entries: HashMap::new(), + entries: Map::new(), grow: 0, } } } impl Set { - pub fn new(regular: u32, entries: HashMap) -> Self { + pub fn new(regular: u32, entries: Map) -> Self { Set { regular: regular, entries: entries, grow: 0 } } diff --git a/src/stack_height/max_height.rs b/src/stack_height/max_height.rs index fc4ca50..3d55e69 100644 --- a/src/stack_height/max_height.rs +++ b/src/stack_height/max_height.rs @@ -1,3 +1,5 @@ +use std::vec::Vec; + use parity_wasm::elements::{self, BlockType, Type}; use super::{resolve_func_type, Error}; diff --git a/src/stack_height/mod.rs b/src/stack_height/mod.rs index 9502ff5..119dedc 100644 --- a/src/stack_height/mod.rs +++ b/src/stack_height/mod.rs @@ -48,6 +48,9 @@ //! between the frames. //! - upon entry into the function entire stack frame is allocated. +use std::string::String; +use std::vec::Vec; + use parity_wasm::elements::{self, Type}; use parity_wasm::builder; diff --git a/src/stack_height/thunk.rs b/src/stack_height/thunk.rs index be1d626..ea1354b 100644 --- a/src/stack_height/thunk.rs +++ b/src/stack_height/thunk.rs @@ -1,8 +1,12 @@ +#[cfg(features = "std")] +use std::collections::{HashMap as Map}; +#[cfg(not(features = "std"))] +use std::collections::{BTreeMap as Map}; +use std::vec::Vec; + use parity_wasm::elements::{self, FunctionType, Internal}; use parity_wasm::builder; -use std::collections::HashMap; - use super::{resolve_func_type, Context, Error}; struct Thunk { @@ -22,7 +26,7 @@ pub(crate) fn generate_thunks( // Function indicies which needs to generate thunks. let mut need_thunks: Vec = Vec::new(); - let mut replacement_map: HashMap = { + let mut replacement_map: Map = { let exports = module .export_section() .map(|es| es.entries()) @@ -42,7 +46,7 @@ pub(crate) fn generate_thunks( .cloned(); // Replacement map is at least export section size. - let mut replacement_map: HashMap = HashMap::new(); + let mut replacement_map: Map = Map::new(); for func_idx in exported_func_indicies.chain(table_func_indicies) { let callee_stack_cost = ctx.stack_cost(func_idx).ok_or_else(|| { diff --git a/src/symbols.rs b/src/symbols.rs index 3348f1e..4e778a8 100644 --- a/src/symbols.rs +++ b/src/symbols.rs @@ -1,7 +1,12 @@ -use parity_wasm::elements; -use std::collections::HashSet; +#[cfg(features = "std")] +use std::collections::{HashSet as Set}; +#[cfg(not(features = "std"))] +use std::collections::{BTreeSet as Set}; +use std::vec::Vec; -#[derive(PartialEq, Eq, Hash, Copy, Clone, Debug)] +use parity_wasm::elements; + +#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Copy, Clone, Debug)] pub enum Symbol { Type(usize), Import(usize), @@ -63,19 +68,19 @@ pub fn push_code_symbols(module: &elements::Module, opcodes: &[elements::Opcode] dest.push(resolve_global(module, idx)) }, _ => { }, - } + } } } -pub fn expand_symbols(module: &elements::Module, set: &mut HashSet) { +pub fn expand_symbols(module: &elements::Module, set: &mut Set) { use self::Symbol::*; // symbols that were already processed - let mut stop: HashSet = HashSet::new(); + let mut stop: Set = Set::new(); let mut fringe = set.iter().cloned().collect::>(); loop { let next = match fringe.pop() { - Some(s) if stop.contains(&s) => { continue; } + Some(s) if stop.contains(&s) => { continue; } Some(s) => s, _ => { break; } }; @@ -86,7 +91,7 @@ pub fn expand_symbols(module: &elements::Module, set: &mut HashSet) { let entry = &module.export_section().expect("Export section to exist").entries()[idx]; match entry.internal() { &elements::Internal::Function(func_idx) => { - let symbol = resolve_function(module, func_idx); + let symbol = resolve_function(module, func_idx); if !stop.contains(&symbol) { fringe.push(symbol); } @@ -97,7 +102,7 @@ pub fn expand_symbols(module: &elements::Module, set: &mut HashSet) { if !stop.contains(&symbol) { fringe.push(symbol); } - set.insert(symbol); + set.insert(symbol); }, _ => {} } @@ -110,9 +115,9 @@ pub fn expand_symbols(module: &elements::Module, set: &mut HashSet) { if !stop.contains(&type_symbol) { fringe.push(type_symbol); } - set.insert(type_symbol); + set.insert(type_symbol); }, - _ => {} + _ => {} } }, Function(idx) => { @@ -142,11 +147,11 @@ pub fn expand_symbols(module: &elements::Module, set: &mut HashSet) { fringe.push(symbol); } set.insert(symbol); - } + } } _ => {} } stop.insert(next); } -} \ No newline at end of file +}