cppcheck/lib/checkmemoryleak.h

414 lines
14 KiB
C
Raw Normal View History

2008-12-18 22:28:57 +01:00
/*
* Cppcheck - A tool for static C/C++ code analysis
* Copyright (C) 2007-2010 Daniel Marjamäki and Cppcheck team.
2008-12-18 22:28:57 +01:00
*
* 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/>.
2008-12-18 22:28:57 +01:00
*/
//---------------------------------------------------------------------------
#ifndef checkmemoryleakH
#define checkmemoryleakH
2008-12-18 22:28:57 +01:00
//---------------------------------------------------------------------------
/**
2010-03-13 22:16:06 +01:00
* @file
*
* %Check for memory leaks
*
* The checking is split up into two specialized classes.
* - CheckMemoryLeakInFunction can detect when a function variable is allocated but not deallocated properly.
* - CheckMemoryLeakInClass can detect when a class variable is allocated but not deallocated properly.
2010-03-13 21:12:18 +01:00
* - CheckMemoryLeakStructMember checks allocation/deallocation of structs and struct members
*/
2008-12-18 22:28:57 +01:00
2009-03-20 18:16:21 +01:00
#include "check.h"
2008-12-18 22:28:57 +01:00
#include <list>
2009-03-20 18:16:21 +01:00
#include <string>
2008-12-18 22:28:57 +01:00
#include <vector>
2009-03-20 18:16:21 +01:00
class Token;
2010-03-13 21:12:18 +01:00
/// @addtogroup Core
/// @{
/** @brief Base class for memory leaks checking */
class CheckMemoryLeak
{
private:
2010-03-13 21:12:18 +01:00
/** For access to the tokens */
const Tokenizer * const tokenizer;
2010-03-13 21:12:18 +01:00
/** ErrorLogger used to report errors */
ErrorLogger * const errorLogger;
/** Disable the default constructors */
CheckMemoryLeak();
/** Disable the default constructors */
CheckMemoryLeak(const CheckMemoryLeak &);
/** disable assignment operator */
void operator=(const CheckMemoryLeak &);
/**
* Report error. Similar with the function Check::reportError
* @param location the token where the error occurs
* @param severity the severity of the bug
* @param id type of message
* @param msg text
*/
2009-08-04 21:36:55 +02:00
void reportErr(const Token *location, Severity::e severity, const std::string &id, const std::string &msg) const;
/**
* Report error. Similar with the function Check::reportError
* @param callstack callstack of error
* @param severity the severity of the bug
* @param id type of message
* @param msg text
*/
2009-08-04 21:36:55 +02:00
void reportErr(const std::list<const Token *> &callstack, Severity::e severity, const std::string &id, const std::string &msg) const;
public:
CheckMemoryLeak(const Tokenizer *t, ErrorLogger *e)
2010-04-15 20:08:51 +02:00
: tokenizer(t), errorLogger(e)
{
}
2010-03-13 21:12:18 +01:00
/** @brief What type of allocation are used.. the "Many" means that several types of allocation and deallocation are used */
enum AllocType { No, Malloc, gMalloc, New, NewArray, File, Fd, Pipe, Dir, Many };
void memoryLeak(const Token *tok, const std::string &varname, AllocType alloctype);
/**
2010-03-13 21:12:18 +01:00
* @brief Get type of deallocation at given position
* @param tok position
* @param varnames variable names
* @return type of deallocation
*/
AllocType getDeallocationType(const Token *tok, const char *varnames[]) const;
/**
2010-03-13 21:12:18 +01:00
* @brief Get type of deallocation at given position
* @param tok position
2009-10-15 18:52:29 +02:00
* @param varid variable id
* @return type of deallocation
*/
AllocType getDeallocationType(const Token *tok, unsigned int varid) const;
/**
2010-03-13 21:12:18 +01:00
* @brief Get type of allocation at given position
*/
AllocType getAllocationType(const Token *tok2, unsigned int varid) const;
/**
2010-03-13 21:12:18 +01:00
* @brief Get type of reallocation at given position
*/
AllocType getReallocationType(const Token *tok2, unsigned int varid) const;
2010-03-13 21:12:18 +01:00
/**
* @brief Is a typename the name of a class?
* @param _tokenizer tokenizer
* @param typestr type name
* @return true if the type name is the name of a class
*/
bool isclass(const Tokenizer *_tokenizer, const Token *typestr) const;
void memleakError(const Token *tok, const std::string &varname);
void resourceLeakError(const Token *tok, const std::string &varname);
2010-03-13 21:12:18 +01:00
/**
* @brief Report error: deallocating a deallocated pointer
* @param tok token where error occurs
* @param varname name of variable
*/
void deallocDeallocError(const Token *tok, const std::string &varname);
void deallocuseError(const Token *tok, const std::string &varname);
void mismatchSizeError(const Token *tok, const std::string &sz);
void mismatchAllocDealloc(const std::list<const Token *> &callstack, const std::string &varname);
/** What type of allocated memory does the given function return? */
AllocType functionReturnType(const Token *tok) const;
};
2010-03-13 21:12:18 +01:00
/// @}
/// @addtogroup Checks
/// @{
/**
2010-03-13 22:16:06 +01:00
* @brief %CheckMemoryLeakInFunction detects when a function variable is allocated but not deallocated properly.
*
* The checking is done by looking at each function variable separately. By repeating these 4 steps over and over:
* -# locate a function variable
* -# create a simple token list that describes the usage of the function variable.
* -# simplify the token list.
* -# finally, check if the simplified token list contain any leaks.
*/
2009-12-22 21:56:00 +01:00
class CheckMemoryLeakInFunction : private Check, public CheckMemoryLeak
2008-12-18 22:28:57 +01:00
{
public:
2010-03-13 21:12:18 +01:00
/** @brief This constructor is used when registering this class */
CheckMemoryLeakInFunction() : Check(), CheckMemoryLeak(0, 0)
{ }
2009-03-20 18:16:21 +01:00
2010-03-13 21:12:18 +01:00
/** @brief This constructor is used when running checks */
2010-04-08 22:56:34 +02:00
CheckMemoryLeakInFunction(const Tokenizer *tokenizr, const Settings *settings, ErrorLogger *errLog)
2010-04-15 20:08:51 +02:00
: Check(tokenizr, settings, errLog), CheckMemoryLeak(tokenizr, errLog)
{ }
2009-03-20 18:16:21 +01:00
2010-03-13 21:12:18 +01:00
/** @brief run all simplified checks */
2010-04-08 22:56:34 +02:00
void runSimplifiedChecks(const Tokenizer *tokenizr, const Settings *settings, ErrorLogger *errLog)
2009-03-20 18:16:21 +01:00
{
2010-04-08 22:56:34 +02:00
CheckMemoryLeakInFunction checkMemoryLeak(tokenizr, settings, errLog);
checkMemoryLeak.check();
2009-03-20 18:16:21 +01:00
}
2010-03-13 21:12:18 +01:00
/** @brief Unit testing : testing the white list */
static bool test_white_list(const std::string &funcname);
2010-03-13 21:12:18 +01:00
/** @brief Perform checking */
void check();
2008-12-18 22:28:57 +01:00
2010-03-13 21:12:18 +01:00
/** @brief experimental: checking via ExecutionPath */
2009-12-14 20:30:31 +01:00
void localleaks();
/**
2010-03-13 22:16:06 +01:00
* @brief %Check all variables in function scope
* @param tok The first '{' token of the function body
* @param tok1 The '(' token in the function declaration
* @param classmember Is this function a class member?
*/
void parseFunctionScope(const Token *tok, const Token *tok1, const bool classmember);
2010-03-13 21:12:18 +01:00
/**
2010-03-13 22:16:06 +01:00
* @brief %Check if there is a "p = foo(p, .." and foo returns the argument (p)
2010-03-13 21:12:18 +01:00
* @param tok token to the ";" before the statement
* @param varid varid to check
*/
bool matchFunctionsThatReturnArg(const Token *tok, unsigned int varid) const;
2008-12-18 22:28:57 +01:00
/**
2010-03-13 22:16:06 +01:00
* @brief %Check if there is a "!var" match inside a condition
* @param tok first token to match
2009-10-15 18:52:29 +02:00
* @param varid variabla id
* @param endpar if this is true the "!var" must be followed by ")"
* @return true if match
2008-12-18 22:28:57 +01:00
*/
bool notvar(const Token *tok, unsigned int varid, bool endpar = false) const;
2008-12-18 22:28:57 +01:00
/**
* Inspect a function call. the call_func and getcode are recursive
* @param tok token where the function call occurs
* @param callstack callstack
2009-10-15 18:52:29 +02:00
* @param varid variable id to check
* @param alloctype if memory is allocated, this indicates the type of allocation
* @param dealloctype if memory is deallocated, this indicates the type of deallocation
* @param sz not used by call_func - see getcode
* @return These are the possible return values:
* - NULL : no significant code
* - "recursive" : recursive function
* - "alloc" : the function returns allocated memory
* - "dealloc" : the function deallocates the variable
* - "dealloc_"
* - "use" : the variable is used (unknown usage of the variable => the checking bails out)
2010-03-13 21:12:18 +01:00
* - "callfunc" : a function call with unknown side effects
* - "&use"
*/
const char * call_func(const Token *tok, std::list<const Token *> callstack, const unsigned int varid, AllocType &alloctype, AllocType &dealloctype, unsigned int sz);
2008-12-18 22:28:57 +01:00
/**
* Extract a new tokens list that is easier to parse than the "_tokenizer->tokens()", the
* extracted tokens list describes how the given variable is used.
* The getcode and call_func are recursive
2008-12-18 22:28:57 +01:00
* @param tok start parse token
* @param callstack callstack
2009-10-15 18:52:29 +02:00
* @param varid variable id
* @param alloctype keep track of what type of allocation is used
* @param dealloctype keeps track of what type of deallocation is used
* @param classmember should be set if the inspected function is a class member
* @param sz size of type, used to check for mismatching size of allocation. for example "int *a;" => the sz is "sizeof(int)"
2008-12-18 22:28:57 +01:00
* @return Newly allocated token array. Caller needs to release reserved
* memory by calling Tokenizer::deleteTokens(returnValue);
* Returned tokens:
* - alloc : the variable is allocated
* - assign : the variable is assigned a new value
2010-03-13 21:12:18 +01:00
* - break : corresponds to "break"
* - callfunc : a function call with unknown side effects
* - continue : corresponds to "continue"
* - dealloc : the variable is deallocated
* - goto : corresponds to a "goto"
* - if : there is an "if"
* - if(var) : corresponds with "if ( var != 0 )"
* - if(!var) : corresponds with "if ( var == 0 )"
* - ifv : the variable is used in some way in a "if"
* - loop : corresponds to either a "for" or a "while"
2010-03-13 21:12:18 +01:00
* - realloc : the variable is reallocated
* - return : corresponds to a "return"
2010-03-13 21:12:18 +01:00
* - use : unknown usage -> bail out checking of this execution path
* - &use : the address of the variable is taken
* - ::use : calling member function of class
2008-12-18 22:28:57 +01:00
*/
Token *getcode(const Token *tok, std::list<const Token *> callstack, const unsigned int varid, AllocType &alloctype, AllocType &dealloctype, bool classmember, unsigned int sz);
2009-02-04 07:11:36 +01:00
/**
* Simplify code e.g. by replacing empty "{ }" with ";"
* @param tok first token. The tokens list can be modified.
2009-02-04 07:11:36 +01:00
*/
void simplifycode(Token *tok);
2008-12-18 22:28:57 +01:00
static const Token *findleak(const Token *tokens);
/**
* Checking the variable varname
* @param Tok1 start token
2009-10-15 18:52:29 +02:00
* @param varname name of variable (for error messages)
* @param varid variable id
* @param classmember is the scope inside a class member function
* @param sz size of type.. if the variable is a "int *" then sz should be "sizeof(int)"
*/
void checkScope(const Token *Tok1, const std::string &varname, unsigned int varid, bool classmember, unsigned int sz);
2010-03-13 21:12:18 +01:00
/** Report all possible errors (for the --errorlist) */
void getErrorMessages()
2009-08-04 21:36:55 +02:00
{
memleakError(0, "varname");
resourceLeakError(0, "varname");
2009-08-04 21:36:55 +02:00
deallocDeallocError(0, "varname");
deallocuseError(0, "varname");
mismatchSizeError(0, "sz");
std::list<const Token *> callstack;
mismatchAllocDealloc(callstack, "varname");
2009-08-04 21:36:55 +02:00
}
2010-03-13 21:12:18 +01:00
/**
* Get name of class (--doc)
* @return name of class
*/
2009-06-12 15:20:08 +02:00
std::string name() const
{
return "Memory leaks (function variables)";
}
2010-03-13 21:12:18 +01:00
/**
* Get class information (--doc)
* @return Wiki formatted information about this class
*/
std::string classInfo() const
{
2009-06-12 15:20:08 +02:00
return "Is there any allocated memory when a function goes out of scope";
}
2010-03-13 21:12:18 +01:00
/** parse tokens to see what functions are "noreturn" */
void parse_noreturn();
2010-03-13 21:12:18 +01:00
/** Function names for functions that are "noreturn" */
std::set<std::string> noreturn;
};
/**
* @brief %Check class variables, variables that are allocated in the constructor should be deallocated in the destructor
*/
class CheckMemoryLeakInClass : private Check, private CheckMemoryLeak
{
public:
2009-07-13 15:50:54 +02:00
CheckMemoryLeakInClass() : Check(), CheckMemoryLeak(0, 0)
{ }
2010-04-08 22:56:34 +02:00
CheckMemoryLeakInClass(const Tokenizer *tokenizr, const Settings *settings, ErrorLogger *errLog)
2010-04-15 20:08:51 +02:00
: Check(tokenizr, settings, errLog), CheckMemoryLeak(tokenizr, errLog)
{ }
2010-04-08 22:56:34 +02:00
void runSimplifiedChecks(const Tokenizer *tokenizr, const Settings *settings, ErrorLogger *errLog)
{
2010-04-08 22:56:34 +02:00
CheckMemoryLeakInClass checkMemoryLeak(tokenizr, settings, errLog);
checkMemoryLeak.check();
}
void check();
private:
void parseClass(const Token *tok1, std::vector<std::string> &classname);
void variable(const std::string &classname, const Token *tokVarname);
/** Public functions: possible double-allocation */
void checkPublicFunctions(const Token *classtok, const unsigned int varid);
void publicAllocationError(const Token *tok, const std::string &varname);
void getErrorMessages()
{ }
2009-06-12 15:20:08 +02:00
std::string name() const
{
return "Memory leaks (class variables)";
}
std::string classInfo() const
{
2009-06-12 15:20:08 +02:00
return "If the constructor allocate memory then the destructor must deallocate it.";
}
2008-12-18 22:28:57 +01:00
};
/** @brief detect simple memory leaks for struct members */
class CheckMemoryLeakStructMember : private Check, private CheckMemoryLeak
{
public:
2009-07-13 15:50:54 +02:00
CheckMemoryLeakStructMember() : Check(), CheckMemoryLeak(0, 0)
{ }
2010-04-08 22:56:34 +02:00
CheckMemoryLeakStructMember(const Tokenizer *tokenizr, const Settings *settings, ErrorLogger *errLog)
2010-04-15 20:08:51 +02:00
: Check(tokenizr, settings, errLog), CheckMemoryLeak(tokenizr, errLog)
{ }
2010-04-08 22:56:34 +02:00
void runSimplifiedChecks(const Tokenizer *tokenizr, const Settings *settings, ErrorLogger *errLog)
{
2010-04-08 22:56:34 +02:00
CheckMemoryLeakStructMember checkMemoryLeak(tokenizr, settings, errLog);
checkMemoryLeak.check();
}
void check();
private:
void getErrorMessages()
{ }
std::string name() const
{
return "Memory leaks (struct members)";
}
std::string classInfo() const
{
return "Don't forget to deallocate struct members";
}
};
/// @}
2008-12-18 22:28:57 +01:00
//---------------------------------------------------------------------------
#endif