ValueFlow: avoid unnecessary ValuePtr and Value copies

firewave · firewave · commit d126b72c35a2 · 2023-08-30T13:26:25.000+02:00
diff --git a/lib/forwardanalyzer.cpp b/lib/forwardanalyzer.cpp
@@ -50,8 +50,8 @@ struct OnExit {
 struct ForwardTraversal {
     enum class Progress { Continue, Break, Skip };
     enum class Terminate { None, Bail, Inconclusive };
-    ForwardTraversal(const ValuePtr<Analyzer>& analyzer, const Settings& settings)
-        : analyzer(analyzer), settings(settings)
+    ForwardTraversal(ValuePtr<Analyzer> analyzer, const Settings& settings)
+        : analyzer(std::move(analyzer)), settings(settings)
     {}
     ValuePtr<Analyzer> analyzer;
     const Settings& settings;
@@ -891,22 +891,22 @@ struct ForwardTraversal {
     }
 };
 
-Analyzer::Result valueFlowGenericForward(Token* start, const Token* end, const ValuePtr<Analyzer>& a, const Settings& settings)
+Analyzer::Result valueFlowGenericForward(Token* start, const Token* end, ValuePtr<Analyzer>& a, const Settings settings)
 {
     if (a->invalid())
         return Analyzer::Result{Analyzer::Action::None, Analyzer::Terminate::Bail};
-    ForwardTraversal ft{a, settings};
+    ForwardTraversal ft{std::move(a), settings};
     ft.updateRange(start, end);
     return Analyzer::Result{ ft.actions, ft.terminate };
 }
 
-Analyzer::Result valueFlowGenericForward(Token* start, const ValuePtr<Analyzer>& a, const Settings& settings)
+Analyzer::Result valueFlowGenericForward(Token* start, ValuePtr<Analyzer> a, const Settings& settings)
 {
     if (Settings::terminated())
         throw TerminateException();
     if (a->invalid())
         return Analyzer::Result{Analyzer::Action::None, Analyzer::Terminate::Bail};
-    ForwardTraversal ft{a, settings};
+    ForwardTraversal ft{std::move(a), settings};
     ft.updateRecursive(start);
     return Analyzer::Result{ ft.actions, ft.terminate };
 }
diff --git a/lib/forwardanalyzer.h b/lib/forwardanalyzer.h
@@ -20,16 +20,16 @@
 #define forwardanalyzerH
 
 #include "analyzer.h"
+#include "valueptr.h"
 
 class Settings;
 class Token;
-template<class T> class ValuePtr;
 
 Analyzer::Result valueFlowGenericForward(Token* start,
                                          const Token* end,
-                                         const ValuePtr<Analyzer>& a,
+                                         ValuePtr<Analyzer> a,
                                          const Settings& settings);
 
-Analyzer::Result valueFlowGenericForward(Token* start, const ValuePtr<Analyzer>& a, const Settings& settings);
+Analyzer::Result valueFlowGenericForward(Token* start, ValuePtr<Analyzer> a, const Settings& settings);
 
 #endif
diff --git a/lib/reverseanalyzer.cpp b/lib/reverseanalyzer.cpp
@@ -36,8 +36,8 @@
 #include <vector>
 
 struct ReverseTraversal {
-    ReverseTraversal(const ValuePtr<Analyzer>& analyzer, const Settings& settings)
-        : analyzer(analyzer), settings(settings)
+    ReverseTraversal(ValuePtr<Analyzer> analyzer, const Settings& settings)
+        : analyzer(std::move(analyzer)), settings(settings)
     {}
     ValuePtr<Analyzer> analyzer;
     const Settings& settings;
@@ -237,7 +237,7 @@ struct ReverseTraversal {
                         if (a) {
                             valueFlowGenericForward(nextAfterAstRightmostLeaf(assignTok->astOperand2()),
                                                     assignTok->astOperand2()->scope()->bodyEnd,
-                                                    a,
+                                                    std::move(a),
                                                     settings);
                         }
                         // Assignment to
@@ -251,7 +251,7 @@ struct ReverseTraversal {
                                                     assignTok->astOperand2()->scope()->bodyEnd,
                                                     a,
                                                     settings);
-                            valueFlowGenericReverse(assignTok->astOperand1()->previous(), end, a, settings);
+                            valueFlowGenericReverse(assignTok->astOperand1()->previous(), end, std::move(a), settings);
                         }
                     }
                 }
