This is an archive of the discontinued LLVM Phabricator instance.

Differential D32702

[analyzer] Fix 'Memory Error' bugtype capitalization.
ClosedPublic

Authored by NoQ on May 1 2017, 9:14 AM.

Details

Reviewers
zaks.anna
dcoughlin
xazax.hun
a.sidorin
Commits
rGb6a513d1b25f: [analyzer] Fix memory error bug category capitalization.
rC302016: [analyzer] Fix memory error bug category capitalization.
rL302016: [analyzer] Fix memory error bug category capitalization.
Summary

It seems that we're not capitalizing every word in our bug type descriptions, however Memory Error is an exception from this rule. Additionally, one of the nullability checkers actually does spell it as Memory error. So i guess it's better to keep everything consistent.

Diff Detail

Event Timeline

NoQ created this revision.May 1 2017, 9:14 AM
xazax.hun accepted this revision.May 1 2017, 9:19 AM

LGTM!

This revision is now accepted and ready to land.May 1 2017, 9:19 AM
a.sidorin edited edge metadata.May 1 2017, 9:28 AM

Hi Artem. It is a good point but I think we should have a literal for this instead.

zaks.anna accepted this revision.May 1 2017, 9:31 AM

Thanks!

NoQ updated this revision to Diff 97574.May 3 2017, 2:08 AM

Added a reusable bug category.

a.sidorin accepted this revision.May 3 2017, 2:10 AM

Thank you!

xazax.hun accepted this revision.May 3 2017, 2:11 AM

Even better :)

Closed by commit rL302016: [analyzer] Fix memory error bug category capitalization. (authored by dergachev). · Explain WhyMay 3 2017, 5:00 AM
This revision was automatically updated to reflect the committed changes.
NoQ mentioned this in D32592: [Analyzer] Iterator Checker - Part 1: Minimal Checker for a Simple Test Case.May 4 2017, 3:18 AM

Revision Contents

PathSize
include/
clang/
StaticAnalyzer/
Core/
BugReporter/
1 line
lib/
StaticAnalyzer/
Checkers/
33 lines
2 lines
5 lines
Core/
1 line
test/
Analysis/
2 lines
4 lines
diagnostics/
2 lines
4 lines
36 lines
4 lines

Diff 97574

include/clang/StaticAnalyzer/Core/BugReporter/CommonBugCategories.h

Context not available.
extern const char * const CoreFoundationObjectiveC; extern const char * const CoreFoundationObjectiveC;
extern const char * const LogicError; extern const char * const LogicError;
extern const char * const MemoryCoreFoundationObjectiveC; extern const char * const MemoryCoreFoundationObjectiveC;
extern const char * const MemoryError;
extern const char * const UnixAPI; extern const char * const UnixAPI;
} }
} }
Context not available.

lib/StaticAnalyzer/Checkers/MallocChecker.cpp

