This is an archive of the discontinued LLVM Phabricator instance.

Differential D34334

Use llvm::make_unique NFC
Needs ReviewPublic

Authored by hokein on Jun 18 2017, 12:27 PM.
This revision needs review, but there are no reviewers specified.

Details

Reviewers
None
Summary

Apply clang-tidy modernize-make-unique check.

Diff Detail

Event Timeline

hokein created this revision.Jun 18 2017, 12:27 PM
Herald added a subscriber: klimek. · View Herald TranscriptJun 18 2017, 12:27 PM

Revision Contents

PathSize
examples/
analyzer-plugin/
2 lines
lib/
ARCMigrate/
4 lines
2 lines
8 lines
2 lines
4 lines
AST/
4 lines
Analysis/
6 lines
2 lines
CodeGen/
4 lines
2 lines
2 lines
16 lines
4 lines
4 lines
8 lines
Driver/
10 lines
ToolChains/
2 lines
6 lines
4 lines
4 lines
4 lines
Format/
12 lines
8 lines
2 lines
2 lines
Frontend/
16 lines
20 lines
4 lines
Rewrite/
4 lines
14 lines
2 lines
2 lines
Parse/
2 lines
66 lines
2 lines
Rewrite/
2 lines
2 lines
Sema/
2 lines
4 lines
4 lines
2 lines
2 lines
2 lines
StaticAnalyzer/
Checkers/
4 lines
2 lines
16 lines
6 lines
2 lines
26 lines
38 lines
4 lines
18 lines
4 lines
6 lines
4 lines
4 lines
2 lines
6 lines
2 lines
4 lines
4 lines
2 lines
6 lines
2 lines
4 lines
4 lines
4 lines
4 lines
44 lines
4 lines
4 lines
4 lines
6 lines
2 lines
8 lines
4 lines
4 lines
6 lines
8 lines
6 lines
22 lines
36 lines
4 lines
8 lines
8 lines
10 lines
18 lines
2 lines
2 lines
4 lines
4 lines
4 lines
2 lines
2 lines
2 lines
4 lines
8 lines
4 lines
Tooling/
4 lines
4 lines
tools/
arcmt-test/
2 lines
c-index-test/
2 lines
clang-check/
6 lines
unittests/
ASTMatchers/
Dynamic/
14 lines
libclang/
4 lines

Diff 102977

examples/analyzer-plugin/MainCallChecker.cpp

Show All 29 Lines if (!II) // if no identifier, not a simple C function
return; return;
if (II->isStr("main")) { if (II->isStr("main")) {
ExplodedNode *N = C.generateErrorNode(); ExplodedNode *N = C.generateErrorNode();
if (!N) if (!N)
return; return;
if (!BT) if (!BT)
BT.reset(new BugType(this, "call to main", "example analyzer plugin")); BT = llvm::make_unique<BugType>(this, "call to main", "example analyzer plugin");
std::unique_ptr<BugReport> report = std::unique_ptr<BugReport> report =
llvm::make_unique<BugReport>(*BT, BT->getName(), N); llvm::make_unique<BugReport>(*BT, BT->getName(), N);
report->addRange(Callee->getSourceRange()); report->addRange(Callee->getSourceRange());
C.emitReport(std::move(report)); C.emitReport(std::move(report));
} }
} }
// Register plugin! // Register plugin!
extern "C" extern "C"
void clang_registerCheckers (CheckerRegistry &registry) { void clang_registerCheckers (CheckerRegistry &registry) {
registry.addChecker<MainCallChecker>("example.MainCallChecker", "Disallows calls to functions called main"); registry.addChecker<MainCallChecker>("example.MainCallChecker", "Disallows calls to functions called main");
} }
extern "C" extern "C"
const char clang_analyzerAPIVersionString[] = CLANG_ANALYZER_API_VERSION_STRING; const char clang_analyzerAPIVersionString[] = CLANG_ANALYZER_API_VERSION_STRING;

lib/ARCMigrate/ARCMT.cpp