@@ -387,10 +387,10 @@ struct ReverseTraversal {
     }
 };
 
-void valueFlowGenericReverse(Token* start, const Token* end, const ValuePtr<Analyzer>& a, const Settings& settings)
+void valueFlowGenericReverse(Token* start, const Token* end, ValuePtr<Analyzer> a, const Settings& settings)
 {
     if (a->invalid())
         return;
-    ReverseTraversal rt{a, settings};
+    ReverseTraversal rt{std::move(a), settings};
     rt.traverse(start, end);
 }
diff --git a/lib/reverseanalyzer.h b/lib/reverseanalyzer.h
@@ -19,12 +19,12 @@
 #ifndef reverseanalyzerH
 #define reverseanalyzerH
 
+#include "valueptr.h"
+
 struct Analyzer;
 class Settings;
 class Token;
-template<class T>
-class ValuePtr;
 
-void valueFlowGenericReverse(Token* start, const Token* end, const ValuePtr<Analyzer>& a, const Settings& settings);
+void valueFlowGenericReverse(Token* start, const Token* end, ValuePtr<Analyzer> a, const Settings& settings);
 
 #endif
diff --git a/lib/valueflow.cpp b/lib/valueflow.cpp
@@ -5274,11 +5274,11 @@ static void valueFlowConditionExpressions(TokenList &tokenlist, const SymbolData
                     if (is1) {
                         const bool isBool = astIsBool(condTok2) || Token::Match(condTok2, "%comp%|%oror%|&&");
                         SameExpressionAnalyzer a1(condTok2, makeConditionValue(1, condTok2, /*assume*/ true, !isBool), tokenlist, &settings); // don't set '1' for non-boolean expressions
-                        valueFlowGenericForward(startTok, startTok->link(), a1, settings);
+                        valueFlowGenericForward(startTok, startTok->link(), std::move(a1), settings);
                     }
 
                     OppositeExpressionAnalyzer a2(true, condTok2, makeConditionValue(0, condTok2, true), tokenlist, &settings);
-                    valueFlowGenericForward(startTok, startTok->link(), a2, settings);
+                    valueFlowGenericForward(startTok, startTok->link(), std::move(a2), settings);
                 }
             }
 
@@ -5289,11 +5289,11 @@ static void valueFlowConditionExpressions(TokenList &tokenlist, const SymbolData
                 startTok = startTok->link()->tokAt(2);
                 for (const Token* condTok2:conds) {
                     SameExpressionAnalyzer a1(condTok2, makeConditionValue(0, condTok2, false), tokenlist, &settings);
-                    valueFlowGenericForward(startTok, startTok->link(), a1, settings);
+                    valueFlowGenericForward(startTok, startTok->link(), std::move(a1), settings);
 
                     if (is1) {
                         OppositeExpressionAnalyzer a2(true, condTok2, makeConditionValue(1, condTok2, false), tokenlist, &settings);
-                        valueFlowGenericForward(startTok, startTok->link(), a2, settings);
+                        valueFlowGenericForward(startTok, startTok->link(), std::move(a2), settings);
                     }
                 }
             }
@@ -5309,11 +5309,11 @@ static void valueFlowConditionExpressions(TokenList &tokenlist, const SymbolData
                 }
                 for (const Token* condTok2:conds) {
                     SameExpressionAnalyzer a1(condTok2, makeConditionValue(0, condTok2, false), tokenlist, &settings);
-                    valueFlowGenericForward(startTok->link()->next(), scope2->bodyEnd, a1, settings);
+                    valueFlowGenericForward(startTok->link()->next(), scope2->bodyEnd, std::move(a1), settings);
 
                     if (is1) {
                         OppositeExpressionAnalyzer a2(true, condTok2, makeConditionValue(1, condTok2, false), tokenlist, &settings);
-                        valueFlowGenericForward(startTok->link()->next(), scope2->bodyEnd, a2, settings);
+                        valueFlowGenericForward(startTok->link()->next(), scope2->bodyEnd, std::move(a2), settings);
                     }
                 }
             }