Context not available.
#include "clang/Basic/SourceManager.h" #include "clang/Basic/SourceManager.h"
#include "clang/Basic/TargetInfo.h" #include "clang/Basic/TargetInfo.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h" #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
#include "clang/StaticAnalyzer/Core/BugReporter/CommonBugCategories.h"
#include "clang/StaticAnalyzer/Core/Checker.h" #include "clang/StaticAnalyzer/Core/Checker.h"
#include "clang/StaticAnalyzer/Core/CheckerManager.h" #include "clang/StaticAnalyzer/Core/CheckerManager.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h" #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
Context not available.
if (ExplodedNode *N = C.generateErrorNode()) { if (ExplodedNode *N = C.generateErrorNode()) {
if (!BT_BadFree[*CheckKind]) if (!BT_BadFree[*CheckKind])
BT_BadFree[*CheckKind].reset( BT_BadFree[*CheckKind].reset(new BugType(
new BugType(CheckNames[*CheckKind], "Bad free", "Memory Error")); CheckNames[*CheckKind], "Bad free", categories::MemoryError));
SmallString<100> buf; SmallString<100> buf;
llvm::raw_svector_ostream os(buf); llvm::raw_svector_ostream os(buf);
Context not available.
if (ExplodedNode *N = C.generateErrorNode()) { if (ExplodedNode *N = C.generateErrorNode()) {
if (!BT_FreeAlloca[*CheckKind]) if (!BT_FreeAlloca[*CheckKind])
BT_FreeAlloca[*CheckKind].reset( BT_FreeAlloca[*CheckKind].reset(new BugType(
new BugType(CheckNames[*CheckKind], "Free alloca()", "Memory Error")); CheckNames[*CheckKind], "Free alloca()", categories::MemoryError));
auto R = llvm::make_unique<BugReport>( auto R = llvm::make_unique<BugReport>(
*BT_FreeAlloca[*CheckKind], *BT_FreeAlloca[*CheckKind],
Context not available.
if (!BT_MismatchedDealloc) if (!BT_MismatchedDealloc)
BT_MismatchedDealloc.reset( BT_MismatchedDealloc.reset(
new BugType(CheckNames[CK_MismatchedDeallocatorChecker], new BugType(CheckNames[CK_MismatchedDeallocatorChecker],
"Bad deallocator", "Memory Error")); "Bad deallocator", categories::MemoryError));
SmallString<100> buf; SmallString<100> buf;
llvm::raw_svector_ostream os(buf); llvm::raw_svector_ostream os(buf);
Context not available.
return; return;
if (!BT_OffsetFree[*CheckKind]) if (!BT_OffsetFree[*CheckKind])
BT_OffsetFree[*CheckKind].reset( BT_OffsetFree[*CheckKind].reset(new BugType(
new BugType(CheckNames[*CheckKind], "Offset free", "Memory Error")); CheckNames[*CheckKind], "Offset free", categories::MemoryError));
SmallString<100> buf; SmallString<100> buf;
llvm::raw_svector_ostream os(buf); llvm::raw_svector_ostream os(buf);
Context not available.
if (ExplodedNode *N = C.generateErrorNode()) { if (ExplodedNode *N = C.generateErrorNode()) {
if (!BT_UseFree[*CheckKind]) if (!BT_UseFree[*CheckKind])
BT_UseFree[*CheckKind].reset(new BugType( BT_UseFree[*CheckKind].reset(new BugType(
CheckNames[*CheckKind], "Use-after-free", "Memory Error")); CheckNames[*CheckKind], "Use-after-free", categories::MemoryError));
auto R = llvm::make_unique<BugReport>(*BT_UseFree[*CheckKind], auto R = llvm::make_unique<BugReport>(*BT_UseFree[*CheckKind],
"Use of memory after it is freed", N); "Use of memory after it is freed", N);
Context not available.
if (ExplodedNode *N = C.generateErrorNode()) { if (ExplodedNode *N = C.generateErrorNode()) {
if (!BT_DoubleFree[*CheckKind]) if (!BT_DoubleFree[*CheckKind])
BT_DoubleFree[*CheckKind].reset( BT_DoubleFree[*CheckKind].reset(new BugType(
new BugType(CheckNames[*CheckKind], "Double free", "Memory Error")); CheckNames[*CheckKind], "Double free", categories::MemoryError));
auto R = llvm::make_unique<BugReport>( auto R = llvm::make_unique<BugReport>(
*BT_DoubleFree[*CheckKind], *BT_DoubleFree[*CheckKind],
Context not available.
if (ExplodedNode *N = C.generateErrorNode()) { if (ExplodedNode *N = C.generateErrorNode()) {
if (!BT_DoubleDelete) if (!BT_DoubleDelete)
BT_DoubleDelete.reset(new BugType(CheckNames[CK_NewDeleteChecker], BT_DoubleDelete.reset(new BugType(CheckNames[CK_NewDeleteChecker],
"Double delete", "Memory Error")); "Double delete",
categories::MemoryError));
auto R = llvm::make_unique<BugReport>( auto R = llvm::make_unique<BugReport>(
*BT_DoubleDelete, "Attempt to delete released memory", N); *BT_DoubleDelete, "Attempt to delete released memory", N);
Context not available.
if (ExplodedNode *N = C.generateErrorNode()) { if (ExplodedNode *N = C.generateErrorNode()) {
if (!BT_UseZerroAllocated[*CheckKind]) if (!BT_UseZerroAllocated[*CheckKind])
BT_UseZerroAllocated[*CheckKind].reset(new BugType( BT_UseZerroAllocated[*CheckKind].reset(
CheckNames[*CheckKind], "Use of zero allocated", "Memory Error")); new BugType(CheckNames[*CheckKind], "Use of zero allocated",
categories::MemoryError));
auto R = llvm::make_unique<BugReport>(*BT_UseZerroAllocated[*CheckKind], auto R = llvm::make_unique<BugReport>(*BT_UseZerroAllocated[*CheckKind],
"Use of zero-allocated memory", N); "Use of zero-allocated memory", N);
Context not available.
assert(N); assert(N);
if (!BT_Leak[*CheckKind]) { if (!BT_Leak[*CheckKind]) {
BT_Leak[*CheckKind].reset( BT_Leak[*CheckKind].reset(new BugType(CheckNames[*CheckKind], "Memory leak",
new BugType(CheckNames[*CheckKind], "Memory leak", "Memory Error")); categories::MemoryError));
// Leaks should not be reported if they are post-dominated by a sink: // Leaks should not be reported if they are post-dominated by a sink:
// (1) Sinks are higher importance bugs. // (1) Sinks are higher importance bugs.
// (2) NoReturnFunctionChecker uses sink nodes to represent paths ending // (2) NoReturnFunctionChecker uses sink nodes to represent paths ending
Context not available.

lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp

Context not available.
const MemRegion *Region, BugReporter &BR, const MemRegion *Region, BugReporter &BR,
const Stmt *ValueExpr = nullptr) const { const Stmt *ValueExpr = nullptr) const {
if (!BT) if (!BT)
BT.reset(new BugType(this, "Nullability", "Memory error")); BT.reset(new BugType(this, "Nullability", categories::MemoryError));
auto R = llvm::make_unique<BugReport>(*BT, Msg, N); auto R = llvm::make_unique<BugReport>(*BT, Msg, N);
if (Region) { if (Region) {
Context not available.

lib/StaticAnalyzer/Checkers/ValistChecker.cpp

Context not available.
if (!BT_uninitaccess) if (!BT_uninitaccess)
BT_uninitaccess.reset(new BugType(CheckNames[CK_Uninitialized], BT_uninitaccess.reset(new BugType(CheckNames[CK_Uninitialized],
"Uninitialized va_list", "Uninitialized va_list",
"Memory Error")); categories::MemoryError));
auto R = llvm::make_unique<BugReport>(*BT_uninitaccess, Msg, N); auto R = llvm::make_unique<BugReport>(*BT_uninitaccess, Msg, N);
R->markInteresting(VAList); R->markInteresting(VAList);
R->addVisitor(llvm::make_unique<ValistBugVisitor>(VAList)); R->addVisitor(llvm::make_unique<ValistBugVisitor>(VAList));
Context not available.
for (auto Reg : LeakedVALists) { for (auto Reg : LeakedVALists) {
if (!BT_leakedvalist) { if (!BT_leakedvalist) {
BT_leakedvalist.reset(new BugType(CheckNames[CK_Unterminated], BT_leakedvalist.reset(new BugType(CheckNames[CK_Unterminated],
"Leaked va_list", "Memory Error")); "Leaked va_list",
categories::MemoryError));
BT_leakedvalist->setSuppressOnSink(true); BT_leakedvalist->setSuppressOnSink(true);
} }
Context not available.

lib/StaticAnalyzer/Core/CommonBugCategories.cpp

Context not available.
const char * const LogicError = "Logic error"; const char * const LogicError = "Logic error";
const char * const MemoryCoreFoundationObjectiveC = const char * const MemoryCoreFoundationObjectiveC =
"Memory (Core Foundation/Objective-C)"; "Memory (Core Foundation/Objective-C)";
const char * const MemoryError = "Memory error";
const char * const UnixAPI = "Unix API"; const char * const UnixAPI = "Unix API";
}}} }}}
Context not available.

test/Analysis/MismatchedDeallocator-path-notes.cpp

Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Memory allocated by &apos;new[]&apos; should be deallocated by &apos;delete[]&apos;, not &apos;delete&apos;</string> // CHECK-NEXT: <key>description</key><string>Memory allocated by &apos;new[]&apos; should be deallocated by &apos;delete[]&apos;, not &apos;delete&apos;</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Bad deallocator</string> // CHECK-NEXT: <key>type</key><string>Bad deallocator</string>
// CHECK-NEXT: <key>check_name</key><string>unix.MismatchedDeallocator</string> // CHECK-NEXT: <key>check_name</key><string>unix.MismatchedDeallocator</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.

test/Analysis/NewDelete-path-notes.cpp

Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Attempt to free released memory</string> // CHECK-NEXT: <key>description</key><string>Attempt to free released memory</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Double free</string> // CHECK-NEXT: <key>type</key><string>Double free</string>
// CHECK-NEXT: <key>check_name</key><string>cplusplus.NewDelete</string> // CHECK-NEXT: <key>check_name</key><string>cplusplus.NewDelete</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Attempt to free released memory</string> // CHECK-NEXT: <key>description</key><string>Attempt to free released memory</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Double free</string> // CHECK-NEXT: <key>type</key><string>Double free</string>
// CHECK-NEXT: <key>check_name</key><string>cplusplus.NewDelete</string> // CHECK-NEXT: <key>check_name</key><string>cplusplus.NewDelete</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.

test/Analysis/diagnostics/report-issues-within-main-file.cpp

Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Memory allocated by &apos;new[]&apos; should be deallocated by &apos;delete[]&apos;, not &apos;delete&apos; (within a call to &apos;~auto_ptr&apos;)</string> // CHECK-NEXT: <key>description</key><string>Memory allocated by &apos;new[]&apos; should be deallocated by &apos;delete[]&apos;, not &apos;delete&apos; (within a call to &apos;~auto_ptr&apos;)</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Bad deallocator</string> // CHECK-NEXT: <key>type</key><string>Bad deallocator</string>
// CHECK-NEXT: <key>check_name</key><string>unix.MismatchedDeallocator</string> // CHECK-NEXT: <key>check_name</key><string>unix.MismatchedDeallocator</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.

test/Analysis/edges-new.mm

Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;buf&apos;</string> // CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;buf&apos;</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Memory leak</string> // CHECK-NEXT: <key>type</key><string>Memory leak</string>
// CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string> // CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Memory allocated by &apos;new[]&apos; should be deallocated by &apos;delete[]&apos;, not &apos;delete&apos;</string> // CHECK-NEXT: <key>description</key><string>Memory allocated by &apos;new[]&apos; should be deallocated by &apos;delete[]&apos;, not &apos;delete&apos;</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Bad deallocator</string> // CHECK-NEXT: <key>type</key><string>Bad deallocator</string>
// CHECK-NEXT: <key>check_name</key><string>unix.MismatchedDeallocator</string> // CHECK-NEXT: <key>check_name</key><string>unix.MismatchedDeallocator</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.

test/Analysis/malloc-plist.c

Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;p&apos;</string> // CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;p&apos;</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Memory leak</string> // CHECK-NEXT: <key>type</key><string>Memory leak</string>
// CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string> // CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;A&apos;</string> // CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;A&apos;</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Memory leak</string> // CHECK-NEXT: <key>type</key><string>Memory leak</string>
// CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string> // CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;buf&apos;</string> // CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;buf&apos;</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Memory leak</string> // CHECK-NEXT: <key>type</key><string>Memory leak</string>
// CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string> // CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;buf&apos;</string> // CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;buf&apos;</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Memory leak</string> // CHECK-NEXT: <key>type</key><string>Memory leak</string>
// CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string> // CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Use of memory after it is freed</string> // CHECK-NEXT: <key>description</key><string>Use of memory after it is freed</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Use-after-free</string> // CHECK-NEXT: <key>type</key><string>Use-after-free</string>
// CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string> // CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;buf&apos;</string> // CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;buf&apos;</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Memory leak</string> // CHECK-NEXT: <key>type</key><string>Memory leak</string>
// CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string> // CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;v&apos;</string> // CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;v&apos;</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Memory leak</string> // CHECK-NEXT: <key>type</key><string>Memory leak</string>
// CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string> // CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Use of memory after it is freed</string> // CHECK-NEXT: <key>description</key><string>Use of memory after it is freed</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Use-after-free</string> // CHECK-NEXT: <key>type</key><string>Use-after-free</string>
// CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string> // CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;m&apos;</string> // CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;m&apos;</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Memory leak</string> // CHECK-NEXT: <key>type</key><string>Memory leak</string>
// CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string> // CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string> // CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Memory leak</string> // CHECK-NEXT: <key>type</key><string>Memory leak</string>
// CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string> // CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string> // CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Memory leak</string> // CHECK-NEXT: <key>type</key><string>Memory leak</string>
// CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string> // CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string> // CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Memory leak</string> // CHECK-NEXT: <key>type</key><string>Memory leak</string>
// CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string> // CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string> // CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Memory leak</string> // CHECK-NEXT: <key>type</key><string>Memory leak</string>
// CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string> // CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string> // CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Memory leak</string> // CHECK-NEXT: <key>type</key><string>Memory leak</string>
// CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string> // CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string> // CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Memory leak</string> // CHECK-NEXT: <key>type</key><string>Memory leak</string>
// CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string> // CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Potential memory leak</string> // CHECK-NEXT: <key>description</key><string>Potential memory leak</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Memory leak</string> // CHECK-NEXT: <key>type</key><string>Memory leak</string>
// CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string> // CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Potential memory leak</string> // CHECK-NEXT: <key>description</key><string>Potential memory leak</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Memory leak</string> // CHECK-NEXT: <key>type</key><string>Memory leak</string>
// CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string> // CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Potential memory leak</string> // CHECK-NEXT: <key>description</key><string>Potential memory leak</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Memory leak</string> // CHECK-NEXT: <key>type</key><string>Memory leak</string>
// CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string> // CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.

test/Analysis/plist-macros.cpp

Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Memory allocated by malloc() should be deallocated by free(), not &apos;delete&apos;</string> // CHECK-NEXT: <key>description</key><string>Memory allocated by malloc() should be deallocated by free(), not &apos;delete&apos;</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Bad deallocator</string> // CHECK-NEXT: <key>type</key><string>Bad deallocator</string>
// CHECK-NEXT: <key>check_name</key><string>unix.MismatchedDeallocator</string> // CHECK-NEXT: <key>check_name</key><string>unix.MismatchedDeallocator</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.
// CHECK-NEXT: </dict> // CHECK-NEXT: </dict>
// CHECK-NEXT: </array> // CHECK-NEXT: </array>
// CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string> // CHECK-NEXT: <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string>
// CHECK-NEXT: <key>category</key><string>Memory Error</string> // CHECK-NEXT: <key>category</key><string>Memory error</string>
// CHECK-NEXT: <key>type</key><string>Memory leak</string> // CHECK-NEXT: <key>type</key><string>Memory leak</string>
// CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string> // CHECK-NEXT: <key>check_name</key><string>unix.Malloc</string>
// CHECK-NEXT: <!-- This hash is experimental and going to change! --> // CHECK-NEXT: <!-- This hash is experimental and going to change! -->
Context not available.