ValueFlow: avoid unnecessary ValuePtr and Value copies

firewave · firewave · commit b43db4162a91 · 2023-03-03T11:07:05.000+01: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, Escape, Modified, Inconclusive, Conditional };
-    ForwardTraversal(const ValuePtr<Analyzer>& analyzer, const Settings* settings)
-        : analyzer(analyzer), settings(settings), actions(Analyzer::Action::None), analyzeOnly(false), analyzeTerminate(false)
+    ForwardTraversal(ValuePtr<Analyzer> analyzer, const Settings* settings)
+        : analyzer(std::move(analyzer)), settings(settings), actions(Analyzer::Action::None), analyzeOnly(false), analyzeTerminate(false)
     {}
     ValuePtr<Analyzer> analyzer;
     const Settings* settings;
@@ -896,18 +896,18 @@ 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)
 {
-    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();
-    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;
@@ -238,7 +238,7 @@ struct ReverseTraversal {
                         if (a) {
                             valueFlowGenericForward(nextAfterAstRightmostLeaf(assignTok->astOperand2()),
                                                     assignTok->astOperand2()->scope()->bodyEnd,
-                                                    a,
+                                                    std::move(a),
                                                     settings);
                         }
                         // Assignment to
@@ -252,7 +252,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);
                         }
                     }
                 }
@@ -388,14 +388,14 @@ struct ReverseTraversal {
     }
 };
 
-void valueFlowGenericReverse(Token* start, const ValuePtr<Analyzer>& a, const Settings* settings)
+void valueFlowGenericReverse(Token* start, ValuePtr<Analyzer> a, const Settings* settings)
 {
-    ReverseTraversal rt{a, settings};
+    ReverseTraversal rt{std::move(a), settings};
     rt.traverse(start);
 }
 
-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)
 {
-    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,13 +19,13 @@
 #ifndef reverseanalyzerH
 #define reverseanalyzerH
 
+#include "valueptr.h"
+
 struct Analyzer;
 class Settings;
 class Token;
-template<class T>
-class ValuePtr;
 
-void valueFlowGenericReverse(Token* start, const ValuePtr<Analyzer>& a, const Settings* settings);
-void valueFlowGenericReverse(Token* start, const Token* end, const ValuePtr<Analyzer>& a, const Settings* settings);
+void valueFlowGenericReverse(Token* start, 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
@@ -5139,11 +5139,11 @@ static void valueFlowConditionExpressions(TokenList *tokenlist, SymbolDatabase*
                     if (is1) {
                         const bool isBool = astIsBool(condTok2) || Token::Match(condTok2, "%comp%|%oror%|&&");
                         SameExpressionAnalyzer a1(condTok2, makeConditionValue(1, condTok2, /*assume*/ true, !isBool), tokenlist); // 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);
-                    valueFlowGenericForward(startTok, startTok->link(), a2, settings);
+                    valueFlowGenericForward(startTok, startTok->link(), std::move(a2), settings);
                 }
             }
 
@@ -5154,11 +5154,11 @@ static void valueFlowConditionExpressions(TokenList *tokenlist, SymbolDatabase*
                 startTok = startTok->link()->tokAt(2);
                 for (const Token* condTok2:conds) {
                     SameExpressionAnalyzer a1(condTok2, makeConditionValue(0, condTok2, false), tokenlist);
-                    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);
-                        valueFlowGenericForward(startTok, startTok->link(), a2, settings);
+                        valueFlowGenericForward(startTok, startTok->link(), std::move(a2), settings);
                     }
                 }
             }
@@ -5174,11 +5174,11 @@ static void valueFlowConditionExpressions(TokenList *tokenlist, SymbolDatabase*
                 }
                 for (const Token* condTok2:conds) {
                     SameExpressionAnalyzer a1(condTok2, makeConditionValue(0, condTok2, false), tokenlist);
-                    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);
-                        valueFlowGenericForward(startTok->link()->next(), scope2->bodyEnd, a2, settings);
+                        valueFlowGenericForward(startTok->link()->next(), scope2->bodyEnd, std::move(a2), settings);
                     }
                 }
             }
