Change storagelocation to include block and msg + fix benches

nascentxyz · Dec 8, 2023 · 3d1b17a · 3d1b17a
1 parent 357d1c9
commit 3d1b17a
Show file tree

Hide file tree

Showing 20 changed files with 516 additions and 42 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -48,9 +48,6 @@ petgraph = "0.6.2"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
-# [dev-dependencies]
-# criterion = { version = "0.4"} # benching
-
 # [workspace]
 # members = ["cli", "shared"]
 

diff --git a/crates/analyzers/src/bounds.rs b/crates/analyzers/src/bounds.rs
@@ -3,9 +3,9 @@ use crate::{FunctionVarsBoundAnalysis, LocSpan, LocStrSpan, ReportConfig, VarBou
 use graph::{
     nodes::ContextNode, range_string::ToRangeString, GraphBackend, Range, RangeEval, SolcRange,
 };
+use shared::StorageLocation;
 
 use ariadne::{Color, Fmt, Label, Span};
-use solang_parser::pt::StorageLocation;
 use std::collections::{BTreeMap, BTreeSet};
 
 pub static MIN_COLOR: Color = Color::Fixed(111);
@@ -171,6 +171,8 @@ impl From<AnalysisItem> for Label<LocStrSpan> {
                     Some(StorageLocation::Memory(..)) => Color::Blue,
                     Some(StorageLocation::Storage(..)) => Color::Green,
                     Some(StorageLocation::Calldata(..)) => Color::White,
+                    Some(StorageLocation::Block(..)) => Color::Magenta,
+                    Some(StorageLocation::Msg(..)) => Color::Cyan,
                     None => Color::Cyan,
                 },
                 val.order,
@@ -185,6 +187,8 @@ impl From<AnalysisItem> for Label<LocStrSpan> {
                     Some(StorageLocation::Memory(..)) => "Memory var ",
                     Some(StorageLocation::Storage(..)) => "Storage var ",
                     Some(StorageLocation::Calldata(..)) => "Calldata var ",
+                    Some(StorageLocation::Block(..)) => "Block var ",
+                    Some(StorageLocation::Msg(..)) => "Msg var ",
                     None => "",
                 },
                 val.name,

diff --git a/crates/analyzers/src/var_analyzer/mod.rs b/crates/analyzers/src/var_analyzer/mod.rs
@@ -7,11 +7,11 @@ use graph::{
     nodes::{ContextNode, ContextVarNode, KilledKind},
     AnalyzerBackend, GraphBackend, Range, SolcRange,
 };
-use shared::Search;
+use shared::{StorageLocation, Search};
 
 use std::collections::BTreeSet;
 
-use solang_parser::pt::{CodeLocation, StorageLocation};
+use solang_parser::pt::CodeLocation;
 use std::collections::BTreeMap;
 
 mod report_display;

diff --git a/crates/graph/src/nodes/context/var/node.rs b/crates/graph/src/nodes/context/var/node.rs
@@ -4,10 +4,10 @@ use crate::{
     AsDotStr, ContextEdge, Edge, GraphBackend, GraphError, Node,
 };
 
-use shared::{NodeIdx, Search};
+use shared::{NodeIdx, Search, StorageLocation};
 
 use petgraph::{visit::EdgeRef, Direction};
-use solang_parser::pt::{Loc, StorageLocation};
+use solang_parser::pt::Loc;
 
 use std::collections::BTreeMap;
 

diff --git a/crates/graph/src/nodes/context/var/typing.rs b/crates/graph/src/nodes/context/var/typing.rs
@@ -3,10 +3,10 @@ use crate::{
     AnalyzerBackend, ContextEdge, Edge, GraphBackend, GraphError, Node, VarType,
 };
 
-use shared::Search;
+use shared::{StorageLocation, Search};
 
 use petgraph::Direction;
-use solang_parser::pt::{Loc, StorageLocation};
+use solang_parser::pt::Loc;
 
 impl ContextVarNode {
     pub fn ty<'a>(&self, analyzer: &'a impl GraphBackend) -> Result<&'a VarType, GraphError> {
@@ -66,6 +66,8 @@ impl ContextVarNode {
 
         Ok((global_first.is_storage(analyzer)?
             || global_first.is_calldata_input(analyzer)
+            || global_first.is_msg(analyzer)?
+            || global_first.is_block(analyzer)?
             || (
                 // if its a function input, and we are evaluating the function
                 // as a standalone (i.e. its internal, but we are treating it like its external)
@@ -84,7 +86,7 @@ impl ContextVarNode {
     }
 
     pub fn is_controllable(&self, analyzer: &impl GraphBackend) -> Result<bool, GraphError> {
-        if self.is_storage_or_calldata_input(analyzer)? {
+        if self.is_storage_or_calldata_input(analyzer)? || self.is_msg(analyzer)? || self.is_block(analyzer)? {
             Ok(true)
         } else if let Some(tmp) = self.tmp_of(analyzer)? {
             let rhs_controllable = if let Some(rhs) = tmp.rhs {
@@ -107,6 +109,20 @@ impl ContextVarNode {
             .any(|edge| Edge::Context(ContextEdge::CalldataVariable) == *edge.weight())
     }
 
+    pub fn is_msg(&self, analyzer: &impl GraphBackend) -> Result<bool, GraphError> {
+        Ok(matches!(
+            self.underlying(analyzer)?.storage,
+            Some(StorageLocation::Msg(..))
+        ))
+    }
+
+    pub fn is_block(&self, analyzer: &impl GraphBackend) -> Result<bool, GraphError> {
+        Ok(matches!(
+            self.underlying(analyzer)?.storage,
+            Some(StorageLocation::Block(..))
+        ))
+    }
+
     pub fn is_func_input(&self, analyzer: &impl GraphBackend) -> bool {
         let first = self.first_version(analyzer);
         analyzer

diff --git a/crates/graph/src/nodes/context/var/underlying.rs b/crates/graph/src/nodes/context/var/underlying.rs
@@ -8,9 +8,9 @@ use crate::{
 };
 
 use crate::range::elem::*;
-use shared::NodeIdx;
+use shared::{StorageLocation, NodeIdx};
 
-use solang_parser::pt::{Loc, StorageLocation};
+use solang_parser::pt::Loc;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ContextVar {

diff --git a/crates/graph/src/nodes/func_ty.rs b/crates/graph/src/nodes/func_ty.rs
@@ -4,14 +4,14 @@ use crate::{
     VarType,
 };
 
-use shared::{NodeIdx, Search};
+use shared::{NodeIdx, Search, StorageLocation};
 
 use petgraph::{visit::EdgeRef, Direction};
 use solang_parser::{
     helpers::CodeLocation,
     pt::{
         Base, Expression, FunctionAttribute, FunctionDefinition, FunctionTy, Identifier, Loc,
-        Parameter, ParameterList, Statement, StorageLocation, Type, VariableDefinition, Visibility,
+        Parameter, ParameterList, Statement, Type, VariableDefinition, Visibility,
     },
 };
 use std::collections::BTreeMap;
@@ -785,7 +785,7 @@ impl FunctionParam {
             loc: param.loc,
             ty: analyzer.parse_expr(&param.ty, None),
             order,
-            storage: param.storage,
+            storage: if let Some(s) = param.storage { Some(s.into()) } else { None },
             name: param.name,
         }
     }
@@ -875,7 +875,7 @@ impl FunctionReturn {
         FunctionReturn {
             loc: param.loc,
             ty: analyzer.parse_expr(&param.ty, None),
-            storage: param.storage,
+            storage: if let Some(s) = param.storage { Some(s.into()) } else { None },
             name: param.name,
         }
     }

diff --git a/crates/graph/src/range/elem/expr.rs b/crates/graph/src/range/elem/expr.rs
@@ -50,13 +50,13 @@ impl RangeExpr<Concrete> {
             if SINGLETON_EQ_OPS.contains(&self.op) {
                 let mut new_self = self.clone();
                 new_self.uncache();
-                new_self.op = new_self.op.logical_inverse().unwrap();
+                new_self.op = new_self.op.logical_inverse()?;
                 Some(new_self)
             } else {
                 // non-singleton, i.e. AND or OR
                 let mut new_self = self.clone();
                 new_self.uncache();
-                new_self.op = new_self.op.inverse().unwrap();
+                new_self.op = new_self.op.inverse()?;
                 if let Some(new_lhs) = new_self.inverse_if_boolean() {
                     *new_self.lhs = Elem::Expr(new_lhs);
                 }
@@ -220,6 +220,32 @@ fn collapse(l: Elem<Concrete>, op: RangeOp, r: Elem<Concrete>) -> MaybeCollapsed
             let y = expr.rhs;
             let z = c;
             match (expr.op, op) {
+                (RangeOp::Sub(false), RangeOp::Min) => {
+                    // min{x - y, z}
+                    // if x <= z, then x - y will be the minimum if y >= 0
+                    if matches!(x.range_ord(&z), Some(std::cmp::Ordering::Equal) | Some(std::cmp::Ordering::Less))
+                    && matches!(y.range_ord(&zero), Some(std::cmp::Ordering::Equal) | Some(std::cmp::Ordering::Greater)) {
+                        MaybeCollapsed::Collapsed(l)
+                    } else {
+                        MaybeCollapsed::Not(l, r)
+                    }
+                }
+                (RangeOp::Add(false), RangeOp::Max) => {
+                    // max{x + y, z}
+                    // if x >= z, then x + y will be the maximum if y >= 0
+                    // or if y >= z, then x + y will be the maximum if x >= 0
+                    if (
+                        matches!(x.range_ord(&z), Some(std::cmp::Ordering::Equal) | Some(std::cmp::Ordering::Greater))
+                        && matches!(y.range_ord(&zero), Some(std::cmp::Ordering::Equal) | Some(std::cmp::Ordering::Greater))
+                    ) || (
+                        matches!(y.range_ord(&z), Some(std::cmp::Ordering::Equal) | Some(std::cmp::Ordering::Greater))
+                        && matches!(x.range_ord(&zero), Some(std::cmp::Ordering::Equal) | Some(std::cmp::Ordering::Greater)) 
+                    ) {
+                        MaybeCollapsed::Collapsed(l)
+                    } else {
+                        MaybeCollapsed::Not(l, r)
+                    }
+                }
                 (RangeOp::Eq, RangeOp::Eq) => {
                     // ((x == y) == z)
                     // can skip if x and z eq

diff --git a/crates/pyrometer/Cargo.toml b/crates/pyrometer/Cargo.toml
@@ -22,4 +22,14 @@ ethers-core.workspace = true
 ariadne.workspace = true
 tracing.workspace = true
 tracing-subscriber.workspace = true
-serde_json = "1"
+serde_json = "1"
+
+
+
+
+[dev-dependencies]
+criterion = { version = "0.4"} # benching
+
+[[bench]]
+name = "parse"
+harness = false
diff --git a/benches/README.md → crates/pyrometer/benches/README.md b/benches/README.md → crates/pyrometer/benches/README.md
diff --git a/benches/flamegraphs/parse.svg → ...s/pyrometer/benches/flamegraphs/parse.svg b/benches/flamegraphs/parse.svg → ...s/pyrometer/benches/flamegraphs/parse.svg
diff --git a/benches/parse.rs → crates/pyrometer/benches/parse.rs b/benches/parse.rs → crates/pyrometer/benches/parse.rs
@@ -1,5 +1,5 @@
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
-use pyrometer::Analyzer;
+use pyrometer::{Analyzer, SourcePath};
 use std::path::PathBuf;
 
 use std::env::{self};
@@ -73,9 +73,7 @@ fn bench(c: &mut Criterion) {
 /// * `path` - A `PathBuf` representing the path to the source code file.
 /// * `sol` - A string containing the Solidity source code.
 fn parse(path: &PathBuf, sol: String) {
-    let mut analyzer = Analyzer {
-        root: path.clone(),
-        ..Default::default()
-    };
-    let (_maybe_entry, mut _all_sources) = analyzer.parse(&sol, &path, true);
+    let mut analyzer = Analyzer::default();
+    let current_path = SourcePath::SolidityFile(path.clone());
+    let _maybe_entry = analyzer.parse(&sol, &current_path, true);
 }
diff --git a/crates/pyrometer/src/builtin_fns.rs b/crates/pyrometer/src/builtin_fns.rs
@@ -1,7 +1,7 @@
 use graph::nodes::{Builtin, Function, FunctionParam, FunctionReturn};
-use shared::{AnalyzerLike, GraphLike};
+use shared::{AnalyzerLike, GraphLike, StorageLocation};
 
-use solang_parser::pt::{FunctionAttribute, Identifier, Loc, StorageLocation, Visibility};
+use solang_parser::pt::{FunctionAttribute, Identifier, Loc, Visibility};
 
 use std::collections::HashMap;
 

diff --git a/crates/shared/src/lib.rs b/crates/shared/src/lib.rs
@@ -5,3 +5,41 @@ mod search;
 pub use analyzer_like::*;
 pub use graph_like::*;
 pub use search::*;
+
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Hash)]
+pub enum StorageLocation {
+	Memory(solang_parser::pt::Loc),
+	Storage(solang_parser::pt::Loc),
+	Calldata(solang_parser::pt::Loc),
+	Block(solang_parser::pt::Loc),
+	Msg(solang_parser::pt::Loc),
+}
+
+impl std::fmt::Display for StorageLocation {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		match self {
+			Self::Memory(_) => write!(f, "memory"),
+			Self::Storage(_) => write!(f, "storage"),
+			Self::Calldata(_) => write!(f, "calldata"),
+			Self::Block(_) => write!(f, "block"),
+			Self::Msg(_) => write!(f, "msg"),
+		}
+	}
+}
+
+impl From<solang_parser::pt::StorageLocation> for StorageLocation {
+	fn from(sl: solang_parser::pt::StorageLocation) -> Self {
+		match sl {
+			solang_parser::pt::StorageLocation::Memory(m) =>{
+				StorageLocation::Memory(m)
+			}
+			solang_parser::pt::StorageLocation::Storage(m) =>{
+				StorageLocation::Storage(m)
+			}
+			solang_parser::pt::StorageLocation::Calldata(m) =>{
+				StorageLocation::Calldata(m)
+			}
+		}
+	}
+}
diff --git a/crates/solc-expressions/src/context_builder/mod.rs b/crates/solc-expressions/src/context_builder/mod.rs
@@ -615,7 +615,7 @@ pub trait ContextBuilder:
                     loc: Some(loc),
                     name: name.to_string(),
                     display_name: name.to_string(),
-                    storage: var_decl.storage.clone(),
+                    storage: if let Some(s) = &var_decl.storage { Some(s.clone().into()) } else { None },
                     is_tmp: false,
                     is_symbolic: true,
                     tmp_of: None,
@@ -642,7 +642,7 @@ pub trait ContextBuilder:
                     loc: Some(loc),
                     name: name.to_string(),
                     display_name: name.to_string(),
-                    storage: var_decl.storage.clone(),
+                    storage: if let Some(s) = &var_decl.storage { Some(s.clone().into()) } else { None },
                     is_tmp: false,
                     is_symbolic: true,
                     tmp_of: None,