1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
/* -*- C++ -*-
* Cppcheck - A tool for static C/C++ code analysis
* Copyright (C) 2007-2025 Cppcheck team.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
//---------------------------------------------------------------------------
#ifndef ctuH
#define ctuH
//---------------------------------------------------------------------------
#include "config.h"
#include "check.h"
#include "errorlogger.h"
#include "mathlib.h"
#include "vfvalue.h"
#include <cstdint>
#include <list>
#include <map>
#include <string>
#include <utility>
#include <vector>
class Function;
class Settings;
class Token;
class Tokenizer;
namespace tinyxml2 {
class XMLElement;
}
/// @addtogroup Core
/// @{
/** @brief Whole program analysis (ctu=Cross Translation Unit) */
namespace CTU {
class CPPCHECKLIB FileInfo : public Check::FileInfo {
public:
enum class InvalidValueType : std::uint8_t { null, uninit, bufferOverflow };
std::string toString() const override;
struct Location {
Location() = default;
Location(const Tokenizer &tokenizer, const Token *tok);
Location(std::string fileName, nonneg int lineNumber, nonneg int column) : fileName(std::move(fileName)), lineNumber(lineNumber), column(column) {}
std::string fileName;
nonneg int lineNumber{};
nonneg int column{};
};
struct Value {
Value& operator=(const ValueFlow::Value& val) & {
value = val.intvalue;
unknownFunctionReturn = val.unknownFunctionReturn;
return *this;
}
MathLib::bigint value{};
ValueFlow::Value::UnknownFunctionReturn unknownFunctionReturn{};
};
struct UnsafeUsage {
UnsafeUsage() = default;
UnsafeUsage(std::string myId, nonneg int myArgNr, std::string myArgumentName, Location location, MathLib::bigint value)
: myId(std::move(myId))
, myArgNr(myArgNr)
, myArgumentName(std::move(myArgumentName))
, location(std::move(location))
, value(value) {}
std::string myId;
nonneg int myArgNr{};
std::string myArgumentName;
Location location;
MathLib::bigint value{};
std::string toString() const;
};
class CallBase {
public:
CallBase() = default;
CallBase(std::string callId, int callArgNr, std::string callFunctionName, Location loc)
: callId(std::move(callId)), callArgNr(callArgNr), callFunctionName(std::move(callFunctionName)), location(std::move(loc))
{}
CallBase(const Tokenizer &tokenizer, const Token *callToken);
virtual ~CallBase() = default;
CallBase(const CallBase&) = default;
std::string callId;
int callArgNr{};
std::string callFunctionName;
Location location;
protected:
std::string toBaseXmlString() const;
bool loadBaseFromXml(const tinyxml2::XMLElement *xmlElement);
};
class FunctionCall : public CallBase {
public:
std::string callArgumentExpression;
Value callArgValue;
ValueFlow::Value::ValueType callValueType;
std::vector<ErrorMessage::FileLocation> callValuePath;
bool warning;
std::string toXmlString() const;
bool loadFromXml(const tinyxml2::XMLElement *xmlElement);
};
class NestedCall : public CallBase {
public:
NestedCall() = default;
NestedCall(std::string myId, nonneg int myArgNr, const std::string &callId, nonneg int callArgnr, const std::string &callFunctionName, const Location &location)
: CallBase(callId, callArgnr, callFunctionName, location),
myId(std::move(myId)),
myArgNr(myArgNr) {}
NestedCall(const Tokenizer &tokenizer, const Function *myFunction, const Token *callToken);
std::string toXmlString() const;
bool loadFromXml(const tinyxml2::XMLElement *xmlElement);
std::string myId;
nonneg int myArgNr{};
};
std::list<FunctionCall> functionCalls;
std::list<NestedCall> nestedCalls;
void loadFromXml(const tinyxml2::XMLElement *xmlElement);
std::map<std::string, std::list<const CallBase *>> getCallsMap() const;
static std::list<ErrorMessage::FileLocation> getErrorPath(InvalidValueType invalidValue,
const UnsafeUsage &unsafeUsage,
const std::map<std::string, std::list<const CallBase *>> &callsMap,
const char info[],
const FunctionCall ** functionCallPtr,
bool warning,
int maxCtuDepth,
ValueFlow::Value::UnknownFunctionReturn *unknownFunctionReturn = nullptr);
};
CPPCHECKLIB std::string toString(const std::list<FileInfo::UnsafeUsage> &unsafeUsage);
CPPCHECKLIB std::string getFunctionId(const Tokenizer &tokenizer, const Function *function);
/** @brief Parse current TU and extract file info */
CPPCHECKLIB RET_NONNULL FileInfo *getFileInfo(const Tokenizer &tokenizer);
CPPCHECKLIB std::list<FileInfo::UnsafeUsage> getUnsafeUsage(const Tokenizer &tokenizer, const Settings &settings, bool (*isUnsafeUsage)(const Settings &settings, const Token *argtok, FileInfo::Value *value));
CPPCHECKLIB std::list<FileInfo::UnsafeUsage> loadUnsafeUsageListFromXml(const tinyxml2::XMLElement *xmlElement);
}
/// @}
//---------------------------------------------------------------------------
#endif // ctuH
|