@@ -7208,7 +7208,7 @@ static void valueFlowInjectParameter(TokenList* tokenlist,
 {
     const bool r = productParams(vars, [&](const std::unordered_map<const Variable*, ValueFlow::Value>& arg) {
         MultiValueFlowAnalyzer a(arg, tokenlist, symboldatabase);
-        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>";
@@ -7655,7 +7655,7 @@ static void valueFlowUninit(TokenList* tokenlist, SymbolDatabase* /*symbolDataba
                     continue;
                 }
                 MemberExpressionAnalyzer analyzer(memVar.nameToken()->str(), tok, uninitValue, tokenlist);
-                valueFlowGenericForward(tok->next(), tok->scope()->bodyEnd, analyzer, settings);
+                valueFlowGenericForward(tok->next(), 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;`
`@@ -238,7 +238,7 @@ struct ReverseTraversal {`
`238`	`238`	`if (a) {`
`239`	`239`	`valueFlowGenericForward(nextAfterAstRightmostLeaf(assignTok->astOperand2()),`
`240`	`240`	`assignTok->astOperand2()->scope()->bodyEnd,`
`241`		`- a,`
	`241`	`+ std::move(a),`
`242`	`242`	`settings);`
`243`	`243`	`}`
`244`	`244`	`// Assignment to`
`@@ -252,7 +252,7 @@ struct ReverseTraversal {`
`252`	`252`	`assignTok->astOperand2()->scope()->bodyEnd,`
`253`	`253`	`a,`
`254`	`254`	`settings);`
`255`		`- valueFlowGenericReverse(assignTok->astOperand1()->previous(), end, a, settings);`
	`255`	`+ valueFlowGenericReverse(assignTok->astOperand1()->previous(), end, std::move(a), settings);`
`256`	`256`	`}`
`257`	`257`	`}`
`258`	`258`	`}`
`@@ -388,14 +388,14 @@ struct ReverseTraversal {`
`388`	`388`	`}`
`389`	`389`	`};`
`390`	`390`
`391`		`-void valueFlowGenericReverse(Token* start, const ValuePtr<Analyzer>& a, const Settings* settings)`
	`391`	`+void valueFlowGenericReverse(Token* start, ValuePtr<Analyzer> a, const Settings* settings)`
`392`	`392`	`{`
`393`		`- ReverseTraversal rt{a, settings};`
	`393`	`+ ReverseTraversal rt{std::move(a), settings};`
`394`	`394`	`rt.traverse(start);`
`395`	`395`	`}`
`396`	`396`
`397`		`-void valueFlowGenericReverse(Token* start, const Token* end, const ValuePtr<Analyzer>& a, const Settings* settings)`
	`397`	`+void valueFlowGenericReverse(Token* start, const Token* end, ValuePtr<Analyzer> a, const Settings* settings)`
`398`	`398`	`{`
`399`		`- ReverseTraversal rt{a, settings};`
	`399`	`+ ReverseTraversal rt{std::move(a), settings};`
`400`	`400`	`rt.traverse(start, end);`
`401`	`401`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5139,11 +5139,11 @@ static void valueFlowConditionExpressions(TokenList tokenlist, SymbolDatabase`
`5139`	`5139`	`if (is1) {`
`5140`	`5140`	`const bool isBool = astIsBool(condTok2) \|\| Token::Match(condTok2, "%comp%\|%oror%\|&&");`
`5141`	`5141`	`SameExpressionAnalyzer a1(condTok2, makeConditionValue(1, condTok2, /assume/ true, !isBool), tokenlist); // don't set '1' for non-boolean expressions`
`5142`		`- valueFlowGenericForward(startTok, startTok->link(), a1, settings);`
	`5142`	`+ valueFlowGenericForward(startTok, startTok->link(), std::move(a1), settings);`
`5143`	`5143`	`}`
`5144`	`5144`
`5145`	`5145`	`OppositeExpressionAnalyzer a2(true, condTok2, makeConditionValue(0, condTok2, true), tokenlist);`
`5146`		`- valueFlowGenericForward(startTok, startTok->link(), a2, settings);`
	`5146`	`+ valueFlowGenericForward(startTok, startTok->link(), std::move(a2), settings);`
`5147`	`5147`	`}`
`5148`	`5148`	`}`
`5149`	`5149`
`@@ -5154,11 +5154,11 @@ static void valueFlowConditionExpressions(TokenList tokenlist, SymbolDatabase`
`5154`	`5154`	`startTok = startTok->link()->tokAt(2);`
`5155`	`5155`	`for (const Token* condTok2:conds) {`
`5156`	`5156`	`SameExpressionAnalyzer a1(condTok2, makeConditionValue(0, condTok2, false), tokenlist);`
`5157`		`- valueFlowGenericForward(startTok, startTok->link(), a1, settings);`
	`5157`	`+ valueFlowGenericForward(startTok, startTok->link(), std::move(a1), settings);`
`5158`	`5158`
`5159`	`5159`	`if (is1) {`
`5160`	`5160`	`OppositeExpressionAnalyzer a2(true, condTok2, makeConditionValue(1, condTok2, false), tokenlist);`
`5161`		`- valueFlowGenericForward(startTok, startTok->link(), a2, settings);`
	`5161`	`+ valueFlowGenericForward(startTok, startTok->link(), std::move(a2), settings);`
`5162`	`5162`	`}`
`5163`	`5163`	`}`
`5164`	`5164`	`}`
`@@ -5174,11 +5174,11 @@ static void valueFlowConditionExpressions(TokenList tokenlist, SymbolDatabase`
`5174`	`5174`	`}`
`5175`	`5175`	`for (const Token* condTok2:conds) {`
`5176`	`5176`	`SameExpressionAnalyzer a1(condTok2, makeConditionValue(0, condTok2, false), tokenlist);`
`5177`		`- valueFlowGenericForward(startTok->link()->next(), scope2->bodyEnd, a1, settings);`
	`5177`	`+ valueFlowGenericForward(startTok->link()->next(), scope2->bodyEnd, std::move(a1), settings);`
`5178`	`5178`
`5179`	`5179`	`if (is1) {`
`5180`	`5180`	`OppositeExpressionAnalyzer a2(true, condTok2, makeConditionValue(1, condTok2, false), tokenlist);`
`5181`		`- valueFlowGenericForward(startTok->link()->next(), scope2->bodyEnd, a2, settings);`
	`5181`	`+ valueFlowGenericForward(startTok->link()->next(), scope2->bodyEnd, std::move(a2), settings);`
`5182`	`5182`	`}`
`5183`	`5183`	`}`
`5184`	`5184`	`}`
`@@ -7208,7 +7208,7 @@ static void valueFlowInjectParameter(TokenList* tokenlist,`
`7208`	`7208`	`{`
`7209`	`7209`	`const bool r = productParams(vars, [&](const std::unordered_map<const Variable*, ValueFlow::Value>& arg) {`
`7210`	`7210`	`MultiValueFlowAnalyzer a(arg, tokenlist, symboldatabase);`
`7211`		`- valueFlowGenericForward(const_cast<Token*>(functionScope->bodyStart), functionScope->bodyEnd, a, settings);`
	`7211`	`+ valueFlowGenericForward(const_cast<Token*>(functionScope->bodyStart), functionScope->bodyEnd, std::move(a), settings);`
`7212`	`7212`	`});`
`7213`	`7213`	`if (!r) {`
`7214`	`7214`	`std::string fname = "<unknown>";`
`@@ -7655,7 +7655,7 @@ static void valueFlowUninit(TokenList* tokenlist, SymbolDatabase* /*symbolDataba`
`7655`	`7655`	`continue;`
`7656`	`7656`	`}`
`7657`	`7657`	`MemberExpressionAnalyzer analyzer(memVar.nameToken()->str(), tok, uninitValue, tokenlist);`
`7658`		`- valueFlowGenericForward(tok->next(), tok->scope()->bodyEnd, analyzer, settings);`
	`7658`	`+ valueFlowGenericForward(tok->next(), tok->scope()->bodyEnd, std::move(analyzer), settings);`
`7659`	`7659`
`7660`	`7660`	`for (auto&& p : *analyzer.partialReads) {`
`7661`	`7661`	`Token* tok2 = p.first;`