Show First 20 Lines • Show All 168 Lines • ▼ Show 20 Linesstatic bool HasARCRuntime(CompilerInvocation &origCI) {
return false; return false;
} }
static CompilerInvocation * static CompilerInvocation *
createInvocationForMigration(CompilerInvocation &origCI, createInvocationForMigration(CompilerInvocation &origCI,
const PCHContainerReader &PCHContainerRdr) { const PCHContainerReader &PCHContainerRdr) {
std::unique_ptr<CompilerInvocation> CInvok; std::unique_ptr<CompilerInvocation> CInvok;
CInvok.reset(new CompilerInvocation(origCI)); CInvok = llvm::make_unique<CompilerInvocation>(origCI);
PreprocessorOptions &PPOpts = CInvok->getPreprocessorOpts(); PreprocessorOptions &PPOpts = CInvok->getPreprocessorOpts();
if (!PPOpts.ImplicitPCHInclude.empty()) { if (!PPOpts.ImplicitPCHInclude.empty()) {
// We can't use a PCH because it was likely built in non-ARC mode and we // We can't use a PCH because it was likely built in non-ARC mode and we
// want to parse in ARC. Include the original header. // want to parse in ARC. Include the original header.
FileManager FileMgr(origCI.getFileSystemOpts()); FileManager FileMgr(origCI.getFileSystemOpts());
IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
IntrusiveRefCntPtr<DiagnosticsEngine> Diags( IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
new DiagnosticsEngine(DiagID, &origCI.getDiagnosticOpts(), new DiagnosticsEngine(DiagID, &origCI.getDiagnosticOpts(),
▲ Show 20 Lines • Show All 353 Lines • ▼ Show 20 Lines IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
new DiagnosticsEngine(DiagID, new DiagnosticOptions, new DiagnosticsEngine(DiagID, new DiagnosticOptions,
DiagClient, /*ShouldOwnClient=*/false)); DiagClient, /*ShouldOwnClient=*/false));
// Filter of all diagnostics. // Filter of all diagnostics.
CaptureDiagnosticConsumer errRec(*Diags, *DiagClient, capturedDiags); CaptureDiagnosticConsumer errRec(*Diags, *DiagClient, capturedDiags);
Diags->setClient(&errRec, /*ShouldOwnClient=*/false); Diags->setClient(&errRec, /*ShouldOwnClient=*/false);
std::unique_ptr<ARCMTMacroTrackerAction> ASTAction; std::unique_ptr<ARCMTMacroTrackerAction> ASTAction;
ASTAction.reset(new ARCMTMacroTrackerAction(ARCMTMacroLocs)); ASTAction = llvm::make_unique<ARCMTMacroTrackerAction>(ARCMTMacroLocs);
std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCompilerInvocationAction( std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCompilerInvocationAction(
std::move(CInvok), PCHContainerOps, Diags, ASTAction.get())); std::move(CInvok), PCHContainerOps, Diags, ASTAction.get()));
if (!Unit) { if (!Unit) {
errRec.FinishCapture(); errRec.FinishCapture();
return true; return true;
} }
Unit->setOwnsRemappedFileBuffers(false); // FileRemapper manages that. Unit->setOwnsRemappedFileBuffers(false); // FileRemapper manages that.
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

lib/ARCMigrate/FileRemapper.cpp

Show All 15 Lines
#include "llvm/Support/Path.h" #include "llvm/Support/Path.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include <fstream> #include <fstream>
using namespace clang; using namespace clang;
using namespace arcmt; using namespace arcmt;
FileRemapper::FileRemapper() { FileRemapper::FileRemapper() {
FileMgr.reset(new FileManager(FileSystemOptions())); FileMgr = llvm::make_unique<FileManager>(FileSystemOptions());
} }
FileRemapper::~FileRemapper() { FileRemapper::~FileRemapper() {
clear(); clear();
} }
void FileRemapper::clear(StringRef outputDir) { void FileRemapper::clear(StringRef outputDir) {
for (MappingsTy::iterator for (MappingsTy::iterator
▲ Show 20 Lines • Show All 225 Lines • Show Last 20 Lines

lib/ARCMigrate/ObjCMT.cpp

Show First 20 Lines • Show All 119 Lines • ▼ Show 20 Lines : MigrateDir(migrateDir),
// FIXME: StringSet should have insert(iter, iter) to use here. // FIXME: StringSet should have insert(iter, iter) to use here.
for (const std::string &Val : WhiteList) for (const std::string &Val : WhiteList)
WhiteListFilenames.insert(Val); WhiteListFilenames.insert(Val);
} }
protected: protected:
void Initialize(ASTContext &Context) override { void Initialize(ASTContext &Context) override {
NSAPIObj.reset(new NSAPI(Context)); NSAPIObj = llvm::make_unique<NSAPI>(Context);
Editor.reset(new edit::EditedSource(Context.getSourceManager(), Editor = llvm::make_unique<edit::EditedSource>(Context.getSourceManager(),
Context.getLangOpts(), Context.getLangOpts(),
PPRec)); PPRec);
} }
bool HandleTopLevelDecl(DeclGroupRef DG) override { bool HandleTopLevelDecl(DeclGroupRef DG) override {
for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I) for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
migrateDecl(*I); migrateDecl(*I);
return true; return true;
} }
void HandleInterestingDecl(DeclGroupRef DG) override { void HandleInterestingDecl(DeclGroupRef DG) override {
▲ Show 20 Lines • Show All 219 Lines • ▼ Show 20 Lines
public: public:
BodyMigrator(ObjCMigrateASTConsumer &consumer) : Consumer(consumer) { } BodyMigrator(ObjCMigrateASTConsumer &consumer) : Consumer(consumer) { }
bool shouldVisitTemplateInstantiations() const { return false; } bool shouldVisitTemplateInstantiations() const { return false; }
bool shouldWalkTypesOfTypeLocs() const { return false; } bool shouldWalkTypesOfTypeLocs() const { return false; }
bool TraverseStmt(Stmt *S) { bool TraverseStmt(Stmt *S) {
PMap.reset(new ParentMap(S)); PMap = llvm::make_unique<ParentMap>(S);
ObjCMigrator(Consumer, *PMap).TraverseStmt(S); ObjCMigrator(Consumer, *PMap).TraverseStmt(S);
return true; return true;
} }
}; };
} // end anonymous namespace } // end anonymous namespace
void ObjCMigrateASTConsumer::migrateDecl(Decl *D) { void ObjCMigrateASTConsumer::migrateDecl(Decl *D) {
if (!D) if (!D)
▲ Show 20 Lines • Show All 1,894 Lines • Show Last 20 Lines

lib/ARCMigrate/TransRetainReleaseDealloc.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines DelegateSel =
Pass.Ctx.Selectors.getNullarySelector(&Pass.Ctx.Idents.get("delegate")); Pass.Ctx.Selectors.getNullarySelector(&Pass.Ctx.Idents.get("delegate"));
FinalizeSel = FinalizeSel =
Pass.Ctx.Selectors.getNullarySelector(&Pass.Ctx.Idents.get("finalize")); Pass.Ctx.Selectors.getNullarySelector(&Pass.Ctx.Idents.get("finalize"));
} }
void transformBody(Stmt *body, Decl *ParentD) { void transformBody(Stmt *body, Decl *ParentD) {
Body = body; Body = body;
collectRemovables(body, Removables); collectRemovables(body, Removables);
StmtMap.reset(new ParentMap(body)); StmtMap = llvm::make_unique<ParentMap>(body);
TraverseStmt(body); TraverseStmt(body);
} }
bool VisitObjCMessageExpr(ObjCMessageExpr *E) { bool VisitObjCMessageExpr(ObjCMessageExpr *E) {
switch (E->getMethodFamily()) { switch (E->getMethodFamily()) {
default: default:
if (E->isInstanceMessage() && E->getSelector() == FinalizeSel) if (E->isInstanceMessage() && E->getSelector() == FinalizeSel)
break; break;
▲ Show 20 Lines • Show All 391 Lines • Show Last 20 Lines

lib/ARCMigrate/TransUnbridgedCasts.cpp

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Linespublic:
UnbridgedCastRewriter(MigrationPass &pass) UnbridgedCastRewriter(MigrationPass &pass)
: Pass(pass), ParentD(nullptr), Body(nullptr) { : Pass(pass), ParentD(nullptr), Body(nullptr) {
SelfII = &Pass.Ctx.Idents.get("self"); SelfII = &Pass.Ctx.Idents.get("self");
} }
void transformBody(Stmt *body, Decl *ParentD) { void transformBody(Stmt *body, Decl *ParentD) {
this->ParentD = ParentD; this->ParentD = ParentD;
Body = body; Body = body;
StmtMap.reset(new ParentMap(body)); StmtMap = llvm::make_unique<ParentMap>(body);
TraverseStmt(body); TraverseStmt(body);
} }
bool TraverseBlockDecl(BlockDecl *D) { bool TraverseBlockDecl(BlockDecl *D) {
// ParentMap does not enter into a BlockDecl to record its stmts, so use a // ParentMap does not enter into a BlockDecl to record its stmts, so use a
// new UnbridgedCastRewriter to handle the block. // new UnbridgedCastRewriter to handle the block.
UnbridgedCastRewriter(Pass).transformBody(D->getBody(), D); UnbridgedCastRewriter(Pass).transformBody(D->getBody(), D);
return true; return true;
▲ Show 20 Lines • Show All 232 Lines • ▼ Show 20 Lines if (!hasSideEffects(E, Pass.Ctx)) {
if (tryRemoving(cast<Expr>(StmtMap->getParentIgnoreParenCasts(E)))) if (tryRemoving(cast<Expr>(StmtMap->getParentIgnoreParenCasts(E))))
return; return;
} }
Pass.TA.replace(OuterRange, InnerRange); Pass.TA.replace(OuterRange, InnerRange);
} }
bool tryRemoving(Expr *E) const { bool tryRemoving(Expr *E) const {
if (!Removables) { if (!Removables) {
Removables.reset(new ExprSet); Removables = llvm::make_unique<ExprSet>();
collectRemovables(Body, *Removables); collectRemovables(Body, *Removables);
} }
if (Removables->count(E)) { if (Removables->count(E)) {
Pass.TA.removeStmt(E); Pass.TA.removeStmt(E);
return true; return true;
} }
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

lib/AST/ASTContext.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 9,130 Lines • ▼ Show 20 Lines
bool ASTContext::isNearlyEmpty(const CXXRecordDecl *RD) const { bool ASTContext::isNearlyEmpty(const CXXRecordDecl *RD) const {
// Pass through to the C++ ABI object // Pass through to the C++ ABI object
return ABI->isNearlyEmpty(RD); return ABI->isNearlyEmpty(RD);
} }
VTableContextBase *ASTContext::getVTableContext() { VTableContextBase *ASTContext::getVTableContext() {
if (!VTContext.get()) { if (!VTContext.get()) {
if (Target->getCXXABI().isMicrosoft()) if (Target->getCXXABI().isMicrosoft())
VTContext.reset(new MicrosoftVTableContext(*this)); VTContext = llvm::make_unique<MicrosoftVTableContext>(*this);
else else
VTContext.reset(new ItaniumVTableContext(*this)); VTContext = llvm::make_unique<ItaniumVTableContext>(*this);
} }
return VTContext.get(); return VTContext.get();
} }
MangleContext *ASTContext::createMangleContext() { MangleContext *ASTContext::createMangleContext() {
switch (Target->getCXXABI().getKind()) { switch (Target->getCXXABI().getKind()) {
case TargetCXXABI::GenericAArch64: case TargetCXXABI::GenericAArch64:
case TargetCXXABI::GenericItanium: case TargetCXXABI::GenericItanium:
▲ Show 20 Lines • Show All 414 Lines • Show Last 20 Lines

lib/Analysis/AnalysisDeclContext.cpp

Show First 20 Lines • Show All 260 Lines • ▼ Show 20 LinesCFGStmtMap *AnalysisDeclContext::getCFGStmtMap() {
return nullptr; return nullptr;
} }
CFGReverseBlockReachabilityAnalysis *AnalysisDeclContext::getCFGReachablityAnalysis() { CFGReverseBlockReachabilityAnalysis *AnalysisDeclContext::getCFGReachablityAnalysis() {
if (CFA) if (CFA)
return CFA.get(); return CFA.get();
if (CFG *c = getCFG()) { if (CFG *c = getCFG()) {
CFA.reset(new CFGReverseBlockReachabilityAnalysis(*c)); CFA = llvm::make_unique<CFGReverseBlockReachabilityAnalysis>(*c);
return CFA.get(); return CFA.get();
} }
return nullptr; return nullptr;
} }
void AnalysisDeclContext::dumpCFG(bool ShowColors) { void AnalysisDeclContext::dumpCFG(bool ShowColors) {
getCFG()->dump(getASTContext().getLangOpts(), ShowColors); getCFG()->dump(getASTContext().getLangOpts(), ShowColors);
} }
ParentMap &AnalysisDeclContext::getParentMap() { ParentMap &AnalysisDeclContext::getParentMap() {
if (!PM) { if (!PM) {
PM.reset(new ParentMap(getBody())); PM = llvm::make_unique<ParentMap>(getBody());
if (const CXXConstructorDecl *C = dyn_cast<CXXConstructorDecl>(getDecl())) { if (const CXXConstructorDecl *C = dyn_cast<CXXConstructorDecl>(getDecl())) {
for (const auto *I : C->inits()) { for (const auto *I : C->inits()) {
PM->addStmt(I->getInit()); PM->addStmt(I->getInit());
} }
} }
if (builtCFG) if (builtCFG)
addParentsForSyntheticStmts(getCFG(), *PM); addParentsForSyntheticStmts(getCFG(), *PM);
if (builtCompleteCFG) if (builtCompleteCFG)
addParentsForSyntheticStmts(getUnoptimizedCFG(), *PM); addParentsForSyntheticStmts(getUnoptimizedCFG(), *PM);
} }
return *PM; return *PM;
} }
PseudoConstantAnalysis *AnalysisDeclContext::getPseudoConstantAnalysis() { PseudoConstantAnalysis *AnalysisDeclContext::getPseudoConstantAnalysis() {
if (!PCA) if (!PCA)
PCA.reset(new PseudoConstantAnalysis(getBody())); PCA = llvm::make_unique<PseudoConstantAnalysis>(getBody());
return PCA.get(); return PCA.get();
} }
AnalysisDeclContext *AnalysisDeclContextManager::getContext(const Decl *D) { AnalysisDeclContext *AnalysisDeclContextManager::getContext(const Decl *D) {
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
// Calling 'hasBody' replaces 'FD' in place with the FunctionDecl // Calling 'hasBody' replaces 'FD' in place with the FunctionDecl
// that has the body. // that has the body.
FD->hasBody(FD); FD->hasBody(FD);
▲ Show 20 Lines • Show All 321 Lines • Show Last 20 Lines

lib/Analysis/ThreadSafety.cpp

Show First 20 Lines • Show All 965 Lines • ▼ Show 20 LinesBeforeSet::BeforeInfo* BeforeSet::insertAttrExprs(const ValueDecl* Vd,
ThreadSafetyAnalyzer& Analyzer) { ThreadSafetyAnalyzer& Analyzer) {
// Create a new entry for Vd. // Create a new entry for Vd.
BeforeInfo *Info = nullptr; BeforeInfo *Info = nullptr;
{ {
// Keep InfoPtr in its own scope in case BMap is modified later and the // Keep InfoPtr in its own scope in case BMap is modified later and the
// reference becomes invalid. // reference becomes invalid.
std::unique_ptr<BeforeInfo> &InfoPtr = BMap[Vd]; std::unique_ptr<BeforeInfo> &InfoPtr = BMap[Vd];
if (!InfoPtr) if (!InfoPtr)
InfoPtr.reset(new BeforeInfo()); InfoPtr = llvm::make_unique<BeforeInfo>();
Info = InfoPtr.get(); Info = InfoPtr.get();
} }
for (Attr* At : Vd->attrs()) { for (Attr* At : Vd->attrs()) {
switch (At->getKind()) { switch (At->getKind()) {
case attr::AcquiredBefore: { case attr::AcquiredBefore: {
auto *A = cast<AcquiredBeforeAttr>(At); auto *A = cast<AcquiredBeforeAttr>(At);
▲ Show 20 Lines • Show All 1,422 Lines • Show Last 20 Lines

lib/CodeGen/BackendUtil.cpp

Show First 20 Lines • Show All 735 Lines • ▼ Show 20 Linesvoid EmitAssemblyHelper::EmitAssembly(BackendAction Action,
switch (Action) { switch (Action) {
case Backend_EmitNothing: case Backend_EmitNothing:
break; break;
case Backend_EmitBC: case Backend_EmitBC:
if (CodeGenOpts.EmitSummaryIndex) { if (CodeGenOpts.EmitSummaryIndex) {
if (!CodeGenOpts.ThinLinkBitcodeFile.empty()) { if (!CodeGenOpts.ThinLinkBitcodeFile.empty()) {
std::error_code EC; std::error_code EC;
ThinLinkOS.reset(new llvm::raw_fd_ostream( ThinLinkOS = llvm::make_unique<llvm::raw_fd_ostream>(
CodeGenOpts.ThinLinkBitcodeFile, EC, CodeGenOpts.ThinLinkBitcodeFile, EC,
llvm::sys::fs::F_None)); llvm::sys::fs::F_None);
if (EC) { if (EC) {
Diags.Report(diag::err_fe_unable_to_open_output) << CodeGenOpts.ThinLinkBitcodeFile Diags.Report(diag::err_fe_unable_to_open_output) << CodeGenOpts.ThinLinkBitcodeFile
<< EC.message(); << EC.message();
return; return;
} }
} }
PerModulePasses.add( PerModulePasses.add(
createWriteThinLTOBitcodePass(*OS, ThinLinkOS.get())); createWriteThinLTOBitcodePass(*OS, ThinLinkOS.get()));
▲ Show 20 Lines • Show All 500 Lines • Show Last 20 Lines

lib/CodeGen/CGCleanup.cpp

Show First 20 Lines • Show All 739 Lines • ▼ Show 20 Linesvoid CodeGenFunction::PopCleanupBlock(bool FallthroughIsBranchThrough) {
std::unique_ptr<char[]> CleanupBufferHeap; std::unique_ptr<char[]> CleanupBufferHeap;
size_t CleanupSize = Scope.getCleanupSize(); size_t CleanupSize = Scope.getCleanupSize();
EHScopeStack::Cleanup *Fn; EHScopeStack::Cleanup *Fn;
if (CleanupSize <= sizeof(CleanupBufferStack)) { if (CleanupSize <= sizeof(CleanupBufferStack)) {
memcpy(CleanupBufferStack.buffer, CleanupSource, CleanupSize); memcpy(CleanupBufferStack.buffer, CleanupSource, CleanupSize);
Fn = reinterpret_cast<EHScopeStack::Cleanup *>(CleanupBufferStack.buffer); Fn = reinterpret_cast<EHScopeStack::Cleanup *>(CleanupBufferStack.buffer);
} else { } else {
CleanupBufferHeap.reset(new char[CleanupSize]); CleanupBufferHeap = llvm::make_unique<char[]>(CleanupSize);
memcpy(CleanupBufferHeap.get(), CleanupSource, CleanupSize); memcpy(CleanupBufferHeap.get(), CleanupSource, CleanupSize);
Fn = reinterpret_cast<EHScopeStack::Cleanup *>(CleanupBufferHeap.get()); Fn = reinterpret_cast<EHScopeStack::Cleanup *>(CleanupBufferHeap.get());
} }
EHScopeStack::Cleanup::Flags cleanupFlags; EHScopeStack::Cleanup::Flags cleanupFlags;
if (Scope.isNormalCleanup()) if (Scope.isNormalCleanup())
cleanupFlags.setIsNormalCleanupKind(); cleanupFlags.setIsNormalCleanupKind();
if (Scope.isEHCleanup()) if (Scope.isEHCleanup())
▲ Show 20 Lines • Show All 509 Lines • Show Last 20 Lines

lib/CodeGen/CGCoroutine.cpp

Show First 20 Lines • Show All 89 Lines • ▼ Show 20 Lines else if (CoroIdExpr)
CGF.CGM.Error(CoroIdExpr->getLocStart(), CGF.CGM.Error(CoroIdExpr->getLocStart(),
"__builtin_coro_id shall not be used in a C++ coroutine"); "__builtin_coro_id shall not be used in a C++ coroutine");
else else
llvm_unreachable("EmitCoroutineBodyStatement called twice?"); llvm_unreachable("EmitCoroutineBodyStatement called twice?");
return; return;
} }
CurCoro.Data = std::unique_ptr<CGCoroData>(new CGCoroData); CurCoro.Data = llvm::make_unique<CGCoroData>();
CurCoro.Data->CoroId = CoroId; CurCoro.Data->CoroId = CoroId;
CurCoro.Data->CoroIdExpr = CoroIdExpr; CurCoro.Data->CoroIdExpr = CoroIdExpr;
} }
// Synthesize a pretty name for a suspend point. // Synthesize a pretty name for a suspend point.
static SmallString<32> buildSuspendPrefixStr(CGCoroData &Coro, AwaitKind Kind) { static SmallString<32> buildSuspendPrefixStr(CGCoroData &Coro, AwaitKind Kind) {
unsigned No = 0; unsigned No = 0;
switch (Kind) { switch (Kind) {
▲ Show 20 Lines • Show All 554 Lines • Show Last 20 Lines

lib/CodeGen/CodeGenModule.cpp

Show First 20 Lines • Show All 125 Lines • ▼ Show 20 LinesCodeGenModule::CodeGenModule(ASTContext &C, const HeaderSearchOptions &HSO,
if (LangOpts.OpenMP) if (LangOpts.OpenMP)
createOpenMPRuntime(); createOpenMPRuntime();
if (LangOpts.CUDA) if (LangOpts.CUDA)
createCUDARuntime(); createCUDARuntime();
// Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0. // Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0.
if (LangOpts.Sanitize.has(SanitizerKind::Thread) || if (LangOpts.Sanitize.has(SanitizerKind::Thread) ||
(!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0)) (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
TBAA.reset(new CodeGenTBAA(Context, VMContext, CodeGenOpts, getLangOpts(), TBAA = llvm::make_unique<CodeGenTBAA>(Context, VMContext, CodeGenOpts, getLangOpts(),
getCXXABI().getMangleContext())); getCXXABI().getMangleContext());
// If debug info or coverage generation is enabled, create the CGDebugInfo // If debug info or coverage generation is enabled, create the CGDebugInfo
// object. // object.
if (CodeGenOpts.getDebugInfo() != codegenoptions::NoDebugInfo || if (CodeGenOpts.getDebugInfo() != codegenoptions::NoDebugInfo ||
CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes) CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes)
DebugInfo.reset(new CGDebugInfo(*this)); DebugInfo = llvm::make_unique<CGDebugInfo>(*this);
Block.GlobalUniqueCount = 0; Block.GlobalUniqueCount = 0;
if (C.getLangOpts().ObjC1) if (C.getLangOpts().ObjC1)
ObjCData.reset(new ObjCEntrypoints()); ObjCData = llvm::make_unique<ObjCEntrypoints>();
if (CodeGenOpts.hasProfileClangUse()) { if (CodeGenOpts.hasProfileClangUse()) {
auto ReaderOrErr = llvm::IndexedInstrProfReader::create( auto ReaderOrErr = llvm::IndexedInstrProfReader::create(
CodeGenOpts.ProfileInstrumentUsePath); CodeGenOpts.ProfileInstrumentUsePath);
if (auto E = ReaderOrErr.takeError()) { if (auto E = ReaderOrErr.takeError()) {
unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error, unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
"Could not read profile %0: %1"); "Could not read profile %0: %1");
llvm::handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EI) { llvm::handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EI) {
getDiags().Report(DiagID) << CodeGenOpts.ProfileInstrumentUsePath getDiags().Report(DiagID) << CodeGenOpts.ProfileInstrumentUsePath
<< EI.message(); << EI.message();
}); });
} else } else
PGOReader = std::move(ReaderOrErr.get()); PGOReader = std::move(ReaderOrErr.get());
} }
// If coverage mapping generation is enabled, create the // If coverage mapping generation is enabled, create the
// CoverageMappingModuleGen object. // CoverageMappingModuleGen object.
if (CodeGenOpts.CoverageMapping) if (CodeGenOpts.CoverageMapping)
CoverageMapping.reset(new CoverageMappingModuleGen(*this, *CoverageInfo)); CoverageMapping = llvm::make_unique<CoverageMappingModuleGen>(*this, *CoverageInfo);
} }
CodeGenModule::~CodeGenModule() {} CodeGenModule::~CodeGenModule() {}
void CodeGenModule::createObjCRuntime() { void CodeGenModule::createObjCRuntime() {
// This is just isGNUFamily(), but we want to force implementors of // This is just isGNUFamily(), but we want to force implementors of
// new ABIs to decide how best to do this. // new ABIs to decide how best to do this.
switch (LangOpts.ObjCRuntime.getKind()) { switch (LangOpts.ObjCRuntime.getKind()) {
Show All 9 Linesvoid CodeGenModule::createObjCRuntime() {
case ObjCRuntime::WatchOS: case ObjCRuntime::WatchOS:
ObjCRuntime.reset(CreateMacObjCRuntime(*this)); ObjCRuntime.reset(CreateMacObjCRuntime(*this));
return; return;
} }
llvm_unreachable("bad runtime kind"); llvm_unreachable("bad runtime kind");
} }
void CodeGenModule::createOpenCLRuntime() { void CodeGenModule::createOpenCLRuntime() {
OpenCLRuntime.reset(new CGOpenCLRuntime(*this)); OpenCLRuntime = llvm::make_unique<CGOpenCLRuntime>(*this);
} }
void CodeGenModule::createOpenMPRuntime() { void CodeGenModule::createOpenMPRuntime() {
// Select a specialized code generation class based on the target, if any. // Select a specialized code generation class based on the target, if any.
// If it does not exist use the default implementation. // If it does not exist use the default implementation.
switch (getTriple().getArch()) { switch (getTriple().getArch()) {
case llvm::Triple::nvptx: case llvm::Triple::nvptx:
case llvm::Triple::nvptx64: case llvm::Triple::nvptx64:
assert(getLangOpts().OpenMPIsDevice && assert(getLangOpts().OpenMPIsDevice &&
"OpenMP NVPTX is only prepared to deal with device code."); "OpenMP NVPTX is only prepared to deal with device code.");
OpenMPRuntime.reset(new CGOpenMPRuntimeNVPTX(*this)); OpenMPRuntime = llvm::make_unique<CGOpenMPRuntimeNVPTX>(*this);
break; break;
default: default:
OpenMPRuntime.reset(new CGOpenMPRuntime(*this)); OpenMPRuntime = llvm::make_unique<CGOpenMPRuntime>(*this);
break; break;
} }
} }
void CodeGenModule::createCUDARuntime() { void CodeGenModule::createCUDARuntime() {
CUDARuntime.reset(CreateNVCUDARuntime(*this)); CUDARuntime.reset(CreateNVCUDARuntime(*this));
} }
▲ Show 20 Lines • Show All 4,264 Lines • Show Last 20 Lines

lib/CodeGen/CodeGenPGO.cpp

Show First 20 Lines • Show All 644 Lines • ▼ Show 20 Lines if (PGOReader) {
SourceManager &SM = CGM.getContext().getSourceManager(); SourceManager &SM = CGM.getContext().getSourceManager();
loadRegionCounts(PGOReader, SM.isInMainFile(D->getLocation())); loadRegionCounts(PGOReader, SM.isInMainFile(D->getLocation()));
computeRegionCounts(D); computeRegionCounts(D);
applyFunctionAttributes(PGOReader, Fn); applyFunctionAttributes(PGOReader, Fn);
} }
} }
void CodeGenPGO::mapRegionCounters(const Decl *D) { void CodeGenPGO::mapRegionCounters(const Decl *D) {
RegionCounterMap.reset(new llvm::DenseMap<const Stmt *, unsigned>); RegionCounterMap = llvm::make_unique<llvm::DenseMap<const Stmt *, unsigned>>();
MapRegionCounters Walker(*RegionCounterMap); MapRegionCounters Walker(*RegionCounterMap);
if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
Walker.TraverseDecl(const_cast<FunctionDecl *>(FD)); Walker.TraverseDecl(const_cast<FunctionDecl *>(FD));
else if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(D)) else if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(D))
Walker.TraverseDecl(const_cast<ObjCMethodDecl *>(MD)); Walker.TraverseDecl(const_cast<ObjCMethodDecl *>(MD));
else if (const BlockDecl *BD = dyn_cast_or_null<BlockDecl>(D)) else if (const BlockDecl *BD = dyn_cast_or_null<BlockDecl>(D))
Walker.TraverseDecl(const_cast<BlockDecl *>(BD)); Walker.TraverseDecl(const_cast<BlockDecl *>(BD));
else if (const CapturedDecl *CD = dyn_cast_or_null<CapturedDecl>(D)) else if (const CapturedDecl *CD = dyn_cast_or_null<CapturedDecl>(D))
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines if (CoverageMapping.empty())
return; return;
setFuncName(Name, Linkage); setFuncName(Name, Linkage);
CGM.getCoverageMapping()->addFunctionMappingRecord( CGM.getCoverageMapping()->addFunctionMappingRecord(
FuncNameVar, FuncName, FunctionHash, CoverageMapping, false); FuncNameVar, FuncName, FunctionHash, CoverageMapping, false);
} }
void CodeGenPGO::computeRegionCounts(const Decl *D) { void CodeGenPGO::computeRegionCounts(const Decl *D) {
StmtCountMap.reset(new llvm::DenseMap<const Stmt *, uint64_t>); StmtCountMap = llvm::make_unique<llvm::DenseMap<const Stmt *, uint64_t>>();
ComputeRegionCounts Walker(*StmtCountMap, *this); ComputeRegionCounts Walker(*StmtCountMap, *this);
if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D)) if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
Walker.VisitFunctionDecl(FD); Walker.VisitFunctionDecl(FD);
else if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(D)) else if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(D))
Walker.VisitObjCMethodDecl(MD); Walker.VisitObjCMethodDecl(MD);
else if (const BlockDecl *BD = dyn_cast_or_null<BlockDecl>(D)) else if (const BlockDecl *BD = dyn_cast_or_null<BlockDecl>(D))
Walker.VisitBlockDecl(BD); Walker.VisitBlockDecl(BD);
else if (const CapturedDecl *CD = dyn_cast_or_null<CapturedDecl>(D)) else if (const CapturedDecl *CD = dyn_cast_or_null<CapturedDecl>(D))
▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

lib/CodeGen/ModuleBuilder.cpp

Show First 20 Lines • Show All 118 Lines • ▼ Show 20 Lines llvm::Constant *GetAddrOfGlobal(GlobalDecl global, bool isForDefinition) {
return Builder->GetAddrOfGlobal(global, ForDefinition_t(isForDefinition)); return Builder->GetAddrOfGlobal(global, ForDefinition_t(isForDefinition));
} }
void Initialize(ASTContext &Context) override { void Initialize(ASTContext &Context) override {
Ctx = &Context; Ctx = &Context;
M->setTargetTriple(Ctx->getTargetInfo().getTriple().getTriple()); M->setTargetTriple(Ctx->getTargetInfo().getTriple().getTriple());
M->setDataLayout(Ctx->getTargetInfo().getDataLayout()); M->setDataLayout(Ctx->getTargetInfo().getDataLayout());
Builder.reset(new CodeGen::CodeGenModule(Context, HeaderSearchOpts, Builder = llvm::make_unique<CodeGen::CodeGenModule>(Context, HeaderSearchOpts,
PreprocessorOpts, CodeGenOpts, PreprocessorOpts, CodeGenOpts,
*M, Diags, CoverageInfo)); *M, Diags, CoverageInfo);
for (auto &&Lib : CodeGenOpts.DependentLibraries) for (auto &&Lib : CodeGenOpts.DependentLibraries)
Builder->AddDependentLib(Lib); Builder->AddDependentLib(Lib);
for (auto &&Opt : CodeGenOpts.LinkerOptions) for (auto &&Opt : CodeGenOpts.LinkerOptions)
Builder->AppendLinkerOptions(Opt); Builder->AppendLinkerOptions(Opt);
} }
void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) override { void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) override {
▲ Show 20 Lines • Show All 190 Lines • Show Last 20 Lines

lib/CodeGen/ObjectFilePCHContainerOperations.cpp

Show First 20 Lines • Show All 156 Lines • ▼ Show 20 Linespublic:
} }
~PCHContainerGenerator() override = default; ~PCHContainerGenerator() override = default;
void Initialize(ASTContext &Context) override { void Initialize(ASTContext &Context) override {
assert(!Ctx && "initialized multiple times"); assert(!Ctx && "initialized multiple times");
Ctx = &Context; Ctx = &Context;
VMContext.reset(new llvm::LLVMContext()); VMContext = llvm::make_unique<llvm::LLVMContext>();
M.reset(new llvm::Module(MainFileName, *VMContext)); M = llvm::make_unique<llvm::Module>(MainFileName, *VMContext);
M->setDataLayout(Ctx->getTargetInfo().getDataLayout()); M->setDataLayout(Ctx->getTargetInfo().getDataLayout());
Builder.reset(new CodeGen::CodeGenModule( Builder = llvm::make_unique<CodeGen::CodeGenModule>(
*Ctx, HeaderSearchOpts, PreprocessorOpts, CodeGenOpts, *M, Diags)); *Ctx, HeaderSearchOpts, PreprocessorOpts, CodeGenOpts, *M, Diags);
// Prepare CGDebugInfo to emit debug info for a clang module. // Prepare CGDebugInfo to emit debug info for a clang module.
auto *DI = Builder->getModuleDebugInfo(); auto *DI = Builder->getModuleDebugInfo();
StringRef ModuleName = llvm::sys::path::filename(MainFileName); StringRef ModuleName = llvm::sys::path::filename(MainFileName);
DI->setPCHDescriptor({ModuleName, "", OutputFileName, DI->setPCHDescriptor({ModuleName, "", OutputFileName,
ASTFileSignature{{{~0U, ~0U, ~0U, ~0U, ~1U}}}}); ASTFileSignature{{{~0U, ~0U, ~0U, ~0U, ~1U}}}});
DI->setModuleMap(MMap); DI->setModuleMap(MMap);
} }
▲ Show 20 Lines • Show All 170 Lines • Show Last 20 Lines

lib/Driver/ToolChain.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
bool ToolChain::useIntegratedAs() const { bool ToolChain::useIntegratedAs() const {
return Args.hasFlag(options::OPT_fintegrated_as, return Args.hasFlag(options::OPT_fintegrated_as,
options::OPT_fno_integrated_as, options::OPT_fno_integrated_as,
IsIntegratedAssemblerDefault()); IsIntegratedAssemblerDefault());
} }
const SanitizerArgs& ToolChain::getSanitizerArgs() const { const SanitizerArgs& ToolChain::getSanitizerArgs() const {
if (!SanitizerArguments.get()) if (!SanitizerArguments.get())
SanitizerArguments.reset(new SanitizerArgs(*this, Args)); SanitizerArguments = llvm::make_unique<SanitizerArgs>(*this, Args);
return *SanitizerArguments.get(); return *SanitizerArguments.get();
} }
const XRayArgs& ToolChain::getXRayArgs() const { const XRayArgs& ToolChain::getXRayArgs() const {
if (!XRayArguments.get()) if (!XRayArguments.get())
XRayArguments.reset(new XRayArgs(*this, Args)); XRayArguments = llvm::make_unique<XRayArgs>(*this, Args);
return *XRayArguments.get(); return *XRayArguments.get();
} }
namespace { namespace {
struct DriverSuffix { struct DriverSuffix {
const char *Suffix; const char *Suffix;
const char *ModeFlag; const char *ModeFlag;
}; };
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Lines
} }
bool ToolChain::IsUnwindTablesDefault() const { bool ToolChain::IsUnwindTablesDefault() const {
return false; return false;
} }
Tool *ToolChain::getClang() const { Tool *ToolChain::getClang() const {
if (!Clang) if (!Clang)
Clang.reset(new tools::Clang(*this)); Clang = llvm::make_unique<tools::Clang>(*this);
return Clang.get(); return Clang.get();
} }
Tool *ToolChain::buildAssembler() const { Tool *ToolChain::buildAssembler() const {
return new tools::ClangAs(*this); return new tools::ClangAs(*this);
} }
Tool *ToolChain::buildLinker() const { Tool *ToolChain::buildLinker() const {
llvm_unreachable("Linking is not supported by this toolchain"); llvm_unreachable("Linking is not supported by this toolchain");
} }
Tool *ToolChain::getAssemble() const { Tool *ToolChain::getAssemble() const {
if (!Assemble) if (!Assemble)
Assemble.reset(buildAssembler()); Assemble.reset(buildAssembler());
return Assemble.get(); return Assemble.get();
} }
Tool *ToolChain::getClangAs() const { Tool *ToolChain::getClangAs() const {
if (!Assemble) if (!Assemble)
Assemble.reset(new tools::ClangAs(*this)); Assemble = llvm::make_unique<tools::ClangAs>(*this);
return Assemble.get(); return Assemble.get();
} }
Tool *ToolChain::getLink() const { Tool *ToolChain::getLink() const {
if (!Link) if (!Link)
Link.reset(buildLinker()); Link.reset(buildLinker());
return Link.get(); return Link.get();
} }
Tool *ToolChain::getOffloadBundler() const { Tool *ToolChain::getOffloadBundler() const {
if (!OffloadBundler) if (!OffloadBundler)
OffloadBundler.reset(new tools::OffloadBundler(*this)); OffloadBundler = llvm::make_unique<tools::OffloadBundler>(*this);
return OffloadBundler.get(); return OffloadBundler.get();
} }
Tool *ToolChain::getTool(Action::ActionClass AC) const { Tool *ToolChain::getTool(Action::ActionClass AC) const {
switch (AC) { switch (AC) {
case Action::AssembleJobClass: case Action::AssembleJobClass:
return getAssemble(); return getAssemble();
▲ Show 20 Lines • Show All 511 Lines • Show Last 20 Lines

lib/Driver/ToolChains/Clang.cpp

Show First 20 Lines • Show All 4,846 Lines • ▼ Show 20 Lines if (Args.hasArg(options::OPT__SLASH_fallback))
CmdArgs.push_back("msvc-fallback"); CmdArgs.push_back("msvc-fallback");
else else
CmdArgs.push_back("msvc"); CmdArgs.push_back("msvc");
} }
} }
visualstudio::Compiler *Clang::getCLFallback() const { visualstudio::Compiler *Clang::getCLFallback() const {
if (!CLFallback) if (!CLFallback)
CLFallback.reset(new visualstudio::Compiler(getToolChain())); CLFallback = llvm::make_unique<visualstudio::Compiler>(getToolChain());
return CLFallback.get(); return CLFallback.get();
} }
const char *Clang::getBaseInputName(const ArgList &Args, const char *Clang::getBaseInputName(const ArgList &Args,
const InputInfo &Input) { const InputInfo &Input) {
return Args.MakeArgString(llvm::sys::path::filename(Input.getBaseInput())); return Args.MakeArgString(llvm::sys::path::filename(Input.getBaseInput()));
} }
▲ Show 20 Lines • Show All 378 Lines • Show Last 20 Lines

lib/Driver/ToolChains/Darwin.cpp

Show First 20 Lines • Show All 805 Lines • ▼ Show 20 Linesstd::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args,
return Triple.getTriple(); return Triple.getTriple();
} }
Tool *MachO::getTool(Action::ActionClass AC) const { Tool *MachO::getTool(Action::ActionClass AC) const {
switch (AC) { switch (AC) {
case Action::LipoJobClass: case Action::LipoJobClass:
if (!Lipo) if (!Lipo)
Lipo.reset(new tools::darwin::Lipo(*this)); Lipo = llvm::make_unique<tools::darwin::Lipo>(*this);
return Lipo.get(); return Lipo.get();
case Action::DsymutilJobClass: case Action::DsymutilJobClass:
if (!Dsymutil) if (!Dsymutil)
Dsymutil.reset(new tools::darwin::Dsymutil(*this)); Dsymutil = llvm::make_unique<tools::darwin::Dsymutil>(*this);
return Dsymutil.get(); return Dsymutil.get();
case Action::VerifyDebugInfoJobClass: case Action::VerifyDebugInfoJobClass:
if (!VerifyDebug) if (!VerifyDebug)
VerifyDebug.reset(new tools::darwin::VerifyDebug(*this)); VerifyDebug = llvm::make_unique<tools::darwin::VerifyDebug>(*this);
return VerifyDebug.get(); return VerifyDebug.get();
default: default:
return ToolChain::getTool(AC); return ToolChain::getTool(AC);
} }
} }
Tool *MachO::buildLinker() const { return new tools::darwin::Linker(*this); } Tool *MachO::buildLinker() const { return new tools::darwin::Linker(*this); }
▲ Show 20 Lines • Show All 1,098 Lines • Show Last 20 Lines

lib/Driver/ToolChains/Gnu.cpp

Show First 20 Lines • Show All 2,243 Lines • ▼ Show 20 Lines
} }
Generic_GCC::~Generic_GCC() {} Generic_GCC::~Generic_GCC() {}
Tool *Generic_GCC::getTool(Action::ActionClass AC) const { Tool *Generic_GCC::getTool(Action::ActionClass AC) const {
switch (AC) { switch (AC) {
case Action::PreprocessJobClass: case Action::PreprocessJobClass:
if (!Preprocess) if (!Preprocess)
Preprocess.reset(new clang::driver::tools::gcc::Preprocessor(*this)); Preprocess = llvm::make_unique<clang::driver::tools::gcc::Preprocessor>(*this);
return Preprocess.get(); return Preprocess.get();
case Action::CompileJobClass: case Action::CompileJobClass:
if (!Compile) if (!Compile)
Compile.reset(new tools::gcc::Compiler(*this)); Compile = llvm::make_unique<tools::gcc::Compiler>(*this);
return Compile.get(); return Compile.get();
default: default:
return ToolChain::getTool(AC); return ToolChain::getTool(AC);
} }
} }
Tool *Generic_GCC::buildAssembler() const { Tool *Generic_GCC::buildAssembler() const {
return new tools::gnutools::Assembler(*this); return new tools::gnutools::Assembler(*this);
▲ Show 20 Lines • Show All 193 Lines • Show Last 20 Lines

lib/Driver/ToolChains/MinGW.cpp

Show First 20 Lines • Show All 322 Lines • ▼ Show 20 Lines
} }
bool toolchains::MinGW::IsIntegratedAssemblerDefault() const { return true; } bool toolchains::MinGW::IsIntegratedAssemblerDefault() const { return true; }
Tool *toolchains::MinGW::getTool(Action::ActionClass AC) const { Tool *toolchains::MinGW::getTool(Action::ActionClass AC) const {
switch (AC) { switch (AC) {
case Action::PreprocessJobClass: case Action::PreprocessJobClass:
if (!Preprocessor) if (!Preprocessor)
Preprocessor.reset(new tools::gcc::Preprocessor(*this)); Preprocessor = llvm::make_unique<tools::gcc::Preprocessor>(*this);
return Preprocessor.get(); return Preprocessor.get();
case Action::CompileJobClass: case Action::CompileJobClass:
if (!Compiler) if (!Compiler)
Compiler.reset(new tools::gcc::Compiler(*this)); Compiler = llvm::make_unique<tools::gcc::Compiler>(*this);
return Compiler.get(); return Compiler.get();
default: default:
return ToolChain::getTool(AC); return ToolChain::getTool(AC);
} }
} }
Tool *toolchains::MinGW::buildAssembler() const { Tool *toolchains::MinGW::buildAssembler() const {
return new tools::MinGW::Assembler(*this); return new tools::MinGW::Assembler(*this);
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

lib/Driver/ToolChains/Myriad.cpp

Show First 20 Lines • Show All 263 Lines • ▼ Show 20 Lines
Tool *MyriadToolChain::SelectTool(const JobAction &JA) const { Tool *MyriadToolChain::SelectTool(const JobAction &JA) const {
// The inherited method works fine if not targeting the SHAVE. // The inherited method works fine if not targeting the SHAVE.
if (!isShaveCompilation(getTriple())) if (!isShaveCompilation(getTriple()))
return ToolChain::SelectTool(JA); return ToolChain::SelectTool(JA);
switch (JA.getKind()) { switch (JA.getKind()) {
case Action::PreprocessJobClass: case Action::PreprocessJobClass:
case Action::CompileJobClass: case Action::CompileJobClass:
if (!Compiler) if (!Compiler)
Compiler.reset(new tools::SHAVE::Compiler(*this)); Compiler = llvm::make_unique<tools::SHAVE::Compiler>(*this);
return Compiler.get(); return Compiler.get();
case Action::AssembleJobClass: case Action::AssembleJobClass:
if (!Assembler) if (!Assembler)
Assembler.reset(new tools::SHAVE::Assembler(*this)); Assembler = llvm::make_unique<tools::SHAVE::Assembler>(*this);
return Assembler.get(); return Assembler.get();
default: default:
return ToolChain::getTool(JA.getKind()); return ToolChain::getTool(JA.getKind());
} }
} }
Tool *MyriadToolChain::buildLinker() const { Tool *MyriadToolChain::buildLinker() const {
return new tools::Myriad::Linker(*this); return new tools::Myriad::Linker(*this);
} }
SanitizerMask MyriadToolChain::getSupportedSanitizers() const { SanitizerMask MyriadToolChain::getSupportedSanitizers() const {
return SanitizerKind::Address; return SanitizerKind::Address;
} }

lib/Format/ContinuationIndenter.cpp

Show First 20 Lines • Show All 1,235 Lines • ▼ Show 20 Lines if (Current.isStringLiteral()) {
// reduce the overhead) for each FormatToken, which is a string, so that we // reduce the overhead) for each FormatToken, which is a string, so that we
// don't run multiple checks here on the hot path. // don't run multiple checks here on the hot path.
if ((Text.endswith(Postfix = "\"") && if ((Text.endswith(Postfix = "\"") &&
(Text.startswith(Prefix = "@\"") || Text.startswith(Prefix = "\"") || (Text.startswith(Prefix = "@\"") || Text.startswith(Prefix = "\"") ||
Text.startswith(Prefix = "u\"") || Text.startswith(Prefix = "U\"") || Text.startswith(Prefix = "u\"") || Text.startswith(Prefix = "U\"") ||
Text.startswith(Prefix = "u8\"") || Text.startswith(Prefix = "u8\"") ||
Text.startswith(Prefix = "L\""))) || Text.startswith(Prefix = "L\""))) ||
(Text.startswith(Prefix = "_T(\"") && Text.endswith(Postfix = "\")"))) { (Text.startswith(Prefix = "_T(\"") && Text.endswith(Postfix = "\")"))) {
Token.reset(new BreakableStringLiteral(Current, StartColumn, Prefix, Token = llvm::make_unique<BreakableStringLiteral>(Current, StartColumn, Prefix,
Postfix, State.Line->InPPDirective, Postfix, State.Line->InPPDirective,
Encoding, Style)); Encoding, Style);
} else { } else {
return 0; return 0;
} }
} else if (Current.is(TT_BlockComment)) { } else if (Current.is(TT_BlockComment)) {
if (!Current.isTrailingComment() || !Style.ReflowComments || if (!Current.isTrailingComment() || !Style.ReflowComments ||
// If a comment token switches formatting, like // If a comment token switches formatting, like
// /* clang-format on */, we don't want to break it further, // /* clang-format on */, we don't want to break it further,
// but we may still want to adjust its indentation. // but we may still want to adjust its indentation.
switchesFormatting(Current)) switchesFormatting(Current))
return addMultilineToken(Current, State); return addMultilineToken(Current, State);
Token.reset(new BreakableBlockComment( Token = llvm::make_unique<BreakableBlockComment>(
Current, StartColumn, Current.OriginalColumn, !Current.Previous, Current, StartColumn, Current.OriginalColumn, !Current.Previous,
State.Line->InPPDirective, Encoding, Style)); State.Line->InPPDirective, Encoding, Style);
} else if (Current.is(TT_LineComment) && } else if (Current.is(TT_LineComment) &&
(Current.Previous == nullptr || (Current.Previous == nullptr ||
Current.Previous->isNot(TT_ImplicitStringLiteral))) { Current.Previous->isNot(TT_ImplicitStringLiteral))) {
if (!Style.ReflowComments || if (!Style.ReflowComments ||
CommentPragmasRegex.match(Current.TokenText.substr(2)) || CommentPragmasRegex.match(Current.TokenText.substr(2)) ||
switchesFormatting(Current)) switchesFormatting(Current))
return 0; return 0;
Token.reset(new BreakableLineCommentSection( Token = llvm::make_unique<BreakableLineCommentSection>(
Current, StartColumn, Current.OriginalColumn, !Current.Previous, Current, StartColumn, Current.OriginalColumn, !Current.Previous,
/*InPPDirective=*/false, Encoding, Style)); /*InPPDirective=*/false, Encoding, Style);
// We don't insert backslashes when breaking line comments. // We don't insert backslashes when breaking line comments.
ColumnLimit = Style.ColumnLimit; ColumnLimit = Style.ColumnLimit;
} else { } else {
return 0; return 0;
} }
if (Current.UnbreakableTailLength >= ColumnLimit) if (Current.UnbreakableTailLength >= ColumnLimit)
return 0; return 0;
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

lib/Format/FormatTokenLexer.cpp

Show All 26 LinesFormatTokenLexer::FormatTokenLexer(const SourceManager &SourceMgr, FileID ID,
const FormatStyle &Style, const FormatStyle &Style,
encoding::Encoding Encoding) encoding::Encoding Encoding)
: FormatTok(nullptr), IsFirstToken(true), StateStack({LexerState::NORMAL}), : FormatTok(nullptr), IsFirstToken(true), StateStack({LexerState::NORMAL}),
Column(0), TrailingWhitespace(0), SourceMgr(SourceMgr), ID(ID), Column(0), TrailingWhitespace(0), SourceMgr(SourceMgr), ID(ID),
Style(Style), IdentTable(getFormattingLangOpts(Style)), Style(Style), IdentTable(getFormattingLangOpts(Style)),
Keywords(IdentTable), Encoding(Encoding), FirstInLineIndex(0), Keywords(IdentTable), Encoding(Encoding), FirstInLineIndex(0),
FormattingDisabled(false), MacroBlockBeginRegex(Style.MacroBlockBegin), FormattingDisabled(false), MacroBlockBeginRegex(Style.MacroBlockBegin),
MacroBlockEndRegex(Style.MacroBlockEnd) { MacroBlockEndRegex(Style.MacroBlockEnd) {
Lex.reset(new Lexer(ID, SourceMgr.getBuffer(ID), SourceMgr, Lex = llvm::make_unique<Lexer>(ID, SourceMgr.getBuffer(ID), SourceMgr,
getFormattingLangOpts(Style))); getFormattingLangOpts(Style));
Lex->SetKeepWhitespaceMode(true); Lex->SetKeepWhitespaceMode(true);
for (const std::string &ForEachMacro : Style.ForEachMacros) for (const std::string &ForEachMacro : Style.ForEachMacros)
ForEachMacros.push_back(&IdentTable.get(ForEachMacro)); ForEachMacros.push_back(&IdentTable.get(ForEachMacro));
std::sort(ForEachMacros.begin(), ForEachMacros.end()); std::sort(ForEachMacros.begin(), ForEachMacros.end());
} }
ArrayRef<FormatToken *> FormatTokenLexer::lex() { ArrayRef<FormatToken *> FormatTokenLexer::lex() {
▲ Show 20 Lines • Show All 609 Lines • ▼ Show 20 Linesvoid FormatTokenLexer::readRawToken(FormatToken &Tok) {
if (Tok.is(tok::comment) && (Tok.TokenText == "// clang-format off" || if (Tok.is(tok::comment) && (Tok.TokenText == "// clang-format off" ||
Tok.TokenText == "/* clang-format off */")) { Tok.TokenText == "/* clang-format off */")) {
FormattingDisabled = true; FormattingDisabled = true;
} }
} }
void FormatTokenLexer::resetLexer(unsigned Offset) { void FormatTokenLexer::resetLexer(unsigned Offset) {
StringRef Buffer = SourceMgr.getBufferData(ID); StringRef Buffer = SourceMgr.getBufferData(ID);
Lex.reset(new Lexer(SourceMgr.getLocForStartOfFile(ID), Lex = llvm::make_unique<Lexer>(SourceMgr.getLocForStartOfFile(ID),
getFormattingLangOpts(Style), Buffer.begin(), getFormattingLangOpts(Style), Buffer.begin(),
Buffer.begin() + Offset, Buffer.end())); Buffer.begin() + Offset, Buffer.end());
Lex->SetKeepWhitespaceMode(true); Lex->SetKeepWhitespaceMode(true);
TrailingWhitespace = 0; TrailingWhitespace = 0;
} }
} // namespace format } // namespace format
} // namespace clang } // namespace clang

lib/Format/TokenAnnotator.cpp

Show First 20 Lines • Show All 457 Lines • ▼ Show 20 Linesprivate:
} }
void updateParameterCount(FormatToken *Left, FormatToken *Current) { void updateParameterCount(FormatToken *Left, FormatToken *Current) {
if (Current->is(tok::l_brace) && Current->BlockKind == BK_Block) if (Current->is(tok::l_brace) && Current->BlockKind == BK_Block)
++Left->BlockParameterCount; ++Left->BlockParameterCount;
if (Current->is(tok::comma)) { if (Current->is(tok::comma)) {
++Left->ParameterCount; ++Left->ParameterCount;
if (!Left->Role) if (!Left->Role)
Left->Role.reset(new CommaSeparatedList(Style)); Left->Role = llvm::make_unique<CommaSeparatedList>(Style);
Left->Role->CommaFound(Current); Left->Role->CommaFound(Current);
} else if (Left->ParameterCount == 0 && Current->isNot(tok::comment)) { } else if (Left->ParameterCount == 0 && Current->isNot(tok::comment)) {
Left->ParameterCount = 1; Left->ParameterCount = 1;
} }
} }
bool parseConditional() { bool parseConditional() {
while (CurrentToken) { while (CurrentToken) {
▲ Show 20 Lines • Show All 2,308 Lines • Show Last 20 Lines

lib/Format/UnwrappedLineParser.cpp

Show First 20 Lines • Show All 229 Lines • ▼ Show 20 LinesUnwrappedLineParser::UnwrappedLineParser(const FormatStyle &Style,
UnwrappedLineConsumer &Callback) UnwrappedLineConsumer &Callback)
: Line(new UnwrappedLine), MustBreakBeforeNextToken(false), : Line(new UnwrappedLine), MustBreakBeforeNextToken(false),
CurrentLines(&Lines), Style(Style), Keywords(Keywords), CurrentLines(&Lines), Style(Style), Keywords(Keywords),
CommentPragmasRegex(Style.CommentPragmas), Tokens(nullptr), CommentPragmasRegex(Style.CommentPragmas), Tokens(nullptr),
Callback(Callback), AllTokens(Tokens), PPBranchLevel(-1) {} Callback(Callback), AllTokens(Tokens), PPBranchLevel(-1) {}
void UnwrappedLineParser::reset() { void UnwrappedLineParser::reset() {
PPBranchLevel = -1; PPBranchLevel = -1;
Line.reset(new UnwrappedLine); Line = llvm::make_unique<UnwrappedLine>();
CommentsBeforeNextToken.clear(); CommentsBeforeNextToken.clear();
FormatTok = nullptr; FormatTok = nullptr;
MustBreakBeforeNextToken = false; MustBreakBeforeNextToken = false;
PreprocessorDirectives.clear(); PreprocessorDirectives.clear();
CurrentLines = &Lines; CurrentLines = &Lines;
DeclarationScopeStack.clear(); DeclarationScopeStack.clear();
PPStack.clear(); PPStack.clear();
} }
▲ Show 20 Lines • Show All 2,155 Lines • Show Last 20 Lines

lib/Frontend/ASTUnit.cpp

Show First 20 Lines • Show All 693 Lines • ▼ Show 20 Linesstd::unique_ptr<ASTUnit> ASTUnit::LoadFromASTFile(
AST->FileMgr = new FileManager(FileSystemOpts, VFS); AST->FileMgr = new FileManager(FileSystemOpts, VFS);
AST->UserFilesAreVolatile = UserFilesAreVolatile; AST->UserFilesAreVolatile = UserFilesAreVolatile;
AST->SourceMgr = new SourceManager(AST->getDiagnostics(), AST->SourceMgr = new SourceManager(AST->getDiagnostics(),
AST->getFileManager(), AST->getFileManager(),
UserFilesAreVolatile); UserFilesAreVolatile);
AST->PCMCache = new MemoryBufferCache; AST->PCMCache = new MemoryBufferCache;
AST->HSOpts = std::make_shared<HeaderSearchOptions>(); AST->HSOpts = std::make_shared<HeaderSearchOptions>();
AST->HSOpts->ModuleFormat = PCHContainerRdr.getFormat(); AST->HSOpts->ModuleFormat = PCHContainerRdr.getFormat();
AST->HeaderInfo.reset(new HeaderSearch(AST->HSOpts, AST->HeaderInfo = llvm::make_unique<HeaderSearch>(AST->HSOpts,
AST->getSourceManager(), AST->getSourceManager(),
AST->getDiagnostics(), AST->getDiagnostics(),
AST->getLangOpts(), AST->getLangOpts(),
/*Target=*/nullptr)); /*Target=*/nullptr);
AST->PPOpts = std::make_shared<PreprocessorOptions>(); AST->PPOpts = std::make_shared<PreprocessorOptions>();
for (const auto &RemappedFile : RemappedFiles) for (const auto &RemappedFile : RemappedFiles)
AST->PPOpts->addRemappedFile(RemappedFile.first, RemappedFile.second); AST->PPOpts->addRemappedFile(RemappedFile.first, RemappedFile.second);
// Gather Info for preprocessor construction later on. // Gather Info for preprocessor construction later on.
HeaderSearch &HeaderInfo = *AST->HeaderInfo; HeaderSearch &HeaderInfo = *AST->HeaderInfo;
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines case ASTReader::HadErrors:
return nullptr; return nullptr;
} }
AST->OriginalSourceFile = AST->Reader->getOriginalSourceFile(); AST->OriginalSourceFile = AST->Reader->getOriginalSourceFile();
PP.setCounterValue(Counter); PP.setCounterValue(Counter);
// Create an AST consumer, even though it isn't used. // Create an AST consumer, even though it isn't used.
AST->Consumer.reset(new ASTConsumer); AST->Consumer = llvm::make_unique<ASTConsumer>();
// Create a semantic analysis object and tell the AST reader about it. // Create a semantic analysis object and tell the AST reader about it.
AST->TheSema.reset(new Sema(PP, Context, *AST->Consumer)); AST->TheSema = llvm::make_unique<Sema>(PP, Context, *AST->Consumer);
AST->TheSema->Initialize(); AST->TheSema->Initialize();
AST->Reader->InitializeSema(*AST->TheSema); AST->Reader->InitializeSema(*AST->TheSema);
// Tell the diagnostic client that we have started a source file. // Tell the diagnostic client that we have started a source file.
AST->getDiagnostics().getClient()->BeginSourceFile(Context.getLangOpts(),&PP); AST->getDiagnostics().getClient()->BeginSourceFile(Context.getLangOpts(),&PP);
return AST; return AST;
} }
▲ Show 20 Lines • Show All 820 Lines • ▼ Show 20 LinesASTUnit::getMainBufferWithPrecompiledPreamble(
// Create the source manager. // Create the source manager.
Clang->setSourceManager(new SourceManager(getDiagnostics(), Clang->setSourceManager(new SourceManager(getDiagnostics(),
Clang->getFileManager())); Clang->getFileManager()));
auto PreambleDepCollector = std::make_shared<DependencyCollector>(); auto PreambleDepCollector = std::make_shared<DependencyCollector>();
Clang->addDependencyCollector(PreambleDepCollector); Clang->addDependencyCollector(PreambleDepCollector);
std::unique_ptr<PrecompilePreambleAction> Act; std::unique_ptr<PrecompilePreambleAction> Act;
Act.reset(new PrecompilePreambleAction(*this)); Act = llvm::make_unique<PrecompilePreambleAction>(*this);
if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) { if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) {
llvm::sys::fs::remove(FrontendOpts.OutputFile); llvm::sys::fs::remove(FrontendOpts.OutputFile);
Preamble.clear(); Preamble.clear();
PreambleRebuildCounter = DefaultPreambleRebuildInterval; PreambleRebuildCounter = DefaultPreambleRebuildInterval;
PreprocessorOpts.RemappedFileBuffers.pop_back(); PreprocessorOpts.RemappedFileBuffers.pop_back();
return nullptr; return nullptr;
} }
▲ Show 20 Lines • Show All 235 Lines • ▼ Show 20 LinesASTUnit *ASTUnit::LoadFromCompilerInvocationAction(
// Create the source manager. // Create the source manager.
Clang->setSourceManager(&AST->getSourceManager()); Clang->setSourceManager(&AST->getSourceManager());
FrontendAction *Act = Action; FrontendAction *Act = Action;
std::unique_ptr<TopLevelDeclTrackerAction> TrackerAct; std::unique_ptr<TopLevelDeclTrackerAction> TrackerAct;
if (!Act) { if (!Act) {
TrackerAct.reset(new TopLevelDeclTrackerAction(*AST)); TrackerAct = llvm::make_unique<TopLevelDeclTrackerAction>(*AST);
Act = TrackerAct.get(); Act = TrackerAct.get();
} }
// Recover resources if we crash before exiting this method. // Recover resources if we crash before exiting this method.
llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction> llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction>
ActCleanup(TrackerAct.get()); ActCleanup(TrackerAct.get());
if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) { if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) {
▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 LinesASTUnit *ASTUnit::LoadFromCommandLine(
AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults; AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
AST->IncludeBriefCommentsInCodeCompletion AST->IncludeBriefCommentsInCodeCompletion
= IncludeBriefCommentsInCodeCompletion; = IncludeBriefCommentsInCodeCompletion;
AST->UserFilesAreVolatile = UserFilesAreVolatile; AST->UserFilesAreVolatile = UserFilesAreVolatile;
AST->NumStoredDiagnosticsFromDriver = StoredDiagnostics.size(); AST->NumStoredDiagnosticsFromDriver = StoredDiagnostics.size();
AST->StoredDiagnostics.swap(StoredDiagnostics); AST->StoredDiagnostics.swap(StoredDiagnostics);
AST->Invocation = CI; AST->Invocation = CI;
if (ForSerialization) if (ForSerialization)
AST->WriterData.reset(new ASTWriterData(*AST->PCMCache)); AST->WriterData = llvm::make_unique<ASTWriterData>(*AST->PCMCache);
// Zero out now to ease cleanup during crash recovery. // Zero out now to ease cleanup during crash recovery.
CI = nullptr; CI = nullptr;
Diags = nullptr; Diags = nullptr;
// Recover resources if we crash before exiting this method. // Recover resources if we crash before exiting this method.
llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit> llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
ASTUnitCleanup(AST.get()); ASTUnitCleanup(AST.get());
▲ Show 20 Lines • Show All 461 Lines • ▼ Show 20 Lines if (OverrideMainBuffer) {
PreprocessorOpts.PrecompiledPreambleBytes.second = false; PreprocessorOpts.PrecompiledPreambleBytes.second = false;
} }
// Disable the preprocessing record if modules are not enabled. // Disable the preprocessing record if modules are not enabled.
if (!Clang->getLangOpts().Modules) if (!Clang->getLangOpts().Modules)
PreprocessorOpts.DetailedRecord = false; PreprocessorOpts.DetailedRecord = false;
std::unique_ptr<SyntaxOnlyAction> Act; std::unique_ptr<SyntaxOnlyAction> Act;
Act.reset(new SyntaxOnlyAction); Act = llvm::make_unique<SyntaxOnlyAction>();
if (Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) { if (Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) {
Act->Execute(); Act->Execute();
Act->EndSourceFile(); Act->EndSourceFile();
} }
} }
bool ASTUnit::Save(StringRef File) { bool ASTUnit::Save(StringRef File) {
if (HadModuleLoaderFatalFailure) if (HadModuleLoaderFatalFailure)
▲ Show 20 Lines • Show All 435 Lines • Show Last 20 Lines

lib/Frontend/CompilerInstance.cpp

Show First 20 Lines • Show All 600 Lines • ▼ Show 20 Linesvoid CompilerInstance::createCodeCompletionConsumer() {
if (CompletionConsumer->isOutputBinary() && if (CompletionConsumer->isOutputBinary() &&
llvm::sys::ChangeStdoutToBinary()) { llvm::sys::ChangeStdoutToBinary()) {
getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary); getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
setCodeCompletionConsumer(nullptr); setCodeCompletionConsumer(nullptr);
} }
} }
void CompilerInstance::createFrontendTimer() { void CompilerInstance::createFrontendTimer() {
FrontendTimerGroup.reset( FrontendTimerGroup = llvm::make_unique<llvm::TimerGroup>(
new llvm::TimerGroup("frontend", "Clang front-end time report")); "frontend", "Clang front-end time report");
FrontendTimer.reset( FrontendTimer = llvm::make_unique<llvm::Timer>(
new llvm::Timer("frontend", "Clang front-end timer", "frontend", "Clang front-end timer",
*FrontendTimerGroup)); *FrontendTimerGroup);
} }
CodeCompleteConsumer * CodeCompleteConsumer *
CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP, CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
StringRef Filename, StringRef Filename,
unsigned Line, unsigned Line,
unsigned Column, unsigned Column,
const CodeCompleteOptions &Opts, const CodeCompleteOptions &Opts,
raw_ostream &OS) { raw_ostream &OS) {
if (EnableCodeCompletion(PP, Filename, Line, Column)) if (EnableCodeCompletion(PP, Filename, Line, Column))
return nullptr; return nullptr;
// Set up the creation routine for code-completion. // Set up the creation routine for code-completion.
return new PrintingCodeCompleteConsumer(Opts, OS); return new PrintingCodeCompleteConsumer(Opts, OS);
} }
void CompilerInstance::createSema(TranslationUnitKind TUKind, void CompilerInstance::createSema(TranslationUnitKind TUKind,
CodeCompleteConsumer *CompletionConsumer) { CodeCompleteConsumer *CompletionConsumer) {
TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(), TheSema = llvm::make_unique<Sema>(getPreprocessor(), getASTContext(), getASTConsumer(),
TUKind, CompletionConsumer)); TUKind, CompletionConsumer);
// Attach the external sema source if there is any. // Attach the external sema source if there is any.
if (ExternalSemaSrc) { if (ExternalSemaSrc) {
TheSema->addExternalSource(ExternalSemaSrc.get()); TheSema->addExternalSource(ExternalSemaSrc.get());
ExternalSemaSrc->InitializeSema(*TheSema); ExternalSemaSrc->InitializeSema(*TheSema);
} }
} }
// Output Files // Output Files
▲ Show 20 Lines • Show All 128 Lines • ▼ Show 20 Lines if (CreateMissingDirectories &&
StringRef Parent = llvm::sys::path::parent_path(OutputPath); StringRef Parent = llvm::sys::path::parent_path(OutputPath);
EC = llvm::sys::fs::create_directories(Parent); EC = llvm::sys::fs::create_directories(Parent);
if (!EC) { if (!EC) {
EC = llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath); EC = llvm::sys::fs::createUniqueFile(TempPath, fd, TempPath);
} }
} }
if (!EC) { if (!EC) {
OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true)); OS = llvm::make_unique<llvm::raw_fd_ostream>(fd, /*shouldClose=*/true);
OSFile = TempFile = TempPath.str(); OSFile = TempFile = TempPath.str();
} }
// If we failed to create the temporary, fallback to writing to the file // If we failed to create the temporary, fallback to writing to the file
// directly. This handles the corner case where we cannot write to the // directly. This handles the corner case where we cannot write to the
// directory, but can write to the file. // directory, but can write to the file.
} }
if (!OS) { if (!OS) {
OSFile = OutFile; OSFile = OutFile;
OS.reset(new llvm::raw_fd_ostream( OS = llvm::make_unique<llvm::raw_fd_ostream>(
OSFile, Error, OSFile, Error,
(Binary ? llvm::sys::fs::F_None : llvm::sys::fs::F_Text))); (Binary ? llvm::sys::fs::F_None : llvm::sys::fs::F_Text));
if (Error) if (Error)
return nullptr; return nullptr;
} }
// Make sure the out stream file gets removed if we crash. // Make sure the out stream file gets removed if we crash.
if (RemoveFileOnSignal) if (RemoveFileOnSignal)
llvm::sys::RemoveFileOnSignal(OSFile); llvm::sys::RemoveFileOnSignal(OSFile);
▲ Show 20 Lines • Show All 1,249 Lines • Show Last 20 Lines

