r327309 - [analyzer] Move the GCDAsyncSemaphoreChecker to optin.performance
George Karpenkov via cfe-commits
cfe-commits at lists.llvm.org
Mon Mar 12 11:27:36 PDT 2018
Author: george.karpenkov
Date: Mon Mar 12 11:27:36 2018
New Revision: 327309
URL: http://llvm.org/viewvc/llvm-project?rev=327309&view=rev
Log:
[analyzer] Move the GCDAsyncSemaphoreChecker to optin.performance
rdar://38383753
Differential Revision: https://reviews.llvm.org/D44228
Added:
cfe/trunk/lib/StaticAnalyzer/Checkers/GCDAntipatternChecker.cpp
- copied, changed from r327294, cfe/trunk/lib/StaticAnalyzer/Checkers/GCDAsyncSemaphoreChecker.cpp
cfe/trunk/test/Analysis/gcdantipatternchecker_test.m
- copied, changed from r327294, cfe/trunk/test/Analysis/gcdasyncsemaphorechecker_test.m
Removed:
cfe/trunk/lib/StaticAnalyzer/Checkers/GCDAsyncSemaphoreChecker.cpp
cfe/trunk/test/Analysis/gcdasyncsemaphorechecker_test.m
Modified:
cfe/trunk/include/clang/StaticAnalyzer/Checkers/Checkers.td
cfe/trunk/lib/StaticAnalyzer/Checkers/CMakeLists.txt
Modified: cfe/trunk/include/clang/StaticAnalyzer/Checkers/Checkers.td
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/StaticAnalyzer/Checkers/Checkers.td?rev=327309&r1=327308&r2=327309&view=diff
==============================================================================
--- cfe/trunk/include/clang/StaticAnalyzer/Checkers/Checkers.td (original)
+++ cfe/trunk/include/clang/StaticAnalyzer/Checkers/Checkers.td Mon Mar 12 11:27:36 2018
@@ -610,12 +610,12 @@ def ObjCSuperDeallocChecker : Checker<"S
} // end "osx.cocoa"
-let ParentPackage = OSXAlpha in {
+let ParentPackage = Performance in {
-def GCDAsyncSemaphoreChecker : Checker<"GCDAsyncSemaphore">,
- HelpText<"Checker for performance anti-pattern when using semaphors from async API">,
- DescFile<"GCDAsyncSemaphoreChecker.cpp">;
-} // end "alpha.osx"
+def GCDAntipattern : Checker<"GCDAntipattern">,
+ HelpText<"Check for performance anti-patterns when using Grand Central Dispatch">,
+ DescFile<"GCDAntipatternChecker.cpp">;
+} // end "optin.performance"
let ParentPackage = CocoaAlpha in {
Modified: cfe/trunk/lib/StaticAnalyzer/Checkers/CMakeLists.txt
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Checkers/CMakeLists.txt?rev=327309&r1=327308&r2=327309&view=diff
==============================================================================
--- cfe/trunk/lib/StaticAnalyzer/Checkers/CMakeLists.txt (original)
+++ cfe/trunk/lib/StaticAnalyzer/Checkers/CMakeLists.txt Mon Mar 12 11:27:36 2018
@@ -37,7 +37,7 @@ add_clang_library(clangStaticAnalyzerChe
DynamicTypeChecker.cpp
ExprInspectionChecker.cpp
FixedAddressChecker.cpp
- GCDAsyncSemaphoreChecker.cpp
+ GCDAntipatternChecker.cpp
GenericTaintChecker.cpp
GTestChecker.cpp
IdenticalExprChecker.cpp
Copied: cfe/trunk/lib/StaticAnalyzer/Checkers/GCDAntipatternChecker.cpp (from r327294, cfe/trunk/lib/StaticAnalyzer/Checkers/GCDAsyncSemaphoreChecker.cpp)
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Checkers/GCDAntipatternChecker.cpp?p2=cfe/trunk/lib/StaticAnalyzer/Checkers/GCDAntipatternChecker.cpp&p1=cfe/trunk/lib/StaticAnalyzer/Checkers/GCDAsyncSemaphoreChecker.cpp&r1=327294&r2=327309&rev=327309&view=diff
==============================================================================
--- cfe/trunk/lib/StaticAnalyzer/Checkers/GCDAsyncSemaphoreChecker.cpp (original)
+++ cfe/trunk/lib/StaticAnalyzer/Checkers/GCDAntipatternChecker.cpp Mon Mar 12 11:27:36 2018
@@ -1,4 +1,4 @@
-//===- GCDAsyncSemaphoreChecker.cpp -----------------------------*- C++ -*-==//
+//===- GCDAntipatternChecker.cpp ---------------------------------*- C++ -*-==//
//
// The LLVM Compiler Infrastructure
//
@@ -7,20 +7,20 @@
//
//===----------------------------------------------------------------------===//
//
-// This file defines GCDAsyncSemaphoreChecker which checks against a common
+// This file defines GCDAntipatternChecker which checks against a common
// antipattern when synchronous API is emulated from asynchronous callbacks
-// using a semaphor:
+// using a semaphore:
+//
+// dispatch_semaphore_t sema = dispatch_semaphore_create(0);
//
-// dispatch_semapshore_t sema = dispatch_semaphore_create(0);
-
// AnyCFunctionCall(^{
// // codeâ¦
-// dispatch_semapshore_signal(sema);
+// dispatch_semaphore_signal(sema);
// })
-// dispatch_semapshore_wait(sema, *)
+// dispatch_semaphore_wait(sema, *)
//
// Such code is a common performance problem, due to inability of GCD to
-// properly handle QoS when a combination of queues and semaphors is used.
+// properly handle QoS when a combination of queues and semaphores is used.
// Good code would either use asynchronous API (when available), or perform
// the necessary action in asynchronous callback.
//
@@ -37,8 +37,6 @@
#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
#include "llvm/Support/Debug.h"
-#define DEBUG_TYPE "gcdasyncsemaphorechecker"
-
using namespace clang;
using namespace ento;
using namespace ast_matchers;
@@ -47,7 +45,7 @@ namespace {
const char *WarningBinding = "semaphore_wait";
-class GCDAsyncSemaphoreChecker : public Checker<check::ASTCodeBody> {
+class GCDAntipatternChecker : public Checker<check::ASTCodeBody> {
public:
void checkASTCodeBody(const Decl *D,
AnalysisManager &AM,
@@ -56,13 +54,13 @@ public:
class Callback : public MatchFinder::MatchCallback {
BugReporter &BR;
- const GCDAsyncSemaphoreChecker *C;
+ const GCDAntipatternChecker *C;
AnalysisDeclContext *ADC;
public:
Callback(BugReporter &BR,
AnalysisDeclContext *ADC,
- const GCDAsyncSemaphoreChecker *C) : BR(BR), C(C), ADC(ADC) {}
+ const GCDAntipatternChecker *C) : BR(BR), C(C), ADC(ADC) {}
virtual void run(const MatchFinder::MatchResult &Result) override;
};
@@ -83,7 +81,7 @@ auto bindAssignmentToDecl(const char *De
declRefExpr(to(varDecl().bind(DeclName)))));
}
-void GCDAsyncSemaphoreChecker::checkASTCodeBody(const Decl *D,
+void GCDAntipatternChecker::checkASTCodeBody(const Decl *D,
AnalysisManager &AM,
BugReporter &BR) const {
@@ -93,6 +91,14 @@ void GCDAsyncSemaphoreChecker::checkASTC
if (StringRef(DeclName).startswith("test"))
return;
}
+ if (const auto *OD = dyn_cast<ObjCMethodDecl>(D)) {
+ if (const auto *CD = dyn_cast<ObjCContainerDecl>(OD->getParent())) {
+ std::string ContainerName = CD->getNameAsString();
+ StringRef CN(ContainerName);
+ if (CN.contains_lower("test") || CN.contains_lower("mock"))
+ return;
+ }
+ }
const char *SemaphoreBinding = "semaphore_name";
auto SemaphoreCreateM = callExpr(callsName("dispatch_semaphore_create"));
@@ -146,14 +152,15 @@ void Callback::run(const MatchFinder::Ma
ADC->getDecl(), C,
/*Name=*/"Semaphore performance anti-pattern",
/*Category=*/"Performance",
- "Possible semaphore performance anti-pattern: wait on a semaphore "
- "signalled to in a callback",
+ "Waiting on a semaphore with Grand Central Dispatch creates useless "
+ "threads and is subject to priority inversion; consider "
+ "using a synchronous API or changing the caller to be asynchronous",
PathDiagnosticLocation::createBegin(SW, BR.getSourceManager(), ADC),
SW->getSourceRange());
}
}
-void ento::registerGCDAsyncSemaphoreChecker(CheckerManager &Mgr) {
- Mgr.registerChecker<GCDAsyncSemaphoreChecker>();
+void ento::registerGCDAntipattern(CheckerManager &Mgr) {
+ Mgr.registerChecker<GCDAntipatternChecker>();
}
Removed: cfe/trunk/lib/StaticAnalyzer/Checkers/GCDAsyncSemaphoreChecker.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Checkers/GCDAsyncSemaphoreChecker.cpp?rev=327308&view=auto
==============================================================================
--- cfe/trunk/lib/StaticAnalyzer/Checkers/GCDAsyncSemaphoreChecker.cpp (original)
+++ cfe/trunk/lib/StaticAnalyzer/Checkers/GCDAsyncSemaphoreChecker.cpp (removed)
@@ -1,159 +0,0 @@
-//===- GCDAsyncSemaphoreChecker.cpp -----------------------------*- C++ -*-==//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines GCDAsyncSemaphoreChecker which checks against a common
-// antipattern when synchronous API is emulated from asynchronous callbacks
-// using a semaphor:
-//
-// dispatch_semapshore_t sema = dispatch_semaphore_create(0);
-
-// AnyCFunctionCall(^{
-// // codeâ¦
-// dispatch_semapshore_signal(sema);
-// })
-// dispatch_semapshore_wait(sema, *)
-//
-// Such code is a common performance problem, due to inability of GCD to
-// properly handle QoS when a combination of queues and semaphors is used.
-// Good code would either use asynchronous API (when available), or perform
-// the necessary action in asynchronous callback.
-//
-// Currently, the check is performed using a simple heuristical AST pattern
-// matching.
-//
-//===----------------------------------------------------------------------===//
-
-#include "ClangSACheckers.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
-#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
-#include "clang/StaticAnalyzer/Core/Checker.h"
-#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
-#include "llvm/Support/Debug.h"
-
-#define DEBUG_TYPE "gcdasyncsemaphorechecker"
-
-using namespace clang;
-using namespace ento;
-using namespace ast_matchers;
-
-namespace {
-
-const char *WarningBinding = "semaphore_wait";
-
-class GCDAsyncSemaphoreChecker : public Checker<check::ASTCodeBody> {
-public:
- void checkASTCodeBody(const Decl *D,
- AnalysisManager &AM,
- BugReporter &BR) const;
-};
-
-class Callback : public MatchFinder::MatchCallback {
- BugReporter &BR;
- const GCDAsyncSemaphoreChecker *C;
- AnalysisDeclContext *ADC;
-
-public:
- Callback(BugReporter &BR,
- AnalysisDeclContext *ADC,
- const GCDAsyncSemaphoreChecker *C) : BR(BR), C(C), ADC(ADC) {}
-
- virtual void run(const MatchFinder::MatchResult &Result) override;
-};
-
-auto callsName(const char *FunctionName)
- -> decltype(callee(functionDecl())) {
- return callee(functionDecl(hasName(FunctionName)));
-}
-
-auto equalsBoundArgDecl(int ArgIdx, const char *DeclName)
- -> decltype(hasArgument(0, expr())) {
- return hasArgument(ArgIdx, ignoringParenCasts(declRefExpr(
- to(varDecl(equalsBoundNode(DeclName))))));
-}
-
-auto bindAssignmentToDecl(const char *DeclName) -> decltype(hasLHS(expr())) {
- return hasLHS(ignoringParenImpCasts(
- declRefExpr(to(varDecl().bind(DeclName)))));
-}
-
-void GCDAsyncSemaphoreChecker::checkASTCodeBody(const Decl *D,
- AnalysisManager &AM,
- BugReporter &BR) const {
-
- // The pattern is very common in tests, and it is OK to use it there.
- if (const auto* ND = dyn_cast<NamedDecl>(D)) {
- std::string DeclName = ND->getNameAsString();
- if (StringRef(DeclName).startswith("test"))
- return;
- }
-
- const char *SemaphoreBinding = "semaphore_name";
- auto SemaphoreCreateM = callExpr(callsName("dispatch_semaphore_create"));
-
- auto SemaphoreBindingM = anyOf(
- forEachDescendant(
- varDecl(hasDescendant(SemaphoreCreateM)).bind(SemaphoreBinding)),
- forEachDescendant(binaryOperator(bindAssignmentToDecl(SemaphoreBinding),
- hasRHS(SemaphoreCreateM))));
-
- auto SemaphoreWaitM = forEachDescendant(
- callExpr(
- allOf(
- callsName("dispatch_semaphore_wait"),
- equalsBoundArgDecl(0, SemaphoreBinding)
- )
- ).bind(WarningBinding));
-
- auto HasBlockArgumentM = hasAnyArgument(hasType(
- hasCanonicalType(blockPointerType())
- ));
-
- auto ArgCallsSignalM = hasArgument(0, hasDescendant(callExpr(
- allOf(
- callsName("dispatch_semaphore_signal"),
- equalsBoundArgDecl(0, SemaphoreBinding)
- ))));
-
- auto HasBlockAndCallsSignalM = allOf(HasBlockArgumentM, ArgCallsSignalM);
-
- auto AcceptsBlockM =
- forEachDescendant(
- stmt(anyOf(
- callExpr(HasBlockAndCallsSignalM),
- objcMessageExpr(HasBlockAndCallsSignalM)
- )));
-
- auto FinalM = compoundStmt(SemaphoreBindingM, SemaphoreWaitM, AcceptsBlockM);
-
- MatchFinder F;
- Callback CB(BR, AM.getAnalysisDeclContext(D), this);
-
- F.addMatcher(FinalM, &CB);
- F.match(*D->getBody(), AM.getASTContext());
-}
-
-void Callback::run(const MatchFinder::MatchResult &Result) {
- const auto *SW = Result.Nodes.getNodeAs<CallExpr>(WarningBinding);
- assert(SW);
- BR.EmitBasicReport(
- ADC->getDecl(), C,
- /*Name=*/"Semaphore performance anti-pattern",
- /*Category=*/"Performance",
- "Possible semaphore performance anti-pattern: wait on a semaphore "
- "signalled to in a callback",
- PathDiagnosticLocation::createBegin(SW, BR.getSourceManager(), ADC),
- SW->getSourceRange());
-}
-
-}
-
-void ento::registerGCDAsyncSemaphoreChecker(CheckerManager &Mgr) {
- Mgr.registerChecker<GCDAsyncSemaphoreChecker>();
-}
Copied: cfe/trunk/test/Analysis/gcdantipatternchecker_test.m (from r327294, cfe/trunk/test/Analysis/gcdasyncsemaphorechecker_test.m)
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/Analysis/gcdantipatternchecker_test.m?p2=cfe/trunk/test/Analysis/gcdantipatternchecker_test.m&p1=cfe/trunk/test/Analysis/gcdasyncsemaphorechecker_test.m&r1=327294&r2=327309&rev=327309&view=diff
==============================================================================
--- cfe/trunk/test/Analysis/gcdasyncsemaphorechecker_test.m (original)
+++ cfe/trunk/test/Analysis/gcdantipatternchecker_test.m Mon Mar 12 11:27:36 2018
@@ -1,4 +1,4 @@
-// RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.osx.GCDAsyncSemaphore %s -fblocks -verify
+// RUN: %clang_analyze_cc1 -analyzer-checker=core,optin.performance.GCDAntipattern %s -fblocks -verify
typedef signed char BOOL;
@protocol NSObject - (BOOL)isEqual:(id)object; @end
@interface NSObject <NSObject> {}
@@ -27,7 +27,7 @@ void use_semaphor_antipattern() {
func(^{
dispatch_semaphore_signal(sema);
});
- dispatch_semaphore_wait(sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
+ dispatch_semaphore_wait(sema, 100); // expected-warning{{Waiting on a semaphore with Grand Central Dispatch creates useless threads and is subject to priority inversion}}
}
// It's OK to use pattern in tests.
@@ -47,14 +47,14 @@ void use_semaphor_antipattern_multiple_t
func(^{
dispatch_semaphore_signal(sema1);
});
- dispatch_semaphore_wait(sema1, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
+ dispatch_semaphore_wait(sema1, 100); // expected-warning{{Waiting on a semaphore with Grand Central Dispatch creates useless threads and is subject to priority inversion}}
dispatch_semaphore_t sema2 = dispatch_semaphore_create(0);
func(^{
dispatch_semaphore_signal(sema2);
});
- dispatch_semaphore_wait(sema2, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
+ dispatch_semaphore_wait(sema2, 100); // expected-warning{{Waiting on a semaphore with Grand Central Dispatch creates useless threads and is subject to priority inversion}}
}
void use_semaphor_antipattern_multiple_wait() {
@@ -64,8 +64,8 @@ void use_semaphor_antipattern_multiple_w
dispatch_semaphore_signal(sema1);
});
// FIXME: multiple waits on same semaphor should not raise a warning.
- dispatch_semaphore_wait(sema1, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
- dispatch_semaphore_wait(sema1, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
+ dispatch_semaphore_wait(sema1, 100); // expected-warning{{Waiting on a semaphore with Grand Central Dispatch creates useless threads and is subject to priority inversion}}
+ dispatch_semaphore_wait(sema1, 100); // expected-warning{{Waiting on a semaphore with Grand Central Dispatch creates useless threads and is subject to priority inversion}}
}
void warn_incorrect_order() {
@@ -73,7 +73,7 @@ void warn_incorrect_order() {
// if out of order.
dispatch_semaphore_t sema = dispatch_semaphore_create(0);
- dispatch_semaphore_wait(sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
+ dispatch_semaphore_wait(sema, 100); // expected-warning{{Waiting on a semaphore with Grand Central Dispatch creates useless threads and is subject to priority inversion}}
func(^{
dispatch_semaphore_signal(sema);
});
@@ -85,7 +85,7 @@ void warn_w_typedef() {
func_w_typedef(^{
dispatch_semaphore_signal(sema);
});
- dispatch_semaphore_wait(sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
+ dispatch_semaphore_wait(sema, 100); // expected-warning{{Waiting on a semaphore with Grand Central Dispatch creates useless threads and is subject to priority inversion}}
}
void warn_nested_ast() {
@@ -100,7 +100,7 @@ void warn_nested_ast() {
dispatch_semaphore_signal(sema);
});
}
- dispatch_semaphore_wait(sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
+ dispatch_semaphore_wait(sema, 100); // expected-warning{{Waiting on a semaphore with Grand Central Dispatch creates useless threads and is subject to priority inversion}}
}
void use_semaphore_assignment() {
@@ -110,7 +110,7 @@ void use_semaphore_assignment() {
func(^{
dispatch_semaphore_signal(sema);
});
- dispatch_semaphore_wait(sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
+ dispatch_semaphore_wait(sema, 100); // expected-warning{{Waiting on a semaphore with Grand Central Dispatch creates useless threads and is subject to priority inversion}}
}
void use_semaphore_assignment_init() {
@@ -120,7 +120,7 @@ void use_semaphore_assignment_init() {
func(^{
dispatch_semaphore_signal(sema);
});
- dispatch_semaphore_wait(sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
+ dispatch_semaphore_wait(sema, 100); // expected-warning{{Waiting on a semaphore with Grand Central Dispatch creates useless threads and is subject to priority inversion}}
}
void differentsemaphoreok() {
@@ -172,17 +172,17 @@ void warn_with_cast() {
func(^{
dispatch_semaphore_signal((int)sema);
});
- dispatch_semaphore_wait((int)sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
+ dispatch_semaphore_wait((int)sema, 100); // expected-warning{{Waiting on a semaphore with Grand Central Dispatch creates useless threads and is subject to priority inversion}}
}
- at interface Test1 : NSObject
+ at interface MyInterface1 : NSObject
-(void)use_method_warn;
-(void)use_objc_callback_warn;
-(void)testNoWarn;
-(void)acceptBlock:(block_t)callback;
@end
- at implementation Test1
+ at implementation MyInterface1
-(void)use_method_warn {
dispatch_semaphore_t sema = dispatch_semaphore_create(0);
@@ -190,7 +190,7 @@ void warn_with_cast() {
func(^{
dispatch_semaphore_signal(sema);
});
- dispatch_semaphore_wait(sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
+ dispatch_semaphore_wait(sema, 100); // expected-warning{{Waiting on a semaphore with Grand Central Dispatch creates useless threads and is subject to priority inversion}}
}
-(void)testNoWarn {
@@ -212,23 +212,55 @@ void warn_with_cast() {
[self acceptBlock:^{
dispatch_semaphore_signal(sema);
}];
- dispatch_semaphore_wait(sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
+ dispatch_semaphore_wait(sema, 100); // expected-warning{{Waiting on a semaphore with Grand Central Dispatch creates useless threads and is subject to priority inversion}}
}
-void use_objc_and_c_callback(Test1 *t) {
+void use_objc_and_c_callback(MyInterface1 *t) {
dispatch_semaphore_t sema = dispatch_semaphore_create(0);
func(^{
dispatch_semaphore_signal(sema);
});
- dispatch_semaphore_wait(sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
+ dispatch_semaphore_wait(sema, 100); // expected-warning{{Waiting on a semaphore with Grand Central Dispatch creates useless threads and is subject to priority inversion}}
dispatch_semaphore_t sema1 = dispatch_semaphore_create(0);
[t acceptBlock:^{
dispatch_semaphore_signal(sema1);
}];
- dispatch_semaphore_wait(sema1, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
+ dispatch_semaphore_wait(sema1, 100); // expected-warning{{Waiting on a semaphore with Grand Central Dispatch creates useless threads and is subject to priority inversion}}
+}
+ at end
+
+// No warnings: class name contains "test"
+ at interface Test1 : NSObject
+-(void)use_method_warn;
+ at end
+
+ at implementation Test1
+-(void)use_method_warn {
+ dispatch_semaphore_t sema = dispatch_semaphore_create(0);
+
+ func(^{
+ dispatch_semaphore_signal(sema);
+ });
+ dispatch_semaphore_wait(sema, 100);
}
+ at end
+
+// No warnings: class name contains "mock"
+ at interface Mock1 : NSObject
+-(void)use_method_warn;
+ at end
+
+ at implementation Mock1
+-(void)use_method_warn {
+ dispatch_semaphore_t sema = dispatch_semaphore_create(0);
+
+ func(^{
+ dispatch_semaphore_signal(sema);
+ });
+ dispatch_semaphore_wait(sema, 100);
+}
@end
Removed: cfe/trunk/test/Analysis/gcdasyncsemaphorechecker_test.m
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/Analysis/gcdasyncsemaphorechecker_test.m?rev=327308&view=auto
==============================================================================
--- cfe/trunk/test/Analysis/gcdasyncsemaphorechecker_test.m (original)
+++ cfe/trunk/test/Analysis/gcdasyncsemaphorechecker_test.m (removed)
@@ -1,234 +0,0 @@
-// RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.osx.GCDAsyncSemaphore %s -fblocks -verify
-typedef signed char BOOL;
- at protocol NSObject - (BOOL)isEqual:(id)object; @end
- at interface NSObject <NSObject> {}
-+(id)alloc;
--(id)init;
--(id)autorelease;
--(id)copy;
--(id)retain;
- at end
-
-typedef int dispatch_semaphore_t;
-typedef void (^block_t)();
-
-dispatch_semaphore_t dispatch_semaphore_create(int);
-void dispatch_semaphore_wait(dispatch_semaphore_t, int);
-void dispatch_semaphore_signal(dispatch_semaphore_t);
-
-void func(void (^)(void));
-void func_w_typedef(block_t);
-
-int coin();
-
-void use_semaphor_antipattern() {
- dispatch_semaphore_t sema = dispatch_semaphore_create(0);
-
- func(^{
- dispatch_semaphore_signal(sema);
- });
- dispatch_semaphore_wait(sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
-}
-
-// It's OK to use pattern in tests.
-// We simply match the containing function name against ^test.
-void test_no_warning() {
- dispatch_semaphore_t sema = dispatch_semaphore_create(0);
-
- func(^{
- dispatch_semaphore_signal(sema);
- });
- dispatch_semaphore_wait(sema, 100);
-}
-
-void use_semaphor_antipattern_multiple_times() {
- dispatch_semaphore_t sema1 = dispatch_semaphore_create(0);
-
- func(^{
- dispatch_semaphore_signal(sema1);
- });
- dispatch_semaphore_wait(sema1, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
-
- dispatch_semaphore_t sema2 = dispatch_semaphore_create(0);
-
- func(^{
- dispatch_semaphore_signal(sema2);
- });
- dispatch_semaphore_wait(sema2, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
-}
-
-void use_semaphor_antipattern_multiple_wait() {
- dispatch_semaphore_t sema1 = dispatch_semaphore_create(0);
-
- func(^{
- dispatch_semaphore_signal(sema1);
- });
- // FIXME: multiple waits on same semaphor should not raise a warning.
- dispatch_semaphore_wait(sema1, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
- dispatch_semaphore_wait(sema1, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
-}
-
-void warn_incorrect_order() {
- // FIXME: ASTMatchers do not allow ordered matching, so would match even
- // if out of order.
- dispatch_semaphore_t sema = dispatch_semaphore_create(0);
-
- dispatch_semaphore_wait(sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
- func(^{
- dispatch_semaphore_signal(sema);
- });
-}
-
-void warn_w_typedef() {
- dispatch_semaphore_t sema = dispatch_semaphore_create(0);
-
- func_w_typedef(^{
- dispatch_semaphore_signal(sema);
- });
- dispatch_semaphore_wait(sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
-}
-
-void warn_nested_ast() {
- dispatch_semaphore_t sema = dispatch_semaphore_create(0);
-
- if (coin()) {
- func(^{
- dispatch_semaphore_signal(sema);
- });
- } else {
- func(^{
- dispatch_semaphore_signal(sema);
- });
- }
- dispatch_semaphore_wait(sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
-}
-
-void use_semaphore_assignment() {
- dispatch_semaphore_t sema;
- sema = dispatch_semaphore_create(0);
-
- func(^{
- dispatch_semaphore_signal(sema);
- });
- dispatch_semaphore_wait(sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
-}
-
-void use_semaphore_assignment_init() {
- dispatch_semaphore_t sema = dispatch_semaphore_create(0);
- sema = dispatch_semaphore_create(1);
-
- func(^{
- dispatch_semaphore_signal(sema);
- });
- dispatch_semaphore_wait(sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
-}
-
-void differentsemaphoreok() {
- dispatch_semaphore_t sema1 = dispatch_semaphore_create(0);
- dispatch_semaphore_t sema2 = dispatch_semaphore_create(0);
-
- func(^{
- dispatch_semaphore_signal(sema1);
- });
- dispatch_semaphore_wait(sema2, 100); // no-warning
-}
-
-void nosignalok() {
- dispatch_semaphore_t sema1 = dispatch_semaphore_create(0);
- dispatch_semaphore_wait(sema1, 100);
-}
-
-void nowaitok() {
- dispatch_semaphore_t sema = dispatch_semaphore_create(0);
- func(^{
- dispatch_semaphore_signal(sema);
- });
-}
-
-void noblockok() {
- dispatch_semaphore_t sema = dispatch_semaphore_create(0);
- dispatch_semaphore_signal(sema);
- dispatch_semaphore_wait(sema, 100);
-}
-
-void storedblockok() {
- dispatch_semaphore_t sema = dispatch_semaphore_create(0);
- block_t b = ^{
- dispatch_semaphore_signal(sema);
- };
- dispatch_semaphore_wait(sema, 100);
-}
-
-void passed_semaphore_ok(dispatch_semaphore_t sema) {
- func(^{
- dispatch_semaphore_signal(sema);
- });
- dispatch_semaphore_wait(sema, 100);
-}
-
-void warn_with_cast() {
- dispatch_semaphore_t sema = dispatch_semaphore_create(0);
-
- func(^{
- dispatch_semaphore_signal((int)sema);
- });
- dispatch_semaphore_wait((int)sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
-}
-
- at interface Test1 : NSObject
--(void)use_method_warn;
--(void)use_objc_callback_warn;
--(void)testNoWarn;
--(void)acceptBlock:(block_t)callback;
- at end
-
- at implementation Test1
-
--(void)use_method_warn {
- dispatch_semaphore_t sema = dispatch_semaphore_create(0);
-
- func(^{
- dispatch_semaphore_signal(sema);
- });
- dispatch_semaphore_wait(sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
-}
-
--(void)testNoWarn {
- dispatch_semaphore_t sema = dispatch_semaphore_create(0);
-
- func(^{
- dispatch_semaphore_signal(sema);
- });
- dispatch_semaphore_wait(sema, 100);
-}
-
--(void)acceptBlock:(block_t) callback {
- callback();
-}
-
--(void)use_objc_callback_warn {
- dispatch_semaphore_t sema = dispatch_semaphore_create(0);
-
- [self acceptBlock:^{
- dispatch_semaphore_signal(sema);
- }];
- dispatch_semaphore_wait(sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
-}
-
-void use_objc_and_c_callback(Test1 *t) {
- dispatch_semaphore_t sema = dispatch_semaphore_create(0);
-
- func(^{
- dispatch_semaphore_signal(sema);
- });
- dispatch_semaphore_wait(sema, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
-
- dispatch_semaphore_t sema1 = dispatch_semaphore_create(0);
-
- [t acceptBlock:^{
- dispatch_semaphore_signal(sema1);
- }];
- dispatch_semaphore_wait(sema1, 100); // expected-warning{{Possible semaphore performance anti-pattern}}
-}
-
- at end
More information about the cfe-commits
mailing list