@@ -7389,7 +7389,7 @@ static void valueFlowInjectParameter(TokenList& tokenlist,
 {
     const bool r = productParams(&settings, vars, [&](const std::unordered_map<const Variable*, ValueFlow::Value>& arg) {
         MultiValueFlowAnalyzer a(arg, tokenlist, &settings);
-        valueFlowGenericForward(const_cast<Token*>(functionScope->bodyStart), functionScope->bodyEnd, a, settings);
+        valueFlowGenericForward(const_cast<Token*>(functionScope->bodyStart), functionScope->bodyEnd, std::move(a), settings);
     });
     if (!r) {
         std::string fname = "<unknown>";
@@ -8014,7 +8014,7 @@ static void valueFlowUninit(TokenList& tokenlist, const Settings* settings)
                     continue;
                 }
                 MemberExpressionAnalyzer analyzer(memVar.nameToken()->str(), tok, uninitValue, tokenlist, settings);
-                valueFlowGenericForward(start, tok->scope()->bodyEnd, analyzer, *settings);
+                valueFlowGenericForward(start, tok->scope()->bodyEnd, std::move(analyzer), *settings);
 
                 for (auto&& p : *analyzer.partialReads) {
                     Token* tok2 = p.first;

Original file line number	Diff line number	Diff line change
`@@ -36,8 +36,8 @@`
`36`	`36`	`#include <vector>`
`37`	`37`
`38`	`38`	`struct ReverseTraversal {`
`39`		`- ReverseTraversal(const ValuePtr<Analyzer>& analyzer, const Settings& settings)`
`40`		`- : analyzer(analyzer), settings(settings)`
	`39`	`+ ReverseTraversal(ValuePtr<Analyzer> analyzer, const Settings& settings)`
	`40`	`+ : analyzer(std::move(analyzer)), settings(settings)`
`41`	`41`	`{}`
`42`	`42`	`ValuePtr<Analyzer> analyzer;`
`43`	`43`	`const Settings& settings;`
`@@ -237,7 +237,7 @@ struct ReverseTraversal {`
`237`	`237`	`if (a) {`
`238`	`238`	`valueFlowGenericForward(nextAfterAstRightmostLeaf(assignTok->astOperand2()),`
`239`	`239`	`assignTok->astOperand2()->scope()->bodyEnd,`
`240`		`- a,`
	`240`	`+ std::move(a),`
`241`	`241`	`settings);`
`242`	`242`	`}`
`243`	`243`	`// Assignment to`
`@@ -251,7 +251,7 @@ struct ReverseTraversal {`
`251`	`251`	`assignTok->astOperand2()->scope()->bodyEnd,`
`252`	`252`	`a,`
`253`	`253`	`settings);`
`254`		`- valueFlowGenericReverse(assignTok->astOperand1()->previous(), end, a, settings);`
	`254`	`+ valueFlowGenericReverse(assignTok->astOperand1()->previous(), end, std::move(a), settings);`
`255`	`255`	`}`
`256`	`256`	`}`
`257`	`257`	`}`
`@@ -387,10 +387,10 @@ struct ReverseTraversal {`
`387`	`387`	`}`
`388`	`388`	`};`
`389`	`389`
`390`		`-void valueFlowGenericReverse(Token* start, const Token* end, const ValuePtr<Analyzer>& a, const Settings& settings)`
	`390`	`+void valueFlowGenericReverse(Token* start, const Token* end, ValuePtr<Analyzer> a, const Settings& settings)`
`391`	`391`	`{`
`392`	`392`	`if (a->invalid())`
`393`	`393`	`return;`
`394`		`- ReverseTraversal rt{a, settings};`
	`394`	`+ ReverseTraversal rt{std::move(a), settings};`
`395`	`395`	`rt.traverse(start, end);`
`396`	`396`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5274,11 +5274,11 @@ static void valueFlowConditionExpressions(TokenList &tokenlist, const SymbolData`
`5274`	`5274`	`if (is1) {`
`5275`	`5275`	`const bool isBool = astIsBool(condTok2) \|\| Token::Match(condTok2, "%comp%\|%oror%\|&&");`
`5276`	`5276`	`SameExpressionAnalyzer a1(condTok2, makeConditionValue(1, condTok2, /assume/ true, !isBool), tokenlist, &settings); // don't set '1' for non-boolean expressions`
`5277`		`- valueFlowGenericForward(startTok, startTok->link(), a1, settings);`
	`5277`	`+ valueFlowGenericForward(startTok, startTok->link(), std::move(a1), settings);`
`5278`	`5278`	`}`
`5279`	`5279`
`5280`	`5280`	`OppositeExpressionAnalyzer a2(true, condTok2, makeConditionValue(0, condTok2, true), tokenlist, &settings);`
`5281`		`- valueFlowGenericForward(startTok, startTok->link(), a2, settings);`
	`5281`	`+ valueFlowGenericForward(startTok, startTok->link(), std::move(a2), settings);`
`5282`	`5282`	`}`
`5283`	`5283`	`}`
`5284`	`5284`
`@@ -5289,11 +5289,11 @@ static void valueFlowConditionExpressions(TokenList &tokenlist, const SymbolData`
`5289`	`5289`	`startTok = startTok->link()->tokAt(2);`
`5290`	`5290`	`for (const Token* condTok2:conds) {`
`5291`	`5291`	`SameExpressionAnalyzer a1(condTok2, makeConditionValue(0, condTok2, false), tokenlist, &settings);`
`5292`		`- valueFlowGenericForward(startTok, startTok->link(), a1, settings);`
	`5292`	`+ valueFlowGenericForward(startTok, startTok->link(), std::move(a1), settings);`
`5293`	`5293`
`5294`	`5294`	`if (is1) {`
`5295`	`5295`	`OppositeExpressionAnalyzer a2(true, condTok2, makeConditionValue(1, condTok2, false), tokenlist, &settings);`
`5296`		`- valueFlowGenericForward(startTok, startTok->link(), a2, settings);`
	`5296`	`+ valueFlowGenericForward(startTok, startTok->link(), std::move(a2), settings);`
`5297`	`5297`	`}`
`5298`	`5298`	`}`
`5299`	`5299`	`}`
`@@ -5309,11 +5309,11 @@ static void valueFlowConditionExpressions(TokenList &tokenlist, const SymbolData`
`5309`	`5309`	`}`
`5310`	`5310`	`for (const Token* condTok2:conds) {`
`5311`	`5311`	`SameExpressionAnalyzer a1(condTok2, makeConditionValue(0, condTok2, false), tokenlist, &settings);`
`5312`		`- valueFlowGenericForward(startTok->link()->next(), scope2->bodyEnd, a1, settings);`
	`5312`	`+ valueFlowGenericForward(startTok->link()->next(), scope2->bodyEnd, std::move(a1), settings);`
`5313`	`5313`
`5314`	`5314`	`if (is1) {`
`5315`	`5315`	`OppositeExpressionAnalyzer a2(true, condTok2, makeConditionValue(1, condTok2, false), tokenlist, &settings);`
`5316`		`- valueFlowGenericForward(startTok->link()->next(), scope2->bodyEnd, a2, settings);`
	`5316`	`+ valueFlowGenericForward(startTok->link()->next(), scope2->bodyEnd, std::move(a2), settings);`
`5317`	`5317`	`}`
`5318`	`5318`	`}`
`5319`	`5319`	`}`
`@@ -7389,7 +7389,7 @@ static void valueFlowInjectParameter(TokenList& tokenlist,`
`7389`	`7389`	`{`
`7390`	`7390`	`const bool r = productParams(&settings, vars, [&](const std::unordered_map<const Variable*, ValueFlow::Value>& arg) {`
`7391`	`7391`	`MultiValueFlowAnalyzer a(arg, tokenlist, &settings);`
`7392`		`- valueFlowGenericForward(const_cast<Token*>(functionScope->bodyStart), functionScope->bodyEnd, a, settings);`
	`7392`	`+ valueFlowGenericForward(const_cast<Token*>(functionScope->bodyStart), functionScope->bodyEnd, std::move(a), settings);`
`7393`	`7393`	`});`
`7394`	`7394`	`if (!r) {`
`7395`	`7395`	`std::string fname = "<unknown>";`
`@@ -8014,7 +8014,7 @@ static void valueFlowUninit(TokenList& tokenlist, const Settings* settings)`
`8014`	`8014`	`continue;`
`8015`	`8015`	`}`
`8016`	`8016`	`MemberExpressionAnalyzer analyzer(memVar.nameToken()->str(), tok, uninitValue, tokenlist, settings);`
`8017`		`- valueFlowGenericForward(start, tok->scope()->bodyEnd, analyzer, *settings);`
	`8017`	`+ valueFlowGenericForward(start, tok->scope()->bodyEnd, std::move(analyzer), *settings);`
`8018`	`8018`
`8019`	`8019`	`for (auto&& p : *analyzer.partialReads) {`
`8020`	`8020`	`Token* tok2 = p.first;`