lib/Frontend/FrontendActions.cpp

Show First 20 Lines • Show All 401 Lines • ▼ Show 20 Lines
} }
void DumpModuleInfoAction::ExecuteAction() { void DumpModuleInfoAction::ExecuteAction() {
// Set up the output file. // Set up the output file.
std::unique_ptr<llvm::raw_fd_ostream> OutFile; std::unique_ptr<llvm::raw_fd_ostream> OutFile;
StringRef OutputFileName = getCompilerInstance().getFrontendOpts().OutputFile; StringRef OutputFileName = getCompilerInstance().getFrontendOpts().OutputFile;
if (!OutputFileName.empty() && OutputFileName != "-") { if (!OutputFileName.empty() && OutputFileName != "-") {
std::error_code EC; std::error_code EC;
OutFile.reset(new llvm::raw_fd_ostream(OutputFileName.str(), EC, OutFile = llvm::make_unique<llvm::raw_fd_ostream>(OutputFileName.str(), EC,
llvm::sys::fs::F_Text)); llvm::sys::fs::F_Text);
} }
llvm::raw_ostream &Out = OutFile.get()? *OutFile.get() : llvm::outs(); llvm::raw_ostream &Out = OutFile.get()? *OutFile.get() : llvm::outs();
Out << "Information for module file '" << getCurrentFile() << "':\n"; Out << "Information for module file '" << getCurrentFile() << "':\n";
auto &FileMgr = getCompilerInstance().getFileManager(); auto &FileMgr = getCompilerInstance().getFileManager();
auto Buffer = FileMgr.getBufferForFile(getCurrentFile()); auto Buffer = FileMgr.getBufferForFile(getCurrentFile());
StringRef Magic = (*Buffer)->getMemBufferRef().getBuffer(); StringRef Magic = (*Buffer)->getMemBufferRef().getBuffer();
bool IsRaw = (Magic.size() >= 4 && Magic[0] == 'C' && Magic[1] == 'P' && bool IsRaw = (Magic.size() >= 4 && Magic[0] == 'C' && Magic[1] == 'P' &&
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

lib/Frontend/Rewrite/FixItRewriter.cpp

Show First 20 Lines • Show All 89 Lines • ▼ Show 20 Linesbool FixItRewriter::WriteFixedFiles(
for (iterator I = buffer_begin(), E = buffer_end(); I != E; ++I) { for (iterator I = buffer_begin(), E = buffer_end(); I != E; ++I) {
const FileEntry *Entry = Rewrite.getSourceMgr().getFileEntryForID(I->first); const FileEntry *Entry = Rewrite.getSourceMgr().getFileEntryForID(I->first);
int fd; int fd;
std::string Filename = FixItOpts->RewriteFilename(Entry->getName(), fd); std::string Filename = FixItOpts->RewriteFilename(Entry->getName(), fd);
std::error_code EC; std::error_code EC;
std::unique_ptr<llvm::raw_fd_ostream> OS; std::unique_ptr<llvm::raw_fd_ostream> OS;
if (fd != -1) { if (fd != -1) {
OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true)); OS = llvm::make_unique<llvm::raw_fd_ostream>(fd, /*shouldClose=*/true);
} else { } else {
OS.reset(new llvm::raw_fd_ostream(Filename, EC, llvm::sys::fs::F_None)); OS = llvm::make_unique<llvm::raw_fd_ostream>(Filename, EC, llvm::sys::fs::F_None);
} }
if (EC) { if (EC) {
Diags.Report(clang::diag::err_fe_unable_to_open_output) << Filename Diags.Report(clang::diag::err_fe_unable_to_open_output) << Filename
<< EC.message(); << EC.message();
continue; continue;
} }
RewriteBuffer &RewriteBuf = I->second; RewriteBuffer &RewriteBuf = I->second;
RewriteBuf.write(*OS); RewriteBuf.write(*OS);
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

lib/Frontend/Rewrite/FrontendActions.cpp

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Lines std::string RewriteFilename(const std::string &Filename, int &fd) override {
return Path.str(); return Path.str();
} }
}; };
} // end anonymous namespace } // end anonymous namespace
bool FixItAction::BeginSourceFileAction(CompilerInstance &CI) { bool FixItAction::BeginSourceFileAction(CompilerInstance &CI) {
const FrontendOptions &FEOpts = getCompilerInstance().getFrontendOpts(); const FrontendOptions &FEOpts = getCompilerInstance().getFrontendOpts();
if (!FEOpts.FixItSuffix.empty()) { if (!FEOpts.FixItSuffix.empty()) {
FixItOpts.reset(new FixItActionSuffixInserter(FEOpts.FixItSuffix, FixItOpts = llvm::make_unique<FixItActionSuffixInserter>(FEOpts.FixItSuffix,
FEOpts.FixWhatYouCan)); FEOpts.FixWhatYouCan);
} else { } else {
FixItOpts.reset(new FixItRewriteInPlace); FixItOpts = llvm::make_unique<FixItRewriteInPlace>();
FixItOpts->FixWhatYouCan = FEOpts.FixWhatYouCan; FixItOpts->FixWhatYouCan = FEOpts.FixWhatYouCan;
} }
Rewriter.reset(new FixItRewriter(CI.getDiagnostics(), CI.getSourceManager(), Rewriter = llvm::make_unique<FixItRewriter>(CI.getDiagnostics(), CI.getSourceManager(),
CI.getLangOpts(), FixItOpts.get())); CI.getLangOpts(), FixItOpts.get());
return true; return true;
} }
void FixItAction::EndSourceFileAction() { void FixItAction::EndSourceFileAction() {
// Otherwise rewrite all files. // Otherwise rewrite all files.
Rewriter->WriteFixedFiles(); Rewriter->WriteFixedFiles();
} }
bool FixItRecompile::BeginInvocation(CompilerInstance &CI) { bool FixItRecompile::BeginInvocation(CompilerInstance &CI) {
std::vector<std::pair<std::string, std::string> > RewrittenFiles; std::vector<std::pair<std::string, std::string> > RewrittenFiles;
bool err = false; bool err = false;
{ {
const FrontendOptions &FEOpts = CI.getFrontendOpts(); const FrontendOptions &FEOpts = CI.getFrontendOpts();
std::unique_ptr<FrontendAction> FixAction(new SyntaxOnlyAction()); std::unique_ptr<FrontendAction> FixAction(new SyntaxOnlyAction());
if (FixAction->BeginSourceFile(CI, FEOpts.Inputs[0])) { if (FixAction->BeginSourceFile(CI, FEOpts.Inputs[0])) {
std::unique_ptr<FixItOptions> FixItOpts; std::unique_ptr<FixItOptions> FixItOpts;
if (FEOpts.FixToTemporaries) if (FEOpts.FixToTemporaries)
FixItOpts.reset(new FixItRewriteToTemp()); FixItOpts = llvm::make_unique<FixItRewriteToTemp>();
else else
FixItOpts.reset(new FixItRewriteInPlace()); FixItOpts = llvm::make_unique<FixItRewriteInPlace>();
FixItOpts->Silent = true; FixItOpts->Silent = true;
FixItOpts->FixWhatYouCan = FEOpts.FixWhatYouCan; FixItOpts->FixWhatYouCan = FEOpts.FixWhatYouCan;
FixItOpts->FixOnlyWarnings = FEOpts.FixOnlyWarnings; FixItOpts->FixOnlyWarnings = FEOpts.FixOnlyWarnings;
FixItRewriter Rewriter(CI.getDiagnostics(), CI.getSourceManager(), FixItRewriter Rewriter(CI.getDiagnostics(), CI.getSourceManager(),
CI.getLangOpts(), FixItOpts.get()); CI.getLangOpts(), FixItOpts.get());
FixAction->Execute(); FixAction->Execute();
err = Rewriter.WriteFixedFiles(&RewrittenFiles); err = Rewriter.WriteFixedFiles(&RewrittenFiles);
▲ Show 20 Lines • Show All 172 Lines • Show Last 20 Lines

lib/Frontend/TextDiagnosticPrinter.cpp

Show All 31 Lines
TextDiagnosticPrinter::~TextDiagnosticPrinter() { TextDiagnosticPrinter::~TextDiagnosticPrinter() {
if (OwnsOutputStream) if (OwnsOutputStream)
delete &OS; delete &OS;
} }
void TextDiagnosticPrinter::BeginSourceFile(const LangOptions &LO, void TextDiagnosticPrinter::BeginSourceFile(const LangOptions &LO,
const Preprocessor *PP) { const Preprocessor *PP) {
// Build the TextDiagnostic utility. // Build the TextDiagnostic utility.
TextDiag.reset(new TextDiagnostic(OS, LO, &*DiagOpts)); TextDiag = llvm::make_unique<TextDiagnostic>(OS, LO, &*DiagOpts);
} }
void TextDiagnosticPrinter::EndSourceFile() { void TextDiagnosticPrinter::EndSourceFile() {
TextDiag.reset(); TextDiag.reset();
} }
/// \brief Print any diagnostic option information to a raw_ostream. /// \brief Print any diagnostic option information to a raw_ostream.
/// ///
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

lib/Frontend/VerifyDiagnosticConsumer.cpp

Show First 20 Lines • Show All 875 Lines • ▼ Show 20 Lines if (SrcManager) {
if (bool(DiagnosticLevelMask::Note & DiagMask)) if (bool(DiagnosticLevelMask::Note & DiagMask))
NumErrors += PrintUnexpected(Diags, nullptr, Buffer->note_begin(), NumErrors += PrintUnexpected(Diags, nullptr, Buffer->note_begin(),
Buffer->note_end(), "note"); Buffer->note_end(), "note");
} }
Diags.setClient(CurClient, Owner.release() != nullptr); Diags.setClient(CurClient, Owner.release() != nullptr);
// Reset the buffer, we have processed all the diagnostics in it. // Reset the buffer, we have processed all the diagnostics in it.
Buffer.reset(new TextDiagnosticBuffer()); Buffer = llvm::make_unique<TextDiagnosticBuffer>();
ED.Reset(); ED.Reset();
} }
std::unique_ptr<Directive> Directive::create(bool RegexKind, std::unique_ptr<Directive> Directive::create(bool RegexKind,
SourceLocation DirectiveLoc, SourceLocation DirectiveLoc,
SourceLocation DiagnosticLoc, SourceLocation DiagnosticLoc,
bool MatchAnyLine, StringRef Text, bool MatchAnyLine, StringRef Text,
unsigned Min, unsigned Max) { unsigned Min, unsigned Max) {
Show All 30 Lines

lib/Parse/ParseDecl.cpp

Show First 20 Lines • Show All 6,296 Lines • ▼ Show 20 Lines if (DS.isEmpty() && ParmDeclarator.getIdentifier() == nullptr &&
if (Tok.is(tok::equal)) { if (Tok.is(tok::equal)) {
SourceLocation EqualLoc = Tok.getLocation(); SourceLocation EqualLoc = Tok.getLocation();
// Parse the default argument // Parse the default argument
if (D.getContext() == Declarator::MemberContext) { if (D.getContext() == Declarator::MemberContext) {
// If we're inside a class definition, cache the tokens // If we're inside a class definition, cache the tokens
// corresponding to the default argument. We'll actually parse // corresponding to the default argument. We'll actually parse
// them when we see the end of the class definition. // them when we see the end of the class definition.
DefArgToks.reset(new CachedTokens); DefArgToks = llvm::make_unique<CachedTokens>();
SourceLocation ArgStartLoc = NextToken().getLocation(); SourceLocation ArgStartLoc = NextToken().getLocation();
if (!ConsumeAndStoreInitializer(*DefArgToks, CIK_DefaultArgument)) { if (!ConsumeAndStoreInitializer(*DefArgToks, CIK_DefaultArgument)) {
DefArgToks.reset(); DefArgToks.reset();
Actions.ActOnParamDefaultArgumentError(Param, EqualLoc); Actions.ActOnParamDefaultArgumentError(Param, EqualLoc);
} else { } else {
Actions.ActOnParamUnparsedDefaultArgument(Param, EqualLoc, Actions.ActOnParamUnparsedDefaultArgument(Param, EqualLoc,
ArgStartLoc); ArgStartLoc);
▲ Show 20 Lines • Show All 465 Lines • Show Last 20 Lines

lib/Parse/ParsePragma.cpp

Show First 20 Lines • Show All 200 Lines • ▼ Show 20 Linesstruct PragmaAttributeHandler : public PragmaHandler {
/// A pool of attributes that were parsed in \#pragma clang attribute. /// A pool of attributes that were parsed in \#pragma clang attribute.
ParsedAttributes AttributesForPragmaAttribute; ParsedAttributes AttributesForPragmaAttribute;
}; };
} // end namespace } // end namespace
void Parser::initializePragmaHandlers() { void Parser::initializePragmaHandlers() {
AlignHandler.reset(new PragmaAlignHandler()); AlignHandler = llvm::make_unique<PragmaAlignHandler>();
PP.AddPragmaHandler(AlignHandler.get()); PP.AddPragmaHandler(AlignHandler.get());
GCCVisibilityHandler.reset(new PragmaGCCVisibilityHandler()); GCCVisibilityHandler = llvm::make_unique<PragmaGCCVisibilityHandler>();
PP.AddPragmaHandler("GCC", GCCVisibilityHandler.get()); PP.AddPragmaHandler("GCC", GCCVisibilityHandler.get());
OptionsHandler.reset(new PragmaOptionsHandler()); OptionsHandler = llvm::make_unique<PragmaOptionsHandler>();
PP.AddPragmaHandler(OptionsHandler.get()); PP.AddPragmaHandler(OptionsHandler.get());
PackHandler.reset(new PragmaPackHandler()); PackHandler = llvm::make_unique<PragmaPackHandler>();
PP.AddPragmaHandler(PackHandler.get()); PP.AddPragmaHandler(PackHandler.get());
MSStructHandler.reset(new PragmaMSStructHandler()); MSStructHandler = llvm::make_unique<PragmaMSStructHandler>();
PP.AddPragmaHandler(MSStructHandler.get()); PP.AddPragmaHandler(MSStructHandler.get());
UnusedHandler.reset(new PragmaUnusedHandler()); UnusedHandler = llvm::make_unique<PragmaUnusedHandler>();
PP.AddPragmaHandler(UnusedHandler.get()); PP.AddPragmaHandler(UnusedHandler.get());
WeakHandler.reset(new PragmaWeakHandler()); WeakHandler = llvm::make_unique<PragmaWeakHandler>();
PP.AddPragmaHandler(WeakHandler.get()); PP.AddPragmaHandler(WeakHandler.get());
RedefineExtnameHandler.reset(new PragmaRedefineExtnameHandler()); RedefineExtnameHandler = llvm::make_unique<PragmaRedefineExtnameHandler>();
PP.AddPragmaHandler(RedefineExtnameHandler.get()); PP.AddPragmaHandler(RedefineExtnameHandler.get());
FPContractHandler.reset(new PragmaFPContractHandler()); FPContractHandler = llvm::make_unique<PragmaFPContractHandler>();
PP.AddPragmaHandler("STDC", FPContractHandler.get()); PP.AddPragmaHandler("STDC", FPContractHandler.get());
PCSectionHandler.reset(new PragmaClangSectionHandler(Actions)); PCSectionHandler = llvm::make_unique<PragmaClangSectionHandler>(Actions);
PP.AddPragmaHandler("clang", PCSectionHandler.get()); PP.AddPragmaHandler("clang", PCSectionHandler.get());
if (getLangOpts().OpenCL) { if (getLangOpts().OpenCL) {
OpenCLExtensionHandler.reset(new PragmaOpenCLExtensionHandler()); OpenCLExtensionHandler = llvm::make_unique<PragmaOpenCLExtensionHandler>();
PP.AddPragmaHandler("OPENCL", OpenCLExtensionHandler.get()); PP.AddPragmaHandler("OPENCL", OpenCLExtensionHandler.get());
PP.AddPragmaHandler("OPENCL", FPContractHandler.get()); PP.AddPragmaHandler("OPENCL", FPContractHandler.get());
} }
if (getLangOpts().OpenMP) if (getLangOpts().OpenMP)
OpenMPHandler.reset(new PragmaOpenMPHandler()); OpenMPHandler = llvm::make_unique<PragmaOpenMPHandler>();
else else
OpenMPHandler.reset(new PragmaNoOpenMPHandler()); OpenMPHandler = llvm::make_unique<PragmaNoOpenMPHandler>();
PP.AddPragmaHandler(OpenMPHandler.get()); PP.AddPragmaHandler(OpenMPHandler.get());
if (getLangOpts().MicrosoftExt || getTargetInfo().getTriple().isPS4()) { if (getLangOpts().MicrosoftExt || getTargetInfo().getTriple().isPS4()) {
MSCommentHandler.reset(new PragmaCommentHandler(Actions)); MSCommentHandler = llvm::make_unique<PragmaCommentHandler>(Actions);
PP.AddPragmaHandler(MSCommentHandler.get()); PP.AddPragmaHandler(MSCommentHandler.get());
} }
if (getLangOpts().MicrosoftExt) { if (getLangOpts().MicrosoftExt) {
MSDetectMismatchHandler.reset(new PragmaDetectMismatchHandler(Actions)); MSDetectMismatchHandler = llvm::make_unique<PragmaDetectMismatchHandler>(Actions);
PP.AddPragmaHandler(MSDetectMismatchHandler.get()); PP.AddPragmaHandler(MSDetectMismatchHandler.get());
MSPointersToMembers.reset(new PragmaMSPointersToMembers()); MSPointersToMembers = llvm::make_unique<PragmaMSPointersToMembers>();
PP.AddPragmaHandler(MSPointersToMembers.get()); PP.AddPragmaHandler(MSPointersToMembers.get());
MSVtorDisp.reset(new PragmaMSVtorDisp()); MSVtorDisp = llvm::make_unique<PragmaMSVtorDisp>();
PP.AddPragmaHandler(MSVtorDisp.get()); PP.AddPragmaHandler(MSVtorDisp.get());
MSInitSeg.reset(new PragmaMSPragma("init_seg")); MSInitSeg = llvm::make_unique<PragmaMSPragma>("init_seg");
PP.AddPragmaHandler(MSInitSeg.get()); PP.AddPragmaHandler(MSInitSeg.get());
MSDataSeg.reset(new PragmaMSPragma("data_seg")); MSDataSeg = llvm::make_unique<PragmaMSPragma>("data_seg");
PP.AddPragmaHandler(MSDataSeg.get()); PP.AddPragmaHandler(MSDataSeg.get());
MSBSSSeg.reset(new PragmaMSPragma("bss_seg")); MSBSSSeg = llvm::make_unique<PragmaMSPragma>("bss_seg");
PP.AddPragmaHandler(MSBSSSeg.get()); PP.AddPragmaHandler(MSBSSSeg.get());
MSConstSeg.reset(new PragmaMSPragma("const_seg")); MSConstSeg = llvm::make_unique<PragmaMSPragma>("const_seg");
PP.AddPragmaHandler(MSConstSeg.get()); PP.AddPragmaHandler(MSConstSeg.get());
MSCodeSeg.reset(new PragmaMSPragma("code_seg")); MSCodeSeg = llvm::make_unique<PragmaMSPragma>("code_seg");
PP.AddPragmaHandler(MSCodeSeg.get()); PP.AddPragmaHandler(MSCodeSeg.get());
MSSection.reset(new PragmaMSPragma("section")); MSSection = llvm::make_unique<PragmaMSPragma>("section");
PP.AddPragmaHandler(MSSection.get()); PP.AddPragmaHandler(MSSection.get());
MSRuntimeChecks.reset(new PragmaMSRuntimeChecksHandler()); MSRuntimeChecks = llvm::make_unique<PragmaMSRuntimeChecksHandler>();
PP.AddPragmaHandler(MSRuntimeChecks.get()); PP.AddPragmaHandler(MSRuntimeChecks.get());
MSIntrinsic.reset(new PragmaMSIntrinsicHandler()); MSIntrinsic = llvm::make_unique<PragmaMSIntrinsicHandler>();
PP.AddPragmaHandler(MSIntrinsic.get()); PP.AddPragmaHandler(MSIntrinsic.get());
} }
if (getLangOpts().CUDA) { if (getLangOpts().CUDA) {
CUDAForceHostDeviceHandler.reset( CUDAForceHostDeviceHandler = llvm::make_unique<PragmaForceCUDAHostDeviceHandler>(
new PragmaForceCUDAHostDeviceHandler(Actions)); Actions);
PP.AddPragmaHandler("clang", CUDAForceHostDeviceHandler.get()); PP.AddPragmaHandler("clang", CUDAForceHostDeviceHandler.get());
} }
OptimizeHandler.reset(new PragmaOptimizeHandler(Actions)); OptimizeHandler = llvm::make_unique<PragmaOptimizeHandler>(Actions);
PP.AddPragmaHandler("clang", OptimizeHandler.get()); PP.AddPragmaHandler("clang", OptimizeHandler.get());
LoopHintHandler.reset(new PragmaLoopHintHandler()); LoopHintHandler = llvm::make_unique<PragmaLoopHintHandler>();
PP.AddPragmaHandler("clang", LoopHintHandler.get()); PP.AddPragmaHandler("clang", LoopHintHandler.get());
UnrollHintHandler.reset(new PragmaUnrollHintHandler("unroll")); UnrollHintHandler = llvm::make_unique<PragmaUnrollHintHandler>("unroll");
PP.AddPragmaHandler(UnrollHintHandler.get()); PP.AddPragmaHandler(UnrollHintHandler.get());
NoUnrollHintHandler.reset(new PragmaUnrollHintHandler("nounroll")); NoUnrollHintHandler = llvm::make_unique<PragmaUnrollHintHandler>("nounroll");
PP.AddPragmaHandler(NoUnrollHintHandler.get()); PP.AddPragmaHandler(NoUnrollHintHandler.get());
FPHandler.reset(new PragmaFPHandler()); FPHandler = llvm::make_unique<PragmaFPHandler>();
PP.AddPragmaHandler("clang", FPHandler.get()); PP.AddPragmaHandler("clang", FPHandler.get());
AttributePragmaHandler.reset(new PragmaAttributeHandler(AttrFactory)); AttributePragmaHandler = llvm::make_unique<PragmaAttributeHandler>(AttrFactory);
PP.AddPragmaHandler("clang", AttributePragmaHandler.get()); PP.AddPragmaHandler("clang", AttributePragmaHandler.get());
} }
void Parser::resetPragmaHandlers() { void Parser::resetPragmaHandlers() {
// Remove the pragma handlers we installed. // Remove the pragma handlers we installed.
PP.RemovePragmaHandler(AlignHandler.get()); PP.RemovePragmaHandler(AlignHandler.get());
AlignHandler.reset(); AlignHandler.reset();
PP.RemovePragmaHandler("GCC", GCCVisibilityHandler.get()); PP.RemovePragmaHandler("GCC", GCCVisibilityHandler.get());
▲ Show 20 Lines • Show All 2,681 Lines • Show Last 20 Lines

lib/Parse/Parser.cpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 LinesParser::Parser(Preprocessor &pp, Sema &actions, bool skipFunctionBodies)
Actions.CurScope = nullptr; Actions.CurScope = nullptr;
NumCachedScopes = 0; NumCachedScopes = 0;
CurParsedObjCImpl = nullptr; CurParsedObjCImpl = nullptr;
// Add #pragma handlers. These are removed and destroyed in the // Add #pragma handlers. These are removed and destroyed in the
// destructor. // destructor.
initializePragmaHandlers(); initializePragmaHandlers();
CommentSemaHandler.reset(new ActionCommentHandler(actions)); CommentSemaHandler = llvm::make_unique<ActionCommentHandler>(actions);
PP.addCommentHandler(CommentSemaHandler.get()); PP.addCommentHandler(CommentSemaHandler.get());
PP.setCodeCompletionHandler(*this); PP.setCodeCompletionHandler(*this);
} }
DiagnosticBuilder Parser::Diag(SourceLocation Loc, unsigned DiagID) { DiagnosticBuilder Parser::Diag(SourceLocation Loc, unsigned DiagID) {
return Diags.Report(Loc, DiagID); return Diags.Report(Loc, DiagID);
} }
▲ Show 20 Lines • Show All 2,170 Lines • Show Last 20 Lines

lib/Rewrite/Rewriter.cpp

Show First 20 Lines • Show All 406 Lines • ▼ Show 20 Lines AtomicallyMovedFile(DiagnosticsEngine &Diagnostics, StringRef Filename,
TempFilename = Filename; TempFilename = Filename;
TempFilename += "-%%%%%%%%"; TempFilename += "-%%%%%%%%";
int FD; int FD;
if (llvm::sys::fs::createUniqueFile(TempFilename, FD, TempFilename)) { if (llvm::sys::fs::createUniqueFile(TempFilename, FD, TempFilename)) {
AllWritten = false; AllWritten = false;
Diagnostics.Report(clang::diag::err_unable_to_make_temp) Diagnostics.Report(clang::diag::err_unable_to_make_temp)
<< TempFilename; << TempFilename;
} else { } else {
FileStream.reset(new llvm::raw_fd_ostream(FD, /*shouldClose=*/true)); FileStream = llvm::make_unique<llvm::raw_fd_ostream>(FD, /*shouldClose=*/true);
} }
} }
~AtomicallyMovedFile() { ~AtomicallyMovedFile() {
if (!ok()) return; if (!ok()) return;
// Close (will also flush) theFileStream. // Close (will also flush) theFileStream.
FileStream->close(); FileStream->close();
Show All 35 Lines

lib/Rewrite/TokenRewriter.cpp

Show All 14 Lines
#include "clang/Rewrite/Core/TokenRewriter.h" #include "clang/Rewrite/Core/TokenRewriter.h"
#include "clang/Basic/SourceManager.h" #include "clang/Basic/SourceManager.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Lex/ScratchBuffer.h" #include "clang/Lex/ScratchBuffer.h"
using namespace clang; using namespace clang;
TokenRewriter::TokenRewriter(FileID FID, SourceManager &SM, TokenRewriter::TokenRewriter(FileID FID, SourceManager &SM,
const LangOptions &LangOpts) { const LangOptions &LangOpts) {
ScratchBuf.reset(new ScratchBuffer(SM)); ScratchBuf = llvm::make_unique<ScratchBuffer>(SM);
// Create a lexer to lex all the tokens of the main file in raw mode. // Create a lexer to lex all the tokens of the main file in raw mode.
const llvm::MemoryBuffer *FromFile = SM.getBuffer(FID); const llvm::MemoryBuffer *FromFile = SM.getBuffer(FID);
Lexer RawLex(FID, FromFile, SM, LangOpts); Lexer RawLex(FID, FromFile, SM, LangOpts);
// Return all comments and whitespace as tokens. // Return all comments and whitespace as tokens.
RawLex.SetKeepWhitespaceMode(true); RawLex.SetKeepWhitespaceMode(true);
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

lib/Sema/AnalysisBasedWarnings.cpp

Show First 20 Lines • Show All 1,982 Lines • ▼ Show 20 Lines AC.getCFGBuildOptions()
.setAlwaysAdd(Stmt::UnaryOperatorClass) .setAlwaysAdd(Stmt::UnaryOperatorClass)
.setAlwaysAdd(Stmt::AttributedStmtClass); .setAlwaysAdd(Stmt::AttributedStmtClass);
} }
// Install the logical handler for -Wtautological-overlap-compare // Install the logical handler for -Wtautological-overlap-compare
std::unique_ptr<LogicalErrorHandler> LEH; std::unique_ptr<LogicalErrorHandler> LEH;
if (!Diags.isIgnored(diag::warn_tautological_overlap_comparison, if (!Diags.isIgnored(diag::warn_tautological_overlap_comparison,
D->getLocStart())) { D->getLocStart())) {
LEH.reset(new LogicalErrorHandler(S)); LEH = llvm::make_unique<LogicalErrorHandler>(S);
AC.getCFGBuildOptions().Observer = LEH.get(); AC.getCFGBuildOptions().Observer = LEH.get();
} }
// Emit delayed diagnostics. // Emit delayed diagnostics.
if (!fscope->PossiblyUnreachableDiags.empty()) { if (!fscope->PossiblyUnreachableDiags.empty()) {
bool analyzed = false; bool analyzed = false;
// Register the expressions with the CFGBuilder. // Register the expressions with the CFGBuilder.
▲ Show 20 Lines • Show All 183 Lines • Show Last 20 Lines

lib/Sema/Sema.cpp

Show First 20 Lines • Show All 100 Lines • ▼ Show 20 Lines : ExternalSource(nullptr), isMultiplexExternalSource(false),
CurScope(nullptr), Ident_super(nullptr), Ident___float128(nullptr) { CurScope(nullptr), Ident_super(nullptr), Ident___float128(nullptr) {
TUScope = nullptr; TUScope = nullptr;
LoadedExternalKnownNamespaces = false; LoadedExternalKnownNamespaces = false;
for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I) for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
NSNumberLiteralMethods[I] = nullptr; NSNumberLiteralMethods[I] = nullptr;
if (getLangOpts().ObjC1) if (getLangOpts().ObjC1)
NSAPIObj.reset(new NSAPI(Context)); NSAPIObj = llvm::make_unique<NSAPI>(Context);
if (getLangOpts().CPlusPlus) if (getLangOpts().CPlusPlus)
FieldCollector.reset(new CXXFieldCollector()); FieldCollector = llvm::make_unique<CXXFieldCollector>();
// Tell diagnostics how to render things from the AST library. // Tell diagnostics how to render things from the AST library.
Diags.SetArgToStringFn(&FormatASTNodeDiagnosticArgument, &Context); Diags.SetArgToStringFn(&FormatASTNodeDiagnosticArgument, &Context);
ExprEvalContexts.emplace_back( ExprEvalContexts.emplace_back(
ExpressionEvaluationContext::PotentiallyEvaluated, 0, CleanupInfo{}, ExpressionEvaluationContext::PotentiallyEvaluated, 0, CleanupInfo{},
nullptr, false); nullptr, false);
▲ Show 20 Lines • Show All 1,571 Lines • Show Last 20 Lines

lib/Sema/SemaChecking.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 11,899 Lines • ▼ Show 20 Lines
} }
} // end anonymous namespace } // end anonymous namespace
void Sema::RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind, void Sema::RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind,
uint64_t MagicValue, QualType Type, uint64_t MagicValue, QualType Type,
bool LayoutCompatible, bool LayoutCompatible,
bool MustBeNull) { bool MustBeNull) {
if (!TypeTagForDatatypeMagicValues) if (!TypeTagForDatatypeMagicValues)
TypeTagForDatatypeMagicValues.reset( TypeTagForDatatypeMagicValues = llvm::make_unique<llvm::DenseMap<TypeTagMagicValue, TypeTagData>>(
new llvm::DenseMap<TypeTagMagicValue, TypeTagData>); );
TypeTagMagicValue Magic(ArgumentKind, MagicValue); TypeTagMagicValue Magic(ArgumentKind, MagicValue);
(*TypeTagForDatatypeMagicValues)[Magic] = (*TypeTagForDatatypeMagicValues)[Magic] =
TypeTagData(Type, LayoutCompatible, MustBeNull); TypeTagData(Type, LayoutCompatible, MustBeNull);
} }
namespace { namespace {
bool IsSameCharType(QualType T1, QualType T2) { bool IsSameCharType(QualType T1, QualType T2) {
▲ Show 20 Lines • Show All 248 Lines • Show Last 20 Lines

lib/Sema/SemaDeclCXX.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 5,253 Lines • ▼ Show 20 Lines for (OverridingMethods::iterator SO = M->second.begin(),
Diag(SO->second.front().Method->getLocation(), Diag(SO->second.front().Method->getLocation(),
diag::note_pure_virtual_function) diag::note_pure_virtual_function)
<< SO->second.front().Method->getDeclName() << RD->getDeclName(); << SO->second.front().Method->getDeclName() << RD->getDeclName();
} }
} }
if (!PureVirtualClassDiagSet) if (!PureVirtualClassDiagSet)
PureVirtualClassDiagSet.reset(new RecordDeclSetTy); PureVirtualClassDiagSet = llvm::make_unique<RecordDeclSetTy>();
PureVirtualClassDiagSet->insert(RD); PureVirtualClassDiagSet->insert(RD);
} }
namespace { namespace {
struct AbstractUsageInfo { struct AbstractUsageInfo {
Sema &S; Sema &S;
CXXRecordDecl *Record; CXXRecordDecl *Record;
CanQualType AbstractType; CanQualType AbstractType;
▲ Show 20 Lines • Show All 9,637 Lines • Show Last 20 Lines

lib/Sema/SemaDeclObjC.cpp

Show First 20 Lines • Show All 2,623 Lines • ▼ Show 20 Linesstatic void CheckProtocolMethodDefs(Sema &S,
// //
// Note: we could generalize this logic for all protocols, and merely // Note: we could generalize this logic for all protocols, and merely
// add the limit on looking at the super class chain for just // add the limit on looking at the super class chain for just
// specially marked protocols. This may be a good optimization. This // specially marked protocols. This may be a good optimization. This
// change is restricted to 'objc_protocol_requires_explicit_implementation' // change is restricted to 'objc_protocol_requires_explicit_implementation'
// protocols for now for controlled evaluation. // protocols for now for controlled evaluation.
if (PDecl->hasAttr<ObjCExplicitProtocolImplAttr>()) { if (PDecl->hasAttr<ObjCExplicitProtocolImplAttr>()) {
if (!ProtocolsExplictImpl) { if (!ProtocolsExplictImpl) {
ProtocolsExplictImpl.reset(new ProtocolNameSet); ProtocolsExplictImpl = llvm::make_unique<ProtocolNameSet>();
findProtocolsWithExplicitImpls(Super, *ProtocolsExplictImpl); findProtocolsWithExplicitImpls(Super, *ProtocolsExplictImpl);
} }
if (ProtocolsExplictImpl->find(PDecl->getIdentifier()) != if (ProtocolsExplictImpl->find(PDecl->getIdentifier()) !=
ProtocolsExplictImpl->end()) ProtocolsExplictImpl->end())
return; return;
// If no super class conforms to the protocol, we should not search // If no super class conforms to the protocol, we should not search
// for methods in the super class to implicitly satisfy the protocol. // for methods in the super class to implicitly satisfy the protocol.
▲ Show 20 Lines • Show All 2,229 Lines • Show Last 20 Lines

lib/Sema/SemaObjCProperty.cpp

Show First 20 Lines • Show All 1,853 Lines • ▼ Show 20 Lines for (auto *PDecl : IDecl->all_referenced_protocols()) {
// of the class, without looking at the superclass. We cannot // of the class, without looking at the superclass. We cannot
// use the call to CollectImmediateProperties() above as that // use the call to CollectImmediateProperties() above as that
// utilizes information from the super class's properties as well // utilizes information from the super class's properties as well
// as scans the adopted protocols. This work only triggers for protocols // as scans the adopted protocols. This work only triggers for protocols
// with the attribute, which is very rare, and only occurs when // with the attribute, which is very rare, and only occurs when
// analyzing the @implementation. // analyzing the @implementation.
if (!LazyMap) { if (!LazyMap) {
ObjCContainerDecl::PropertyMap NoNeedToImplPropMap; ObjCContainerDecl::PropertyMap NoNeedToImplPropMap;
LazyMap.reset(new ObjCContainerDecl::PropertyMap()); LazyMap = llvm::make_unique<ObjCContainerDecl::PropertyMap>();
CollectImmediateProperties(CDecl, *LazyMap, NoNeedToImplPropMap, CollectImmediateProperties(CDecl, *LazyMap, NoNeedToImplPropMap,
/* CollectClassPropsOnly */ false, /* CollectClassPropsOnly */ false,
/* IncludeProtocols */ false); /* IncludeProtocols */ false);
} }
// Add the properties of 'PDecl' to the list of properties that // Add the properties of 'PDecl' to the list of properties that
// need to be implemented. // need to be implemented.
for (auto *PropDecl : PDecl->properties()) { for (auto *PropDecl : PDecl->properties()) {
if ((*LazyMap)[std::make_pair(PropDecl->getIdentifier(), if ((*LazyMap)[std::make_pair(PropDecl->getIdentifier(),
▲ Show 20 Lines • Show All 672 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/ArrayBoundChecker.cpp

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Linesvoid ArrayBoundChecker::checkLocation(SVal l, bool isLoad, const Stmt* LoadS,
ProgramStateRef StInBound = state->assumeInBound(Idx, NumElements, true); ProgramStateRef StInBound = state->assumeInBound(Idx, NumElements, true);
ProgramStateRef StOutBound = state->assumeInBound(Idx, NumElements, false); ProgramStateRef StOutBound = state->assumeInBound(Idx, NumElements, false);
if (StOutBound && !StInBound) { if (StOutBound && !StInBound) {
ExplodedNode *N = C.generateErrorNode(StOutBound); ExplodedNode *N = C.generateErrorNode(StOutBound);
if (!N) if (!N)
return; return;
if (!BT) if (!BT)
BT.reset(new BuiltinBug( BT = llvm::make_unique<BuiltinBug>(
this, "Out-of-bound array access", this, "Out-of-bound array access",
"Access out-of-bound array element (buffer overflow)")); "Access out-of-bound array element (buffer overflow)");
// FIXME: It would be nice to eventually make this diagnostic more clear, // FIXME: It would be nice to eventually make this diagnostic more clear,
// e.g., by referencing the original declaration or by saying *why* this // e.g., by referencing the original declaration or by saying *why* this
// reference is outside the range. // reference is outside the range.
// Generate a report for this bug. // Generate a report for this bug.
auto report = llvm::make_unique<BugReport>(*BT, BT->getDescription(), N); auto report = llvm::make_unique<BugReport>(*BT, BT->getDescription(), N);
Show All 13 Lines

lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp

Show First 20 Lines • Show All 229 Lines • ▼ Show 20 Linesvoid ArrayBoundCheckerV2::reportOOB(CheckerContext &checkerContext,
ProgramStateRef errorState, ProgramStateRef errorState,
OOB_Kind kind) const { OOB_Kind kind) const {
ExplodedNode *errorNode = checkerContext.generateErrorNode(errorState); ExplodedNode *errorNode = checkerContext.generateErrorNode(errorState);
if (!errorNode) if (!errorNode)
return; return;
if (!BT) if (!BT)
BT.reset(new BuiltinBug(this, "Out-of-bound access")); BT = llvm::make_unique<BuiltinBug>(this, "Out-of-bound access");
// FIXME: This diagnostics are preliminary. We should get far better // FIXME: This diagnostics are preliminary. We should get far better
// diagnostics for explaining buffer overruns. // diagnostics for explaining buffer overruns.
SmallString<256> buf; SmallString<256> buf;
llvm::raw_svector_ostream os(buf); llvm::raw_svector_ostream os(buf);
os << "Out of bound memory access "; os << "Out of bound memory access ";
switch (kind) { switch (kind) {
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp

Show First 20 Lines • Show All 198 Lines • ▼ Show 20 Lines
} }
void NilArgChecker::generateBugReport(ExplodedNode *N, void NilArgChecker::generateBugReport(ExplodedNode *N,
StringRef Msg, StringRef Msg,
SourceRange Range, SourceRange Range,
const Expr *E, const Expr *E,
CheckerContext &C) const { CheckerContext &C) const {
if (!BT) if (!BT)
BT.reset(new APIMisuse(this, "nil argument")); BT = llvm::make_unique<APIMisuse>(this, "nil argument");
auto R = llvm::make_unique<BugReport>(*BT, Msg, N); auto R = llvm::make_unique<BugReport>(*BT, Msg, N);
R->addRange(Range); R->addRange(Range);
bugreporter::trackNullOrUndefValue(N, E, *R); bugreporter::trackNullOrUndefValue(N, E, *R);
C.emitReport(std::move(R)); C.emitReport(std::move(R));
} }
void NilArgChecker::checkPreObjCMessage(const ObjCMethodCall &msg, void NilArgChecker::checkPreObjCMessage(const ObjCMethodCall &msg,
▲ Show 20 Lines • Show All 293 Lines • ▼ Show 20 Lines if (PrimitiveTypeSize < CFNumberSize)
<< " bits of the CFNumber value will " << " bits of the CFNumber value will "
<< (isCreate ? "be garbage." : "overwrite adjacent storage."); << (isCreate ? "be garbage." : "overwrite adjacent storage.");
else else
os << (PrimitiveTypeSize - CFNumberSize) os << (PrimitiveTypeSize - CFNumberSize)
<< " bits of the integer value will be " << " bits of the integer value will be "
<< (isCreate ? "lost." : "garbage."); << (isCreate ? "lost." : "garbage.");
if (!BT) if (!BT)
BT.reset(new APIMisuse(this, "Bad use of CFNumber APIs")); BT = llvm::make_unique<APIMisuse>(this, "Bad use of CFNumber APIs");
auto report = llvm::make_unique<BugReport>(*BT, os.str(), N); auto report = llvm::make_unique<BugReport>(*BT, os.str(), N);
report->addRange(CE->getArg(2)->getSourceRange()); report->addRange(CE->getArg(2)->getSourceRange());
C.emitReport(std::move(report)); C.emitReport(std::move(report));
} }
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Show All 25 Lines if (!FD)
return; return;
if (!BT) { if (!BT) {
ASTContext &Ctx = C.getASTContext(); ASTContext &Ctx = C.getASTContext();
Retain = &Ctx.Idents.get("CFRetain"); Retain = &Ctx.Idents.get("CFRetain");
Release = &Ctx.Idents.get("CFRelease"); Release = &Ctx.Idents.get("CFRelease");
MakeCollectable = &Ctx.Idents.get("CFMakeCollectable"); MakeCollectable = &Ctx.Idents.get("CFMakeCollectable");
Autorelease = &Ctx.Idents.get("CFAutorelease"); Autorelease = &Ctx.Idents.get("CFAutorelease");
BT.reset(new APIMisuse( BT = llvm::make_unique<APIMisuse>(
this, "null passed to CF memory management function")); this, "null passed to CF memory management function");
} }
// Check if we called CFRetain/CFRelease/CFMakeCollectable/CFAutorelease. // Check if we called CFRetain/CFRelease/CFMakeCollectable/CFAutorelease.
const IdentifierInfo *FuncII = FD->getIdentifier(); const IdentifierInfo *FuncII = FD->getIdentifier();
if (!(FuncII == Retain || FuncII == Release || FuncII == MakeCollectable || if (!(FuncII == Retain || FuncII == Release || FuncII == MakeCollectable ||
FuncII == Autorelease)) FuncII == Autorelease))
return; return;
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
public: public:
void checkPreObjCMessage(const ObjCMethodCall &msg, CheckerContext &C) const; void checkPreObjCMessage(const ObjCMethodCall &msg, CheckerContext &C) const;
}; };
} // end anonymous namespace } // end anonymous namespace
void ClassReleaseChecker::checkPreObjCMessage(const ObjCMethodCall &msg, void ClassReleaseChecker::checkPreObjCMessage(const ObjCMethodCall &msg,
CheckerContext &C) const { CheckerContext &C) const {
if (!BT) { if (!BT) {
BT.reset(new APIMisuse( BT = llvm::make_unique<APIMisuse>(
this, "message incorrectly sent to class instead of class instance")); this, "message incorrectly sent to class instead of class instance");
ASTContext &Ctx = C.getASTContext(); ASTContext &Ctx = C.getASTContext();
releaseS = GetNullarySelector("release", Ctx); releaseS = GetNullarySelector("release", Ctx);
retainS = GetNullarySelector("retain", Ctx); retainS = GetNullarySelector("retain", Ctx);
autoreleaseS = GetNullarySelector("autorelease", Ctx); autoreleaseS = GetNullarySelector("autorelease", Ctx);
drainS = GetNullarySelector("drain", Ctx); drainS = GetNullarySelector("drain", Ctx);
} }
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Lines switch (findKnownClass(Class)) {
return false; return false;
} }
} }
} }
void VariadicMethodTypeChecker::checkPreObjCMessage(const ObjCMethodCall &msg, void VariadicMethodTypeChecker::checkPreObjCMessage(const ObjCMethodCall &msg,
CheckerContext &C) const { CheckerContext &C) const {
if (!BT) { if (!BT) {
BT.reset(new APIMisuse(this, BT = llvm::make_unique<APIMisuse>(this,
"Arguments passed to variadic method aren't all " "Arguments passed to variadic method aren't all "
"Objective-C pointer types")); "Objective-C pointer types");
ASTContext &Ctx = C.getASTContext(); ASTContext &Ctx = C.getASTContext();
arrayWithObjectsS = GetUnarySelector("arrayWithObjects", Ctx); arrayWithObjectsS = GetUnarySelector("arrayWithObjects", Ctx);
dictionaryWithObjectsAndKeysS = dictionaryWithObjectsAndKeysS =
GetUnarySelector("dictionaryWithObjectsAndKeys", Ctx); GetUnarySelector("dictionaryWithObjectsAndKeys", Ctx);
setWithObjectsS = GetUnarySelector("setWithObjects", Ctx); setWithObjectsS = GetUnarySelector("setWithObjects", Ctx);
orderedSetWithObjectsS = GetUnarySelector("orderedSetWithObjects", Ctx); orderedSetWithObjectsS = GetUnarySelector("orderedSetWithObjects", Ctx);
▲ Show 20 Lines • Show All 542 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/BlockInCriticalSectionChecker.cpp

Show First 20 Lines • Show All 64 Lines • ▼ Show 20 Lines : LockFn("lock"), UnlockFn("unlock"), SleepFn("sleep"), GetcFn("getc"),
PthreadLockFn("pthread_mutex_lock"), PthreadLockFn("pthread_mutex_lock"),
PthreadTryLockFn("pthread_mutex_trylock"), PthreadTryLockFn("pthread_mutex_trylock"),
PthreadUnlockFn("pthread_mutex_unlock"), PthreadUnlockFn("pthread_mutex_unlock"),
MtxLock("mtx_lock"), MtxLock("mtx_lock"),
MtxTimedLock("mtx_timedlock"), MtxTimedLock("mtx_timedlock"),
MtxTryLock("mtx_trylock"), MtxTryLock("mtx_trylock"),
MtxUnlock("mtx_unlock") { MtxUnlock("mtx_unlock") {
// Initialize the bug type. // Initialize the bug type.
BlockInCritSectionBugType.reset( BlockInCritSectionBugType = llvm::make_unique<BugType>(
new BugType(this, "Call to blocking function in critical section", this, "Call to blocking function in critical section",
"Blocking Error")); "Blocking Error");
} }
bool BlockInCriticalSectionChecker::isBlockingFunction(const CallEvent &Call) const { bool BlockInCriticalSectionChecker::isBlockingFunction(const CallEvent &Call) const {
if (Call.isCalled(SleepFn) if (Call.isCalled(SleepFn)
|| Call.isCalled(GetcFn) || Call.isCalled(GetcFn)
|| Call.isCalled(FgetsFn) || Call.isCalled(FgetsFn)
|| Call.isCalled(ReadFn) || Call.isCalled(ReadFn)
|| Call.isCalled(RecvFn)) { || Call.isCalled(RecvFn)) {
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/BoolAssignmentChecker.cpp

Show All 28 Lines public:
void checkBind(SVal loc, SVal val, const Stmt *S, CheckerContext &C) const; void checkBind(SVal loc, SVal val, const Stmt *S, CheckerContext &C) const;
}; };
} // end anonymous namespace } // end anonymous namespace
void BoolAssignmentChecker::emitReport(ProgramStateRef state, void BoolAssignmentChecker::emitReport(ProgramStateRef state,
CheckerContext &C) const { CheckerContext &C) const {
if (ExplodedNode *N = C.generateNonFatalErrorNode(state)) { if (ExplodedNode *N = C.generateNonFatalErrorNode(state)) {
if (!BT) if (!BT)
BT.reset(new BuiltinBug(this, "Assignment of a non-Boolean value")); BT = llvm::make_unique<BuiltinBug>(this, "Assignment of a non-Boolean value");
C.emitReport(llvm::make_unique<BugReport>(*BT, BT->getDescription(), N)); C.emitReport(llvm::make_unique<BugReport>(*BT, BT->getDescription(), N));
} }
} }
static bool isBooleanType(QualType Ty) { static bool isBooleanType(QualType Ty) {
if (Ty->isBooleanType()) // C++ or C99 if (Ty->isBooleanType()) // C++ or C99
return true; return true;
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/CStringChecker.cpp

Show First 20 Lines • Show All 240 Lines • ▼ Show 20 Lines if (stateNull && !stateNonNull) {
if (!Filter.CheckCStringNullArg) if (!Filter.CheckCStringNullArg)
return nullptr; return nullptr;
ExplodedNode *N = C.generateErrorNode(stateNull); ExplodedNode *N = C.generateErrorNode(stateNull);
if (!N) if (!N)
return nullptr; return nullptr;
if (!BT_Null) if (!BT_Null)
BT_Null.reset(new BuiltinBug( BT_Null = llvm::make_unique<BuiltinBug>(
Filter.CheckNameCStringNullArg, categories::UnixAPI, Filter.CheckNameCStringNullArg, categories::UnixAPI,
"Null pointer argument in call to byte string function")); "Null pointer argument in call to byte string function");
SmallString<80> buf; SmallString<80> buf;
llvm::raw_svector_ostream os(buf); llvm::raw_svector_ostream os(buf);
assert(CurrentFunctionDescription); assert(CurrentFunctionDescription);
os << "Null pointer argument in call to " << CurrentFunctionDescription; os << "Null pointer argument in call to " << CurrentFunctionDescription;
// Generate a report for this bug. // Generate a report for this bug.
BuiltinBug *BT = static_cast<BuiltinBug*>(BT_Null.get()); BuiltinBug *BT = static_cast<BuiltinBug*>(BT_Null.get());
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 LinesProgramStateRef CStringChecker::CheckLocation(CheckerContext &C,
ProgramStateRef StInBound = state->assumeInBound(Idx, Size, true); ProgramStateRef StInBound = state->assumeInBound(Idx, Size, true);
ProgramStateRef StOutBound = state->assumeInBound(Idx, Size, false); ProgramStateRef StOutBound = state->assumeInBound(Idx, Size, false);
if (StOutBound && !StInBound) { if (StOutBound && !StInBound) {
ExplodedNode *N = C.generateErrorNode(StOutBound); ExplodedNode *N = C.generateErrorNode(StOutBound);
if (!N) if (!N)
return nullptr; return nullptr;
if (!BT_Bounds) { if (!BT_Bounds) {
BT_Bounds.reset(new BuiltinBug( BT_Bounds = llvm::make_unique<BuiltinBug>(
Filter.CheckNameCStringOutOfBounds, "Out-of-bound array access", Filter.CheckNameCStringOutOfBounds, "Out-of-bound array access",
"Byte string function accesses out-of-bound array element")); "Byte string function accesses out-of-bound array element");
} }
BuiltinBug *BT = static_cast<BuiltinBug*>(BT_Bounds.get()); BuiltinBug *BT = static_cast<BuiltinBug*>(BT_Bounds.get());
// Generate a report for this bug. // Generate a report for this bug.
std::unique_ptr<BugReport> report; std::unique_ptr<BugReport> report;
if (warningMsg) { if (warningMsg) {
report = llvm::make_unique<BugReport>(*BT, warningMsg, N); report = llvm::make_unique<BugReport>(*BT, warningMsg, N);
} else { } else {
▲ Show 20 Lines • Show All 214 Lines • ▼ Show 20 Lines
void CStringChecker::emitOverlapBug(CheckerContext &C, ProgramStateRef state, void CStringChecker::emitOverlapBug(CheckerContext &C, ProgramStateRef state,
const Stmt *First, const Stmt *Second) const { const Stmt *First, const Stmt *Second) const {
ExplodedNode *N = C.generateErrorNode(state); ExplodedNode *N = C.generateErrorNode(state);
if (!N) if (!N)
return; return;
if (!BT_Overlap) if (!BT_Overlap)
BT_Overlap.reset(new BugType(Filter.CheckNameCStringBufferOverlap, BT_Overlap = llvm::make_unique<BugType>(Filter.CheckNameCStringBufferOverlap,
categories::UnixAPI, "Improper arguments")); categories::UnixAPI, "Improper arguments");
// Generate a report for this bug. // Generate a report for this bug.
auto report = llvm::make_unique<BugReport>( auto report = llvm::make_unique<BugReport>(
*BT_Overlap, "Arguments must not be overlapping buffers", N); *BT_Overlap, "Arguments must not be overlapping buffers", N);
report->addRange(First->getSourceRange()); report->addRange(First->getSourceRange());
report->addRange(Second->getSourceRange()); report->addRange(Second->getSourceRange());
C.emitReport(std::move(report)); C.emitReport(std::move(report));
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines if (Optional<NonLoc> maxMinusRightNL = maxMinusRight.getAs<NonLoc>()) {
if (stateOverflow && !stateOkay) { if (stateOverflow && !stateOkay) {
// We have an overflow. Emit a bug report. // We have an overflow. Emit a bug report.
ExplodedNode *N = C.generateErrorNode(stateOverflow); ExplodedNode *N = C.generateErrorNode(stateOverflow);
if (!N) if (!N)
return nullptr; return nullptr;
if (!BT_AdditionOverflow) if (!BT_AdditionOverflow)
BT_AdditionOverflow.reset( BT_AdditionOverflow = llvm::make_unique<BuiltinBug>(
new BuiltinBug(Filter.CheckNameCStringOutOfBounds, "API", Filter.CheckNameCStringOutOfBounds, "API",
"Sum of expressions causes overflow")); "Sum of expressions causes overflow");
// This isn't a great error message, but this should never occur in real // This isn't a great error message, but this should never occur in real
// code anyway -- you'd have to create a buffer longer than a size_t can // code anyway -- you'd have to create a buffer longer than a size_t can
// represent, which is sort of a contradiction. // represent, which is sort of a contradiction.
const char *warning = const char *warning =
"This expression will create a string whose length is too big to " "This expression will create a string whose length is too big to "
"be represented as a size_t"; "be represented as a size_t";
▲ Show 20 Lines • Show All 100 Lines • ▼ Show 20 Lines if (!MR) {
// C string. In the context of locations, the only time we can issue such // C string. In the context of locations, the only time we can issue such
// a warning is for labels. // a warning is for labels.
if (Optional<loc::GotoLabel> Label = Buf.getAs<loc::GotoLabel>()) { if (Optional<loc::GotoLabel> Label = Buf.getAs<loc::GotoLabel>()) {
if (!Filter.CheckCStringNotNullTerm) if (!Filter.CheckCStringNotNullTerm)
return UndefinedVal(); return UndefinedVal();
if (ExplodedNode *N = C.generateNonFatalErrorNode(state)) { if (ExplodedNode *N = C.generateNonFatalErrorNode(state)) {
if (!BT_NotCString) if (!BT_NotCString)
BT_NotCString.reset(new BuiltinBug( BT_NotCString = llvm::make_unique<BuiltinBug>(
Filter.CheckNameCStringNotNullTerm, categories::UnixAPI, Filter.CheckNameCStringNotNullTerm, categories::UnixAPI,
"Argument is not a null-terminated string.")); "Argument is not a null-terminated string.");
SmallString<120> buf; SmallString<120> buf;
llvm::raw_svector_ostream os(buf); llvm::raw_svector_ostream os(buf);
assert(CurrentFunctionDescription); assert(CurrentFunctionDescription);
os << "Argument to " << CurrentFunctionDescription os << "Argument to " << CurrentFunctionDescription
<< " is the address of the label '" << Label->getLabel()->getName() << " is the address of the label '" << Label->getLabel()->getName()
<< "', which is not a null-terminated string"; << "', which is not a null-terminated string";
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines default:
// Other regions (mostly non-data) can't have a reliable C string length. // Other regions (mostly non-data) can't have a reliable C string length.
// In this case, an error is emitted and UndefinedVal is returned. // In this case, an error is emitted and UndefinedVal is returned.
// The caller should always be prepared to handle this case. // The caller should always be prepared to handle this case.
if (!Filter.CheckCStringNotNullTerm) if (!Filter.CheckCStringNotNullTerm)
return UndefinedVal(); return UndefinedVal();
if (ExplodedNode *N = C.generateNonFatalErrorNode(state)) { if (ExplodedNode *N = C.generateNonFatalErrorNode(state)) {
if (!BT_NotCString) if (!BT_NotCString)
BT_NotCString.reset(new BuiltinBug( BT_NotCString = llvm::make_unique<BuiltinBug>(
Filter.CheckNameCStringNotNullTerm, categories::UnixAPI, Filter.CheckNameCStringNotNullTerm, categories::UnixAPI,
"Argument is not a null-terminated string.")); "Argument is not a null-terminated string.");
SmallString<120> buf; SmallString<120> buf;
llvm::raw_svector_ostream os(buf); llvm::raw_svector_ostream os(buf);
assert(CurrentFunctionDescription); assert(CurrentFunctionDescription);
os << "Argument to " << CurrentFunctionDescription << " is "; os << "Argument to " << CurrentFunctionDescription << " is ";
if (SummarizeRegion(os, C.getASTContext(), MR)) if (SummarizeRegion(os, C.getASTContext(), MR))
▲ Show 20 Lines • Show All 1,432 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Lines void emitNilReceiverBug(CheckerContext &C, const ObjCMethodCall &msg,
ExplodedNode *N) const; ExplodedNode *N) const;
void HandleNilReceiver(CheckerContext &C, void HandleNilReceiver(CheckerContext &C,
ProgramStateRef state, ProgramStateRef state,
const ObjCMethodCall &msg) const; const ObjCMethodCall &msg) const;
void LazyInit_BT(const char *desc, std::unique_ptr<BugType> &BT) const { void LazyInit_BT(const char *desc, std::unique_ptr<BugType> &BT) const {
if (!BT) if (!BT)
BT.reset(new BuiltinBug(this, desc)); BT = llvm::make_unique<BuiltinBug>(this, desc);
} }
bool uninitRefOrPointer(CheckerContext &C, const SVal &V, bool uninitRefOrPointer(CheckerContext &C, const SVal &V,
SourceRange ArgRange, const Expr *ArgEx, SourceRange ArgRange, const Expr *ArgEx,
std::unique_ptr<BugType> &BT, std::unique_ptr<BugType> &BT,
const ParmVarDecl *ParamDecl, const char *BD, const ParmVarDecl *ParamDecl, const char *BD,
int ArgumentNumber) const; int ArgumentNumber) const;
}; };
} // end anonymous namespace } // end anonymous namespace
▲ Show 20 Lines • Show All 222 Lines • ▼ Show 20 Linesvoid CallAndMessageChecker::checkPreStmt(const CallExpr *CE,
const Expr *Callee = CE->getCallee()->IgnoreParens(); const Expr *Callee = CE->getCallee()->IgnoreParens();
ProgramStateRef State = C.getState(); ProgramStateRef State = C.getState();
const LocationContext *LCtx = C.getLocationContext(); const LocationContext *LCtx = C.getLocationContext();
SVal L = State->getSVal(Callee, LCtx); SVal L = State->getSVal(Callee, LCtx);
if (L.isUndef()) { if (L.isUndef()) {
if (!BT_call_undef) if (!BT_call_undef)
BT_call_undef.reset(new BuiltinBug( BT_call_undef = llvm::make_unique<BuiltinBug>(
this, "Called function pointer is an uninitialized pointer value")); this, "Called function pointer is an uninitialized pointer value");
emitBadCall(BT_call_undef.get(), C, Callee); emitBadCall(BT_call_undef.get(), C, Callee);
return; return;
} }
ProgramStateRef StNonNull, StNull; ProgramStateRef StNonNull, StNull;
std::tie(StNonNull, StNull) = State->assume(L.castAs<DefinedOrUnknownSVal>()); std::tie(StNonNull, StNull) = State->assume(L.castAs<DefinedOrUnknownSVal>());
if (StNull && !StNonNull) { if (StNull && !StNonNull) {
if (!BT_call_null) if (!BT_call_null)
BT_call_null.reset(new BuiltinBug( BT_call_null = llvm::make_unique<BuiltinBug>(
this, "Called function pointer is null (null dereference)")); this, "Called function pointer is null (null dereference)");
emitBadCall(BT_call_null.get(), C, Callee); emitBadCall(BT_call_null.get(), C, Callee);
return; return;
} }
C.addTransition(StNonNull); C.addTransition(StNonNull);
} }
void CallAndMessageChecker::checkPreStmt(const CXXDeleteExpr *DE, void CallAndMessageChecker::checkPreStmt(const CXXDeleteExpr *DE,
CheckerContext &C) const { CheckerContext &C) const {
SVal Arg = C.getSVal(DE->getArgument()); SVal Arg = C.getSVal(DE->getArgument());
if (Arg.isUndef()) { if (Arg.isUndef()) {
StringRef Desc; StringRef Desc;
ExplodedNode *N = C.generateErrorNode(); ExplodedNode *N = C.generateErrorNode();
if (!N) if (!N)
return; return;
if (!BT_cxx_delete_undef) if (!BT_cxx_delete_undef)
BT_cxx_delete_undef.reset( BT_cxx_delete_undef = llvm::make_unique<BuiltinBug>(
new BuiltinBug(this, "Uninitialized argument value")); this, "Uninitialized argument value");
if (DE->isArrayFormAsWritten()) if (DE->isArrayFormAsWritten())
Desc = "Argument to 'delete[]' is uninitialized"; Desc = "Argument to 'delete[]' is uninitialized";
else else
Desc = "Argument to 'delete' is uninitialized"; Desc = "Argument to 'delete' is uninitialized";
BugType *BT = BT_cxx_delete_undef.get(); BugType *BT = BT_cxx_delete_undef.get();
auto R = llvm::make_unique<BugReport>(*BT, Desc, N); auto R = llvm::make_unique<BugReport>(*BT, Desc, N);
bugreporter::trackNullOrUndefValue(N, DE, *R); bugreporter::trackNullOrUndefValue(N, DE, *R);
C.emitReport(std::move(R)); C.emitReport(std::move(R));
return; return;
} }
} }
void CallAndMessageChecker::checkPreCall(const CallEvent &Call, void CallAndMessageChecker::checkPreCall(const CallEvent &Call,
CheckerContext &C) const { CheckerContext &C) const {
ProgramStateRef State = C.getState(); ProgramStateRef State = C.getState();
// If this is a call to a C++ method, check if the callee is null or // If this is a call to a C++ method, check if the callee is null or
// undefined. // undefined.
if (const CXXInstanceCall *CC = dyn_cast<CXXInstanceCall>(&Call)) { if (const CXXInstanceCall *CC = dyn_cast<CXXInstanceCall>(&Call)) {
SVal V = CC->getCXXThisVal(); SVal V = CC->getCXXThisVal();
if (V.isUndef()) { if (V.isUndef()) {
if (!BT_cxx_call_undef) if (!BT_cxx_call_undef)
BT_cxx_call_undef.reset( BT_cxx_call_undef = llvm::make_unique<BuiltinBug>(
new BuiltinBug(this, "Called C++ object pointer is uninitialized")); this, "Called C++ object pointer is uninitialized");
emitBadCall(BT_cxx_call_undef.get(), C, CC->getCXXThisExpr()); emitBadCall(BT_cxx_call_undef.get(), C, CC->getCXXThisExpr());
return; return;
} }
ProgramStateRef StNonNull, StNull; ProgramStateRef StNonNull, StNull;
std::tie(StNonNull, StNull) = std::tie(StNonNull, StNull) =
State->assume(V.castAs<DefinedOrUnknownSVal>()); State->assume(V.castAs<DefinedOrUnknownSVal>());
if (StNull && !StNonNull) { if (StNull && !StNonNull) {
if (!BT_cxx_call_null) if (!BT_cxx_call_null)
BT_cxx_call_null.reset( BT_cxx_call_null = llvm::make_unique<BuiltinBug>(
new BuiltinBug(this, "Called C++ object pointer is null")); this, "Called C++ object pointer is null");
emitBadCall(BT_cxx_call_null.get(), C, CC->getCXXThisExpr()); emitBadCall(BT_cxx_call_null.get(), C, CC->getCXXThisExpr());
return; return;
} }
State = StNonNull; State = StNonNull;
} }
const Decl *D = Call.getDecl(); const Decl *D = Call.getDecl();
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Linesvoid CallAndMessageChecker::checkPreObjCMessage(const ObjCMethodCall &msg,
CheckerContext &C) const { CheckerContext &C) const {
SVal recVal = msg.getReceiverSVal(); SVal recVal = msg.getReceiverSVal();
if (recVal.isUndef()) { if (recVal.isUndef()) {
if (ExplodedNode *N = C.generateErrorNode()) { if (ExplodedNode *N = C.generateErrorNode()) {
BugType *BT = nullptr; BugType *BT = nullptr;
switch (msg.getMessageKind()) { switch (msg.getMessageKind()) {
case OCM_Message: case OCM_Message:
if (!BT_msg_undef) if (!BT_msg_undef)
BT_msg_undef.reset(new BuiltinBug(this, BT_msg_undef = llvm::make_unique<BuiltinBug>(this,
"Receiver in message expression " "Receiver in message expression "
"is an uninitialized value")); "is an uninitialized value");
BT = BT_msg_undef.get(); BT = BT_msg_undef.get();
break; break;
case OCM_PropertyAccess: case OCM_PropertyAccess:
if (!BT_objc_prop_undef) if (!BT_objc_prop_undef)
BT_objc_prop_undef.reset(new BuiltinBug( BT_objc_prop_undef = llvm::make_unique<BuiltinBug>(
this, "Property access on an uninitialized object pointer")); this, "Property access on an uninitialized object pointer");
BT = BT_objc_prop_undef.get(); BT = BT_objc_prop_undef.get();
break; break;
case OCM_Subscript: case OCM_Subscript:
if (!BT_objc_subscript_undef) if (!BT_objc_subscript_undef)
BT_objc_subscript_undef.reset(new BuiltinBug( BT_objc_subscript_undef = llvm::make_unique<BuiltinBug>(
this, "Subscript access on an uninitialized object pointer")); this, "Subscript access on an uninitialized object pointer");
BT = BT_objc_subscript_undef.get(); BT = BT_objc_subscript_undef.get();
break; break;
} }
assert(BT && "Unknown message kind."); assert(BT && "Unknown message kind.");
auto R = llvm::make_unique<BugReport>(*BT, BT->getName(), N); auto R = llvm::make_unique<BugReport>(*BT, BT->getName(), N);
const ObjCMessageExpr *ME = msg.getOriginExpr(); const ObjCMessageExpr *ME = msg.getOriginExpr();
R->addRange(ME->getReceiverRange()); R->addRange(ME->getReceiverRange());
Show All 12 Linesvoid CallAndMessageChecker::checkObjCMessageNil(const ObjCMethodCall &msg,
HandleNilReceiver(C, C.getState(), msg); HandleNilReceiver(C, C.getState(), msg);
} }
void CallAndMessageChecker::emitNilReceiverBug(CheckerContext &C, void CallAndMessageChecker::emitNilReceiverBug(CheckerContext &C,
const ObjCMethodCall &msg, const ObjCMethodCall &msg,
ExplodedNode *N) const { ExplodedNode *N) const {
if (!BT_msg_ret) if (!BT_msg_ret)
BT_msg_ret.reset( BT_msg_ret = llvm::make_unique<BuiltinBug>(
new BuiltinBug(this, "Receiver in message expression is 'nil'")); this, "Receiver in message expression is 'nil'");
const ObjCMessageExpr *ME = msg.getOriginExpr(); const ObjCMessageExpr *ME = msg.getOriginExpr();
QualType ResTy = msg.getResultType(); QualType ResTy = msg.getResultType();
SmallString<200> buf; SmallString<200> buf;
llvm::raw_svector_ostream os(buf); llvm::raw_svector_ostream os(buf);
os << "The receiver of message '"; os << "The receiver of message '";
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/CastSizeChecker.cpp

Show First 20 Lines • Show All 124 Lines • ▼ Show 20 Linesvoid CastSizeChecker::checkPreStmt(const CastExpr *CE,CheckerContext &C) const {
if (regionSize % typeSize == 0) if (regionSize % typeSize == 0)
return; return;
if (evenFlexibleArraySize(Ctx, regionSize, typeSize, ToPointeeTy)) if (evenFlexibleArraySize(Ctx, regionSize, typeSize, ToPointeeTy))
return; return;
if (ExplodedNode *errorNode = C.generateErrorNode()) { if (ExplodedNode *errorNode = C.generateErrorNode()) {
if (!BT) if (!BT)
BT.reset(new BuiltinBug(this, "Cast region with wrong size.", BT = llvm::make_unique<BuiltinBug>(this, "Cast region with wrong size.",
"Cast a region whose size is not a multiple" "Cast a region whose size is not a multiple"
" of the destination type size.")); " of the destination type size.");
auto R = llvm::make_unique<BugReport>(*BT, BT->getDescription(), errorNode); auto R = llvm::make_unique<BugReport>(*BT, BT->getDescription(), errorNode);
R->addRange(CE->getSourceRange()); R->addRange(CE->getSourceRange());
C.emitReport(std::move(R)); C.emitReport(std::move(R));
} }
} }
void ento::registerCastSizeChecker(CheckerManager &mgr) { void ento::registerCastSizeChecker(CheckerManager &mgr) {
// PR31226: C++ is more complicated than what this checker currently supports. // PR31226: C++ is more complicated than what this checker currently supports.
// There are derived-to-base casts, there are different rules for 0-size // There are derived-to-base casts, there are different rules for 0-size
// structures, no flexible arrays, etc. // structures, no flexible arrays, etc.
// FIXME: Disabled on C++ for now. // FIXME: Disabled on C++ for now.
if (!mgr.getLangOpts().CPlusPlus) if (!mgr.getLangOpts().CPlusPlus)
mgr.registerChecker<CastSizeChecker>(); mgr.registerChecker<CastSizeChecker>();
} }

lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp

Show First 20 Lines • Show All 753 Lines • ▼ Show 20 Linesbool ObjCDeallocChecker::diagnoseMistakenDealloc(SymbolRef DeallocedValue,
return true; return true;
} }
ObjCDeallocChecker::ObjCDeallocChecker() ObjCDeallocChecker::ObjCDeallocChecker()
: NSObjectII(nullptr), SenTestCaseII(nullptr), XCTestCaseII(nullptr), : NSObjectII(nullptr), SenTestCaseII(nullptr), XCTestCaseII(nullptr),
CIFilterII(nullptr) { CIFilterII(nullptr) {
MissingReleaseBugType.reset( MissingReleaseBugType = llvm::make_unique<BugType>(
new BugType(this, "Missing ivar release (leak)", this, "Missing ivar release (leak)",
categories::MemoryCoreFoundationObjectiveC)); categories::MemoryCoreFoundationObjectiveC);
ExtraReleaseBugType.reset( ExtraReleaseBugType = llvm::make_unique<BugType>(
new BugType(this, "Extra ivar release", this, "Extra ivar release",
categories::MemoryCoreFoundationObjectiveC)); categories::MemoryCoreFoundationObjectiveC);
MistakenDeallocBugType.reset( MistakenDeallocBugType = llvm::make_unique<BugType>(
new BugType(this, "Mistaken dealloc", this, "Mistaken dealloc",
categories::MemoryCoreFoundationObjectiveC)); categories::MemoryCoreFoundationObjectiveC);
} }
void ObjCDeallocChecker::initIdentifierInfoAndSelectors( void ObjCDeallocChecker::initIdentifierInfoAndSelectors(
ASTContext &Ctx) const { ASTContext &Ctx) const {
if (NSObjectII) if (NSObjectII)
return; return;
NSObjectII = &Ctx.Idents.get("NSObject"); NSObjectII = &Ctx.Idents.get("NSObject");
▲ Show 20 Lines • Show All 320 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/ChrootChecker.cpp

Show First 20 Lines • Show All 136 Lines • ▼ Show 20 Lines if (FD->getIdentifier() == II_chroot || FD->getIdentifier() == II_chdir)
return; return;
// If jail state is ROOT_CHANGED, generate BugReport. // If jail state is ROOT_CHANGED, generate BugReport.
void *const* k = C.getState()->FindGDM(ChrootChecker::getTag()); void *const* k = C.getState()->FindGDM(ChrootChecker::getTag());
if (k) if (k)
if (isRootChanged((intptr_t) *k)) if (isRootChanged((intptr_t) *k))
if (ExplodedNode *N = C.generateNonFatalErrorNode()) { if (ExplodedNode *N = C.generateNonFatalErrorNode()) {
if (!BT_BreakJail) if (!BT_BreakJail)
BT_BreakJail.reset(new BuiltinBug( BT_BreakJail = llvm::make_unique<BuiltinBug>(
this, "Break out of jail", "No call of chdir(\"/\") immediately " this, "Break out of jail", "No call of chdir(\"/\") immediately "
"after chroot")); "after chroot");
C.emitReport(llvm::make_unique<BugReport>( C.emitReport(llvm::make_unique<BugReport>(
*BT_BreakJail, BT_BreakJail->getDescription(), N)); *BT_BreakJail, BT_BreakJail->getDescription(), N));
} }
} }
void ento::registerChrootChecker(CheckerManager &mgr) { void ento::registerChrootChecker(CheckerManager &mgr) {
mgr.registerChecker<ChrootChecker>(); mgr.registerChecker<ChrootChecker>();
} }

lib/StaticAnalyzer/Checkers/CloneChecker.cpp

Show First 20 Lines • Show All 106 Lines • ▼ Show 20 Lines return PathDiagnosticLocation::createBegin(
Mgr.getAnalysisDeclContext(ACtx.getTranslationUnitDecl())); Mgr.getAnalysisDeclContext(ACtx.getTranslationUnitDecl()));
} }
void CloneChecker::reportClones( void CloneChecker::reportClones(
BugReporter &BR, AnalysisManager &Mgr, BugReporter &BR, AnalysisManager &Mgr,
std::vector<CloneDetector::CloneGroup> &CloneGroups) const { std::vector<CloneDetector::CloneGroup> &CloneGroups) const {
if (!BT_Exact) if (!BT_Exact)
BT_Exact.reset(new BugType(this, "Exact code clone", "Code clone")); BT_Exact = llvm::make_unique<BugType>(this, "Exact code clone", "Code clone");
for (const CloneDetector::CloneGroup &Group : CloneGroups) { for (const CloneDetector::CloneGroup &Group : CloneGroups) {
// We group the clones by printing the first as a warning and all others // We group the clones by printing the first as a warning and all others
// as a note. // as a note.
auto R = llvm::make_unique<BugReport>(*BT_Exact, "Duplicate code detected", auto R = llvm::make_unique<BugReport>(*BT_Exact, "Duplicate code detected",
makeLocation(Group.front(), Mgr)); makeLocation(Group.front(), Mgr));
R->addRange(Group.front().getSourceRange()); R->addRange(Group.front().getSourceRange());
Show All 29 Lines for (unsigned i = 0; i < Group.size(); ++i) {
Pairs.push_back(ClonePair); Pairs.push_back(ClonePair);
break; break;
} }
} }
} }
} }
if (!BT_Suspicious) if (!BT_Suspicious)
BT_Suspicious.reset( BT_Suspicious = llvm::make_unique<BugType>(
new BugType(this, "Suspicious code clone", "Code clone")); this, "Suspicious code clone", "Code clone");
ASTContext &ACtx = BR.getContext(); ASTContext &ACtx = BR.getContext();
SourceManager &SM = ACtx.getSourceManager(); SourceManager &SM = ACtx.getSourceManager();
AnalysisDeclContext *ADC = AnalysisDeclContext *ADC =
Mgr.getAnalysisDeclContext(ACtx.getTranslationUnitDecl()); Mgr.getAnalysisDeclContext(ACtx.getTranslationUnitDecl());
for (VariablePattern::SuspiciousClonePair &Pair : Pairs) { for (VariablePattern::SuspiciousClonePair &Pair : Pairs) {
// FIXME: We are ignoring the suggestions currently, because they are // FIXME: We are ignoring the suggestions currently, because they are
Show All 29 Lines

lib/StaticAnalyzer/Checkers/ConversionChecker.cpp

Show First 20 Lines • Show All 109 Lines • ▼ Show 20 Lines if (LossOfSign || LossOfPrecision) {
if (LossOfPrecision) if (LossOfPrecision)
reportBug(N, C, "Loss of precision in implicit conversion"); reportBug(N, C, "Loss of precision in implicit conversion");
} }
} }
void ConversionChecker::reportBug(ExplodedNode *N, CheckerContext &C, void ConversionChecker::reportBug(ExplodedNode *N, CheckerContext &C,
const char Msg[]) const { const char Msg[]) const {
if (!BT) if (!BT)
BT.reset( BT = llvm::make_unique<BuiltinBug>(
new BuiltinBug(this, "Conversion", "Possible loss of sign/precision.")); this, "Conversion", "Possible loss of sign/precision.");
// Generate a report for this bug. // Generate a report for this bug.
auto R = llvm::make_unique<BugReport>(*BT, Msg, N); auto R = llvm::make_unique<BugReport>(*BT, Msg, N);
C.emitReport(std::move(R)); C.emitReport(std::move(R));
} }
// Is E value greater or equal than Val? // Is E value greater or equal than Val?
static bool isGreaterEqual(CheckerContext &C, const Expr *E, static bool isGreaterEqual(CheckerContext &C, const Expr *E,
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/DeadStoresChecker.cpp

Show First 20 Lines • Show All 144 Lines • ▼ Show 20 Linespublic:
~DeadStoreObs() override {} ~DeadStoreObs() override {}
bool isLive(const LiveVariables::LivenessValues &Live, const VarDecl *D) { bool isLive(const LiveVariables::LivenessValues &Live, const VarDecl *D) {
if (Live.isLive(D)) if (Live.isLive(D))
return true; return true;
// Lazily construct the set that records which VarDecls are in // Lazily construct the set that records which VarDecls are in
// EH code. // EH code.
if (!InEH.get()) { if (!InEH.get()) {
InEH.reset(new llvm::DenseSet<const VarDecl *>()); InEH = llvm::make_unique<llvm::DenseSet<const VarDecl *>>();
EHCodeVisitor V(*InEH.get()); EHCodeVisitor V(*InEH.get());
V.TraverseStmt(AC->getBody()); V.TraverseStmt(AC->getBody());
} }
// Treat all VarDecls that occur in EH code as being "always live" // Treat all VarDecls that occur in EH code as being "always live"
// when considering to suppress dead stores. Frequently stores // when considering to suppress dead stores. Frequently stores
// are followed by reads in EH code, but we don't have the ability // are followed by reads in EH code, but we don't have the ability
// to analyze that yet. // to analyze that yet.
return InEH->count(D); return InEH->count(D);
} }
void Report(const VarDecl *V, DeadStoreKind dsk, void Report(const VarDecl *V, DeadStoreKind dsk,
PathDiagnosticLocation L, SourceRange R) { PathDiagnosticLocation L, SourceRange R) {
if (Escaped.count(V)) if (Escaped.count(V))
return; return;
// Compute reachable blocks within the CFG for trivial cases // Compute reachable blocks within the CFG for trivial cases
// where a bogus dead store can be reported because itself is unreachable. // where a bogus dead store can be reported because itself is unreachable.
if (!reachableCode.get()) { if (!reachableCode.get()) {
reachableCode.reset(new ReachableCode(cfg)); reachableCode = llvm::make_unique<ReachableCode>(cfg);
reachableCode->computeReachableBlocks(); reachableCode->computeReachableBlocks();
} }
if (!reachableCode->isReachable(currentBlock)) if (!reachableCode->isReachable(currentBlock))
return; return;
SmallString<64> buf; SmallString<64> buf;
llvm::raw_svector_ostream os(buf); llvm::raw_svector_ostream os(buf);
▲ Show 20 Lines • Show All 302 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/DebugCheckers.cpp

Show First 20 Lines • Show All 218 Lines • ▼ Show 20 Lines
namespace { namespace {
class BugHashDumper : public Checker<check::PostStmt<Stmt>> { class BugHashDumper : public Checker<check::PostStmt<Stmt>> {
public: public:
mutable std::unique_ptr<BugType> BT; mutable std::unique_ptr<BugType> BT;
void checkPostStmt(const Stmt *S, CheckerContext &C) const { void checkPostStmt(const Stmt *S, CheckerContext &C) const {
if (!BT) if (!BT)
BT.reset(new BugType(this, "Dump hash components", "debug")); BT = llvm::make_unique<BugType>(this, "Dump hash components", "debug");
ExplodedNode *N = C.generateNonFatalErrorNode(); ExplodedNode *N = C.generateNonFatalErrorNode();
if (!N) if (!N)
return; return;
const LangOptions &Opts = C.getLangOpts(); const LangOptions &Opts = C.getLangOpts();
const SourceManager &SM = C.getSourceManager(); const SourceManager &SM = C.getSourceManager();
FullSourceLoc FL(S->getLocStart(), SM); FullSourceLoc FL(S->getLocStart(), SM);
Show All 12 Lines

lib/StaticAnalyzer/Checkers/DereferenceChecker.cpp

Show First 20 Lines • Show All 115 Lines • ▼ Show 20 Linesvoid DereferenceChecker::reportBug(ProgramStateRef State, const Stmt *S,
// Generate an error node. // Generate an error node.
ExplodedNode *N = C.generateErrorNode(State); ExplodedNode *N = C.generateErrorNode(State);
if (!N) if (!N)
return; return;
// We know that 'location' cannot be non-null. This is what // We know that 'location' cannot be non-null. This is what
// we call an "explicit" null dereference. // we call an "explicit" null dereference.
if (!BT_null) if (!BT_null)
BT_null.reset(new BuiltinBug(this, "Dereference of null pointer")); BT_null = llvm::make_unique<BuiltinBug>(this, "Dereference of null pointer");
SmallString<100> buf; SmallString<100> buf;
llvm::raw_svector_ostream os(buf); llvm::raw_svector_ostream os(buf);
SmallVector<SourceRange, 2> Ranges; SmallVector<SourceRange, 2> Ranges;
switch (S->getStmtClass()) { switch (S->getStmtClass()) {
case Stmt::ArraySubscriptExprClass: { case Stmt::ArraySubscriptExprClass: {
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
} }
void DereferenceChecker::checkLocation(SVal l, bool isLoad, const Stmt* S, void DereferenceChecker::checkLocation(SVal l, bool isLoad, const Stmt* S,
CheckerContext &C) const { CheckerContext &C) const {
// Check for dereference of an undefined value. // Check for dereference of an undefined value.
if (l.isUndef()) { if (l.isUndef()) {
if (ExplodedNode *N = C.generateErrorNode()) { if (ExplodedNode *N = C.generateErrorNode()) {
if (!BT_undef) if (!BT_undef)
BT_undef.reset( BT_undef = llvm::make_unique<BuiltinBug>(
new BuiltinBug(this, "Dereference of undefined pointer value")); this, "Dereference of undefined pointer value");
auto report = auto report =
llvm::make_unique<BugReport>(*BT_undef, BT_undef->getDescription(), N); llvm::make_unique<BugReport>(*BT_undef, BT_undef->getDescription(), N);
bugreporter::trackNullOrUndefValue(N, bugreporter::getDerefExpr(S), bugreporter::trackNullOrUndefValue(N, bugreporter::getDerefExpr(S),
*report); *report);
C.emitReport(std::move(report)); C.emitReport(std::move(report));
} }
return; return;
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp

Show All 31 Lines
}; };
} // end anonymous namespace } // end anonymous namespace
void DivZeroChecker::reportBug(const char *Msg, void DivZeroChecker::reportBug(const char *Msg,
ProgramStateRef StateZero, ProgramStateRef StateZero,
CheckerContext &C) const { CheckerContext &C) const {
if (ExplodedNode *N = C.generateErrorNode(StateZero)) { if (ExplodedNode *N = C.generateErrorNode(StateZero)) {
if (!BT) if (!BT)
BT.reset(new BuiltinBug(this, "Division by zero")); BT = llvm::make_unique<BuiltinBug>(this, "Division by zero");
auto R = llvm::make_unique<BugReport>(*BT, Msg, N); auto R = llvm::make_unique<BugReport>(*BT, Msg, N);
bugreporter::trackNullOrUndefValue(N, bugreporter::GetDenomExpr(N), *R); bugreporter::trackNullOrUndefValue(N, bugreporter::GetDenomExpr(N), *R);
C.emitReport(std::move(R)); C.emitReport(std::move(R));
} }
} }
void DivZeroChecker::checkPreStmt(const BinaryOperator *B, void DivZeroChecker::checkPreStmt(const BinaryOperator *B,
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/DynamicTypeChecker.cpp

Show All 28 Lines
using namespace clang; using namespace clang;
using namespace ento; using namespace ento;
namespace { namespace {
class DynamicTypeChecker : public Checker<check::PostStmt<ImplicitCastExpr>> { class DynamicTypeChecker : public Checker<check::PostStmt<ImplicitCastExpr>> {
mutable std::unique_ptr<BugType> BT; mutable std::unique_ptr<BugType> BT;
void initBugType() const { void initBugType() const {
if (!BT) if (!BT)
BT.reset( BT = llvm::make_unique<BugType>(
new BugType(this, "Dynamic and static type mismatch", "Type Error")); this, "Dynamic and static type mismatch", "Type Error");
} }
class DynamicTypeBugVisitor class DynamicTypeBugVisitor
: public BugReporterVisitorImpl<DynamicTypeBugVisitor> { : public BugReporterVisitorImpl<DynamicTypeBugVisitor> {
public: public:
DynamicTypeBugVisitor(const MemRegion *Reg) : Reg(Reg) {} DynamicTypeBugVisitor(const MemRegion *Reg) : Reg(Reg) {}
void Profile(llvm::FoldingSetNodeID &ID) const override { void Profile(llvm::FoldingSetNodeID &ID) const override {
▲ Show 20 Lines • Show All 165 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Linesclass DynamicTypePropagation:
ExplodedNode *dynamicTypePropagationOnCasts(const CastExpr *CE, ExplodedNode *dynamicTypePropagationOnCasts(const CastExpr *CE,
ProgramStateRef &State, ProgramStateRef &State,
CheckerContext &C) const; CheckerContext &C) const;
mutable std::unique_ptr<BugType> ObjCGenericsBugType; mutable std::unique_ptr<BugType> ObjCGenericsBugType;
void initBugType() const { void initBugType() const {
if (!ObjCGenericsBugType) if (!ObjCGenericsBugType)
ObjCGenericsBugType.reset( ObjCGenericsBugType = llvm::make_unique<BugType>(
new BugType(this, "Generics", categories::CoreFoundationObjectiveC)); this, "Generics", categories::CoreFoundationObjectiveC);
} }
class GenericsBugVisitor : public BugReporterVisitorImpl<GenericsBugVisitor> { class GenericsBugVisitor : public BugReporterVisitorImpl<GenericsBugVisitor> {
public: public:
GenericsBugVisitor(SymbolRef S) : Sym(S) {} GenericsBugVisitor(SymbolRef S) : Sym(S) {}
void Profile(llvm::FoldingSetNodeID &ID) const override { void Profile(llvm::FoldingSetNodeID &ID) const override {
static int X = 0; static int X = 0;
▲ Show 20 Lines • Show All 912 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp

Show First 20 Lines • Show All 128 Lines • ▼ Show 20 Lines
ExplodedNode *ExprInspectionChecker::reportBug(llvm::StringRef Msg, ExplodedNode *ExprInspectionChecker::reportBug(llvm::StringRef Msg,
BugReporter &BR, BugReporter &BR,
ExplodedNode *N) const { ExplodedNode *N) const {
if (!N) if (!N)
return nullptr; return nullptr;
if (!BT) if (!BT)
BT.reset(new BugType(this, "Checking analyzer assumptions", "debug")); BT = llvm::make_unique<BugType>(this, "Checking analyzer assumptions", "debug");
BR.emitReport(llvm::make_unique<BugReport>(*BT, Msg, N)); BR.emitReport(llvm::make_unique<BugReport>(*BT, Msg, N));
return N; return N;
} }
void ExprInspectionChecker::analyzerEval(const CallExpr *CE, void ExprInspectionChecker::analyzerEval(const CallExpr *CE,
CheckerContext &C) const { CheckerContext &C) const {
const LocationContext *LC = C.getPredecessor()->getLocationContext(); const LocationContext *LC = C.getPredecessor()->getLocationContext();
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/FixedAddressChecker.cpp

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Linesvoid FixedAddressChecker::checkPreStmt(const BinaryOperator *B,
ProgramStateRef state = C.getState(); ProgramStateRef state = C.getState();
SVal RV = state->getSVal(B->getRHS(), C.getLocationContext()); SVal RV = state->getSVal(B->getRHS(), C.getLocationContext());
if (!RV.isConstant() || RV.isZeroConstant()) if (!RV.isConstant() || RV.isZeroConstant())
return; return;
if (ExplodedNode *N = C.generateNonFatalErrorNode()) { if (ExplodedNode *N = C.generateNonFatalErrorNode()) {
if (!BT) if (!BT)
BT.reset( BT = llvm::make_unique<BuiltinBug>(
new BuiltinBug(this, "Use fixed address", this, "Use fixed address",
"Using a fixed address is not portable because that " "Using a fixed address is not portable because that "
"address will probably not be valid in all " "address will probably not be valid in all "
"environments or platforms.")); "environments or platforms.");
auto R = llvm::make_unique<BugReport>(*BT, BT->getDescription(), N); auto R = llvm::make_unique<BugReport>(*BT, BT->getDescription(), N);
R->addRange(B->getRHS()->getSourceRange()); R->addRange(B->getRHS()->getSourceRange());
C.emitReport(std::move(R)); C.emitReport(std::move(R));
} }
} }
void ento::registerFixedAddressChecker(CheckerManager &mgr) { void ento::registerFixedAddressChecker(CheckerManager &mgr) {
mgr.registerChecker<FixedAddressChecker>(); mgr.registerChecker<FixedAddressChecker>();
} }

lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp

Show All 39 Lines
private: private:
static const unsigned InvalidArgIndex = UINT_MAX; static const unsigned InvalidArgIndex = UINT_MAX;
/// Denotes the return vale. /// Denotes the return vale.
static const unsigned ReturnValueIndex = UINT_MAX - 1; static const unsigned ReturnValueIndex = UINT_MAX - 1;
mutable std::unique_ptr<BugType> BT; mutable std::unique_ptr<BugType> BT;
inline void initBugType() const { inline void initBugType() const {
if (!BT) if (!BT)
BT.reset(new BugType(this, "Use of Untrusted Data", "Untrusted Data")); BT = llvm::make_unique<BugType>(this, "Use of Untrusted Data", "Untrusted Data");
} }
/// \brief Catch taint related bugs. Check if tainted data is passed to a /// \brief Catch taint related bugs. Check if tainted data is passed to a
/// system call etc. /// system call etc.
bool checkPre(const CallExpr *CE, CheckerContext &C) const; bool checkPre(const CallExpr *CE, CheckerContext &C) const;
/// \brief Add taint sources on a pre-visit. /// \brief Add taint sources on a pre-visit.
void addSourcesPre(const CallExpr *CE, CheckerContext &C) const; void addSourcesPre(const CallExpr *CE, CheckerContext &C) const;
▲ Show 20 Lines • Show All 721 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/IteratorChecker.cpp

Show First 20 Lines • Show All 252 Lines • ▼ Show 20 Lines
const ContainerData *getContainerData(ProgramStateRef State, const ContainerData *getContainerData(ProgramStateRef State,
const MemRegion *Cont); const MemRegion *Cont);
ProgramStateRef setContainerData(ProgramStateRef State, const MemRegion *Cont, ProgramStateRef setContainerData(ProgramStateRef State, const MemRegion *Cont,
const ContainerData &CData); const ContainerData &CData);
bool isOutOfRange(ProgramStateRef State, const IteratorPosition &Pos); bool isOutOfRange(ProgramStateRef State, const IteratorPosition &Pos);
} // namespace } // namespace
IteratorChecker::IteratorChecker() { IteratorChecker::IteratorChecker() {
OutOfRangeBugType.reset( OutOfRangeBugType = llvm::make_unique<BugType>(
new BugType(this, "Iterator out of range", "Misuse of STL APIs")); this, "Iterator out of range", "Misuse of STL APIs");
OutOfRangeBugType->setSuppressOnSink(true); OutOfRangeBugType->setSuppressOnSink(true);
} }
void IteratorChecker::checkPreCall(const CallEvent &Call, void IteratorChecker::checkPreCall(const CallEvent &Call,
CheckerContext &C) const { CheckerContext &C) const {
// Check for out of range access // Check for out of range access
const auto *Func = dyn_cast_or_null<FunctionDecl>(Call.getDecl()); const auto *Func = dyn_cast_or_null<FunctionDecl>(Call.getDecl());
if (!Func) if (!Func)
▲ Show 20 Lines • Show All 563 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp

Show First 20 Lines • Show All 100 Lines • ▼ Show 20 Lines
}; };
} // end anonymous namespace } // end anonymous namespace
REGISTER_MAP_WITH_PROGRAMSTATE(LocalizedMemMap, const MemRegion *, REGISTER_MAP_WITH_PROGRAMSTATE(LocalizedMemMap, const MemRegion *,
LocalizedState) LocalizedState)
NonLocalizedStringChecker::NonLocalizedStringChecker() { NonLocalizedStringChecker::NonLocalizedStringChecker() {
BT.reset(new BugType(this, "Unlocalizable string", BT = llvm::make_unique<BugType>(this, "Unlocalizable string",
"Localizability Issue (Apple)")); "Localizability Issue (Apple)");
} }
namespace { namespace {
class NonLocalizedStringBRVisitor final class NonLocalizedStringBRVisitor final
: public BugReporterVisitorImpl<NonLocalizedStringBRVisitor> { : public BugReporterVisitorImpl<NonLocalizedStringBRVisitor> {
const MemRegion *NonLocalizedString; const MemRegion *NonLocalizedString;
bool Satisfied; bool Satisfied;
▲ Show 20 Lines • Show All 1,204 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Linesprivate:
static const unsigned NoErr = 0; static const unsigned NoErr = 0;
/// Given the function name, returns the index of the allocator/deallocator /// Given the function name, returns the index of the allocator/deallocator
/// function. /// function.
static unsigned getTrackedFunctionIndex(StringRef Name, bool IsAllocator); static unsigned getTrackedFunctionIndex(StringRef Name, bool IsAllocator);
inline void initBugType() const { inline void initBugType() const {
if (!BT) if (!BT)
BT.reset(new BugType(this, "Improper use of SecKeychain API", BT = llvm::make_unique<BugType>(this, "Improper use of SecKeychain API",
"API Misuse (Apple)")); "API Misuse (Apple)");
} }
void generateDeallocatorMismatchReport(const AllocationPair &AP, void generateDeallocatorMismatchReport(const AllocationPair &AP,
const Expr *ArgExpr, const Expr *ArgExpr,
CheckerContext &C) const; CheckerContext &C) const;
/// Find the allocation site for Sym on the path leading to the node N. /// Find the allocation site for Sym on the path leading to the node N.
const ExplodedNode *getAllocationNode(const ExplodedNode *N, SymbolRef Sym, const ExplodedNode *getAllocationNode(const ExplodedNode *N, SymbolRef Sym,
▲ Show 20 Lines • Show All 515 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/MacOSXAPIChecker.cpp

Show First 20 Lines • Show All 131 Lines • ▼ Show 20 Linesvoid MacOSXAPIChecker::CheckDispatchOnce(CheckerContext &C, const CallExpr *CE,
if (SuggestStatic) if (SuggestStatic)
os << " Perhaps you intended to declare the variable as 'static'?"; os << " Perhaps you intended to declare the variable as 'static'?";
ExplodedNode *N = C.generateErrorNode(); ExplodedNode *N = C.generateErrorNode();
if (!N) if (!N)
return; return;
if (!BT_dispatchOnce) if (!BT_dispatchOnce)
BT_dispatchOnce.reset(new BugType(this, "Improper use of 'dispatch_once'", BT_dispatchOnce = llvm::make_unique<BugType>(this, "Improper use of 'dispatch_once'",
"API Misuse (Apple)")); "API Misuse (Apple)");
auto report = llvm::make_unique<BugReport>(*BT_dispatchOnce, os.str(), N); auto report = llvm::make_unique<BugReport>(*BT_dispatchOnce, os.str(), N);
report->addRange(CE->getArg(0)->getSourceRange()); report->addRange(CE->getArg(0)->getSourceRange());
C.emitReport(std::move(report)); C.emitReport(std::move(report));
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Central dispatch function. // Central dispatch function.
Show All 27 Lines

lib/StaticAnalyzer/Checkers/MallocChecker.cpp

Show First 20 Lines • Show All 1,748 Lines • ▼ Show 20 Linesvoid MallocChecker::ReportBadFree(CheckerContext &C, SVal ArgVal,
Optional<MallocChecker::CheckKind> CheckKind = Optional<MallocChecker::CheckKind> CheckKind =
getCheckIfTracked(C, DeallocExpr); getCheckIfTracked(C, DeallocExpr);
if (!CheckKind.hasValue()) if (!CheckKind.hasValue())
return; return;
if (ExplodedNode *N = C.generateErrorNode()) { if (ExplodedNode *N = C.generateErrorNode()) {
if (!BT_BadFree[*CheckKind]) if (!BT_BadFree[*CheckKind])
BT_BadFree[*CheckKind].reset(new BugType( BT_BadFree[*CheckKind] = llvm::make_unique<BugType>(
CheckNames[*CheckKind], "Bad free", categories::MemoryError)); CheckNames[*CheckKind], "Bad free", categories::MemoryError);
SmallString<100> buf; SmallString<100> buf;
llvm::raw_svector_ostream os(buf); llvm::raw_svector_ostream os(buf);
const MemRegion *MR = ArgVal.getAsRegion(); const MemRegion *MR = ArgVal.getAsRegion();
while (const ElementRegion *ER = dyn_cast_or_null<ElementRegion>(MR)) while (const ElementRegion *ER = dyn_cast_or_null<ElementRegion>(MR))
MR = ER->getSuperRegion(); MR = ER->getSuperRegion();
Show All 27 Lines if (ChecksEnabled[CK_MallocChecker])
CheckKind = CK_MallocChecker; CheckKind = CK_MallocChecker;
else if (ChecksEnabled[CK_MismatchedDeallocatorChecker]) else if (ChecksEnabled[CK_MismatchedDeallocatorChecker])
CheckKind = CK_MismatchedDeallocatorChecker; CheckKind = CK_MismatchedDeallocatorChecker;
else else
return; return;
if (ExplodedNode *N = C.generateErrorNode()) { if (ExplodedNode *N = C.generateErrorNode()) {
if (!BT_FreeAlloca[*CheckKind]) if (!BT_FreeAlloca[*CheckKind])
BT_FreeAlloca[*CheckKind].reset(new BugType( BT_FreeAlloca[*CheckKind] = llvm::make_unique<BugType>(
CheckNames[*CheckKind], "Free alloca()", categories::MemoryError)); CheckNames[*CheckKind], "Free alloca()", categories::MemoryError);
auto R = llvm::make_unique<BugReport>( auto R = llvm::make_unique<BugReport>(
*BT_FreeAlloca[*CheckKind], *BT_FreeAlloca[*CheckKind],
"Memory allocated by alloca() should not be deallocated", N); "Memory allocated by alloca() should not be deallocated", N);
R->markInteresting(ArgVal.getAsRegion()); R->markInteresting(ArgVal.getAsRegion());
R->addRange(Range); R->addRange(Range);
C.emitReport(std::move(R)); C.emitReport(std::move(R));
} }
} }
void MallocChecker::ReportMismatchedDealloc(CheckerContext &C, void MallocChecker::ReportMismatchedDealloc(CheckerContext &C,
SourceRange Range, SourceRange Range,
const Expr *DeallocExpr, const Expr *DeallocExpr,
const RefState *RS, const RefState *RS,
SymbolRef Sym, SymbolRef Sym,
bool OwnershipTransferred) const { bool OwnershipTransferred) const {
if (!ChecksEnabled[CK_MismatchedDeallocatorChecker]) if (!ChecksEnabled[CK_MismatchedDeallocatorChecker])
return; return;
if (ExplodedNode *N = C.generateErrorNode()) { if (ExplodedNode *N = C.generateErrorNode()) {
if (!BT_MismatchedDealloc) if (!BT_MismatchedDealloc)
BT_MismatchedDealloc.reset( BT_MismatchedDealloc = llvm::make_unique<BugType>(
new BugType(CheckNames[CK_MismatchedDeallocatorChecker], CheckNames[CK_MismatchedDeallocatorChecker],
"Bad deallocator", categories::MemoryError)); "Bad deallocator", categories::MemoryError);
SmallString<100> buf; SmallString<100> buf;
llvm::raw_svector_ostream os(buf); llvm::raw_svector_ostream os(buf);
const Expr *AllocExpr = cast<Expr>(RS->getStmt()); const Expr *AllocExpr = cast<Expr>(RS->getStmt());
SmallString<20> AllocBuf; SmallString<20> AllocBuf;
llvm::raw_svector_ostream AllocOs(AllocBuf); llvm::raw_svector_ostream AllocOs(AllocBuf);
SmallString<20> DeallocBuf; SmallString<20> DeallocBuf;
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Linesvoid MallocChecker::ReportOffsetFree(CheckerContext &C, SVal ArgVal,
if (!CheckKind.hasValue()) if (!CheckKind.hasValue())
return; return;
ExplodedNode *N = C.generateErrorNode(); ExplodedNode *N = C.generateErrorNode();
if (!N) if (!N)
return; return;
if (!BT_OffsetFree[*CheckKind]) if (!BT_OffsetFree[*CheckKind])
BT_OffsetFree[*CheckKind].reset(new BugType( BT_OffsetFree[*CheckKind] = llvm::make_unique<BugType>(
CheckNames[*CheckKind], "Offset free", categories::MemoryError)); CheckNames[*CheckKind], "Offset free", categories::MemoryError);
SmallString<100> buf; SmallString<100> buf;
llvm::raw_svector_ostream os(buf); llvm::raw_svector_ostream os(buf);
SmallString<20> AllocNameBuf; SmallString<20> AllocNameBuf;
llvm::raw_svector_ostream AllocNameOs(AllocNameBuf); llvm::raw_svector_ostream AllocNameOs(AllocNameBuf);
const MemRegion *MR = ArgVal.getAsRegion(); const MemRegion *MR = ArgVal.getAsRegion();
assert(MR && "Only MemRegion based symbols can have offset free errors"); assert(MR && "Only MemRegion based symbols can have offset free errors");
Show All 33 Lines if (!ChecksEnabled[CK_MallocChecker] &&
return; return;
Optional<MallocChecker::CheckKind> CheckKind = getCheckIfTracked(C, Sym); Optional<MallocChecker::CheckKind> CheckKind = getCheckIfTracked(C, Sym);
if (!CheckKind.hasValue()) if (!CheckKind.hasValue())
return; return;
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] = llvm::make_unique<BugType>(
CheckNames[*CheckKind], "Use-after-free", categories::MemoryError)); 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);
R->markInteresting(Sym); R->markInteresting(Sym);
R->addRange(Range); R->addRange(Range);
R->addVisitor(llvm::make_unique<MallocBugVisitor>(Sym)); R->addVisitor(llvm::make_unique<MallocBugVisitor>(Sym));
C.emitReport(std::move(R)); C.emitReport(std::move(R));
Show All 9 Lines if (!ChecksEnabled[CK_MallocChecker] &&
return; return;
Optional<MallocChecker::CheckKind> CheckKind = getCheckIfTracked(C, Sym); Optional<MallocChecker::CheckKind> CheckKind = getCheckIfTracked(C, Sym);
if (!CheckKind.hasValue()) if (!CheckKind.hasValue())
return; return;
if (ExplodedNode *N = C.generateErrorNode()) { if (ExplodedNode *N = C.generateErrorNode()) {
if (!BT_DoubleFree[*CheckKind]) if (!BT_DoubleFree[*CheckKind])
BT_DoubleFree[*CheckKind].reset(new BugType( BT_DoubleFree[*CheckKind] = llvm::make_unique<BugType>(
CheckNames[*CheckKind], "Double free", categories::MemoryError)); CheckNames[*CheckKind], "Double free", categories::MemoryError);
auto R = llvm::make_unique<BugReport>( auto R = llvm::make_unique<BugReport>(
*BT_DoubleFree[*CheckKind], *BT_DoubleFree[*CheckKind],
(Released ? "Attempt to free released memory" (Released ? "Attempt to free released memory"
: "Attempt to free non-owned memory"), : "Attempt to free non-owned memory"),
N); N);
R->addRange(Range); R->addRange(Range);
R->markInteresting(Sym); R->markInteresting(Sym);
Show All 10 Lines if (!ChecksEnabled[CK_NewDeleteChecker])
return; return;
Optional<MallocChecker::CheckKind> CheckKind = getCheckIfTracked(C, Sym); Optional<MallocChecker::CheckKind> CheckKind = getCheckIfTracked(C, Sym);
if (!CheckKind.hasValue()) if (!CheckKind.hasValue())
return; return;
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 = llvm::make_unique<BugType>(CheckNames[CK_NewDeleteChecker],
"Double delete", "Double delete",
categories::MemoryError)); 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);
R->markInteresting(Sym); R->markInteresting(Sym);
R->addVisitor(llvm::make_unique<MallocBugVisitor>(Sym)); R->addVisitor(llvm::make_unique<MallocBugVisitor>(Sym));
C.emitReport(std::move(R)); C.emitReport(std::move(R));
} }
Show All 9 Linesvoid MallocChecker::ReportUseZeroAllocated(CheckerContext &C,
Optional<MallocChecker::CheckKind> CheckKind = getCheckIfTracked(C, Sym); Optional<MallocChecker::CheckKind> CheckKind = getCheckIfTracked(C, Sym);
if (!CheckKind.hasValue()) if (!CheckKind.hasValue())
return; return;
if (ExplodedNode *N = C.generateErrorNode()) { if (ExplodedNode *N = C.generateErrorNode()) {
if (!BT_UseZerroAllocated[*CheckKind]) if (!BT_UseZerroAllocated[*CheckKind])
BT_UseZerroAllocated[*CheckKind].reset( BT_UseZerroAllocated[*CheckKind] = llvm::make_unique<BugType>(
new BugType(CheckNames[*CheckKind], "Use of zero allocated", CheckNames[*CheckKind], "Use of zero allocated",
categories::MemoryError)); 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);
R->addRange(Range); R->addRange(Range);
if (Sym) { if (Sym) {
R->markInteresting(Sym); R->markInteresting(Sym);
R->addVisitor(llvm::make_unique<MallocBugVisitor>(Sym)); R->addVisitor(llvm::make_unique<MallocBugVisitor>(Sym));
Show All 9 Lines if (!ChecksEnabled[CK_MallocChecker])
return; return;
Optional<MallocChecker::CheckKind> CheckKind = getCheckIfTracked(C, FreeExpr); Optional<MallocChecker::CheckKind> CheckKind = getCheckIfTracked(C, FreeExpr);
if (!CheckKind.hasValue()) if (!CheckKind.hasValue())
return; return;
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] = llvm::make_unique<BugType>(
new BugType(CheckNames[*CheckKind], "Bad free", "Memory Error")); CheckNames[*CheckKind], "Bad free", "Memory Error");
SmallString<100> Buf; SmallString<100> Buf;
llvm::raw_svector_ostream Os(Buf); llvm::raw_svector_ostream Os(Buf);
const MemRegion *MR = ArgVal.getAsRegion(); const MemRegion *MR = ArgVal.getAsRegion();
while (const ElementRegion *ER = dyn_cast_or_null<ElementRegion>(MR)) while (const ElementRegion *ER = dyn_cast_or_null<ElementRegion>(MR))
MR = ER->getSuperRegion(); MR = ER->getSuperRegion();
▲ Show 20 Lines • Show All 191 Lines • ▼ Show 20 Linesvoid MallocChecker::reportLeak(SymbolRef Sym, ExplodedNode *N,
Optional<MallocChecker::CheckKind> Optional<MallocChecker::CheckKind>
CheckKind = getCheckIfTracked(Family, true); CheckKind = getCheckIfTracked(Family, true);
if (!CheckKind.hasValue()) if (!CheckKind.hasValue())
return; return;
assert(N); assert(N);
if (!BT_Leak[*CheckKind]) { if (!BT_Leak[*CheckKind]) {
BT_Leak[*CheckKind].reset(new BugType(CheckNames[*CheckKind], "Memory leak", BT_Leak[*CheckKind] = llvm::make_unique<BugType>(CheckNames[*CheckKind], "Memory leak",
categories::MemoryError)); 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
// with __noreturn functions such as assert() or exit(). We choose not // with __noreturn functions such as assert() or exit(). We choose not
// to report leaks on such paths. // to report leaks on such paths.
BT_Leak[*CheckKind]->setSuppressOnSink(true); BT_Leak[*CheckKind]->setSuppressOnSink(true);
} }
▲ Show 20 Lines • Show All 651 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/MisusedMovedObjectChecker.cpp

Show First 20 Lines • Show All 174 Lines • ▼ Show 20 Lines
} }
ExplodedNode *MisusedMovedObjectChecker::reportBug(const MemRegion *Region, ExplodedNode *MisusedMovedObjectChecker::reportBug(const MemRegion *Region,
const CallEvent &Call, const CallEvent &Call,
CheckerContext &C, CheckerContext &C,
bool isCopy = false) const { bool isCopy = false) const {
if (ExplodedNode *N = C.generateNonFatalErrorNode()) { if (ExplodedNode *N = C.generateNonFatalErrorNode()) {
if (!BT) if (!BT)
BT.reset(new BugType(this, "Usage of a 'moved-from' object", BT = llvm::make_unique<BugType>(this, "Usage of a 'moved-from' object",
"C++ move semantics")); "C++ move semantics");
// Uniqueing report to the same object. // Uniqueing report to the same object.
PathDiagnosticLocation LocUsedForUniqueing; PathDiagnosticLocation LocUsedForUniqueing;
const ExplodedNode *MoveNode = getMoveLocation(N, Region, C); const ExplodedNode *MoveNode = getMoveLocation(N, Region, C);
if (const Stmt *MoveStmt = PathDiagnosticLocation::getStmt(MoveNode)) if (const Stmt *MoveStmt = PathDiagnosticLocation::getStmt(MoveNode))
LocUsedForUniqueing = PathDiagnosticLocation::createBegin( LocUsedForUniqueing = PathDiagnosticLocation::createBegin(
MoveStmt, C.getSourceManager(), MoveNode->getLocationContext()); MoveStmt, C.getSourceManager(), MoveNode->getLocationContext());
▲ Show 20 Lines • Show All 289 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/NSAutoreleasePoolChecker.cpp

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Linesvoid NSAutoreleasePoolChecker::checkPreObjCMessage(const ObjCMethodCall &msg,
if (releaseS.isNull()) if (releaseS.isNull())
releaseS = GetNullarySelector("release", C.getASTContext()); releaseS = GetNullarySelector("release", C.getASTContext());
// Sending 'release' message? // Sending 'release' message?
if (msg.getSelector() != releaseS) if (msg.getSelector() != releaseS)
return; return;
if (!BT) if (!BT)
BT.reset(new BugType(this, "Use -drain instead of -release", BT = llvm::make_unique<BugType>(this, "Use -drain instead of -release",
"API Upgrade (Apple)")); "API Upgrade (Apple)");
ExplodedNode *N = C.generateNonFatalErrorNode(); ExplodedNode *N = C.generateNonFatalErrorNode();
if (!N) { if (!N) {
assert(0); assert(0);
return; return;
} }
auto Report = llvm::make_unique<BugReport>( auto Report = llvm::make_unique<BugReport>(
Show All 10 Lines

lib/StaticAnalyzer/Checkers/NSErrorChecker.cpp

Show First 20 Lines • Show All 261 Lines • ▼ Show 20 Lines os << (isNSError
? "in 'Creating and Returning NSError Objects' the parameter" ? "in 'Creating and Returning NSError Objects' the parameter"
: "documented in CoreFoundation/CFError.h the parameter"); : "documented in CoreFoundation/CFError.h the parameter");
os << " may be null"; os << " may be null";
BugType *bug = nullptr; BugType *bug = nullptr;
if (isNSError) { if (isNSError) {
if (!NSBT) if (!NSBT)
NSBT.reset(new NSErrorDerefBug(this)); NSBT = llvm::make_unique<NSErrorDerefBug>(this);
bug = NSBT.get(); bug = NSBT.get();
} }
else { else {
if (!CFBT) if (!CFBT)
CFBT.reset(new CFErrorDerefBug(this)); CFBT = llvm::make_unique<CFErrorDerefBug>(this);
bug = CFBT.get(); bug = CFBT.get();
} }
BR.emitReport(llvm::make_unique<BugReport>(*bug, os.str(), event.SinkNode)); BR.emitReport(llvm::make_unique<BugReport>(*bug, os.str(), event.SinkNode));
} }
static bool IsNSError(QualType T, IdentifierInfo *II) { static bool IsNSError(QualType T, IdentifierInfo *II) {
const PointerType* PPT = T->getAs<PointerType>(); const PointerType* PPT = T->getAs<PointerType>();
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/NonNullParamChecker.cpp

Show First 20 Lines • Show All 181 Lines • ▼ Show 20 Lines
std::unique_ptr<BugReport> std::unique_ptr<BugReport>
NonNullParamChecker::genReportNullAttrNonNull(const ExplodedNode *ErrorNode, NonNullParamChecker::genReportNullAttrNonNull(const ExplodedNode *ErrorNode,
const Expr *ArgE) const { const Expr *ArgE) const {
// Lazily allocate the BugType object if it hasn't already been // Lazily allocate the BugType object if it hasn't already been
// created. Ownership is transferred to the BugReporter object once // created. Ownership is transferred to the BugReporter object once
// the BugReport is passed to 'EmitWarning'. // the BugReport is passed to 'EmitWarning'.
if (!BTAttrNonNull) if (!BTAttrNonNull)
BTAttrNonNull.reset(new BugType( BTAttrNonNull = llvm::make_unique<BugType>(
this, "Argument with 'nonnull' attribute passed null", "API")); this, "Argument with 'nonnull' attribute passed null", "API");
auto R = llvm::make_unique<BugReport>( auto R = llvm::make_unique<BugReport>(
*BTAttrNonNull, *BTAttrNonNull,
"Null pointer passed as an argument to a 'nonnull' parameter", ErrorNode); "Null pointer passed as an argument to a 'nonnull' parameter", ErrorNode);
if (ArgE) if (ArgE)
bugreporter::trackNullOrUndefValue(ErrorNode, ArgE, *R); bugreporter::trackNullOrUndefValue(ErrorNode, ArgE, *R);
return R; return R;
} }
std::unique_ptr<BugReport> NonNullParamChecker::genReportReferenceToNullPointer( std::unique_ptr<BugReport> NonNullParamChecker::genReportReferenceToNullPointer(
const ExplodedNode *ErrorNode, const Expr *ArgE) const { const ExplodedNode *ErrorNode, const Expr *ArgE) const {
if (!BTNullRefArg) if (!BTNullRefArg)
BTNullRefArg.reset(new BuiltinBug(this, "Dereference of null pointer")); BTNullRefArg = llvm::make_unique<BuiltinBug>(this, "Dereference of null pointer");
auto R = llvm::make_unique<BugReport>( auto R = llvm::make_unique<BugReport>(
*BTNullRefArg, "Forming reference to null pointer", ErrorNode); *BTNullRefArg, "Forming reference to null pointer", ErrorNode);
if (ArgE) { if (ArgE) {
const Expr *ArgEDeref = bugreporter::getDerefExpr(ArgE); const Expr *ArgEDeref = bugreporter::getDerefExpr(ArgE);
if (!ArgEDeref) if (!ArgEDeref)
ArgEDeref = ArgE; ArgEDeref = ArgE;
bugreporter::trackNullOrUndefValue(ErrorNode, bugreporter::trackNullOrUndefValue(ErrorNode,
Show All 10 Lines

lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp

Show First 20 Lines • Show All 172 Lines • ▼ Show 20 Lines void reportBugIfInvariantHolds(StringRef Msg, ErrorKind Error,
CheckerContext &C, CheckerContext &C,
const Stmt *ValueExpr = nullptr, const Stmt *ValueExpr = nullptr,
bool SuppressPath = false) const; bool SuppressPath = false) const;
void reportBug(StringRef Msg, ErrorKind Error, ExplodedNode *N, void reportBug(StringRef Msg, ErrorKind Error, ExplodedNode *N,
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", categories::MemoryError)); BT = llvm::make_unique<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) {
R->markInteresting(Region); R->markInteresting(Region);
R->addVisitor(llvm::make_unique<NullabilityBugVisitor>(Region)); R->addVisitor(llvm::make_unique<NullabilityBugVisitor>(Region));
} }
if (ValueExpr) { if (ValueExpr) {
R->addRange(ValueExpr->getSourceRange()); R->addRange(ValueExpr->getSourceRange());
▲ Show 20 Lines • Show All 1,049 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/ObjCAtSyncChecker.cpp

Show All 39 Linesvoid ObjCAtSyncChecker::checkPreStmt(const ObjCAtSynchronizedStmt *S,
const Expr *Ex = S->getSynchExpr(); const Expr *Ex = S->getSynchExpr();
ProgramStateRef state = C.getState(); ProgramStateRef state = C.getState();
SVal V = state->getSVal(Ex, C.getLocationContext()); SVal V = state->getSVal(Ex, C.getLocationContext());
// Uninitialized value used for the mutex? // Uninitialized value used for the mutex?
if (V.getAs<UndefinedVal>()) { if (V.getAs<UndefinedVal>()) {
if (ExplodedNode *N = C.generateErrorNode()) { if (ExplodedNode *N = C.generateErrorNode()) {
if (!BT_undef) if (!BT_undef)
BT_undef.reset(new BuiltinBug(this, "Uninitialized value used as mutex " BT_undef = llvm::make_unique<BuiltinBug>(this, "Uninitialized value used as mutex "
"for @synchronized")); "for @synchronized");
auto report = auto report =
llvm::make_unique<BugReport>(*BT_undef, BT_undef->getDescription(), N); llvm::make_unique<BugReport>(*BT_undef, BT_undef->getDescription(), N);
bugreporter::trackNullOrUndefValue(N, Ex, *report); bugreporter::trackNullOrUndefValue(N, Ex, *report);
C.emitReport(std::move(report)); C.emitReport(std::move(report));
} }
return; return;
} }
if (V.isUnknown()) if (V.isUnknown())
return; return;
// Check for null mutexes. // Check for null mutexes.
ProgramStateRef notNullState, nullState; ProgramStateRef notNullState, nullState;
std::tie(notNullState, nullState) = state->assume(V.castAs<DefinedSVal>()); std::tie(notNullState, nullState) = state->assume(V.castAs<DefinedSVal>());
if (nullState) { if (nullState) {
if (!notNullState) { if (!notNullState) {
// Generate an error node. This isn't a sink since // Generate an error node. This isn't a sink since
// a null mutex just means no synchronization occurs. // a null mutex just means no synchronization occurs.
if (ExplodedNode *N = C.generateNonFatalErrorNode(nullState)) { if (ExplodedNode *N = C.generateNonFatalErrorNode(nullState)) {
if (!BT_null) if (!BT_null)
BT_null.reset(new BuiltinBug( BT_null = llvm::make_unique<BuiltinBug>(
this, "Nil value used as mutex for @synchronized() " this, "Nil value used as mutex for @synchronized() "
"(no synchronization will occur)")); "(no synchronization will occur)");
auto report = auto report =
llvm::make_unique<BugReport>(*BT_null, BT_null->getDescription(), N); llvm::make_unique<BugReport>(*BT_null, BT_null->getDescription(), N);
bugreporter::trackNullOrUndefValue(N, Ex, *report); bugreporter::trackNullOrUndefValue(N, Ex, *report);
C.emitReport(std::move(report)); C.emitReport(std::move(report));
return; return;
} }
} }
Show All 13 Lines

lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp

Show All 28 Lines
namespace { namespace {
class ObjCContainersChecker : public Checker< check::PreStmt<CallExpr>, class ObjCContainersChecker : public Checker< check::PreStmt<CallExpr>,
check::PostStmt<CallExpr>, check::PostStmt<CallExpr>,
check::PointerEscape> { check::PointerEscape> {
mutable std::unique_ptr<BugType> BT; mutable std::unique_ptr<BugType> BT;
inline void initBugType() const { inline void initBugType() const {
if (!BT) if (!BT)
BT.reset(new BugType(this, "CFArray API", BT = llvm::make_unique<BugType>(this, "CFArray API",
categories::CoreFoundationObjectiveC)); categories::CoreFoundationObjectiveC);
} }
inline SymbolRef getArraySym(const Expr *E, CheckerContext &C) const { inline SymbolRef getArraySym(const Expr *E, CheckerContext &C) const {
SVal ArrayRef = C.getState()->getSVal(E, C.getLocationContext()); SVal ArrayRef = C.getState()->getSVal(E, C.getLocationContext());
SymbolRef ArraySym = ArrayRef.getAsSymbol(); SymbolRef ArraySym = ArrayRef.getAsSymbol();
return ArraySym; return ArraySym;
} }
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp

Show First 20 Lines • Show All 152 Lines • ▼ Show 20 Lines if (!isInvalidSelf(E, C))
return; return;
// Generate an error node. // Generate an error node.
ExplodedNode *N = C.generateErrorNode(); ExplodedNode *N = C.generateErrorNode();
if (!N) if (!N)
return; return;
if (!BT) if (!BT)
BT.reset(new BugType(this, "Missing \"self = [(super or self) init...]\"", BT = llvm::make_unique<BugType>(this, "Missing \"self = [(super or self) init...]\"",
categories::CoreFoundationObjectiveC)); categories::CoreFoundationObjectiveC);
C.emitReport(llvm::make_unique<BugReport>(*BT, errorStr, N)); C.emitReport(llvm::make_unique<BugReport>(*BT, errorStr, N));
} }
void ObjCSelfInitChecker::checkPostObjCMessage(const ObjCMethodCall &Msg, void ObjCSelfInitChecker::checkPostObjCMessage(const ObjCMethodCall &Msg,
CheckerContext &C) const { CheckerContext &C) const {
// When encountering a message that does initialization (init rule), // When encountering a message that does initialization (init rule),
// tag the return value so that we know later on that if self has this value // tag the return value so that we know later on that if self has this value
// then it is properly initialized. // then it is properly initialized.
▲ Show 20 Lines • Show All 269 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/ObjCSuperDeallocChecker.cpp

Show First 20 Lines • Show All 216 Lines • ▼ Show 20 Lines if (State->contains<CalledSuperDealloc>(Sym)) {
return; return;
} }
} }
} }
ObjCSuperDeallocChecker::ObjCSuperDeallocChecker() ObjCSuperDeallocChecker::ObjCSuperDeallocChecker()
: IIdealloc(nullptr), IINSObject(nullptr) { : IIdealloc(nullptr), IINSObject(nullptr) {
DoubleSuperDeallocBugType.reset( DoubleSuperDeallocBugType = llvm::make_unique<BugType>(
new BugType(this, "[super dealloc] should not be called more than once", this, "[super dealloc] should not be called more than once",
categories::CoreFoundationObjectiveC)); categories::CoreFoundationObjectiveC);
} }
void void
ObjCSuperDeallocChecker::initIdentifierInfoAndSelectors(ASTContext &Ctx) const { ObjCSuperDeallocChecker::initIdentifierInfoAndSelectors(ASTContext &Ctx) const {
if (IIdealloc) if (IIdealloc)
return; return;
IIdealloc = &Ctx.Idents.get("dealloc"); IIdealloc = &Ctx.Idents.get("dealloc");
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/PointerArithChecker.cpp

Show First 20 Lines • Show All 165 Lines • ▼ Show 20 Linesvoid PointerArithChecker::reportPointerArithMisuse(const Expr *E,
bool IsPolymorphic = false; bool IsPolymorphic = false;
AllocKind Kind = AllocKind::Unknown; AllocKind Kind = AllocKind::Unknown;
if (const MemRegion *ArrayRegion = if (const MemRegion *ArrayRegion =
getArrayRegion(Region, IsPolymorphic, Kind, C)) { getArrayRegion(Region, IsPolymorphic, Kind, C)) {
if (!IsPolymorphic) if (!IsPolymorphic)
return; return;
if (ExplodedNode *N = C.generateNonFatalErrorNode()) { if (ExplodedNode *N = C.generateNonFatalErrorNode()) {
if (!BT_polyArray) if (!BT_polyArray)
BT_polyArray.reset(new BuiltinBug( BT_polyArray = llvm::make_unique<BuiltinBug>(
this, "Dangerous pointer arithmetic", this, "Dangerous pointer arithmetic",
"Pointer arithmetic on a pointer to base class is dangerous " "Pointer arithmetic on a pointer to base class is dangerous "
"because derived and base class may have different size.")); "because derived and base class may have different size.");
auto R = llvm::make_unique<BugReport>(*BT_polyArray, auto R = llvm::make_unique<BugReport>(*BT_polyArray,
BT_polyArray->getDescription(), N); BT_polyArray->getDescription(), N);
R->addRange(E->getSourceRange()); R->addRange(E->getSourceRange());
R->markInteresting(ArrayRegion); R->markInteresting(ArrayRegion);
C.emitReport(std::move(R)); C.emitReport(std::move(R));
} }
return; return;
} }
if (Kind == AllocKind::Reinterpreted) if (Kind == AllocKind::Reinterpreted)
return; return;
// We might not have enough information about symbolic regions. // We might not have enough information about symbolic regions.
if (Kind != AllocKind::SingleObject && if (Kind != AllocKind::SingleObject &&
Region->getKind() == MemRegion::Kind::SymbolicRegionKind) Region->getKind() == MemRegion::Kind::SymbolicRegionKind)
return; return;
if (ExplodedNode *N = C.generateNonFatalErrorNode()) { if (ExplodedNode *N = C.generateNonFatalErrorNode()) {
if (!BT_pointerArith) if (!BT_pointerArith)
BT_pointerArith.reset(new BuiltinBug(this, "Dangerous pointer arithmetic", BT_pointerArith = llvm::make_unique<BuiltinBug>(this, "Dangerous pointer arithmetic",
"Pointer arithmetic on non-array " "Pointer arithmetic on non-array "
"variables relies on memory layout, " "variables relies on memory layout, "
"which is dangerous.")); "which is dangerous.");
auto R = llvm::make_unique<BugReport>(*BT_pointerArith, auto R = llvm::make_unique<BugReport>(*BT_pointerArith,
BT_pointerArith->getDescription(), N); BT_pointerArith->getDescription(), N);
R->addRange(SR); R->addRange(SR);
R->markInteresting(Region); R->markInteresting(Region);
C.emitReport(std::move(R)); C.emitReport(std::move(R));
} }
} }
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/PointerSubChecker.cpp

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines if (BaseLR == BaseRR)
return; return;
// Allow arithmetic on different symbolic regions. // Allow arithmetic on different symbolic regions.
if (isa<SymbolicRegion>(BaseLR) || isa<SymbolicRegion>(BaseRR)) if (isa<SymbolicRegion>(BaseLR) || isa<SymbolicRegion>(BaseRR))
return; return;
if (ExplodedNode *N = C.generateNonFatalErrorNode()) { if (ExplodedNode *N = C.generateNonFatalErrorNode()) {
if (!BT) if (!BT)
BT.reset( BT = llvm::make_unique<BuiltinBug>(
new BuiltinBug(this, "Pointer subtraction", this, "Pointer subtraction",
"Subtraction of two pointers that do not point to " "Subtraction of two pointers that do not point to "
"the same memory chunk may cause incorrect result.")); "the same memory chunk may cause incorrect result.");
auto R = llvm::make_unique<BugReport>(*BT, BT->getDescription(), N); auto R = llvm::make_unique<BugReport>(*BT, BT->getDescription(), N);
R->addRange(B->getSourceRange()); R->addRange(B->getSourceRange());
C.emitReport(std::move(R)); C.emitReport(std::move(R));
} }
} }
void ento::registerPointerSubChecker(CheckerManager &mgr) { void ento::registerPointerSubChecker(CheckerManager &mgr) {
mgr.registerChecker<PointerSubChecker>(); mgr.registerChecker<PointerSubChecker>();
} }

lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp

Show First 20 Lines • Show All 200 Lines • ▼ Show 20 Linesvoid PthreadLockChecker::AcquireLock(CheckerContext &C, const CallExpr *CE,
if (X.isUnknownOrUndef()) if (X.isUnknownOrUndef())
return; return;
DefinedSVal retVal = X.castAs<DefinedSVal>(); DefinedSVal retVal = X.castAs<DefinedSVal>();
if (const LockState *LState = state->get<LockMap>(lockR)) { if (const LockState *LState = state->get<LockMap>(lockR)) {
if (LState->isLocked()) { if (LState->isLocked()) {
if (!BT_doublelock) if (!BT_doublelock)
BT_doublelock.reset(new BugType(this, "Double locking", BT_doublelock = llvm::make_unique<BugType>(this, "Double locking",
"Lock checker")); "Lock checker");
ExplodedNode *N = C.generateErrorNode(); ExplodedNode *N = C.generateErrorNode();
if (!N) if (!N)
return; return;
auto report = llvm::make_unique<BugReport>( auto report = llvm::make_unique<BugReport>(
*BT_doublelock, "This lock has already been acquired", N); *BT_doublelock, "This lock has already been acquired", N);
report->addRange(CE->getArg(0)->getSourceRange()); report->addRange(CE->getArg(0)->getSourceRange());
C.emitReport(std::move(report)); C.emitReport(std::move(report));
return; return;
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Linesvoid PthreadLockChecker::ReleaseLock(CheckerContext &C, const CallExpr *CE,
ProgramStateRef state = C.getState(); ProgramStateRef state = C.getState();
const SymbolRef *sym = state->get<DestroyRetVal>(lockR); const SymbolRef *sym = state->get<DestroyRetVal>(lockR);
if (sym) if (sym)
state = resolvePossiblyDestroyedMutex(state, lockR, sym); state = resolvePossiblyDestroyedMutex(state, lockR, sym);
if (const LockState *LState = state->get<LockMap>(lockR)) { if (const LockState *LState = state->get<LockMap>(lockR)) {
if (LState->isUnlocked()) { if (LState->isUnlocked()) {
if (!BT_doubleunlock) if (!BT_doubleunlock)
BT_doubleunlock.reset(new BugType(this, "Double unlocking", BT_doubleunlock = llvm::make_unique<BugType>(this, "Double unlocking",
"Lock checker")); "Lock checker");
ExplodedNode *N = C.generateErrorNode(); ExplodedNode *N = C.generateErrorNode();
if (!N) if (!N)
return; return;
auto Report = llvm::make_unique<BugReport>( auto Report = llvm::make_unique<BugReport>(
*BT_doubleunlock, "This lock has already been unlocked", N); *BT_doubleunlock, "This lock has already been unlocked", N);
Report->addRange(CE->getArg(0)->getSourceRange()); Report->addRange(CE->getArg(0)->getSourceRange());
C.emitReport(std::move(Report)); C.emitReport(std::move(Report));
return; return;
} else if (LState->isDestroyed()) { } else if (LState->isDestroyed()) {
reportUseDestroyedBug(C, CE); reportUseDestroyedBug(C, CE);
return; return;
} }
} }
LockSetTy LS = state->get<LockSet>(); LockSetTy LS = state->get<LockSet>();
// FIXME: Better analysis requires IPA for wrappers. // FIXME: Better analysis requires IPA for wrappers.
if (!LS.isEmpty()) { if (!LS.isEmpty()) {
const MemRegion *firstLockR = LS.getHead(); const MemRegion *firstLockR = LS.getHead();
if (firstLockR != lockR) { if (firstLockR != lockR) {
if (!BT_lor) if (!BT_lor)
BT_lor.reset(new BugType(this, "Lock order reversal", "Lock checker")); BT_lor = llvm::make_unique<BugType>(this, "Lock order reversal", "Lock checker");
ExplodedNode *N = C.generateErrorNode(); ExplodedNode *N = C.generateErrorNode();
if (!N) if (!N)
return; return;
auto report = llvm::make_unique<BugReport>( auto report = llvm::make_unique<BugReport>(
*BT_lor, "This was not the most recently acquired lock. Possible " *BT_lor, "This was not the most recently acquired lock. Possible "
"lock order reversal", N); "lock order reversal", N);
report->addRange(CE->getArg(0)->getSourceRange()); report->addRange(CE->getArg(0)->getSourceRange());
C.emitReport(std::move(report)); C.emitReport(std::move(report));
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Linesvoid PthreadLockChecker::DestroyLock(CheckerContext &C, const CallExpr *CE,
if (LState->isLocked()) { if (LState->isLocked()) {
Message = "This lock is still locked"; Message = "This lock is still locked";
} else { } else {
Message = "This lock has already been destroyed"; Message = "This lock has already been destroyed";
} }
if (!BT_destroylock) if (!BT_destroylock)
BT_destroylock.reset(new BugType(this, "Destroy invalid lock", BT_destroylock = llvm::make_unique<BugType>(this, "Destroy invalid lock",
"Lock checker")); "Lock checker");
ExplodedNode *N = C.generateErrorNode(); ExplodedNode *N = C.generateErrorNode();
if (!N) if (!N)
return; return;
auto Report = llvm::make_unique<BugReport>(*BT_destroylock, Message, N); auto Report = llvm::make_unique<BugReport>(*BT_destroylock, Message, N);
Report->addRange(CE->getArg(0)->getSourceRange()); Report->addRange(CE->getArg(0)->getSourceRange());
C.emitReport(std::move(Report)); C.emitReport(std::move(Report));
} }
Show All 21 Linesvoid PthreadLockChecker::InitLock(CheckerContext &C, const CallExpr *CE,
if (LState->isLocked()) { if (LState->isLocked()) {
Message = "This lock is still being held"; Message = "This lock is still being held";
} else { } else {
Message = "This lock has already been initialized"; Message = "This lock has already been initialized";
} }
if (!BT_initlock) if (!BT_initlock)
BT_initlock.reset(new BugType(this, "Init invalid lock", BT_initlock = llvm::make_unique<BugType>(this, "Init invalid lock",
"Lock checker")); "Lock checker");
ExplodedNode *N = C.generateErrorNode(); ExplodedNode *N = C.generateErrorNode();
if (!N) if (!N)
return; return;
auto Report = llvm::make_unique<BugReport>(*BT_initlock, Message, N); auto Report = llvm::make_unique<BugReport>(*BT_initlock, Message, N);
Report->addRange(CE->getArg(0)->getSourceRange()); Report->addRange(CE->getArg(0)->getSourceRange());
C.emitReport(std::move(Report)); C.emitReport(std::move(Report));
} }
void PthreadLockChecker::reportUseDestroyedBug(CheckerContext &C, void PthreadLockChecker::reportUseDestroyedBug(CheckerContext &C,
const CallExpr *CE) const { const CallExpr *CE) const {
if (!BT_destroylock) if (!BT_destroylock)
BT_destroylock.reset(new BugType(this, "Use destroyed lock", BT_destroylock = llvm::make_unique<BugType>(this, "Use destroyed lock",
"Lock checker")); "Lock checker");
ExplodedNode *N = C.generateErrorNode(); ExplodedNode *N = C.generateErrorNode();
if (!N) if (!N)
return; return;
auto Report = llvm::make_unique<BugReport>( auto Report = llvm::make_unique<BugReport>(
*BT_destroylock, "This lock has already been destroyed", N); *BT_destroylock, "This lock has already been destroyed", N);
Report->addRange(CE->getArg(0)->getSourceRange()); Report->addRange(CE->getArg(0)->getSourceRange());
C.emitReport(std::move(Report)); C.emitReport(std::move(Report));
} }
Show All 24 Lines

lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp

Show First 20 Lines • Show All 2,554 Lines • ▼ Show 20 Lines void checkEndAnalysis(ExplodedGraph &G, BugReporter &BR,
ShouldResetSummaryLog = !SummaryLog.empty(); ShouldResetSummaryLog = !SummaryLog.empty();
} }
CFRefBug *getLeakWithinFunctionBug(const LangOptions &LOpts, CFRefBug *getLeakWithinFunctionBug(const LangOptions &LOpts,
bool GCEnabled) const { bool GCEnabled) const {
if (GCEnabled) { if (GCEnabled) {
if (!leakWithinFunctionGC) if (!leakWithinFunctionGC)
leakWithinFunctionGC.reset(new Leak(this, "Leak of object when using " leakWithinFunctionGC = llvm::make_unique<Leak>(this, "Leak of object when using "
"garbage collection")); "garbage collection");
return leakWithinFunctionGC.get(); return leakWithinFunctionGC.get();
} else { } else {
if (!leakWithinFunction) { if (!leakWithinFunction) {
if (LOpts.getGC() == LangOptions::HybridGC) { if (LOpts.getGC() == LangOptions::HybridGC) {
leakWithinFunction.reset(new Leak(this, leakWithinFunction = llvm::make_unique<Leak>(this,
"Leak of object when not using " "Leak of object when not using "
"garbage collection (GC) in " "garbage collection (GC) in "
"dual GC/non-GC code")); "dual GC/non-GC code");
} else { } else {
leakWithinFunction.reset(new Leak(this, "Leak")); leakWithinFunction = llvm::make_unique<Leak>(this, "Leak");
} }
} }
return leakWithinFunction.get(); return leakWithinFunction.get();
} }
} }
CFRefBug *getLeakAtReturnBug(const LangOptions &LOpts, bool GCEnabled) const { CFRefBug *getLeakAtReturnBug(const LangOptions &LOpts, bool GCEnabled) const {
if (GCEnabled) { if (GCEnabled) {
if (!leakAtReturnGC) if (!leakAtReturnGC)
leakAtReturnGC.reset(new Leak(this, leakAtReturnGC = llvm::make_unique<Leak>(this,
"Leak of returned object when using " "Leak of returned object when using "
"garbage collection")); "garbage collection");
return leakAtReturnGC.get(); return leakAtReturnGC.get();
} else { } else {
if (!leakAtReturn) { if (!leakAtReturn) {
if (LOpts.getGC() == LangOptions::HybridGC) { if (LOpts.getGC() == LangOptions::HybridGC) {
leakAtReturn.reset(new Leak(this, leakAtReturn = llvm::make_unique<Leak>(this,
"Leak of returned object when not using " "Leak of returned object when not using "
"garbage collection (GC) in dual " "garbage collection (GC) in dual "
"GC/non-GC code")); "GC/non-GC code");
} else { } else {
leakAtReturn.reset(new Leak(this, "Leak of returned object")); leakAtReturn = llvm::make_unique<Leak>(this, "Leak of returned object");
} }
} }
return leakAtReturn.get(); return leakAtReturn.get();
} }
} }
RetainSummaryManager &getSummaryManager(ASTContext &Ctx, RetainSummaryManager &getSummaryManager(ASTContext &Ctx,
bool GCEnabled) const { bool GCEnabled) const {
// FIXME: We don't support ARC being turned on and off during one analysis. // FIXME: We don't support ARC being turned on and off during one analysis.
// (nor, for that matter, do we support changing ASTContexts) // (nor, for that matter, do we support changing ASTContexts)
bool ARCEnabled = (bool)Ctx.getLangOpts().ObjCAutoRefCount; bool ARCEnabled = (bool)Ctx.getLangOpts().ObjCAutoRefCount;
if (GCEnabled) { if (GCEnabled) {
if (!SummariesGC) if (!SummariesGC)
SummariesGC.reset(new RetainSummaryManager(Ctx, true, ARCEnabled)); SummariesGC = llvm::make_unique<RetainSummaryManager>(Ctx, true, ARCEnabled);
else else
assert(SummariesGC->isARCEnabled() == ARCEnabled); assert(SummariesGC->isARCEnabled() == ARCEnabled);
return *SummariesGC; return *SummariesGC;
} else { } else {
if (!Summaries) if (!Summaries)
Summaries.reset(new RetainSummaryManager(Ctx, false, ARCEnabled)); Summaries = llvm::make_unique<RetainSummaryManager>(Ctx, false, ARCEnabled);
else else
assert(Summaries->isARCEnabled() == ARCEnabled); assert(Summaries->isARCEnabled() == ARCEnabled);
return *Summaries; return *Summaries;
} }
} }
RetainSummaryManager &getSummaryManager(CheckerContext &C) const { RetainSummaryManager &getSummaryManager(CheckerContext &C) const {
return getSummaryManager(C.getASTContext(), C.isObjCGCEnabled()); return getSummaryManager(C.getASTContext(), C.isObjCGCEnabled());
▲ Show 20 Lines • Show All 694 Lines • ▼ Show 20 Lines if (!N)
return; return;
CFRefBug *BT; CFRefBug *BT;
switch (ErrorKind) { switch (ErrorKind) {
default: default:
llvm_unreachable("Unhandled error."); llvm_unreachable("Unhandled error.");
case RefVal::ErrorUseAfterRelease: case RefVal::ErrorUseAfterRelease:
if (!useAfterRelease) if (!useAfterRelease)
useAfterRelease.reset(new UseAfterRelease(this)); useAfterRelease = llvm::make_unique<UseAfterRelease>(this);
BT = useAfterRelease.get(); BT = useAfterRelease.get();
break; break;
case RefVal::ErrorReleaseNotOwned: case RefVal::ErrorReleaseNotOwned:
if (!releaseNotOwned) if (!releaseNotOwned)
releaseNotOwned.reset(new BadRelease(this)); releaseNotOwned = llvm::make_unique<BadRelease>(this);
BT = releaseNotOwned.get(); BT = releaseNotOwned.get();
break; break;
case RefVal::ErrorDeallocGC: case RefVal::ErrorDeallocGC:
if (!deallocGC) if (!deallocGC)
deallocGC.reset(new DeallocGC(this)); deallocGC = llvm::make_unique<DeallocGC>(this);
BT = deallocGC.get(); BT = deallocGC.get();
break; break;
case RefVal::ErrorDeallocNotOwned: case RefVal::ErrorDeallocNotOwned:
if (!deallocNotOwned) if (!deallocNotOwned)
deallocNotOwned.reset(new DeallocNotOwned(this)); deallocNotOwned = llvm::make_unique<DeallocNotOwned>(this);
BT = deallocNotOwned.get(); BT = deallocNotOwned.get();
break; break;
} }
assert(BT); assert(BT);
auto report = std::unique_ptr<BugReport>( auto report = std::unique_ptr<BugReport>(
new CFRefReport(*BT, C.getASTContext().getLangOpts(), C.isObjCGCEnabled(), new CFRefReport(*BT, C.getASTContext().getLangOpts(), C.isObjCGCEnabled(),
SummaryLog, N, Sym)); SummaryLog, N, Sym));
▲ Show 20 Lines • Show All 248 Lines • ▼ Show 20 Lines if (RE.isOwned()) {
state = setRefBinding(state, Sym, X ^ RefVal::ErrorReturnedNotOwned); state = setRefBinding(state, Sym, X ^ RefVal::ErrorReturnedNotOwned);
static CheckerProgramPointTag static CheckerProgramPointTag
ReturnNotOwnedTag(this, "ReturnNotOwnedForOwned"); ReturnNotOwnedTag(this, "ReturnNotOwnedForOwned");
ExplodedNode *N = C.addTransition(state, Pred, &ReturnNotOwnedTag); ExplodedNode *N = C.addTransition(state, Pred, &ReturnNotOwnedTag);
if (N) { if (N) {
if (!returnNotOwnedForOwned) if (!returnNotOwnedForOwned)
returnNotOwnedForOwned.reset(new ReturnedNotOwnedForOwned(this)); returnNotOwnedForOwned = llvm::make_unique<ReturnedNotOwnedForOwned>(this);
C.emitReport(std::unique_ptr<BugReport>(new CFRefReport( C.emitReport(std::unique_ptr<BugReport>(new CFRefReport(
*returnNotOwnedForOwned, C.getASTContext().getLangOpts(), *returnNotOwnedForOwned, C.getASTContext().getLangOpts(),
C.isObjCGCEnabled(), SummaryLog, N, Sym))); C.isObjCGCEnabled(), SummaryLog, N, Sym)));
} }
} }
} }
} }
▲ Show 20 Lines • Show All 187 Lines • ▼ Show 20 Lines if (N) {
os << "Object was autoreleased "; os << "Object was autoreleased ";
if (V.getAutoreleaseCount() > 1) if (V.getAutoreleaseCount() > 1)
os << V.getAutoreleaseCount() << " times but the object "; os << V.getAutoreleaseCount() << " times but the object ";
else else
os << "but "; os << "but ";
os << "has a +" << V.getCount() << " retain count"; os << "has a +" << V.getCount() << " retain count";
if (!overAutorelease) if (!overAutorelease)
overAutorelease.reset(new OverAutorelease(this)); overAutorelease = llvm::make_unique<OverAutorelease>(this);
const LangOptions &LOpts = Ctx.getASTContext().getLangOpts(); const LangOptions &LOpts = Ctx.getASTContext().getLangOpts();
Ctx.emitReport(std::unique_ptr<BugReport>( Ctx.emitReport(std::unique_ptr<BugReport>(
new CFRefReport(*overAutorelease, LOpts, /* GCEnabled = */ false, new CFRefReport(*overAutorelease, LOpts, /* GCEnabled = */ false,
SummaryLog, N, Sym, os.str()))); SummaryLog, N, Sym, os.str())));
} }
return nullptr; return nullptr;
▲ Show 20 Lines • Show All 219 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/ReturnPointerRangeChecker.cpp

Show First 20 Lines • Show All 64 Lines • ▼ Show 20 Lines if (StOutBound && !StInBound) {
ExplodedNode *N = C.generateErrorNode(StOutBound); ExplodedNode *N = C.generateErrorNode(StOutBound);
if (!N) if (!N)
return; return;
// FIXME: This bug correspond to CWE-466. Eventually we should have bug // FIXME: This bug correspond to CWE-466. Eventually we should have bug
// types explicitly reference such exploit categories (when applicable). // types explicitly reference such exploit categories (when applicable).
if (!BT) if (!BT)
BT.reset(new BuiltinBug( BT = llvm::make_unique<BuiltinBug>(
this, "Return of pointer value outside of expected range", this, "Return of pointer value outside of expected range",
"Returned pointer value points outside the original object " "Returned pointer value points outside the original object "
"(potential buffer overflow)")); "(potential buffer overflow)");
// FIXME: It would be nice to eventually make this diagnostic more clear, // FIXME: It would be nice to eventually make this diagnostic more clear,
// e.g., by referencing the original declaration or by saying *why* this // e.g., by referencing the original declaration or by saying *why* this
// reference is outside the range. // reference is outside the range.
// Generate a report for this bug. // Generate a report for this bug.
auto report = llvm::make_unique<BugReport>(*BT, BT->getDescription(), N); auto report = llvm::make_unique<BugReport>(*BT, BT->getDescription(), N);
report->addRange(RetE->getSourceRange()); report->addRange(RetE->getSourceRange());
C.emitReport(std::move(report)); C.emitReport(std::move(report));
} }
} }
void ento::registerReturnPointerRangeChecker(CheckerManager &mgr) { void ento::registerReturnPointerRangeChecker(CheckerManager &mgr) {
mgr.registerChecker<ReturnPointerRangeChecker>(); mgr.registerChecker<ReturnPointerRangeChecker>();
} }

lib/StaticAnalyzer/Checkers/ReturnUndefChecker.cpp

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Linesstatic void emitBug(CheckerContext &C, BuiltinBug &BT, const Expr *RetE,
Report->addRange(RetE->getSourceRange()); Report->addRange(RetE->getSourceRange());
bugreporter::trackNullOrUndefValue(N, TrackingE ? TrackingE : RetE, *Report); bugreporter::trackNullOrUndefValue(N, TrackingE ? TrackingE : RetE, *Report);
C.emitReport(std::move(Report)); C.emitReport(std::move(Report));
} }
void ReturnUndefChecker::emitUndef(CheckerContext &C, const Expr *RetE) const { void ReturnUndefChecker::emitUndef(CheckerContext &C, const Expr *RetE) const {
if (!BT_Undef) if (!BT_Undef)
BT_Undef.reset( BT_Undef = llvm::make_unique<BuiltinBug>(
new BuiltinBug(this, "Garbage return value", this, "Garbage return value",
"Undefined or garbage value returned to caller")); "Undefined or garbage value returned to caller");
emitBug(C, *BT_Undef, RetE); emitBug(C, *BT_Undef, RetE);
} }
void ReturnUndefChecker::checkReference(CheckerContext &C, const Expr *RetE, void ReturnUndefChecker::checkReference(CheckerContext &C, const Expr *RetE,
DefinedOrUnknownSVal RetVal) const { DefinedOrUnknownSVal RetVal) const {
ProgramStateRef StNonNull, StNull; ProgramStateRef StNonNull, StNull;
std::tie(StNonNull, StNull) = C.getState()->assume(RetVal); std::tie(StNonNull, StNull) = C.getState()->assume(RetVal);
if (StNonNull) { if (StNonNull) {
// Going forward, assume the location is non-null. // Going forward, assume the location is non-null.
C.addTransition(StNonNull); C.addTransition(StNonNull);
return; return;
} }
// The return value is known to be null. Emit a bug report. // The return value is known to be null. Emit a bug report.
if (!BT_NullReference) if (!BT_NullReference)
BT_NullReference.reset(new BuiltinBug(this, "Returning null reference")); BT_NullReference = llvm::make_unique<BuiltinBug>(this, "Returning null reference");
emitBug(C, *BT_NullReference, RetE, bugreporter::getDerefExpr(RetE)); emitBug(C, *BT_NullReference, RetE, bugreporter::getDerefExpr(RetE));
} }
void ento::registerReturnUndefChecker(CheckerManager &mgr) { void ento::registerReturnUndefChecker(CheckerManager &mgr) {
mgr.registerChecker<ReturnUndefChecker>(); mgr.registerChecker<ReturnUndefChecker>();
} }

lib/StaticAnalyzer/Checkers/SimpleStreamChecker.cpp

Show First 20 Lines • Show All 100 Lines • ▼ Show 20 Lines bool VisitSymbol(SymbolRef sym) override {
return true; return true;
} }
}; };
} // end anonymous namespace } // end anonymous namespace
SimpleStreamChecker::SimpleStreamChecker() SimpleStreamChecker::SimpleStreamChecker()
: OpenFn("fopen"), CloseFn("fclose", 1) { : OpenFn("fopen"), CloseFn("fclose", 1) {
// Initialize the bug types. // Initialize the bug types.
DoubleCloseBugType.reset( DoubleCloseBugType = llvm::make_unique<BugType>(
new BugType(this, "Double fclose", "Unix Stream API Error")); this, "Double fclose", "Unix Stream API Error");
LeakBugType.reset( LeakBugType = llvm::make_unique<BugType>(
new BugType(this, "Resource Leak", "Unix Stream API Error")); this, "Resource Leak", "Unix Stream API Error");
// Sinks are higher importance bugs as well as calls to assert() or exit(0). // Sinks are higher importance bugs as well as calls to assert() or exit(0).
LeakBugType->setSuppressOnSink(true); LeakBugType->setSuppressOnSink(true);
} }
void SimpleStreamChecker::checkPostCall(const CallEvent &Call, void SimpleStreamChecker::checkPostCall(const CallEvent &Call,
CheckerContext &C) const { CheckerContext &C) const {
if (!Call.isGlobalCFunction()) if (!Call.isGlobalCFunction())
return; return;
▲ Show 20 Lines • Show All 150 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/StackAddrEscapeChecker.cpp

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
void StackAddrEscapeChecker::EmitStackError(CheckerContext &C, const MemRegion *R, void StackAddrEscapeChecker::EmitStackError(CheckerContext &C, const MemRegion *R,
const Expr *RetE) const { const Expr *RetE) const {
ExplodedNode *N = C.generateErrorNode(); ExplodedNode *N = C.generateErrorNode();
if (!N) if (!N)
return; return;
if (!BT_returnstack) if (!BT_returnstack)
BT_returnstack.reset( BT_returnstack = llvm::make_unique<BuiltinBug>(
new BuiltinBug(this, "Return of address to stack-allocated memory")); this, "Return of address to stack-allocated memory");
// Generate a report for this bug. // Generate a report for this bug.
SmallString<512> buf; SmallString<512> buf;
llvm::raw_svector_ostream os(buf); llvm::raw_svector_ostream os(buf);
SourceRange range = genName(os, R, C.getASTContext()); SourceRange range = genName(os, R, C.getASTContext());
os << " returned to caller"; os << " returned to caller";
auto report = llvm::make_unique<BugReport>(*BT_returnstack, os.str(), N); auto report = llvm::make_unique<BugReport>(*BT_returnstack, os.str(), N);
report->addRange(RetE->getSourceRange()); report->addRange(RetE->getSourceRange());
▲ Show 20 Lines • Show All 107 Lines • ▼ Show 20 Lines if (cb.V.empty())
return; return;
// Generate an error node. // Generate an error node.
ExplodedNode *N = Ctx.generateNonFatalErrorNode(state); ExplodedNode *N = Ctx.generateNonFatalErrorNode(state);
if (!N) if (!N)
return; return;
if (!BT_stackleak) if (!BT_stackleak)
BT_stackleak.reset( BT_stackleak = llvm::make_unique<BuiltinBug>(
new BuiltinBug(this, "Stack address stored into global variable", this, "Stack address stored into global variable",
"Stack address was saved into a global variable. " "Stack address was saved into a global variable. "
"This is dangerous because the address will become " "This is dangerous because the address will become "
"invalid after returning from the function")); "invalid after returning from the function");
for (unsigned i = 0, e = cb.V.size(); i != e; ++i) { for (unsigned i = 0, e = cb.V.size(); i != e; ++i) {
// Generate a report for this bug. // Generate a report for this bug.
SmallString<512> buf; SmallString<512> buf;
llvm::raw_svector_ostream os(buf); llvm::raw_svector_ostream os(buf);
SourceRange range = genName(os, cb.V[i].second, Ctx.getASTContext()); SourceRange range = genName(os, cb.V[i].second, Ctx.getASTContext());
os << " is still referred to by the "; os << " is still referred to by the ";
if (isa<StaticGlobalSpaceRegion>(cb.V[i].first->getMemorySpace())) if (isa<StaticGlobalSpaceRegion>(cb.V[i].first->getMemorySpace()))
Show All 18 Lines

lib/StaticAnalyzer/Checkers/StreamChecker.cpp

Show First 20 Lines • Show All 266 Lines • ▼ Show 20 Lines if (!CI)
return; return;
int64_t x = CI->getValue().getSExtValue(); int64_t x = CI->getValue().getSExtValue();
if (x >= 0 && x <= 2) if (x >= 0 && x <= 2)
return; return;
if (ExplodedNode *N = C.generateNonFatalErrorNode(state)) { if (ExplodedNode *N = C.generateNonFatalErrorNode(state)) {
if (!BT_illegalwhence) if (!BT_illegalwhence)
BT_illegalwhence.reset( BT_illegalwhence = llvm::make_unique<BuiltinBug>(
new BuiltinBug(this, "Illegal whence argument", this, "Illegal whence argument",
"The whence argument to fseek() should be " "The whence argument to fseek() should be "
"SEEK_SET, SEEK_END, or SEEK_CUR.")); "SEEK_SET, SEEK_END, or SEEK_CUR.");
C.emitReport(llvm::make_unique<BugReport>( C.emitReport(llvm::make_unique<BugReport>(
*BT_illegalwhence, BT_illegalwhence->getDescription(), N)); *BT_illegalwhence, BT_illegalwhence->getDescription(), N));
} }
} }
void StreamChecker::Ftell(CheckerContext &C, const CallExpr *CE) const { void StreamChecker::Ftell(CheckerContext &C, const CallExpr *CE) const {
ProgramStateRef state = C.getState(); ProgramStateRef state = C.getState();
if (!CheckNullStream(state->getSVal(CE->getArg(0), C.getLocationContext()), if (!CheckNullStream(state->getSVal(CE->getArg(0), C.getLocationContext()),
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 LinesProgramStateRef StreamChecker::CheckNullStream(SVal SV, ProgramStateRef state,
ConstraintManager &CM = C.getConstraintManager(); ConstraintManager &CM = C.getConstraintManager();
ProgramStateRef stateNotNull, stateNull; ProgramStateRef stateNotNull, stateNull;
std::tie(stateNotNull, stateNull) = CM.assumeDual(state, *DV); std::tie(stateNotNull, stateNull) = CM.assumeDual(state, *DV);
if (!stateNotNull && stateNull) { if (!stateNotNull && stateNull) {
if (ExplodedNode *N = C.generateErrorNode(stateNull)) { if (ExplodedNode *N = C.generateErrorNode(stateNull)) {
if (!BT_nullfp) if (!BT_nullfp)
BT_nullfp.reset(new BuiltinBug(this, "NULL stream pointer", BT_nullfp = llvm::make_unique<BuiltinBug>(this, "NULL stream pointer",
"Stream pointer might be NULL.")); "Stream pointer might be NULL.");
C.emitReport(llvm::make_unique<BugReport>( C.emitReport(llvm::make_unique<BugReport>(
*BT_nullfp, BT_nullfp->getDescription(), N)); *BT_nullfp, BT_nullfp->getDescription(), N));
} }
return nullptr; return nullptr;
} }
return stateNotNull; return stateNotNull;
} }
Show All 12 Lines if (!SS)
return state; return state;
// Check: Double close a File Descriptor could cause undefined behaviour. // Check: Double close a File Descriptor could cause undefined behaviour.
// Conforming to man-pages // Conforming to man-pages
if (SS->isClosed()) { if (SS->isClosed()) {
ExplodedNode *N = C.generateErrorNode(); ExplodedNode *N = C.generateErrorNode();
if (N) { if (N) {
if (!BT_doubleclose) if (!BT_doubleclose)
BT_doubleclose.reset(new BuiltinBug( BT_doubleclose = llvm::make_unique<BuiltinBug>(
this, "Double fclose", "Try to close a file Descriptor already" this, "Double fclose", "Try to close a file Descriptor already"
" closed. Cause undefined behaviour.")); " closed. Cause undefined behaviour.");
C.emitReport(llvm::make_unique<BugReport>( C.emitReport(llvm::make_unique<BugReport>(
*BT_doubleclose, BT_doubleclose->getDescription(), N)); *BT_doubleclose, BT_doubleclose->getDescription(), N));
} }
return nullptr; return nullptr;
} }
// Close the File Descriptor. // Close the File Descriptor.
return state->set<StreamMap>(Sym, StreamState::getClosed(CE)); return state->set<StreamMap>(Sym, StreamState::getClosed(CE));
Show All 9 Lines for (SymbolReaper::dead_iterator I = SymReaper.dead_begin(),
const StreamState *SS = state->get<StreamMap>(Sym); const StreamState *SS = state->get<StreamMap>(Sym);
if (!SS) if (!SS)
continue; continue;
if (SS->isOpened()) { if (SS->isOpened()) {
ExplodedNode *N = C.generateErrorNode(); ExplodedNode *N = C.generateErrorNode();
if (N) { if (N) {
if (!BT_ResourceLeak) if (!BT_ResourceLeak)
BT_ResourceLeak.reset(new BuiltinBug( BT_ResourceLeak = llvm::make_unique<BuiltinBug>(
this, "Resource Leak", this, "Resource Leak",
"Opened File never closed. Potential Resource leak.")); "Opened File never closed. Potential Resource leak.");
C.emitReport(llvm::make_unique<BugReport>( C.emitReport(llvm::make_unique<BugReport>(
*BT_ResourceLeak, BT_ResourceLeak->getDescription(), N)); *BT_ResourceLeak, BT_ResourceLeak->getDescription(), N));
} }
} }
} }
} }
void ento::registerStreamChecker(CheckerManager &mgr) { void ento::registerStreamChecker(CheckerManager &mgr) {
mgr.registerChecker<StreamChecker>(); mgr.registerChecker<StreamChecker>();
} }

lib/StaticAnalyzer/Checkers/TaintTesterChecker.cpp

Show All 32 Lines
public: public:
void checkPostStmt(const Expr *E, CheckerContext &C) const; void checkPostStmt(const Expr *E, CheckerContext &C) const;
}; };
} }
inline void TaintTesterChecker::initBugType() const { inline void TaintTesterChecker::initBugType() const {
if (!BT) if (!BT)
BT.reset(new BugType(this, "Tainted data", "General")); BT = llvm::make_unique<BugType>(this, "Tainted data", "General");
} }
void TaintTesterChecker::checkPostStmt(const Expr *E, void TaintTesterChecker::checkPostStmt(const Expr *E,
CheckerContext &C) const { CheckerContext &C) const {
ProgramStateRef State = C.getState(); ProgramStateRef State = C.getState();
if (!State) if (!State)
return; return;
Show All 13 Lines

lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp

Show First 20 Lines • Show All 162 Lines • ▼ Show 20 Linesbool TestAfterDivZeroChecker::hasDivZeroMap(SVal Var,
ZeroState ZS(SR, C.getBlockID(), C.getStackFrame()); ZeroState ZS(SR, C.getBlockID(), C.getStackFrame());
return C.getState()->contains<DivZeroMap>(ZS); return C.getState()->contains<DivZeroMap>(ZS);
} }
void TestAfterDivZeroChecker::reportBug(SVal Val, CheckerContext &C) const { void TestAfterDivZeroChecker::reportBug(SVal Val, CheckerContext &C) const {
if (ExplodedNode *N = C.generateErrorNode(C.getState())) { if (ExplodedNode *N = C.generateErrorNode(C.getState())) {
if (!DivZeroBug) if (!DivZeroBug)
DivZeroBug.reset(new BuiltinBug(this, "Division by zero")); DivZeroBug = llvm::make_unique<BuiltinBug>(this, "Division by zero");
auto R = llvm::make_unique<BugReport>( auto R = llvm::make_unique<BugReport>(
*DivZeroBug, "Value being compared against zero has already been used " *DivZeroBug, "Value being compared against zero has already been used "
"for division", "for division",
N); N);
R->addVisitor(llvm::make_unique<DivisionBRVisitor>(Val.getAsSymbol(), R->addVisitor(llvm::make_unique<DivisionBRVisitor>(Val.getAsSymbol(),
C.getStackFrame())); C.getStackFrame()));
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/UndefBranchChecker.cpp

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Linesvoid UndefBranchChecker::checkBranchCondition(const Stmt *Condition,
CheckerContext &Ctx) const { CheckerContext &Ctx) const {
SVal X = Ctx.getState()->getSVal(Condition, Ctx.getLocationContext()); SVal X = Ctx.getState()->getSVal(Condition, Ctx.getLocationContext());
if (X.isUndef()) { if (X.isUndef()) {
// Generate a sink node, which implicitly marks both outgoing branches as // Generate a sink node, which implicitly marks both outgoing branches as
// infeasible. // infeasible.
ExplodedNode *N = Ctx.generateErrorNode(); ExplodedNode *N = Ctx.generateErrorNode();
if (N) { if (N) {
if (!BT) if (!BT)
BT.reset(new BuiltinBug( BT = llvm::make_unique<BuiltinBug>(
this, "Branch condition evaluates to a garbage value")); this, "Branch condition evaluates to a garbage value");
// What's going on here: we want to highlight the subexpression of the // What's going on here: we want to highlight the subexpression of the
// condition that is the most likely source of the "uninitialized // condition that is the most likely source of the "uninitialized
// branch condition." We do a recursive walk of the condition's // branch condition." We do a recursive walk of the condition's
// subexpressions and roughly look for the most nested subexpression // subexpressions and roughly look for the most nested subexpression
// that binds to Undefined. We then highlight that expression's range. // that binds to Undefined. We then highlight that expression's range.
// Get the predecessor node and check if is a PostStmt with the Stmt // Get the predecessor node and check if is a PostStmt with the Stmt
Show All 33 Lines

lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines for (; I != E; ++I) {
if (VD->hasAttr<BlocksAttr>() || !VD->hasLocalStorage()) if (VD->hasAttr<BlocksAttr>() || !VD->hasLocalStorage())
continue; continue;
// Get the VarRegion associated with VD in the local stack frame. // Get the VarRegion associated with VD in the local stack frame.
if (Optional<UndefinedVal> V = if (Optional<UndefinedVal> V =
state->getSVal(I.getOriginalRegion()).getAs<UndefinedVal>()) { state->getSVal(I.getOriginalRegion()).getAs<UndefinedVal>()) {
if (ExplodedNode *N = C.generateErrorNode()) { if (ExplodedNode *N = C.generateErrorNode()) {
if (!BT) if (!BT)
BT.reset( BT = llvm::make_unique<BuiltinBug>(
new BuiltinBug(this, "uninitialized variable captured by block")); this, "uninitialized variable captured by block");
// Generate a bug report. // Generate a bug report.
SmallString<128> buf; SmallString<128> buf;
llvm::raw_svector_ostream os(buf); llvm::raw_svector_ostream os(buf);
os << "Variable '" << VD->getName() os << "Variable '" << VD->getName()
<< "' is uninitialized when captured by block"; << "' is uninitialized when captured by block";
Show All 16 Lines

lib/StaticAnalyzer/Checkers/UndefResultChecker.cpp

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Lines if (const FunctionDecl *EnclosingFunctionDecl =
return; return;
// Generate an error node. // Generate an error node.
ExplodedNode *N = C.generateErrorNode(); ExplodedNode *N = C.generateErrorNode();
if (!N) if (!N)
return; return;
if (!BT) if (!BT)
BT.reset( BT = llvm::make_unique<BuiltinBug>(
new BuiltinBug(this, "Result of operation is garbage or undefined")); this, "Result of operation is garbage or undefined");
SmallString<256> sbuf; SmallString<256> sbuf;
llvm::raw_svector_ostream OS(sbuf); llvm::raw_svector_ostream OS(sbuf);
const Expr *Ex = nullptr; const Expr *Ex = nullptr;
bool isLeft = true; bool isLeft = true;
if (state->getSVal(B->getLHS(), LCtx).isUndef()) { if (state->getSVal(B->getLHS(), LCtx).isUndef()) {
Ex = B->getLHS()->IgnoreParenCasts(); Ex = B->getLHS()->IgnoreParenCasts();
Show All 36 Lines

lib/StaticAnalyzer/Checkers/UndefinedArraySubscriptChecker.cpp

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 LinesUndefinedArraySubscriptChecker::checkPreStmt(const ArraySubscriptExpr *A,
if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(D)) if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(D))
if (Ctor->isDefaulted()) if (Ctor->isDefaulted())
return; return;
ExplodedNode *N = C.generateErrorNode(); ExplodedNode *N = C.generateErrorNode();
if (!N) if (!N)
return; return;
if (!BT) if (!BT)
BT.reset(new BuiltinBug(this, "Array subscript is undefined")); BT = llvm::make_unique<BuiltinBug>(this, "Array subscript is undefined");
// Generate a report for this bug. // Generate a report for this bug.
auto R = llvm::make_unique<BugReport>(*BT, BT->getName(), N); auto R = llvm::make_unique<BugReport>(*BT, BT->getName(), N);
R->addRange(A->getIdx()->getSourceRange()); R->addRange(A->getIdx()->getSourceRange());
bugreporter::trackNullOrUndefValue(N, A->getIdx(), *R); bugreporter::trackNullOrUndefValue(N, A->getIdx(), *R);
C.emitReport(std::move(R)); C.emitReport(std::move(R));
} }
void ento::registerUndefinedArraySubscriptChecker(CheckerManager &mgr) { void ento::registerUndefinedArraySubscriptChecker(CheckerManager &mgr) {
mgr.registerChecker<UndefinedArraySubscriptChecker>(); mgr.registerChecker<UndefinedArraySubscriptChecker>();
} }

lib/StaticAnalyzer/Checkers/UndefinedAssignmentChecker.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Linesvoid UndefinedAssignmentChecker::checkBind(SVal location, SVal val,
ExplodedNode *N = C.generateErrorNode(); ExplodedNode *N = C.generateErrorNode();
if (!N) if (!N)
return; return;
const char *str = "Assigned value is garbage or undefined"; const char *str = "Assigned value is garbage or undefined";
if (!BT) if (!BT)
BT.reset(new BuiltinBug(this, str)); BT = llvm::make_unique<BuiltinBug>(this, str);
// Generate a report for this bug. // Generate a report for this bug.
const Expr *ex = nullptr; const Expr *ex = nullptr;
while (StoreE) { while (StoreE) {
if (const BinaryOperator *B = dyn_cast<BinaryOperator>(StoreE)) { if (const BinaryOperator *B = dyn_cast<BinaryOperator>(StoreE)) {
if (B->isCompoundAssignmentOp()) { if (B->isCompoundAssignmentOp()) {
ProgramStateRef state = C.getState(); ProgramStateRef state = C.getState();
Show All 31 Lines

lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Linesprivate:
void BasicAllocationCheck(CheckerContext &C, void BasicAllocationCheck(CheckerContext &C,
const CallExpr *CE, const CallExpr *CE,
const unsigned numArgs, const unsigned numArgs,
const unsigned sizeArg, const unsigned sizeArg,
const char *fn) const; const char *fn) const;
void LazyInitialize(std::unique_ptr<BugType> &BT, const char *name) const { void LazyInitialize(std::unique_ptr<BugType> &BT, const char *name) const {
if (BT) if (BT)
return; return;
BT.reset(new BugType(this, name, categories::UnixAPI)); BT = llvm::make_unique<BugType>(this, name, categories::UnixAPI);
} }
void ReportOpenBug(CheckerContext &C, void ReportOpenBug(CheckerContext &C,
ProgramStateRef State, ProgramStateRef State,
const char *Msg, const char *Msg,
SourceRange SR) const; SourceRange SR) const;
}; };
} //end anonymous namespace } //end anonymous namespace
▲ Show 20 Lines • Show All 376 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/VLASizeChecker.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Linesvoid VLASizeChecker::reportBug(VLASize_Kind Kind,
ProgramStateRef State, ProgramStateRef State,
CheckerContext &C) const { CheckerContext &C) const {
// Generate an error node. // Generate an error node.
ExplodedNode *N = C.generateErrorNode(State); ExplodedNode *N = C.generateErrorNode(State);
if (!N) if (!N)
return; return;
if (!BT) if (!BT)
BT.reset(new BuiltinBug( BT = llvm::make_unique<BuiltinBug>(
this, "Dangerous variable-length array (VLA) declaration")); this, "Dangerous variable-length array (VLA) declaration");
SmallString<256> buf; SmallString<256> buf;
llvm::raw_svector_ostream os(buf); llvm::raw_svector_ostream os(buf);
os << "Declared variable-length array (VLA) "; os << "Declared variable-length array (VLA) ";
switch (Kind) { switch (Kind) {
case VLA_Garbage: case VLA_Garbage:
os << "uses a garbage value as its size"; os << "uses a garbage value as its size";
break; break;
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/ValistChecker.cpp

Show First 20 Lines • Show All 248 Lines • ▼ Show 20 Lines
void ValistChecker::reportUninitializedAccess(const MemRegion *VAList, void ValistChecker::reportUninitializedAccess(const MemRegion *VAList,
StringRef Msg, StringRef Msg,
CheckerContext &C) const { CheckerContext &C) const {
if (!ChecksEnabled[CK_Uninitialized]) if (!ChecksEnabled[CK_Uninitialized])
return; return;
if (ExplodedNode *N = C.generateErrorNode()) { if (ExplodedNode *N = C.generateErrorNode()) {
if (!BT_uninitaccess) if (!BT_uninitaccess)
BT_uninitaccess.reset(new BugType(CheckNames[CK_Uninitialized], BT_uninitaccess = llvm::make_unique<BugType>(CheckNames[CK_Uninitialized],
"Uninitialized va_list", "Uninitialized va_list",
categories::MemoryError)); 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));
C.emitReport(std::move(R)); C.emitReport(std::move(R));
} }
} }
void ValistChecker::reportLeakedVALists(const RegionVector &LeakedVALists, void ValistChecker::reportLeakedVALists(const RegionVector &LeakedVALists,
StringRef Msg1, StringRef Msg2, StringRef Msg1, StringRef Msg2,
CheckerContext &C, ExplodedNode *N, CheckerContext &C, ExplodedNode *N,
bool ForceReport) const { bool ForceReport) const {
if (!(ChecksEnabled[CK_Unterminated] || if (!(ChecksEnabled[CK_Unterminated] ||
(ChecksEnabled[CK_Uninitialized] && ForceReport))) (ChecksEnabled[CK_Uninitialized] && ForceReport)))
return; return;
for (auto Reg : LeakedVALists) { for (auto Reg : LeakedVALists) {
if (!BT_leakedvalist) { if (!BT_leakedvalist) {
BT_leakedvalist.reset(new BugType(CheckNames[CK_Unterminated], BT_leakedvalist = llvm::make_unique<BugType>(CheckNames[CK_Unterminated],
"Leaked va_list", "Leaked va_list",
categories::MemoryError)); categories::MemoryError);
BT_leakedvalist->setSuppressOnSink(true); BT_leakedvalist->setSuppressOnSink(true);
} }
const ExplodedNode *StartNode = getStartCallSite(N, Reg); const ExplodedNode *StartNode = getStartCallSite(N, Reg);
PathDiagnosticLocation LocUsedForUniqueing; PathDiagnosticLocation LocUsedForUniqueing;
if (const Stmt *StartCallStmt = PathDiagnosticLocation::getStmt(StartNode)) if (const Stmt *StartCallStmt = PathDiagnosticLocation::getStmt(StartNode))
LocUsedForUniqueing = PathDiagnosticLocation::createBegin( LocUsedForUniqueing = PathDiagnosticLocation::createBegin(
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

lib/StaticAnalyzer/Checkers/VforkChecker.cpp

Show First 20 Lines • Show All 116 Lines • ▼ Show 20 Linesbool VforkChecker::isCallWhitelisted(const IdentifierInfo *II,
return VforkWhitelist.count(II); return VforkWhitelist.count(II);
} }
void VforkChecker::reportBug(const char *What, CheckerContext &C, void VforkChecker::reportBug(const char *What, CheckerContext &C,
const char *Details) const { const char *Details) const {
if (ExplodedNode *N = C.generateErrorNode(C.getState())) { if (ExplodedNode *N = C.generateErrorNode(C.getState())) {
if (!BT) if (!BT)
BT.reset(new BuiltinBug(this, BT = llvm::make_unique<BuiltinBug>(this,
"Dangerous construct in a vforked process")); "Dangerous construct in a vforked process");
SmallString<256> buf; SmallString<256> buf;
llvm::raw_svector_ostream os(buf); llvm::raw_svector_ostream os(buf);
os << What << " is prohibited after a successful vfork"; os << What << " is prohibited after a successful vfork";
if (Details) if (Details)
os << "; " << Details; os << "; " << Details;
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

lib/Tooling/CommonOptionsParser.cpp

Show First 20 Lines • Show All 133 Lines • ▼ Show 20 Lines if (!BuildPath.empty()) {
CompilationDatabase::autoDetectFromDirectory(BuildPath, ErrorMessage); CompilationDatabase::autoDetectFromDirectory(BuildPath, ErrorMessage);
} else { } else {
Compilations = CompilationDatabase::autoDetectFromSource(SourcePaths[0], Compilations = CompilationDatabase::autoDetectFromSource(SourcePaths[0],
ErrorMessage); ErrorMessage);
} }
if (!Compilations) { if (!Compilations) {
llvm::errs() << "Error while trying to load a compilation database:\n" llvm::errs() << "Error while trying to load a compilation database:\n"
<< ErrorMessage << "Running without flags.\n"; << ErrorMessage << "Running without flags.\n";
Compilations.reset( Compilations = llvm::make_unique<FixedCompilationDatabase>(
new FixedCompilationDatabase(".", std::vector<std::string>())); ".", std::vector<std::string>());
} }
} }
auto AdjustingCompilations = auto AdjustingCompilations =
llvm::make_unique<ArgumentsAdjustingCompilations>( llvm::make_unique<ArgumentsAdjustingCompilations>(
std::move(Compilations)); std::move(Compilations));
AdjustingCompilations->appendArgumentsAdjuster( AdjustingCompilations->appendArgumentsAdjuster(
getInsertArgumentAdjuster(ArgsBefore, ArgumentInsertPosition::BEGIN)); getInsertArgumentAdjuster(ArgsBefore, ArgumentInsertPosition::BEGIN));
AdjustingCompilations->appendArgumentsAdjuster( AdjustingCompilations->appendArgumentsAdjuster(
getInsertArgumentAdjuster(ArgsAfter, ArgumentInsertPosition::END)); getInsertArgumentAdjuster(ArgsAfter, ArgumentInsertPosition::END));
Compilations = std::move(AdjustingCompilations); Compilations = std::move(AdjustingCompilations);
} }

lib/Tooling/CompilationDatabase.cpp

Show First 20 Lines • Show All 294 Lines • ▼ Show 20 LinesFixedCompilationDatabase::loadFromCommandLine(int &Argc,
if (DoubleDash == Argv + Argc) if (DoubleDash == Argv + Argc)
return nullptr; return nullptr;
std::vector<const char *> CommandLine(DoubleDash + 1, Argv + Argc); std::vector<const char *> CommandLine(DoubleDash + 1, Argv + Argc);
Argc = DoubleDash - Argv; Argc = DoubleDash - Argv;
std::vector<std::string> StrippedArgs; std::vector<std::string> StrippedArgs;
if (!stripPositionalArgs(CommandLine, StrippedArgs, ErrorMsg)) if (!stripPositionalArgs(CommandLine, StrippedArgs, ErrorMsg))
return nullptr; return nullptr;
return std::unique_ptr<FixedCompilationDatabase>( return llvm::make_unique<FixedCompilationDatabase>(
new FixedCompilationDatabase(Directory, StrippedArgs)); Directory, StrippedArgs);
} }
FixedCompilationDatabase:: FixedCompilationDatabase::
FixedCompilationDatabase(Twine Directory, ArrayRef<std::string> CommandLine) { FixedCompilationDatabase(Twine Directory, ArrayRef<std::string> CommandLine) {
std::vector<std::string> ToolCommandLine(1, "clang-tool"); std::vector<std::string> ToolCommandLine(1, "clang-tool");
ToolCommandLine.insert(ToolCommandLine.end(), ToolCommandLine.insert(ToolCommandLine.end(),
CommandLine.begin(), CommandLine.end()); CommandLine.begin(), CommandLine.end());
CompileCommands.emplace_back(Directory, StringRef(), CompileCommands.emplace_back(Directory, StringRef(),
Show All 32 Lines

tools/arcmt-test/arcmt-test.cpp

Show First 20 Lines • Show All 177 Lines • ▼ Show 20 Linesstatic bool performTransformations(StringRef resourcesPath,
std::vector<TransformFn> std::vector<TransformFn>
transforms = arcmt::getAllTransformations(origCI.getLangOpts()->getGC(), transforms = arcmt::getAllTransformations(origCI.getLangOpts()->getGC(),
origCI.getMigratorOpts().NoFinalizeRemoval); origCI.getMigratorOpts().NoFinalizeRemoval);
assert(!transforms.empty()); assert(!transforms.empty());
std::unique_ptr<PrintTransforms> transformPrinter; std::unique_ptr<PrintTransforms> transformPrinter;
if (OutputTransformations) if (OutputTransformations)
transformPrinter.reset(new PrintTransforms(llvm::outs())); transformPrinter = llvm::make_unique<PrintTransforms>(llvm::outs());
for (unsigned i=0, e = transforms.size(); i != e; ++i) { for (unsigned i=0, e = transforms.size(); i != e; ++i) {
bool err = migration.applyTransform(transforms[i], transformPrinter.get()); bool err = migration.applyTransform(transforms[i], transformPrinter.get());
if (err) return true; if (err) return true;
if (VerboseOpt) { if (VerboseOpt) {
if (i == e-1) if (i == e-1)
llvm::errs() << "\n##### FINAL RESULT #####\n"; llvm::errs() << "\n##### FINAL RESULT #####\n";
▲ Show 20 Lines • Show All 183 Lines • Show Last 20 Lines

tools/c-index-test/core_main.cpp

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Linesclass PrintIndexDataConsumer : public IndexDataConsumer {
raw_ostream &OS; raw_ostream &OS;
std::unique_ptr<CodegenNameGenerator> CGNameGen; std::unique_ptr<CodegenNameGenerator> CGNameGen;
public: public:
PrintIndexDataConsumer(raw_ostream &OS) : OS(OS) { PrintIndexDataConsumer(raw_ostream &OS) : OS(OS) {
} }
void initialize(ASTContext &Ctx) override { void initialize(ASTContext &Ctx) override {
CGNameGen.reset(new CodegenNameGenerator(Ctx)); CGNameGen = llvm::make_unique<CodegenNameGenerator>(Ctx);
} }
bool handleDeclOccurence(const Decl *D, SymbolRoleSet Roles, bool handleDeclOccurence(const Decl *D, SymbolRoleSet Roles,
ArrayRef<SymbolRelation> Relations, ArrayRef<SymbolRelation> Relations,
FileID FID, unsigned Offset, FileID FID, unsigned Offset,
ASTNodeInfo ASTNode) override { ASTNodeInfo ASTNode) override {
ASTContext &Ctx = D->getASTContext(); ASTContext &Ctx = D->getASTContext();
SourceManager &SM = Ctx.getSourceManager(); SourceManager &SM = Ctx.getSourceManager();
▲ Show 20 Lines • Show All 215 Lines • Show Last 20 Lines

tools/clang-check/ClangCheck.cpp

Show First 20 Lines • Show All 119 Lines • ▼ Show 20 Linespublic:
bool IncludeInDiagnosticCounts() const override { return false; } bool IncludeInDiagnosticCounts() const override { return false; }
}; };
/// \brief Subclasses \c clang::FixItAction so that we can install the custom /// \brief Subclasses \c clang::FixItAction so that we can install the custom
/// \c FixItRewriter. /// \c FixItRewriter.
class FixItAction : public clang::FixItAction { class FixItAction : public clang::FixItAction {
public: public:
bool BeginSourceFileAction(clang::CompilerInstance& CI) override { bool BeginSourceFileAction(clang::CompilerInstance& CI) override {
FixItOpts.reset(new FixItOptions); FixItOpts = llvm::make_unique<FixItOptions>();
Rewriter.reset(new FixItRewriter(CI.getDiagnostics(), CI.getSourceManager(), Rewriter = llvm::make_unique<FixItRewriter>(CI.getDiagnostics(), CI.getSourceManager(),
CI.getLangOpts(), FixItOpts.get())); CI.getLangOpts(), FixItOpts.get());
return true; return true;
} }
}; };
class ClangCheckActionFactory { class ClangCheckActionFactory {
public: public:
std::unique_ptr<clang::ASTConsumer> newASTConsumer() { std::unique_ptr<clang::ASTConsumer> newASTConsumer() {
if (ASTList) if (ASTList)
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

unittests/ASTMatchers/Dynamic/RegistryTest.cpp

Show First 20 Lines • Show All 389 Lines • ▼ Show 20 Lines
} }
TEST_F(RegistryTest, Errors) { TEST_F(RegistryTest, Errors) {
// Incorrect argument count. // Incorrect argument count.
std::unique_ptr<Diagnostics> Error(new Diagnostics()); std::unique_ptr<Diagnostics> Error(new Diagnostics());
EXPECT_TRUE(constructMatcher("hasInitializer", Error.get()).isNull()); EXPECT_TRUE(constructMatcher("hasInitializer", Error.get()).isNull());
EXPECT_EQ("Incorrect argument count. (Expected = 1) != (Actual = 0)", EXPECT_EQ("Incorrect argument count. (Expected = 1) != (Actual = 0)",
Error->toString()); Error->toString());
Error.reset(new Diagnostics()); Error = llvm::make_unique<Diagnostics>();
EXPECT_TRUE(constructMatcher("isArrow", StringRef(), Error.get()).isNull()); EXPECT_TRUE(constructMatcher("isArrow", StringRef(), Error.get()).isNull());
EXPECT_EQ("Incorrect argument count. (Expected = 0) != (Actual = 1)", EXPECT_EQ("Incorrect argument count. (Expected = 0) != (Actual = 1)",
Error->toString()); Error->toString());
Error.reset(new Diagnostics()); Error = llvm::make_unique<Diagnostics>();
EXPECT_TRUE(constructMatcher("anyOf", Error.get()).isNull()); EXPECT_TRUE(constructMatcher("anyOf", Error.get()).isNull());
EXPECT_EQ("Incorrect argument count. (Expected = (2, )) != (Actual = 0)", EXPECT_EQ("Incorrect argument count. (Expected = (2, )) != (Actual = 0)",
Error->toString()); Error->toString());
Error.reset(new Diagnostics()); Error = llvm::make_unique<Diagnostics>();
EXPECT_TRUE(constructMatcher("unless", StringRef(), StringRef(), EXPECT_TRUE(constructMatcher("unless", StringRef(), StringRef(),
Error.get()).isNull()); Error.get()).isNull());
EXPECT_EQ("Incorrect argument count. (Expected = (1, 1)) != (Actual = 2)", EXPECT_EQ("Incorrect argument count. (Expected = (1, 1)) != (Actual = 2)",
Error->toString()); Error->toString());
// Bad argument type // Bad argument type
Error.reset(new Diagnostics()); Error = llvm::make_unique<Diagnostics>();
EXPECT_TRUE(constructMatcher("ofClass", StringRef(), Error.get()).isNull()); EXPECT_TRUE(constructMatcher("ofClass", StringRef(), Error.get()).isNull());
EXPECT_EQ("Incorrect type for arg 1. (Expected = Matcher<CXXRecordDecl>) != " EXPECT_EQ("Incorrect type for arg 1. (Expected = Matcher<CXXRecordDecl>) != "
"(Actual = String)", "(Actual = String)",
Error->toString()); Error->toString());
Error.reset(new Diagnostics()); Error = llvm::make_unique<Diagnostics>();
EXPECT_TRUE( EXPECT_TRUE(
constructMatcher("cxxRecordDecl", constructMatcher("cxxRecordDecl"), constructMatcher("cxxRecordDecl", constructMatcher("cxxRecordDecl"),
constructMatcher("parameterCountIs", 3), Error.get()) constructMatcher("parameterCountIs", 3), Error.get())
.isNull()); .isNull());
EXPECT_EQ("Incorrect type for arg 2. (Expected = Matcher<CXXRecordDecl>) != " EXPECT_EQ("Incorrect type for arg 2. (Expected = Matcher<CXXRecordDecl>) != "
"(Actual = Matcher<FunctionDecl|FunctionProtoType>)", "(Actual = Matcher<FunctionDecl|FunctionProtoType>)",
Error->toString()); Error->toString());
// Bad argument type with variadic. // Bad argument type with variadic.
Error.reset(new Diagnostics()); Error = llvm::make_unique<Diagnostics>();
EXPECT_TRUE(constructMatcher("anyOf", StringRef(), StringRef(), EXPECT_TRUE(constructMatcher("anyOf", StringRef(), StringRef(),
Error.get()).isNull()); Error.get()).isNull());
EXPECT_EQ( EXPECT_EQ(
"Incorrect type for arg 1. (Expected = Matcher<>) != (Actual = String)", "Incorrect type for arg 1. (Expected = Matcher<>) != (Actual = String)",
Error->toString()); Error->toString());
Error.reset(new Diagnostics()); Error = llvm::make_unique<Diagnostics>();
EXPECT_TRUE(constructMatcher( EXPECT_TRUE(constructMatcher(
"cxxRecordDecl", "cxxRecordDecl",
constructMatcher("allOf", constructMatcher("allOf",
constructMatcher("isDerivedFrom", StringRef("FOO")), constructMatcher("isDerivedFrom", StringRef("FOO")),
constructMatcher("isArrow")), constructMatcher("isArrow")),
Error.get()).isNull()); Error.get()).isNull());
EXPECT_EQ("Incorrect type for arg 1. " EXPECT_EQ("Incorrect type for arg 1. "
"(Expected = Matcher<CXXRecordDecl>) != " "(Expected = Matcher<CXXRecordDecl>) != "
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

unittests/libclang/LibclangTest.cpp

Show First 20 Lines • Show All 392 Lines • ▼ Show 20 Linespublic:
} }
void MapUnsavedFile(std::string Filename, const std::string &Contents) { void MapUnsavedFile(std::string Filename, const std::string &Contents) {
if (!llvm::sys::path::is_absolute(Filename)) { if (!llvm::sys::path::is_absolute(Filename)) {
llvm::SmallString<256> Path(TestDir); llvm::SmallString<256> Path(TestDir);
llvm::sys::path::append(Path, Filename); llvm::sys::path::append(Path, Filename);
Filename = Path.str(); Filename = Path.str();
} }
auto it = UnsavedFileContents.insert(std::make_pair( auto it = UnsavedFileContents.insert(std::make_pair(
fixed_addr_string(new std::string(Filename)), llvm::make_unique<std::string>(Filename),
fixed_addr_string(new std::string(Contents)))); llvm::make_unique<std::string>(Contents)));
UnsavedFiles.push_back({ UnsavedFiles.push_back({
it.first->first->c_str(), // filename it.first->first->c_str(), // filename
it.first->second->c_str(), // contents it.first->second->c_str(), // contents
it.first->second->size() // length it.first->second->size() // length
}); });
} }
template<typename F> template<typename F>
void Traverse(const F &TraversalFunctor) { void Traverse(const F &TraversalFunctor) {
▲ Show 20 Lines • Show All 164 Lines • Show Last 20 Lines