This is an archive of the discontinued LLVM Phabricator instance.

Differential D51251

[analyzer] Move analyzer-eagerly-assume to AnalyzerOptions, enable by default
ClosedPublic

Authored by george.karpenkov on Aug 24 2018, 6:44 PM.

Details

Reviewers
dcoughlin
NoQ
Commits
rGa393e68b27fc: [analyzer] Move analyzer-eagerly-assume to AnalyzerOptions, enable by default
rL340963: [analyzer] Move analyzer-eagerly-assume to AnalyzerOptions, enable by default
rC340963: [analyzer] Move analyzer-eagerly-assume to AnalyzerOptions, enable by default
Summary

analyzer-eagerly-assume should not be a frontend option, but should be an analyzer option.
Moreover, it should be enabled by default both when invoked via driver or via frontend.

Current situation leads to the fact that most tests are written *without* it, while we are *enabling* it by default -- the fact that should be ideally addressed in future (either by not enabling it by default, or by changing most tests).

Diff Detail

Repository
rL LLVM

Event Timeline

george.karpenkov created this revision.Aug 24 2018, 6:44 PM
Herald added subscribers: Szelethus, mikhail.ramalho, a.sidorin and 4 others. · View Herald TranscriptAug 24 2018, 6:44 PM
NoQ accepted this revision.Aug 29 2018, 11:49 AM

Should be great as long as various analyzer UIs don't try to enforce this flag manually. Eg., scan-build seems to trust the driver here and doesn't expose it as an option.

This revision is now accepted and ready to land.Aug 29 2018, 11:49 AM
Closed by commit rC340963: [analyzer] Move analyzer-eagerly-assume to AnalyzerOptions, enable by default (authored by george.karpenkov). · Explain WhyAug 29 2018, 1:31 PM
This revision was automatically updated to reflect the committed changes.
Herald added a subscriber: cfe-commits. · View Herald TranscriptAug 29 2018, 1:31 PM
Closed by commit rL340963: [analyzer] Move analyzer-eagerly-assume to AnalyzerOptions, enable by default (authored by george.karpenkov). · Explain WhyAug 29 2018, 1:31 PM
This revision was automatically updated to reflect the committed changes.
Herald added a subscriber: llvm-commits. · View Herald TranscriptAug 29 2018, 1:31 PM
NoQ mentioned this in D53483: [analyzer] Restrict AnalyzerOptions' interface so that non-checker objects have to be registered.Nov 2 2018, 12:10 PM

Revision Contents

PathSize
cfe/
trunk/
include/
clang/
Driver/
2 lines
StaticAnalyzer/
Core/
23 lines
lib/
Driver/
ToolChains/
2 lines
Frontend/
1 line
StaticAnalyzer/
Core/
7 lines
4 lines
test/
Analysis/
4 lines
2 lines
4 lines
2 lines
2 lines
3 lines
3 lines
2 lines
2 lines
4 lines
8 lines
10 lines
2 lines
4 lines
4 lines
2 lines
2 lines
8 lines
8 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
inlining/
2 lines
8 lines
2 lines
6 lines
4 lines
4 lines
4 lines
2 lines
12 lines
2 lines
2 lines
4 lines
2 lines
8 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
2 lines
10 lines
10 lines
2 lines
2 lines
4 lines
4 lines
8 lines
4 lines
2 lines
2 lines
2 lines

Diff 163178

cfe/trunk/include/clang/Driver/CC1Options.td

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Linesdef analyzer_opt_analyze_headers : Flag<["-"], "analyzer-opt-analyze-headers">,
HelpText<"Force the static analyzer to analyze functions defined in header files">; HelpText<"Force the static analyzer to analyze functions defined in header files">;
def analyzer_opt_analyze_nested_blocks : Flag<["-"], "analyzer-opt-analyze-nested-blocks">, def analyzer_opt_analyze_nested_blocks : Flag<["-"], "analyzer-opt-analyze-nested-blocks">,
HelpText<"Analyze the definitions of blocks in addition to functions">; HelpText<"Analyze the definitions of blocks in addition to functions">;
def analyzer_display_progress : Flag<["-"], "analyzer-display-progress">, def analyzer_display_progress : Flag<["-"], "analyzer-display-progress">,
HelpText<"Emit verbose output about the analyzer's progress">; HelpText<"Emit verbose output about the analyzer's progress">;
def analyze_function : Separate<["-"], "analyze-function">, def analyze_function : Separate<["-"], "analyze-function">,
HelpText<"Run analysis on specific function (for C++ include parameters in name)">; HelpText<"Run analysis on specific function (for C++ include parameters in name)">;
def analyze_function_EQ : Joined<["-"], "analyze-function=">, Alias<analyze_function>; def analyze_function_EQ : Joined<["-"], "analyze-function=">, Alias<analyze_function>;
def analyzer_eagerly_assume : Flag<["-"], "analyzer-eagerly-assume">,
HelpText<"Eagerly assume the truth/falseness of some symbolic constraints">;
def trim_egraph : Flag<["-"], "trim-egraph">, def trim_egraph : Flag<["-"], "trim-egraph">,
HelpText<"Only show error-related paths in the analysis graph">; HelpText<"Only show error-related paths in the analysis graph">;
def analyzer_viz_egraph_graphviz : Flag<["-"], "analyzer-viz-egraph-graphviz">, def analyzer_viz_egraph_graphviz : Flag<["-"], "analyzer-viz-egraph-graphviz">,
HelpText<"Display exploded graph using GraphViz">; HelpText<"Display exploded graph using GraphViz">;
def analyzer_viz_egraph_ubigraph : Flag<["-"], "analyzer-viz-egraph-ubigraph">, def analyzer_viz_egraph_ubigraph : Flag<["-"], "analyzer-viz-egraph-ubigraph">,
HelpText<"Display exploded graph using Ubigraph">; HelpText<"Display exploded graph using Ubigraph">;
def analyzer_inline_max_stack_depth : Separate<["-"], "analyzer-inline-max-stack-depth">, def analyzer_inline_max_stack_depth : Separate<["-"], "analyzer-inline-max-stack-depth">,
▲ Show 20 Lines • Show All 760 Lines • Show Last 20 Lines

cfe/trunk/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h

Show First 20 Lines • Show All 154 Lines • ▼ Show 20 Linespublic:
unsigned DisableAllChecks : 1; unsigned DisableAllChecks : 1;
unsigned ShowCheckerHelp : 1; unsigned ShowCheckerHelp : 1;
unsigned ShowEnabledCheckerList : 1; unsigned ShowEnabledCheckerList : 1;
unsigned AnalyzeAll : 1; unsigned AnalyzeAll : 1;
unsigned AnalyzerDisplayProgress : 1; unsigned AnalyzerDisplayProgress : 1;
unsigned AnalyzeNestedBlocks : 1; unsigned AnalyzeNestedBlocks : 1;
/// The flag regulates if we should eagerly assume evaluations of
/// conditionals, thus, bifurcating the path.
///
/// This flag indicates how the engine should handle expressions such as: 'x =
/// (y != 0)'. When this flag is true then the subexpression 'y != 0' will be
/// eagerly assumed to be true or false, thus evaluating it to the integers 0
/// or 1 respectively. The upside is that this can increase analysis
/// precision until we have a better way to lazily evaluate such logic. The
/// downside is that it eagerly bifurcates paths.
unsigned eagerlyAssumeBinOpBifurcation : 1; unsigned eagerlyAssumeBinOpBifurcation : 1;
unsigned TrimGraph : 1; unsigned TrimGraph : 1;
unsigned visualizeExplodedGraphWithGraphViz : 1; unsigned visualizeExplodedGraphWithGraphViz : 1;
unsigned visualizeExplodedGraphWithUbiGraph : 1; unsigned visualizeExplodedGraphWithUbiGraph : 1;
unsigned UnoptimizedCFG : 1; unsigned UnoptimizedCFG : 1;
unsigned PrintStats : 1; unsigned PrintStats : 1;
▲ Show 20 Lines • Show All 136 Lines • ▼ Show 20 Linesprivate:
Optional<bool> UnrollLoops; Optional<bool> UnrollLoops;
/// \sa shouldDisplayNotesAsEvents /// \sa shouldDisplayNotesAsEvents
Optional<bool> DisplayNotesAsEvents; Optional<bool> DisplayNotesAsEvents;
/// \sa shouldAggressivelySimplifyBinaryOperation /// \sa shouldAggressivelySimplifyBinaryOperation
Optional<bool> AggressiveBinaryOperationSimplification; Optional<bool> AggressiveBinaryOperationSimplification;
/// \sa shouldEagerlyAssume
Optional<bool> EagerlyAssumeBinOpBifurcation;
/// \sa getCTUDir /// \sa getCTUDir
Optional<StringRef> CTUDir; Optional<StringRef> CTUDir;
/// \sa getCTUIndexName /// \sa getCTUIndexName
Optional<StringRef> CTUIndexName; Optional<StringRef> CTUIndexName;
/// \sa naiveCTUEnabled /// \sa naiveCTUEnabled
Optional<bool> NaiveCTU; Optional<bool> NaiveCTU;
▲ Show 20 Lines • Show All 367 Lines • ▼ Show 20 Linespublic:
/// quarter of the maximum value of that type. /// quarter of the maximum value of that type.
/// ///
/// A + n <OP> B + m becomes A - B <OP> m - n, where A and B symbolic, /// A + n <OP> B + m becomes A - B <OP> m - n, where A and B symbolic,
/// n and m are integers. <OP> is any of '==', '!=', '<', '<=', '>', '>=', /// n and m are integers. <OP> is any of '==', '!=', '<', '<=', '>', '>=',
/// '+' or '-'. The rearrangement also happens with '-' instead of '+' on /// '+' or '-'. The rearrangement also happens with '-' instead of '+' on
// either or both side and also if any or both integers are missing. // either or both side and also if any or both integers are missing.
bool shouldAggressivelySimplifyBinaryOperation(); bool shouldAggressivelySimplifyBinaryOperation();
/// Returns true if we should eagerly assume evaluations of
/// conditionals, thus, bifurcating the path.
///
/// This indicates how the engine should handle expressions such as: 'x =
/// (y != 0)'. When this is true then the subexpression 'y != 0' will be
/// eagerly assumed to be true or false, thus evaluating it to the integers 0
/// or 1 respectively. The upside is that this can increase analysis
/// precision until we have a better way to lazily evaluate such logic. The
/// downside is that it eagerly bifurcates paths.
bool shouldEagerlyAssume();
/// Returns the directory containing the CTU related files. /// Returns the directory containing the CTU related files.
StringRef getCTUDir(); StringRef getCTUDir();
/// Returns the name of the file containing the CTU index of functions. /// Returns the name of the file containing the CTU index of functions.
StringRef getCTUIndexName(); StringRef getCTUIndexName();
/// Returns true when naive cross translation unit analysis is enabled. /// Returns true when naive cross translation unit analysis is enabled.
/// This is an experimental feature to inline functions from another /// This is an experimental feature to inline functions from another
Show All 16 Lines

cfe/trunk/lib/Driver/ToolChains/Clang.cpp

Show First 20 Lines • Show All 2,227 Lines • ▼ Show 20 Linesstatic void RenderAnalyzerOptions(const ArgList &Args, ArgStringList &CmdArgs,
const llvm::Triple &Triple, const llvm::Triple &Triple,
const InputInfo &Input) { const InputInfo &Input) {
// Enable region store model by default. // Enable region store model by default.
CmdArgs.push_back("-analyzer-store=region"); CmdArgs.push_back("-analyzer-store=region");
// Treat blocks as analysis entry points. // Treat blocks as analysis entry points.
CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks"); CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks");
CmdArgs.push_back("-analyzer-eagerly-assume");
// Add default argument set. // Add default argument set.
if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) { if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) {
CmdArgs.push_back("-analyzer-checker=core"); CmdArgs.push_back("-analyzer-checker=core");
CmdArgs.push_back("-analyzer-checker=apiModeling"); CmdArgs.push_back("-analyzer-checker=apiModeling");
if (!Triple.isWindowsMSVCEnvironment()) { if (!Triple.isWindowsMSVCEnvironment()) {
CmdArgs.push_back("-analyzer-checker=unix"); CmdArgs.push_back("-analyzer-checker=unix");
} else { } else {
▲ Show 20 Lines • Show All 3,486 Lines • Show Last 20 Lines

cfe/trunk/lib/Frontend/CompilerInvocation.cpp

Show First 20 Lines • Show All 285 Lines • ▼ Show 20 Lines Opts.visualizeExplodedGraphWithGraphViz =
Args.hasArg(OPT_analyzer_viz_egraph_graphviz); Args.hasArg(OPT_analyzer_viz_egraph_graphviz);
Opts.visualizeExplodedGraphWithUbiGraph = Opts.visualizeExplodedGraphWithUbiGraph =
Args.hasArg(OPT_analyzer_viz_egraph_ubigraph); Args.hasArg(OPT_analyzer_viz_egraph_ubigraph);
Opts.NoRetryExhausted = Args.hasArg(OPT_analyzer_disable_retry_exhausted); Opts.NoRetryExhausted = Args.hasArg(OPT_analyzer_disable_retry_exhausted);
Opts.AnalyzeAll = Args.hasArg(OPT_analyzer_opt_analyze_headers); Opts.AnalyzeAll = Args.hasArg(OPT_analyzer_opt_analyze_headers);
Opts.AnalyzerDisplayProgress = Args.hasArg(OPT_analyzer_display_progress); Opts.AnalyzerDisplayProgress = Args.hasArg(OPT_analyzer_display_progress);
Opts.AnalyzeNestedBlocks = Opts.AnalyzeNestedBlocks =
Args.hasArg(OPT_analyzer_opt_analyze_nested_blocks); Args.hasArg(OPT_analyzer_opt_analyze_nested_blocks);
Opts.eagerlyAssumeBinOpBifurcation = Args.hasArg(OPT_analyzer_eagerly_assume);
Opts.AnalyzeSpecificFunction = Args.getLastArgValue(OPT_analyze_function); Opts.AnalyzeSpecificFunction = Args.getLastArgValue(OPT_analyze_function);
Opts.UnoptimizedCFG = Args.hasArg(OPT_analysis_UnoptimizedCFG); Opts.UnoptimizedCFG = Args.hasArg(OPT_analysis_UnoptimizedCFG);
Opts.TrimGraph = Args.hasArg(OPT_trim_egraph); Opts.TrimGraph = Args.hasArg(OPT_trim_egraph);
Opts.maxBlockVisitOnPath = Opts.maxBlockVisitOnPath =
getLastArgIntValue(Args, OPT_analyzer_max_loop, 4, Diags); getLastArgIntValue(Args, OPT_analyzer_max_loop, 4, Diags);
Opts.PrintStats = Args.hasArg(OPT_analyzer_stats); Opts.PrintStats = Args.hasArg(OPT_analyzer_stats);
Opts.InlineMaxStackDepth = Opts.InlineMaxStackDepth =
getLastArgIntValue(Args, OPT_analyzer_inline_max_stack_depth, getLastArgIntValue(Args, OPT_analyzer_inline_max_stack_depth,
▲ Show 20 Lines • Show All 2,968 Lines • Show Last 20 Lines

cfe/trunk/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp

Show First 20 Lines • Show All 465 Lines • ▼ Show 20 Lines
bool AnalyzerOptions::shouldAggressivelySimplifyBinaryOperation() { bool AnalyzerOptions::shouldAggressivelySimplifyBinaryOperation() {
if (!AggressiveBinaryOperationSimplification.hasValue()) if (!AggressiveBinaryOperationSimplification.hasValue())
AggressiveBinaryOperationSimplification = AggressiveBinaryOperationSimplification =
getBooleanOption("aggressive-binary-operation-simplification", getBooleanOption("aggressive-binary-operation-simplification",
/*Default=*/false); /*Default=*/false);
return AggressiveBinaryOperationSimplification.getValue(); return AggressiveBinaryOperationSimplification.getValue();
} }
bool AnalyzerOptions::shouldEagerlyAssume() {
if (!EagerlyAssumeBinOpBifurcation.hasValue())
EagerlyAssumeBinOpBifurcation =
getBooleanOption("eagerly-assume", true);
return EagerlyAssumeBinOpBifurcation.getValue();
}
StringRef AnalyzerOptions::getCTUDir() { StringRef AnalyzerOptions::getCTUDir() {
if (!CTUDir.hasValue()) { if (!CTUDir.hasValue()) {
CTUDir = getOptionAsString("ctu-dir", ""); CTUDir = getOptionAsString("ctu-dir", "");
if (!llvm::sys::fs::is_directory(*CTUDir)) if (!llvm::sys::fs::is_directory(*CTUDir))
CTUDir = ""; CTUDir = "";
} }
return CTUDir.getValue(); return CTUDir.getValue();
} }
Show All 14 Lines

cfe/trunk/lib/StaticAnalyzer/Core/ExprEngine.cpp

Show First 20 Lines • Show All 1,476 Lines • ▼ Show 20 Lines case Stmt::BinaryOperatorClass: {
state->BindExpr(B, Pred->getLocationContext(), state->BindExpr(B, Pred->getLocationContext(),
state->getSVal(B->getRHS(), state->getSVal(B->getRHS(),
Pred->getLocationContext()))); Pred->getLocationContext())));
break; break;
} }
Bldr.takeNodes(Pred); Bldr.takeNodes(Pred);
if (AMgr.options.eagerlyAssumeBinOpBifurcation && if (AMgr.options.shouldEagerlyAssume() &&
(B->isRelationalOp() || B->isEqualityOp())) { (B->isRelationalOp() || B->isEqualityOp())) {
ExplodedNodeSet Tmp; ExplodedNodeSet Tmp;
VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Tmp); VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Tmp);
evalEagerlyAssumeBinOpBifurcation(Dst, Tmp, cast<Expr>(S)); evalEagerlyAssumeBinOpBifurcation(Dst, Tmp, cast<Expr>(S));
} }
else else
VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Dst); VisitBinaryOperator(cast<BinaryOperator>(S), Pred, Dst);
▲ Show 20 Lines • Show All 247 Lines • ▼ Show 20 Lines case Stmt::StmtExprClass: {
Pred->getLocationContext()))); Pred->getLocationContext())));
} }
break; break;
} }
case Stmt::UnaryOperatorClass: { case Stmt::UnaryOperatorClass: {
Bldr.takeNodes(Pred); Bldr.takeNodes(Pred);
const auto *U = cast<UnaryOperator>(S); const auto *U = cast<UnaryOperator>(S);
if (AMgr.options.eagerlyAssumeBinOpBifurcation && (U->getOpcode() == UO_LNot)) { if (AMgr.options.shouldEagerlyAssume() && (U->getOpcode() == UO_LNot)) {
ExplodedNodeSet Tmp; ExplodedNodeSet Tmp;
VisitUnaryOperator(U, Pred, Tmp); VisitUnaryOperator(U, Pred, Tmp);
evalEagerlyAssumeBinOpBifurcation(Dst, Tmp, U); evalEagerlyAssumeBinOpBifurcation(Dst, Tmp, U);
} }
else else
VisitUnaryOperator(U, Pred, Dst); VisitUnaryOperator(U, Pred, Dst);
Bldr.addNodes(Dst); Bldr.addNodes(Dst);
break; break;
▲ Show 20 Lines • Show All 1,439 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/MisusedMovedObject.cpp

// RUN: %clang_cc1 -analyze -analyzer-checker=alpha.cplusplus.MisusedMovedObject -std=c++11 -verify -analyzer-output=text -analyzer-config exploration_strategy=unexplored_first_queue %s // RUN: %clang_cc1 -analyze -analyzer-checker=alpha.cplusplus.MisusedMovedObject -std=c++11 -verify -analyzer-output=text -analyzer-config exploration_strategy=unexplored_first_queue,eagerly-assume=false %s
// RUN: %clang_cc1 -analyze -analyzer-checker=alpha.cplusplus.MisusedMovedObject -std=c++11 -analyzer-config exploration_strategy=dfs -verify -analyzer-output=text -DDFS=1 %s // RUN: %clang_cc1 -analyze -analyzer-checker=alpha.cplusplus.MisusedMovedObject -std=c++11 -analyzer-config exploration_strategy=dfs,eagerly-assume=false -verify -analyzer-output=text -DDFS=1 %s
namespace std { namespace std {
template <typename> template <typename>
struct remove_reference; struct remove_reference;
template <typename _Tp> template <typename _Tp>
struct remove_reference { typedef _Tp type; }; struct remove_reference { typedef _Tp type; };
▲ Show 20 Lines • Show All 670 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/PR24184.cpp

// UNSUPPORTED: z3 // UNSUPPORTED: z3
// RUN: %clang_analyze_cc1 -w -analyzer-eagerly-assume -fcxx-exceptions -analyzer-checker=core -analyzer-checker=alpha.core.PointerArithm,alpha.core.CastToStruct -analyzer-max-loop 64 -verify %s // RUN: %clang_analyze_cc1 -w -fcxx-exceptions -analyzer-checker=core -analyzer-checker=alpha.core.PointerArithm,alpha.core.CastToStruct -analyzer-max-loop 64 -verify %s
// RUN: %clang_analyze_cc1 -w -analyzer-checker=core -analyzer-checker=cplusplus -fcxx-exceptions -analyzer-checker alpha.core.PointerArithm,alpha.core.CastToStruct -analyzer-max-loop 63 -verify %s // RUN: %clang_analyze_cc1 -w -analyzer-checker=core -analyzer-checker=cplusplus -fcxx-exceptions -analyzer-checker alpha.core.PointerArithm,alpha.core.CastToStruct -analyzer-max-loop 63 -verify %s
// These tests used to hit an assertion in the bug report. Test case from http://llvm.org/PR24184. // These tests used to hit an assertion in the bug report. Test case from http://llvm.org/PR24184.
typedef struct { typedef struct {
int cbData; int cbData;
unsigned pbData; unsigned pbData;
} CRYPT_DATA_BLOB; } CRYPT_DATA_BLOB;
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/PR37855.c

// RUN: %clang_cc1 -analyze -analyzer-eagerly-assume -analyzer-checker=core -w -DNO_CROSSCHECK -verify %s // RUN: %clang_cc1 -analyze -analyzer-checker=core -w -DNO_CROSSCHECK -verify %s
// RUN: %clang_cc1 -analyze -analyzer-eagerly-assume -analyzer-checker=core -w -analyzer-config crosscheck-with-z3=true -verify %s // RUN: %clang_cc1 -analyze -analyzer-checker=core -w -analyzer-config crosscheck-with-z3=true -verify %s
// REQUIRES: z3 // REQUIRES: z3
typedef struct o p; typedef struct o p;
struct o { struct o {
struct { struct {
} s; } s;
}; };
Show All 14 Lines

cfe/trunk/test/Analysis/additive-folding-range-constraints.c

// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config eagerly-assume=false -verify %s
void clang_analyzer_eval(int); void clang_analyzer_eval(int);
#define UINT_MAX (~0U) #define UINT_MAX (~0U)
#define INT_MAX (UINT_MAX & (UINT_MAX >> 1)) #define INT_MAX (UINT_MAX & (UINT_MAX >> 1))
#define INT_MIN (-INT_MAX - 1) #define INT_MIN (-INT_MAX - 1)
▲ Show 20 Lines • Show All 295 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/additive-folding.cpp

// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -verify -Wno-tautological-compare %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -verify -Wno-tautological-compare -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(bool); void clang_analyzer_eval(bool);
#define UINT_MAX (~0U) #define UINT_MAX (~0U)
#define INT_MAX (UINT_MAX & (UINT_MAX >> 1)) #define INT_MAX (UINT_MAX & (UINT_MAX >> 1))
#define INT_MIN (-INT_MAX - 1) #define INT_MIN (-INT_MAX - 1)
//--------------- //---------------
▲ Show 20 Lines • Show All 207 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/analyzer-config.c

Show All 12 Lines
// CHECK: [config] // CHECK: [config]
// CHECK-NEXT: cfg-conditional-static-initializers = true // CHECK-NEXT: cfg-conditional-static-initializers = true
// CHECK-NEXT: cfg-implicit-dtors = true // CHECK-NEXT: cfg-implicit-dtors = true
// CHECK-NEXT: cfg-lifetime = false // CHECK-NEXT: cfg-lifetime = false
// CHECK-NEXT: cfg-loopexit = false // CHECK-NEXT: cfg-loopexit = false
// CHECK-NEXT: cfg-rich-constructors = true // CHECK-NEXT: cfg-rich-constructors = true
// CHECK-NEXT: cfg-scopes = false // CHECK-NEXT: cfg-scopes = false
// CHECK-NEXT: cfg-temporary-dtors = true // CHECK-NEXT: cfg-temporary-dtors = true
// CHECK-NEXT: eagerly-assume = true
// CHECK-NEXT: elide-constructors = true // CHECK-NEXT: elide-constructors = true
// CHECK-NEXT: exploration_strategy = unexplored_first_queue // CHECK-NEXT: exploration_strategy = unexplored_first_queue
// CHECK-NEXT: faux-bodies = true // CHECK-NEXT: faux-bodies = true
// CHECK-NEXT: graph-trim-interval = 1000 // CHECK-NEXT: graph-trim-interval = 1000
// CHECK-NEXT: inline-lambdas = true // CHECK-NEXT: inline-lambdas = true
// CHECK-NEXT: ipa = dynamic-bifurcate // CHECK-NEXT: ipa = dynamic-bifurcate
// CHECK-NEXT: ipa-always-inline-size = 3 // CHECK-NEXT: ipa-always-inline-size = 3
// CHECK-NEXT: leak-diagnostics-reference-allocation = false // CHECK-NEXT: leak-diagnostics-reference-allocation = false
// CHECK-NEXT: max-inlinable-size = 100 // CHECK-NEXT: max-inlinable-size = 100
// CHECK-NEXT: max-nodes = 225000 // CHECK-NEXT: max-nodes = 225000
// CHECK-NEXT: max-times-inline-large = 32 // CHECK-NEXT: max-times-inline-large = 32
// CHECK-NEXT: min-cfg-size-treat-functions-as-large = 14 // CHECK-NEXT: min-cfg-size-treat-functions-as-large = 14
// CHECK-NEXT: mode = deep // CHECK-NEXT: mode = deep
// CHECK-NEXT: region-store-small-struct-limit = 2 // CHECK-NEXT: region-store-small-struct-limit = 2
// CHECK-NEXT: serialize-stats = false // CHECK-NEXT: serialize-stats = false
// CHECK-NEXT: unroll-loops = false // CHECK-NEXT: unroll-loops = false
// CHECK-NEXT: widen-loops = false // CHECK-NEXT: widen-loops = false
// CHECK-NEXT: [stats] // CHECK-NEXT: [stats]
// CHECK-NEXT: num-entries = 24 // CHECK-NEXT: num-entries = 25

cfe/trunk/test/Analysis/analyzer-config.cpp

Show All 26 Lines
// CHECK-NEXT: c++-template-inlining = true // CHECK-NEXT: c++-template-inlining = true
// CHECK-NEXT: cfg-conditional-static-initializers = true // CHECK-NEXT: cfg-conditional-static-initializers = true
// CHECK-NEXT: cfg-implicit-dtors = true // CHECK-NEXT: cfg-implicit-dtors = true
// CHECK-NEXT: cfg-lifetime = false // CHECK-NEXT: cfg-lifetime = false
// CHECK-NEXT: cfg-loopexit = false // CHECK-NEXT: cfg-loopexit = false
// CHECK-NEXT: cfg-rich-constructors = true // CHECK-NEXT: cfg-rich-constructors = true
// CHECK-NEXT: cfg-scopes = false // CHECK-NEXT: cfg-scopes = false
// CHECK-NEXT: cfg-temporary-dtors = true // CHECK-NEXT: cfg-temporary-dtors = true
// CHECK-NEXT: eagerly-assume = true
// CHECK-NEXT: elide-constructors = true // CHECK-NEXT: elide-constructors = true
// CHECK-NEXT: experimental-enable-naive-ctu-analysis = false // CHECK-NEXT: experimental-enable-naive-ctu-analysis = false
// CHECK-NEXT: exploration_strategy = unexplored_first_queue // CHECK-NEXT: exploration_strategy = unexplored_first_queue
// CHECK-NEXT: faux-bodies = true // CHECK-NEXT: faux-bodies = true
// CHECK-NEXT: graph-trim-interval = 1000 // CHECK-NEXT: graph-trim-interval = 1000
// CHECK-NEXT: inline-lambdas = true // CHECK-NEXT: inline-lambdas = true
// CHECK-NEXT: ipa = dynamic-bifurcate // CHECK-NEXT: ipa = dynamic-bifurcate
// CHECK-NEXT: ipa-always-inline-size = 3 // CHECK-NEXT: ipa-always-inline-size = 3
// CHECK-NEXT: leak-diagnostics-reference-allocation = false // CHECK-NEXT: leak-diagnostics-reference-allocation = false
// CHECK-NEXT: max-inlinable-size = 100 // CHECK-NEXT: max-inlinable-size = 100
// CHECK-NEXT: max-nodes = 225000 // CHECK-NEXT: max-nodes = 225000
// CHECK-NEXT: max-times-inline-large = 32 // CHECK-NEXT: max-times-inline-large = 32
// CHECK-NEXT: min-cfg-size-treat-functions-as-large = 14 // CHECK-NEXT: min-cfg-size-treat-functions-as-large = 14
// CHECK-NEXT: mode = deep // CHECK-NEXT: mode = deep
// CHECK-NEXT: region-store-small-struct-limit = 2 // CHECK-NEXT: region-store-small-struct-limit = 2
// CHECK-NEXT: serialize-stats = false // CHECK-NEXT: serialize-stats = false
// CHECK-NEXT: unroll-loops = false // CHECK-NEXT: unroll-loops = false
// CHECK-NEXT: widen-loops = false // CHECK-NEXT: widen-loops = false
// CHECK-NEXT: [stats] // CHECK-NEXT: [stats]
// CHECK-NEXT: num-entries = 31 // CHECK-NEXT: num-entries = 32

cfe/trunk/test/Analysis/array-struct-region.c

// RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.core,debug.ExprInspection -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.core,debug.ExprInspection -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(int); void clang_analyzer_eval(int);
int string_literal_init() { int string_literal_init() {
char a[] = "abc"; char a[] = "abc";
char b[2] = "abc"; // expected-warning{{too long}} char b[2] = "abc"; // expected-warning{{too long}}
char c[5] = "abc"; char c[5] = "abc";
▲ Show 20 Lines • Show All 346 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/atomics.c

// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -verify %s -analyzer-config eagerly-assume=false
// Tests for c11 atomics. Many of these tests currently yield unknown // Tests for c11 atomics. Many of these tests currently yield unknown
// because we don't fully model the atomics and instead imprecisely // because we don't fully model the atomics and instead imprecisely
// treat their arguments as escaping. // treat their arguments as escaping.
typedef unsigned int uint32_t; typedef unsigned int uint32_t;
typedef enum memory_order { typedef enum memory_order {
memory_order_relaxed = __ATOMIC_RELAXED, memory_order_relaxed = __ATOMIC_RELAXED,
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/blocks-no-inline.c

// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,debug.ExprInspection -analyzer-config ipa=none -fblocks -verify %s // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,debug.ExprInspection -analyzer-config ipa=none -fblocks -analyzer-config eagerly-assume=false -verify %s
// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,debug.ExprInspection -analyzer-config ipa=none -fblocks -verify -x c++ %s // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,debug.ExprInspection -analyzer-config ipa=none -fblocks -analyzer-config eagerly-assume=false -verify -x c++ %s
void clang_analyzer_eval(int); void clang_analyzer_eval(int);
void testInvalidation() { void testInvalidation() {
__block int i = 0; __block int i = 0;
^{ ^{
++i; ++i;
}(); }();
Show All 30 Lines

cfe/trunk/test/Analysis/bstring.c

// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.cstring,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.cstring,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -DUSE_BUILTINS -analyzer-checker=core,unix.cstring,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -verify %s // RUN: %clang_analyze_cc1 -DUSE_BUILTINS -analyzer-checker=core,unix.cstring,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -DVARIANT -analyzer-checker=core,unix.cstring,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -verify %s // RUN: %clang_analyze_cc1 -DVARIANT -analyzer-checker=core,unix.cstring,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -DUSE_BUILTINS -DVARIANT -analyzer-checker=core,unix.cstring,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -verify %s // RUN: %clang_analyze_cc1 -DUSE_BUILTINS -DVARIANT -analyzer-checker=core,unix.cstring,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -verify -analyzer-config eagerly-assume=false %s
//===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===
// Declarations // Declarations
//===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===
// Some functions are so similar to each other that they follow the same code // Some functions are so similar to each other that they follow the same code
// path, such as memcpy and __memcpy_chk, or memcmp and bcmp. If VARIANT is // path, such as memcpy and __memcpy_chk, or memcmp and bcmp. If VARIANT is
// defined, make sure to use the variants instead to make sure they are still // defined, make sure to use the variants instead to make sure they are still
▲ Show 20 Lines • Show All 473 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/bstring.cpp

// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.cstring,unix.Malloc,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.cstring,unix.Malloc,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -DUSE_BUILTINS -analyzer-checker=core,unix.cstring,unix.Malloc,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -verify %s // RUN: %clang_analyze_cc1 -DUSE_BUILTINS -analyzer-checker=core,unix.cstring,unix.Malloc,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -DVARIANT -analyzer-checker=core,unix.cstring,alpha.unix.cstring,unix.Malloc,debug.ExprInspection -analyzer-store=region -verify %s // RUN: %clang_analyze_cc1 -DVARIANT -analyzer-checker=core,unix.cstring,alpha.unix.cstring,unix.Malloc,debug.ExprInspection -analyzer-store=region -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -DUSE_BUILTINS -DVARIANT -analyzer-checker=core,unix.cstring,alpha.unix.cstring,unix.Malloc,debug.ExprInspection -analyzer-store=region -verify %s // RUN: %clang_analyze_cc1 -DUSE_BUILTINS -DVARIANT -analyzer-checker=core,unix.cstring,alpha.unix.cstring,unix.Malloc,debug.ExprInspection -analyzer-store=region -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -DSUPPRESS_OUT_OF_BOUND -analyzer-checker=core,unix.cstring,unix.Malloc,alpha.unix.cstring.BufferOverlap,alpha.unix.cstring.NotNullTerminated,debug.ExprInspection -analyzer-store=region -verify %s // RUN: %clang_analyze_cc1 -DSUPPRESS_OUT_OF_BOUND -analyzer-checker=core,unix.cstring,unix.Malloc,alpha.unix.cstring.BufferOverlap,alpha.unix.cstring.NotNullTerminated,debug.ExprInspection -analyzer-store=region -verify -analyzer-config eagerly-assume=false %s
#include "Inputs/system-header-simulator-cxx.h" #include "Inputs/system-header-simulator-cxx.h"
#include "Inputs/system-header-simulator-for-malloc.h" #include "Inputs/system-header-simulator-for-malloc.h"
// This provides us with four possible mempcpy() definitions. // This provides us with four possible mempcpy() definitions.
// See also comments in bstring.c. // See also comments in bstring.c.
#ifdef USE_BUILTINS #ifdef USE_BUILTINS
▲ Show 20 Lines • Show All 182 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/call-invalidation.cpp

// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(bool); void clang_analyzer_eval(bool);
void usePointer(int * const *); void usePointer(int * const *);
void useReference(int * const &); void useReference(int * const &);
void testPointer() { void testPointer() {
int x; int x;
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/casts.c

// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin9 -analyzer-checker=core,alpha.core,debug.ExprInspection -analyzer-store=region -verify %s // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin9 -analyzer-checker=core,alpha.core,debug.ExprInspection -analyzer-store=region -analyzer-config eagerly-assume=false -verify %s
// RUN: %clang_analyze_cc1 -triple i386-apple-darwin9 -analyzer-checker=core,alpha.core,debug.ExprInspection -analyzer-store=region -verify %s // RUN: %clang_analyze_cc1 -triple i386-apple-darwin9 -analyzer-checker=core,alpha.core,debug.ExprInspection -analyzer-store=region -analyzer-config eagerly-assume=false -verify %s
extern void clang_analyzer_eval(_Bool); extern void clang_analyzer_eval(_Bool);
// Test if the 'storage' region gets properly initialized after it is cast to // Test if the 'storage' region gets properly initialized after it is cast to
// 'struct sockaddr *'. // 'struct sockaddr *'.
typedef unsigned char __uint8_t; typedef unsigned char __uint8_t;
typedef unsigned int __uint32_t; typedef unsigned int __uint32_t;
▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/conditional-operator.cpp

// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection %s -analyzer-output=text -verify // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config eagerly-assume=false %s -analyzer-output=text -verify
void clang_analyzer_eval(bool); void clang_analyzer_eval(bool);
// Test that the analyzer does not crash on GNU extension operator "?:". // Test that the analyzer does not crash on GNU extension operator "?:".
void NoCrashTest(int x, int y) { void NoCrashTest(int x, int y) {
int w = x ?: y; int w = x ?: y;
} }
void OperatorEvaluationTest(int y) { void OperatorEvaluationTest(int y) {
int x = 1; int x = 1;
int w = x ?: y; // expected-note {{'?' condition is true}} int w = x ?: y; // expected-note {{'?' condition is true}}
// TODO: We are not precise when processing the "?:" operator in C++. // TODO: We are not precise when processing the "?:" operator in C++.
clang_analyzer_eval(w == 1); // expected-warning{{UNKNOWN}} clang_analyzer_eval(w == 1); // expected-warning{{UNKNOWN}}
// expected-note@-1{{UNKNOWN}} // expected-note@-1{{UNKNOWN}}
} }
No newline at end of file

cfe/trunk/test/Analysis/const-method-call.cpp

// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(bool); void clang_analyzer_eval(bool);
struct A { struct A {
int x; int x;
void foo() const; void foo() const;
void bar(); void bar();
▲ Show 20 Lines • Show All 264 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/constant-folding.c

// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(int); void clang_analyzer_eval(int);
// There should be no warnings unless otherwise indicated. // There should be no warnings unless otherwise indicated.
void testComparisons (int a) { void testComparisons (int a) {
// Sema can already catch the simple comparison a==a, // Sema can already catch the simple comparison a==a,
// since that's usually a logic error (and not path-dependent). // since that's usually a logic error (and not path-dependent).
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/copy-elision.cpp

// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -std=c++11 -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -std=c++11 -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -std=c++17 -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -std=c++17 -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -std=c++11 -analyzer-config elide-constructors=false -DNO_ELIDE_FLAG -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -std=c++11 -analyzer-config elide-constructors=false -DNO_ELIDE_FLAG -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -std=c++17 -analyzer-config elide-constructors=false -DNO_ELIDE_FLAG -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -std=c++17 -analyzer-config elide-constructors=false -DNO_ELIDE_FLAG -verify -analyzer-config eagerly-assume=false %s
// Copy elision always occurs in C++17, otherwise it's under // Copy elision always occurs in C++17, otherwise it's under
// an on-by-default flag. // an on-by-default flag.
#if __cplusplus >= 201703L #if __cplusplus >= 201703L
#define ELIDE 1 #define ELIDE 1
#else #else
#ifndef NO_ELIDE_FLAG #ifndef NO_ELIDE_FLAG
#define ELIDE 1 #define ELIDE 1
▲ Show 20 Lines • Show All 355 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/ctor.mm

// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -DI386 -analyzer-checker=core,debug.ExprInspection -fobjc-arc -analyzer-config c++-inlining=constructors -Wno-null-dereference -std=c++11 -verify %s // RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -DI386 -analyzer-checker=core,debug.ExprInspection -fobjc-arc -analyzer-config c++-inlining=constructors -Wno-null-dereference -std=c++11 -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -DI386 -analyzer-checker=core,debug.ExprInspection -fobjc-arc -analyzer-config c++-inlining=constructors -Wno-null-dereference -std=c++11 -verify -DTEST_INLINABLE_ALLOCATORS %s // RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -DI386 -analyzer-checker=core,debug.ExprInspection -fobjc-arc -analyzer-config c++-inlining=constructors -Wno-null-dereference -std=c++11 -verify -DTEST_INLINABLE_ALLOCATORS -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin12 -analyzer-checker=core,debug.ExprInspection -fobjc-arc -analyzer-config c++-inlining=constructors -Wno-null-dereference -std=c++11 -verify %s // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin12 -analyzer-checker=core,debug.ExprInspection -fobjc-arc -analyzer-config c++-inlining=constructors -Wno-null-dereference -std=c++11 -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin12 -analyzer-checker=core,debug.ExprInspection -fobjc-arc -analyzer-config c++-inlining=constructors -Wno-null-dereference -std=c++11 -verify -DTEST_INLINABLE_ALLOCATORS %s // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin12 -analyzer-checker=core,debug.ExprInspection -fobjc-arc -analyzer-config c++-inlining=constructors -Wno-null-dereference -std=c++11 -verify -DTEST_INLINABLE_ALLOCATORS -analyzer-config eagerly-assume=false %s
#include "Inputs/system-header-simulator-cxx.h" #include "Inputs/system-header-simulator-cxx.h"
void clang_analyzer_eval(bool); void clang_analyzer_eval(bool);
void clang_analyzer_checkInlined(bool); void clang_analyzer_checkInlined(bool);
// A simplified version of std::move. // A simplified version of std::move.
template <typename T> template <typename T>
▲ Show 20 Lines • Show All 852 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/cxx-for-range.cpp

// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core -analyzer-output=plist-multi-file -o %t.plist -verify %s // RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core -analyzer-output=plist-multi-file -o %t.plist -verify -analyzer-config eagerly-assume=false %s
// RUN: tail -n +11 %t.plist | diff -u -w - %S/Inputs/expected-plists/cxx-for-range.cpp.plist // RUN: tail -n +11 %t.plist | diff -u -w - %S/Inputs/expected-plists/cxx-for-range.cpp.plist
extern void work(); extern void work();
void testLoop() { void testLoop() {
int z[] = {1,2}; int z[] = {1,2};
for (int y : z) { for (int y : z) {
work(); work();
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/dtor.cpp

// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,debug.ExprInspection,cplusplus -analyzer-config c++-inlining=destructors -Wno-null-dereference -Wno-inaccessible-base -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,debug.ExprInspection,cplusplus -analyzer-config c++-inlining=destructors -Wno-null-dereference -Wno-inaccessible-base -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(bool); void clang_analyzer_eval(bool);
void clang_analyzer_checkInlined(bool); void clang_analyzer_checkInlined(bool);
class A { class A {
public: public:
~A() { ~A() {
int *x = 0; int *x = 0;
▲ Show 20 Lines • Show All 533 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/edges-new.mm

// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,deadcode.DeadStores,osx.cocoa.RetainCount,unix.Malloc,unix.MismatchedDeallocator -analyzer-eagerly-assume -analyzer-output=plist -o %t -w %s // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,deadcode.DeadStores,osx.cocoa.RetainCount,unix.Malloc,unix.MismatchedDeallocator -analyzer-output=plist -o %t -w %s
// RUN: tail -n +11 %t | diff -u -w - %S/Inputs/expected-plists/edges-new.mm.plist // RUN: tail -n +11 %t | diff -u -w - %S/Inputs/expected-plists/edges-new.mm.plist
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Forward declarations (from headers). // Forward declarations (from headers).
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
typedef const struct __CFNumber * CFNumberRef; typedef const struct __CFNumber * CFNumberRef;
typedef const struct __CFAllocator * CFAllocatorRef; typedef const struct __CFAllocator * CFAllocatorRef;
▲ Show 20 Lines • Show All 583 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/func.c

// RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.core,debug.ExprInspection -analyzer-store=region -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.core,debug.ExprInspection -analyzer-store=region -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(int); void clang_analyzer_eval(int);
void clang_analyzer_warnIfReached(); void clang_analyzer_warnIfReached();
void f(void) { void f(void) {
void (*p)(void); void (*p)(void);
p = f; p = f;
p = &f; p = &f;
Show All 32 Lines

cfe/trunk/test/Analysis/global-region-invalidation.c

// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -disable-free -analyzer-eagerly-assume -analyzer-checker=core,deadcode,alpha.security.taint,debug.TaintTest,debug.ExprInspection -verify %s // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -disable-free -analyzer-checker=core,deadcode,alpha.security.taint,debug.TaintTest,debug.ExprInspection -verify %s
void clang_analyzer_eval(int); void clang_analyzer_eval(int);
// Note, we do need to include headers here, since the analyzer checks if the function declaration is located in a system header. // Note, we do need to include headers here, since the analyzer checks if the function declaration is located in a system header.
#include "Inputs/system-header-simulator.h" #include "Inputs/system-header-simulator.h"
// Test that system header does not invalidate the internal global. // Test that system header does not invalidate the internal global.
int size_rdar9373039 = 1; int size_rdar9373039 = 1;
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/global_region_invalidation.mm

// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,debug.ExprInspection -verify %s // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,debug.ExprInspection -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(int); void clang_analyzer_eval(int);
#include "Inputs/system-header-simulator.h" #include "Inputs/system-header-simulator.h"
void use(int); void use(int);
id foo(int x) { id foo(int x) {
if (x) if (x)
▲ Show 20 Lines • Show All 179 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/gtest.cpp

//RUN: %clang_analyze_cc1 -cc1 -std=c++11 -analyzer-checker=core,apiModeling.google.GTest,debug.ExprInspection -analyzer-eagerly-assume %s -verify //RUN: %clang_analyze_cc1 -cc1 -std=c++11 -analyzer-checker=core,apiModeling.google.GTest,debug.ExprInspection %s -verify
//RUN: %clang_analyze_cc1 -cc1 -std=c++11 -analyzer-checker=core,apiModeling.google.GTest,debug.ExprInspection -analyzer-eagerly-assume -DGTEST_VERSION_1_8_AND_LATER=1 %s -verify //RUN: %clang_analyze_cc1 -cc1 -std=c++11 -analyzer-checker=core,apiModeling.google.GTest,debug.ExprInspection -DGTEST_VERSION_1_8_AND_LATER=1 %s -verify
void clang_analyzer_eval(int); void clang_analyzer_eval(int);
void clang_analyzer_warnIfReached(); void clang_analyzer_warnIfReached();
namespace std { namespace std {
class string { class string {
public: public:
~string(); ~string();
▲ Show 20 Lines • Show All 154 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/inline-plist.c

// RUN: %clang_analyze_cc1 %s -analyzer-checker=core.NullDereference,core.DivideZero -fblocks -analyzer-output=text -analyzer-config suppress-null-return-paths=false -verify %s // RUN: %clang_analyze_cc1 %s -analyzer-checker=core.NullDereference,core.DivideZero -fblocks -analyzer-output=text -analyzer-config suppress-null-return-paths=false -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 %s -analyzer-checker=core.NullDereference,core.DivideZero -fblocks -analyzer-output=plist -analyzer-config suppress-null-return-paths=false -o %t // RUN: %clang_analyze_cc1 -analyzer-config eagerly-assume=false %s -analyzer-checker=core.NullDereference,core.DivideZero -fblocks -analyzer-output=plist -analyzer-config suppress-null-return-paths=false -o %t
// RUN: tail -n +11 %t | diff -u -w - %S/Inputs/expected-plists/inline-plist.c.plist // RUN: tail -n +11 %t | diff -u -w - %S/Inputs/expected-plists/inline-plist.c.plist
// <rdar://problem/10967815> // <rdar://problem/10967815>
void mmm(int y) { void mmm(int y) {
if (y != 0) if (y != 0)
y++; y++;
} }
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/inline.cpp

// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-config ipa=inlining -analyzer-config c++-allocator-inlining=true -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-config ipa=inlining -analyzer-config c++-allocator-inlining=true -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(bool); void clang_analyzer_eval(bool);
void clang_analyzer_checkInlined(bool); void clang_analyzer_checkInlined(bool);
typedef __typeof__(sizeof(int)) size_t; typedef __typeof__(sizeof(int)) size_t;
extern "C" void *malloc(size_t); extern "C" void *malloc(size_t);
// This is the standard placement new. // This is the standard placement new.
▲ Show 20 Lines • Show All 434 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/inlining/InlineObjCClassMethod.m

// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config ipa=dynamic-bifurcate -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config ipa=dynamic-bifurcate -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_checkInlined(int); void clang_analyzer_checkInlined(int);
void clang_analyzer_eval(int); void clang_analyzer_eval(int);
// Test inlining of ObjC class methods. // Test inlining of ObjC class methods.
typedef signed char BOOL; typedef signed char BOOL;
typedef struct objc_class *Class; typedef struct objc_class *Class;
▲ Show 20 Lines • Show All 302 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/inlining/containers.cpp

// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-config c++-inlining=destructors -analyzer-config c++-container-inlining=false -verify %s // RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-config c++-inlining=destructors -analyzer-config c++-container-inlining=false -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-config c++-inlining=destructors -analyzer-config c++-container-inlining=true -DINLINE=1 -verify %s // RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-config c++-inlining=destructors -analyzer-config c++-container-inlining=true -DINLINE=1 -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-config c++-inlining=destructors -analyzer-config c++-container-inlining=false -DTEST_INLINABLE_ALLOCATORS -verify %s // RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-config c++-inlining=destructors -analyzer-config c++-container-inlining=false -DTEST_INLINABLE_ALLOCATORS -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-config c++-inlining=destructors -analyzer-config c++-container-inlining=true -DTEST_INLINABLE_ALLOCATORS -DINLINE=1 -verify %s // RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-config c++-inlining=destructors -analyzer-config c++-container-inlining=true -DTEST_INLINABLE_ALLOCATORS -DINLINE=1 -verify -analyzer-config eagerly-assume=false %s
#ifndef HEADER #ifndef HEADER
void clang_analyzer_eval(bool); void clang_analyzer_eval(bool);
void clang_analyzer_checkInlined(bool); void clang_analyzer_checkInlined(bool);
#define HEADER #define HEADER
#include "containers.cpp" #include "containers.cpp"
▲ Show 20 Lines • Show All 261 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/inlining/dyn-dispatch-bifurcate.cpp

// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config ipa=dynamic-bifurcate -verify -Wno-reinterpret-base-class %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config ipa=dynamic-bifurcate -verify -Wno-reinterpret-base-class -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(bool); void clang_analyzer_eval(bool);
class A { class A {
public: public:
virtual int get() { return 0; } virtual int get() { return 0; }
}; };
Show All 29 Lines

cfe/trunk/test/Analysis/inlining/false-positive-suppression.c

// RUN: %clang_analyze_cc1 -analyzer-eagerly-assume -analyzer-checker=core -analyzer-config suppress-null-return-paths=false -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-config suppress-null-return-paths=false -verify %s
// RUN: %clang_analyze_cc1 -analyzer-eagerly-assume -analyzer-checker=core -verify -DSUPPRESSED=1 %s // RUN: %clang_analyze_cc1 -analyzer-checker=core -verify -DSUPPRESSED=1 %s
// RUN: %clang_analyze_cc1 -analyzer-eagerly-assume -analyzer-checker=core -analyzer-config avoid-suppressing-null-argument-paths=true -DSUPPRESSED=1 -DNULL_ARGS=1 -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-config avoid-suppressing-null-argument-paths=true -DSUPPRESSED=1 -DNULL_ARGS=1 -verify %s
int opaquePropertyCheck(void *object); int opaquePropertyCheck(void *object);
int coin(); int coin();
int *getNull() { int *getNull() {
return 0; return 0;
} }
▲ Show 20 Lines • Show All 373 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/inlining/stl.cpp

// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,cplusplus.NewDelete,debug.ExprInspection -analyzer-config c++-container-inlining=true -analyzer-config c++-stdlib-inlining=false -std=c++11 -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,cplusplus.NewDelete,debug.ExprInspection -analyzer-config c++-container-inlining=true -analyzer-config c++-stdlib-inlining=false -std=c++11 -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,cplusplus.NewDelete,debug.ExprInspection -analyzer-config c++-container-inlining=true -analyzer-config c++-stdlib-inlining=true -std=c++11 -DINLINE=1 -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,cplusplus.NewDelete,debug.ExprInspection -analyzer-config c++-container-inlining=true -analyzer-config c++-stdlib-inlining=true -std=c++11 -DINLINE=1 -verify -analyzer-config eagerly-assume=false %s
#include "../Inputs/system-header-simulator-cxx.h" #include "../Inputs/system-header-simulator-cxx.h"
void clang_analyzer_eval(bool); void clang_analyzer_eval(bool);
void testVector(std::vector<int> &nums) { void testVector(std::vector<int> &nums) {
if (nums.begin() != nums.end()) return; if (nums.begin() != nums.end()) return;
Show All 18 Lines

cfe/trunk/test/Analysis/invalidated-iterator.cpp

// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,alpha.cplusplus.InvalidatedIterator -analyzer-eagerly-assume -analyzer-config aggressive-relational-comparison-simplification=true -analyzer-config c++-container-inlining=false %s -verify // RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,alpha.cplusplus.InvalidatedIterator -analyzer-config aggressive-relational-comparison-simplification=true -analyzer-config c++-container-inlining=false %s -verify
// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,alpha.cplusplus.InvalidatedIterator -analyzer-eagerly-assume -analyzer-config aggressive-relational-comparison-simplification=true -analyzer-config c++-container-inlining=true -DINLINE=1 %s -verify // RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,alpha.cplusplus.InvalidatedIterator -analyzer-config aggressive-relational-comparison-simplification=true -analyzer-config c++-container-inlining=true -DINLINE=1 %s -verify
#include "Inputs/system-header-simulator-cxx.h" #include "Inputs/system-header-simulator-cxx.h"
void bad_copy_assign_operator_list1(std::list<int> &L1, void bad_copy_assign_operator_list1(std::list<int> &L1,
const std::list<int> &L2) { const std::list<int> &L2) {
auto i0 = L1.cbegin(); auto i0 = L1.cbegin();
L1 = L2; L1 = L2;
*i0; // expected-warning{{Invalidated iterator accessed}} *i0; // expected-warning{{Invalidated iterator accessed}}
Show All 22 Lines

cfe/trunk/test/Analysis/iterator-range.cpp

// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,alpha.cplusplus.IteratorRange -analyzer-eagerly-assume -analyzer-config aggressive-binary-operation-simplification=true -analyzer-config c++-container-inlining=false %s -verify // RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,alpha.cplusplus.IteratorRange -analyzer-config aggressive-binary-operation-simplification=true -analyzer-config c++-container-inlining=false %s -verify
// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,alpha.cplusplus.IteratorRange -analyzer-eagerly-assume -analyzer-config aggressive-binary-operation-simplification=true -analyzer-config c++-container-inlining=true -DINLINE=1 %s -verify // RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,alpha.cplusplus.IteratorRange -analyzer-config aggressive-binary-operation-simplification=true -analyzer-config c++-container-inlining=true -DINLINE=1 %s -verify
#include "Inputs/system-header-simulator-cxx.h" #include "Inputs/system-header-simulator-cxx.h"
void clang_analyzer_warnIfReached(); void clang_analyzer_warnIfReached();
void simple_good_end(const std::vector<int> &v) { void simple_good_end(const std::vector<int> &v) {
auto i = v.end(); auto i = v.end();
if (i != v.end()) { if (i != v.end()) {
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/ivars.m

// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-store=region -fblocks -verify -Wno-objc-root-class %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-store=region -fblocks -verify -Wno-objc-root-class -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(int); void clang_analyzer_eval(int);
@interface Root { @interface Root {
@public @public
int uniqueID; int uniqueID;
} }
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/lifetime-extension.cpp

// RUN: %clang_analyze_cc1 -Wno-unused -std=c++11 -analyzer-checker=core,debug.ExprInspection -analyzer-config cfg-temporary-dtors=false -verify %s // RUN: %clang_analyze_cc1 -Wno-unused -std=c++11 -analyzer-checker=core,debug.ExprInspection -analyzer-config cfg-temporary-dtors=false -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -Wno-unused -std=c++11 -analyzer-checker=core,debug.ExprInspection -analyzer-config cfg-temporary-dtors=true,c++-temp-dtor-inlining=true -DTEMPORARIES -verify %s // RUN: %clang_analyze_cc1 -Wno-unused -std=c++11 -analyzer-checker=core,debug.ExprInspection -analyzer-config cfg-temporary-dtors=true,c++-temp-dtor-inlining=true -DTEMPORARIES -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -Wno-unused -std=c++17 -analyzer-checker=core,debug.ExprInspection -analyzer-config cfg-temporary-dtors=true,c++-temp-dtor-inlining=true -DTEMPORARIES %s // RUN: %clang_analyze_cc1 -Wno-unused -std=c++17 -analyzer-checker=core,debug.ExprInspection -analyzer-config cfg-temporary-dtors=true,c++-temp-dtor-inlining=true -DTEMPORARIES -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -Wno-unused -std=c++11 -analyzer-checker=core,debug.ExprInspection -analyzer-config cfg-temporary-dtors=false -DMOVES -verify %s // RUN: %clang_analyze_cc1 -Wno-unused -std=c++11 -analyzer-checker=core,debug.ExprInspection -analyzer-config cfg-temporary-dtors=false -DMOVES -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -Wno-unused -std=c++11 -analyzer-checker=core,debug.ExprInspection -analyzer-config cfg-temporary-dtors=true,c++-temp-dtor-inlining=true -DTEMPORARIES -DMOVES -verify %s // RUN: %clang_analyze_cc1 -Wno-unused -std=c++11 -analyzer-checker=core,debug.ExprInspection -analyzer-config cfg-temporary-dtors=true,c++-temp-dtor-inlining=true -DTEMPORARIES -DMOVES -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -Wno-unused -std=c++17 -analyzer-checker=core,debug.ExprInspection -analyzer-config cfg-temporary-dtors=true,c++-temp-dtor-inlining=true -DTEMPORARIES -DMOVES %s // RUN: %clang_analyze_cc1 -Wno-unused -std=c++17 -analyzer-checker=core,debug.ExprInspection -analyzer-config cfg-temporary-dtors=true,c++-temp-dtor-inlining=true -DTEMPORARIES -DMOVES -analyzer-config eagerly-assume=false %s
// Note: The C++17 run-lines don't -verify yet - it is a no-crash test. // Note: The C++17 run-lines don't -verify yet - it is a no-crash test.
void clang_analyzer_eval(bool); void clang_analyzer_eval(bool);
void clang_analyzer_checkInlined(bool); void clang_analyzer_checkInlined(bool);
namespace pr17001_call_wrong_destructor { namespace pr17001_call_wrong_destructor {
bool x; bool x;
▲ Show 20 Lines • Show All 320 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/logical-ops.c

// RUN: %clang_analyze_cc1 -Wno-pointer-bool-conversion -analyzer-checker=core,debug.ExprInspection -verify %s // RUN: %clang_analyze_cc1 -Wno-pointer-bool-conversion -analyzer-checker=core,debug.ExprInspection -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(int); void clang_analyzer_eval(int);
void testAnd(int i, int *p) { void testAnd(int i, int *p) {
int *nullP = 0; int *nullP = 0;
int *knownP = &i; int *knownP = &i;
clang_analyzer_eval((knownP && knownP) == 1); // expected-warning{{TRUE}} clang_analyzer_eval((knownP && knownP) == 1); // expected-warning{{TRUE}}
clang_analyzer_eval((knownP && nullP) == 0); // expected-warning{{TRUE}} clang_analyzer_eval((knownP && nullP) == 0); // expected-warning{{TRUE}}
Show All 30 Lines

cfe/trunk/test/Analysis/loop-widening-notes.cpp

// RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha -analyzer-max-loop 2 -analyzer-config widen-loops=true -analyzer-output=text -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha -analyzer-max-loop 2 -analyzer-config widen-loops=true -analyzer-output=text -verify -analyzer-config eagerly-assume=false %s
int *p_a; int *p_a;
int bar(); int bar();
int flag_a; int flag_a;
int test_for_bug_25609() { int test_for_bug_25609() {
if (p_a == 0) // expected-note {{Assuming 'p_a' is equal to null}} if (p_a == 0) // expected-note {{Assuming 'p_a' is equal to null}}
// expected-note@-1 {{Taking true branch}} // expected-note@-1 {{Taking true branch}}
bar(); bar();
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/loop-widening.c

// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-max-loop 4 -analyzer-config widen-loops=true -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-max-loop 4 -analyzer-config widen-loops=true -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -DTEST_NULL_TERM -analyzer-checker=core,unix.Malloc,debug.ExprInspection,alpha.cplusplus.IteratorRange -analyzer-max-loop 4 -analyzer-config widen-loops=true -verify %s // RUN: %clang_analyze_cc1 -DTEST_NULL_TERM -analyzer-checker=core,unix.Malloc,debug.ExprInspection,alpha.cplusplus.IteratorRange -analyzer-max-loop 4 -analyzer-config widen-loops=true -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(int); void clang_analyzer_eval(int);
void clang_analyzer_warnIfReached(); void clang_analyzer_warnIfReached();
typedef __typeof(sizeof(int)) size_t; typedef __typeof(sizeof(int)) size_t;
void *malloc(size_t); void *malloc(size_t);
void free(void *); void free(void *);
▲ Show 20 Lines • Show All 194 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/malloc-plist.c

// RUN: rm -f %t // RUN: rm -f %t
// RUN: %clang_analyze_cc1 -fblocks -analyzer-checker=core,unix.Malloc -analyzer-output=plist -verify -o %t %s // RUN: %clang_analyze_cc1 -fblocks -analyzer-checker=core,unix.Malloc -analyzer-output=plist -verify -o %t -analyzer-config eagerly-assume=false %s
// RUN: FileCheck -input-file %t %s // RUN: FileCheck -input-file %t %s
typedef __typeof(sizeof(int)) size_t; typedef __typeof(sizeof(int)) size_t;
void *malloc(size_t); void *malloc(size_t);
void free(void *); void free(void *);
void *realloc(void *ptr, size_t size); void *realloc(void *ptr, size_t size);
void diagnosticTest(int in) { void diagnosticTest(int in) {
▲ Show 20 Lines • Show All 5,234 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/misc-ps-eager-assume.m

// RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.core -analyzer-store=region -verify -fblocks %s -analyzer-eagerly-assume // RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.core -analyzer-store=region -verify -fblocks %s
// expected-no-diagnostics // expected-no-diagnostics
// Delta-reduced header stuff (needed for test cases). // Delta-reduced header stuff (needed for test cases).
typedef signed char BOOL; typedef signed char BOOL;
typedef unsigned int NSUInteger; typedef unsigned int NSUInteger;
typedef struct _NSZone NSZone; typedef struct _NSZone NSZone;
@class NSInvocation, NSMethodSignature, NSCoder, NSString, NSEnumerator; @class NSInvocation, NSMethodSignature, NSCoder, NSString, NSEnumerator;
@protocol NSObject - (BOOL)isEqual:(id)object; @protocol NSObject - (BOOL)isEqual:(id)object;
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines
} }
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
// <rdar://problem/7342806> // <rdar://problem/7342806>
// This false positive occurred because the symbolic constraint on a short was // This false positive occurred because the symbolic constraint on a short was
// not maintained via sign extension. The analyzer doesn't properly handle // not maintained via sign extension. The analyzer doesn't properly handle
// the sign extension, but now tracks the constraint. This particular // the sign extension, but now tracks the constraint. This particular
// case relies on -analyzer-eagerly-assume because of the expression // case relies on -analyzer-options eagerly-assume=true because of the expression
// 'Flag1 != Count > 0'. // 'Flag1 != Count > 0'.
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
void rdar7342806_aux(short x); void rdar7342806_aux(short x);
void rdar7342806() { void rdar7342806() {
extern short Count; extern short Count;
extern short Flag1; extern short Flag1;
Show All 22 Lines for( Which = 0;
// This statement can only execute if Count > 0 which can only // This statement can only execute if Count > 0 which can only
// happen when Flag1 and Flag2 are both true and Flag2 will only // happen when Flag1 and Flag2 are both true and Flag2 will only
// be true when Pointer is not NULL. // be true when Pointer is not NULL.
rdar7342806_aux(*Pointer); // no-warning rdar7342806_aux(*Pointer); // no-warning
} }
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
// PR 5627 - http://llvm.org/bugs/show_bug.cgi?id=5627 // PR 5627 - http://llvm.org/bugs/show_bug.cgi?id=5627
// This test case depends on using -analyzer-eagerly-assume and // This test case depends on using -analyzer-config eagerly-assume=true and
// -analyzer-store=region. The '-analyzer-eagerly-assume' causes the path // -analyzer-store=region. The 'eagerly-assume=true' causes the path
// to bifurcate when evaluating the function call argument, and a state // to bifurcate when evaluating the function call argument, and a state
// caching bug in GRExprEngine::CheckerVisit (and friends) caused the store // caching bug in GRExprEngine::CheckerVisit (and friends) caused the store
// to 'p' to not be evaluated along one path, but then an autotransition caused // to 'p' to not be evaluated along one path, but then an autotransition caused
// the path to keep on propagating with 'p' still set to an undefined value. // the path to keep on propagating with 'p' still set to an undefined value.
// We would then get a bogus report of returning uninitialized memory. // We would then get a bogus report of returning uninitialized memory.
// Note: CheckerVisit mistakenly cleared an existing node, and the cleared // Note: CheckerVisit mistakenly cleared an existing node, and the cleared
// node was resurrected by GRStmtNodeBuilder::~GRStmtNodeBuilder(), where // node was resurrected by GRStmtNodeBuilder::~GRStmtNodeBuilder(), where
// 'p' was not assigned. // 'p' was not assigned.
Show All 10 Lines

cfe/trunk/test/Analysis/misc-ps.c

// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -disable-free -analyzer-eagerly-assume -analyzer-checker=core,deadcode,debug.ExprInspection -verify %s // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -disable-free -analyzer-checker=core,deadcode,debug.ExprInspection -verify %s
void clang_analyzer_eval(int); void clang_analyzer_eval(int);
int size_rdar9373039 = 1; int size_rdar9373039 = 1;
int foo_rdar9373039(const char *); int foo_rdar9373039(const char *);
int rdar93730392() { int rdar93730392() {
int x; int x;
▲ Show 20 Lines • Show All 194 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/missing-bind-temporary.cpp

// RUN: %clang_analyze_cc1 -triple x86_64-unknown-linux -analyzer-checker=debug.DumpCFG -std=c++14 %s > %t 2>&1 // RUN: %clang_analyze_cc1 -triple x86_64-unknown-linux -analyzer-checker=debug.DumpCFG -std=c++14 -analyzer-config eagerly-assume=false %s > %t 2>&1
// RUN: FileCheck --input-file=%t %s // RUN: FileCheck --input-file=%t %s
// RUN: %clang_analyze_cc1 -triple x86_64-unknown-linux -analyzer-checker=core,debug.ExprInspection -std=c++14 -verify %s // RUN: %clang_analyze_cc1 -triple x86_64-unknown-linux -analyzer-checker=core,debug.ExprInspection -std=c++14 -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(bool); void clang_analyzer_eval(bool);
int global; int global;
namespace variant_0 { namespace variant_0 {
// This variant of the code works correctly. Function foo() is not a template // This variant of the code works correctly. Function foo() is not a template
// function. Note that there are two destructors within foo(). // function. Note that there are two destructors within foo().
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/new-ctor-conservative.cpp

// RUN: %clang_analyze_cc1 -w -analyzer-checker=core,debug.ExprInspection -analyzer-config c++-allocator-inlining=true -std=c++11 -verify %s // RUN: %clang_analyze_cc1 -w -analyzer-checker=core,debug.ExprInspection -analyzer-config c++-allocator-inlining=true -std=c++11 -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(bool); void clang_analyzer_eval(bool);
void clang_analyzer_warnIfReached(); void clang_analyzer_warnIfReached();
struct S { struct S {
int x; int x;
S() : x(1) {} S() : x(1) {}
~S() {} ~S() {}
Show All 37 Lines

cfe/trunk/test/Analysis/new-ctor-inlined.cpp

// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config c++-allocator-inlining=true -std=c++11 -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config c++-allocator-inlining=true -std=c++11 -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(bool); void clang_analyzer_eval(bool);
typedef __typeof__(sizeof(int)) size_t; typedef __typeof__(sizeof(int)) size_t;
void *conjure(); void *conjure();
void exit(int); void exit(int);
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/new-ctor-recursive.cpp

// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus.NewDelete,cplusplus.NewDeleteLeaks,debug.ExprInspection -analyzer-config c++-allocator-inlining=true -std=c++11 -verify %s // RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus.NewDelete,cplusplus.NewDeleteLeaks,debug.ExprInspection -analyzer-config c++-allocator-inlining=true -std=c++11 -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(bool); void clang_analyzer_eval(bool);
void clang_analyzer_dump(int); void clang_analyzer_dump(int);
typedef __typeof__(sizeof(int)) size_t; typedef __typeof__(sizeof(int)) size_t;
void *conjure(); void *conjure();
void exit(int); void exit(int);
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/new-ctor-symbolic.cpp

// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config c++-allocator-inlining=true -std=c++11 -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config c++-allocator-inlining=true -std=c++11 -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(bool); void clang_analyzer_eval(bool);
void clang_analyzer_warnOnDeadSymbol(int); void clang_analyzer_warnOnDeadSymbol(int);
typedef __typeof__(sizeof(int)) size_t; typedef __typeof__(sizeof(int)) size_t;
int conjure(); int conjure();
void exit(int); void exit(int);
Show All 24 Lines

cfe/trunk/test/Analysis/new.cpp

// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-store region -std=c++11 -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-store region -std=c++11 -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-store region -std=c++11 -DTEST_INLINABLE_ALLOCATORS -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-store region -std=c++11 -DTEST_INLINABLE_ALLOCATORS -verify -analyzer-config eagerly-assume=false %s
#include "Inputs/system-header-simulator-cxx.h" #include "Inputs/system-header-simulator-cxx.h"
void clang_analyzer_eval(bool); void clang_analyzer_eval(bool);
typedef __typeof__(sizeof(int)) size_t; typedef __typeof__(sizeof(int)) size_t;
extern "C" void *malloc(size_t); extern "C" void *malloc(size_t);
extern "C" void free(void *); extern "C" void free(void *);
▲ Show 20 Lines • Show All 361 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/null-deref-path-notes.cpp

// RUN: %clang_analyze_cc1 -w -x c++ -analyzer-checker=core -analyzer-output=text -analyzer-eagerly-assume -verify %s // RUN: %clang_analyze_cc1 -w -x c++ -analyzer-checker=core -analyzer-output=text -verify %s
namespace pr34731 { namespace pr34731 {
int b; int b;
class c { class c {
class B { class B {
public: public:
double ***d; double ***d;
B(); B();
Show All 16 Lines

cfe/trunk/test/Analysis/objc-for.m

// RUN: %clang_analyze_cc1 -analyzer-checker=core,osx.cocoa.Loops,debug.ExprInspection -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,osx.cocoa.Loops,debug.ExprInspection -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(int); void clang_analyzer_eval(int);
void clang_analyzer_warnIfReached(); void clang_analyzer_warnIfReached();
#define nil ((id)0) #define nil ((id)0)
typedef unsigned long NSUInteger; typedef unsigned long NSUInteger;
@protocol NSFastEnumeration @protocol NSFastEnumeration
▲ Show 20 Lines • Show All 344 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/plist-macros.cpp

// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix -analyzer-eagerly-assume -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix -verify %s
// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix -analyzer-eagerly-assume -analyzer-output=plist-multi-file %s -o %t.plist // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix -analyzer-output=plist-multi-file %s -o %t.plist
// RUN: tail -n +11 %t.plist | diff -u -w - %S/Inputs/expected-plists/plist-macros.cpp.plist // RUN: tail -n +11 %t.plist | diff -u -w - %S/Inputs/expected-plists/plist-macros.cpp.plist
typedef __typeof(sizeof(int)) size_t; typedef __typeof(sizeof(int)) size_t;
void *malloc(size_t); void *malloc(size_t);
#define mallocmemory int *x = (int*)malloc(12); #define mallocmemory int *x = (int*)malloc(12);
void noteOnMacro(int y) { void noteOnMacro(int y) {
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/plist-output.m

// RUN: %clang_analyze_cc1 %s -analyzer-checker=osx.cocoa.RetainCount,deadcode.DeadStores,core -analyzer-output=plist -o %t.plist // RUN: %clang_analyze_cc1 -analyzer-config eagerly-assume=false %s -analyzer-checker=osx.cocoa.RetainCount,deadcode.DeadStores,core -analyzer-output=plist -o %t.plist
// RUN: tail -n +11 %t.plist | diff -u -w - %S/Inputs/expected-plists/plist-output.m.plist // RUN: tail -n +11 %t.plist | diff -u -w - %S/Inputs/expected-plists/plist-output.m.plist
void test_null_init(void) { void test_null_init(void) {
int *p = 0; int *p = 0;
*p = 0xDEADBEEF; *p = 0xDEADBEEF;
} }
void test_null_assign(void) { void test_null_assign(void) {
▲ Show 20 Lines • Show All 187 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/pr22954.c

// Given code 'struct aa { char s1[4]; char * s2;} a; memcpy(a.s1, ...);', // Given code 'struct aa { char s1[4]; char * s2;} a; memcpy(a.s1, ...);',
// this test checks that the CStringChecker only invalidates the destination buffer array a.s1 (instead of a.s1 and a.s2). // this test checks that the CStringChecker only invalidates the destination buffer array a.s1 (instead of a.s1 and a.s2).
// At the moment the whole of the destination array content is invalidated. // At the moment the whole of the destination array content is invalidated.
// If a.s1 region has a symbolic offset, the whole region of 'a' is invalidated. // If a.s1 region has a symbolic offset, the whole region of 'a' is invalidated.
// Specific triple set to test structures of size 0. // Specific triple set to test structures of size 0.
// RUN: %clang_analyze_cc1 -triple x86_64-pc-linux-gnu -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-store=region -verify %s // RUN: %clang_analyze_cc1 -triple x86_64-pc-linux-gnu -analyzer-checker=core,unix.Malloc,debug.ExprInspection -analyzer-store=region -verify -analyzer-config eagerly-assume=false %s
typedef __typeof(sizeof(int)) size_t; typedef __typeof(sizeof(int)) size_t;
char *strdup(const char *s); char *strdup(const char *s);
void free(void *); void free(void *);
void *memcpy(void *dst, const void *src, size_t n); // expected-note{{passing argument to parameter 'dst' here}} void *memcpy(void *dst, const void *src, size_t n); // expected-note{{passing argument to parameter 'dst' here}}
void *malloc(size_t n); void *malloc(size_t n);
▲ Show 20 Lines • Show All 903 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/properties.m

// RUN: %clang_analyze_cc1 -analyzer-checker=core,osx.cocoa.RetainCount,osx.cocoa.Dealloc,debug.ExprInspection -analyzer-store=region -verify -Wno-objc-root-class %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,osx.cocoa.RetainCount,osx.cocoa.Dealloc,debug.ExprInspection -analyzer-store=region -verify -Wno-objc-root-class -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -analyzer-checker=core,osx.cocoa.RetainCount,osx.cocoa.Dealloc,debug.ExprInspection -analyzer-store=region -verify -Wno-objc-root-class -fobjc-arc %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,osx.cocoa.RetainCount,osx.cocoa.Dealloc,debug.ExprInspection -analyzer-store=region -verify -Wno-objc-root-class -fobjc-arc -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(int); void clang_analyzer_eval(int);
typedef const void * CFTypeRef; typedef const void * CFTypeRef;
extern CFTypeRef CFRetain(CFTypeRef cf); extern CFTypeRef CFRetain(CFTypeRef cf);
void CFRelease(CFTypeRef cf); void CFRelease(CFTypeRef cf);
typedef signed char BOOL; typedef signed char BOOL;
▲ Show 20 Lines • Show All 997 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/ptr-arith.c

// RUN: %clang_analyze_cc1 -analyzer-checker=alpha.core.FixedAddr,alpha.core.PointerArithm,alpha.core.PointerSub,debug.ExprInspection -analyzer-store=region -verify -triple x86_64-apple-darwin9 -Wno-tautological-pointer-compare %s // RUN: %clang_analyze_cc1 -analyzer-checker=alpha.core.FixedAddr,alpha.core.PointerArithm,alpha.core.PointerSub,debug.ExprInspection -analyzer-store=region -verify -triple x86_64-apple-darwin9 -Wno-tautological-pointer-compare -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -analyzer-checker=alpha.core.FixedAddr,alpha.core.PointerArithm,alpha.core.PointerSub,debug.ExprInspection -analyzer-store=region -verify -triple i686-apple-darwin9 -Wno-tautological-pointer-compare %s // RUN: %clang_analyze_cc1 -analyzer-checker=alpha.core.FixedAddr,alpha.core.PointerArithm,alpha.core.PointerSub,debug.ExprInspection -analyzer-store=region -verify -triple i686-apple-darwin9 -Wno-tautological-pointer-compare -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(int); void clang_analyzer_eval(int);
void f1() { void f1() {
int a[10]; int a[10];
int *p = a; int *p = a;
++p; ++p;
} }
▲ Show 20 Lines • Show All 322 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/reference.cpp

// RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.core,debug.ExprInspection -analyzer-store=region -verify -Wno-null-dereference -Wno-tautological-undefined-compare %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.core,debug.ExprInspection -analyzer-store=region -verify -Wno-null-dereference -Wno-tautological-undefined-compare -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(bool); void clang_analyzer_eval(bool);
typedef typeof(sizeof(int)) size_t; typedef typeof(sizeof(int)) size_t;
void malloc (size_t); void malloc (size_t);
void f1() { void f1() {
int const &i = 3; int const &i = 3;
▲ Show 20 Lines • Show All 249 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/region-store.c

// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix,debug.ExprInspection -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix,debug.ExprInspection -verify -analyzer-config eagerly-assume=false %s
int printf(const char *restrict,...); int printf(const char *restrict,...);
// Testing core functionality of the region store. // Testing core functionality of the region store.
// radar://10127782 // radar://10127782
int compoundLiteralTest() { int compoundLiteralTest() {
int index = 0; int index = 0;
for (index = 0; index < 2; index++) { for (index = 0; index < 2; index++) {
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/self-assign.cpp

// RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,unix.Malloc,debug.ExprInspection %s -verify -analyzer-output=text // RUN: %clang_analyze_cc1 -std=c++11 -analyzer-checker=core,cplusplus,unix.Malloc,debug.ExprInspection -analyzer-config eagerly-assume=false %s -verify -analyzer-output=text
extern "C" char *strdup(const char* s); extern "C" char *strdup(const char* s);
extern "C" void free(void* ptr); extern "C" void free(void* ptr);
namespace std { namespace std {
template<class T> struct remove_reference { typedef T type; }; template<class T> struct remove_reference { typedef T type; };
template<class T> struct remove_reference<T&> { typedef T type; }; template<class T> struct remove_reference<T&> { typedef T type; };
template<class T> struct remove_reference<T&&> { typedef T type; }; template<class T> struct remove_reference<T&&> { typedef T type; };
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/std-c-library-functions.c

// RUN: %clang_analyze_cc1 -analyzer-checker=unix.StdCLibraryFunctions,debug.ExprInspection -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=unix.StdCLibraryFunctions,debug.ExprInspection -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -triple i686-unknown-linux -analyzer-checker=unix.StdCLibraryFunctions,debug.ExprInspection -verify %s // RUN: %clang_analyze_cc1 -triple i686-unknown-linux -analyzer-checker=unix.StdCLibraryFunctions,debug.ExprInspection -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -triple x86_64-unknown-linux -analyzer-checker=unix.StdCLibraryFunctions,debug.ExprInspection -verify %s // RUN: %clang_analyze_cc1 -triple x86_64-unknown-linux -analyzer-checker=unix.StdCLibraryFunctions,debug.ExprInspection -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -triple armv7-a15-linux -analyzer-checker=unix.StdCLibraryFunctions,debug.ExprInspection -verify %s // RUN: %clang_analyze_cc1 -triple armv7-a15-linux -analyzer-checker=unix.StdCLibraryFunctions,debug.ExprInspection -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -triple thumbv7-a15-linux -analyzer-checker=unix.StdCLibraryFunctions,debug.ExprInspection -verify %s // RUN: %clang_analyze_cc1 -triple thumbv7-a15-linux -analyzer-checker=unix.StdCLibraryFunctions,debug.ExprInspection -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(int); void clang_analyzer_eval(int);
int glob; int glob;
typedef struct FILE FILE; typedef struct FILE FILE;
#define EOF -1 #define EOF -1
▲ Show 20 Lines • Show All 174 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/string.c

// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.cstring,unix.Malloc,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -Wno-null-dereference -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.cstring,unix.Malloc,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -Wno-null-dereference -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -DUSE_BUILTINS -analyzer-checker=core,unix.cstring,unix.Malloc,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -Wno-null-dereference -verify %s // RUN: %clang_analyze_cc1 -DUSE_BUILTINS -analyzer-checker=core,unix.cstring,unix.Malloc,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -Wno-null-dereference -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -DVARIANT -analyzer-checker=core,unix.cstring,unix.Malloc,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -Wno-null-dereference -verify %s // RUN: %clang_analyze_cc1 -DVARIANT -analyzer-checker=core,unix.cstring,unix.Malloc,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -Wno-null-dereference -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -DUSE_BUILTINS -DVARIANT -analyzer-checker=alpha.security.taint,core,unix.cstring,unix.Malloc,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -Wno-null-dereference -verify %s // RUN: %clang_analyze_cc1 -DUSE_BUILTINS -DVARIANT -analyzer-checker=alpha.security.taint,core,unix.cstring,unix.Malloc,alpha.unix.cstring,debug.ExprInspection -analyzer-store=region -Wno-null-dereference -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -DSUPPRESS_OUT_OF_BOUND -analyzer-checker=core,unix.cstring,unix.Malloc,alpha.unix.cstring.BufferOverlap,alpha.unix.cstring.NotNullTerminated,debug.ExprInspection -analyzer-store=region -Wno-null-dereference -verify %s // RUN: %clang_analyze_cc1 -DSUPPRESS_OUT_OF_BOUND -analyzer-checker=core,unix.cstring,unix.Malloc,alpha.unix.cstring.BufferOverlap,alpha.unix.cstring.NotNullTerminated,debug.ExprInspection -analyzer-store=region -Wno-null-dereference -verify -analyzer-config eagerly-assume=false %s
//===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===
// Declarations // Declarations
//===----------------------------------------------------------------------=== //===----------------------------------------------------------------------===
// Some functions are so similar to each other that they follow the same code // Some functions are so similar to each other that they follow the same code
// path, such as memcpy and __memcpy_chk, or memcmp and bcmp. If VARIANT is // path, such as memcpy and __memcpy_chk, or memcmp and bcmp. If VARIANT is
// defined, make sure to use the variants instead to make sure they are still // defined, make sure to use the variants instead to make sure they are still
▲ Show 20 Lines • Show All 1,483 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/svalbuilder-rearrange-comparisons.c

// RUN: %clang_analyze_cc1 -analyzer-checker=debug.ExprInspection,core.builtin -analyzer-config aggressive-binary-operation-simplification=true -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=debug.ExprInspection,core.builtin -analyzer-config aggressive-binary-operation-simplification=true -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_dump(int x); void clang_analyzer_dump(int x);
void clang_analyzer_eval(int x); void clang_analyzer_eval(int x);
void exit(int); void exit(int);
#define UINT_MAX (~0U) #define UINT_MAX (~0U)
#define INT_MAX (UINT_MAX & (UINT_MAX >> 1)) #define INT_MAX (UINT_MAX & (UINT_MAX >> 1))
▲ Show 20 Lines • Show All 927 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/switch-case.c

// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(int); void clang_analyzer_eval(int);
void clang_analyzer_warnIfReached(); void clang_analyzer_warnIfReached();
#define INT_MIN 0x80000000 #define INT_MIN 0x80000000
#define INT_MAX 0x7fffffff #define INT_MAX 0x7fffffff
// PR16833: Analyzer consumes memory until killed by kernel OOM killer // PR16833: Analyzer consumes memory until killed by kernel OOM killer
▲ Show 20 Lines • Show All 211 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/temp-obj-dtors-option.cpp

// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config c++-temp-dtor-inlining=false -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config c++-temp-dtor-inlining=false -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config c++-temp-dtor-inlining=true -DINLINE -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -analyzer-config c++-temp-dtor-inlining=true -DINLINE -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(bool); void clang_analyzer_eval(bool);
struct S { struct S {
int &x; int &x;
S(int &x) : x(x) { ++x; } S(int &x) : x(x) { ++x; }
~S() { --x; } ~S() { --x; }
Show All 12 Lines

cfe/trunk/test/Analysis/templates.cpp

// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -fblocks -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -fblocks -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -fblocks -analyzer-config c++-template-inlining=false -DNO_INLINE -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -fblocks -analyzer-config c++-template-inlining=false -DNO_INLINE -verify -analyzer-config eagerly-assume=false %s
void clang_analyzer_eval(bool); void clang_analyzer_eval(bool);
// Do not crash on this templated code which uses a block. // Do not crash on this templated code which uses a block.
typedef void (^my_block)(void); typedef void (^my_block)(void);
static void useBlock(my_block block){} static void useBlock(my_block block){}
template<class T> class MyClass; template<class T> class MyClass;
typedef MyClass<float> Mf; typedef MyClass<float> Mf;
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/temporaries.cpp

// RUN: %clang_analyze_cc1 -Wno-non-pod-varargs -analyzer-checker=core,cplusplus,debug.ExprInspection -analyzer-config cfg-temporary-dtors=false -verify -w -std=c++03 %s // RUN: %clang_analyze_cc1 -Wno-non-pod-varargs -analyzer-checker=core,cplusplus,debug.ExprInspection -analyzer-config cfg-temporary-dtors=false -verify -w -std=c++03 -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -Wno-non-pod-varargs -analyzer-checker=core,cplusplus,debug.ExprInspection -analyzer-config cfg-temporary-dtors=false -verify -w -std=c++11 %s // RUN: %clang_analyze_cc1 -Wno-non-pod-varargs -analyzer-checker=core,cplusplus,debug.ExprInspection -analyzer-config cfg-temporary-dtors=false -verify -w -std=c++11 -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -Wno-non-pod-varargs -analyzer-checker=core,cplusplus,debug.ExprInspection -DTEMPORARY_DTORS -verify -w -analyzer-config cfg-temporary-dtors=true,c++-temp-dtor-inlining=true %s -std=c++11 // RUN: %clang_analyze_cc1 -Wno-non-pod-varargs -analyzer-checker=core,cplusplus,debug.ExprInspection -DTEMPORARY_DTORS -verify -w -analyzer-config cfg-temporary-dtors=true,c++-temp-dtor-inlining=true -analyzer-config eagerly-assume=false %s -std=c++11
// RUN: %clang_analyze_cc1 -Wno-non-pod-varargs -analyzer-checker=core,cplusplus,debug.ExprInspection -DTEMPORARY_DTORS -w -analyzer-config cfg-temporary-dtors=true,c++-temp-dtor-inlining=true %s -std=c++17 // RUN: %clang_analyze_cc1 -Wno-non-pod-varargs -analyzer-checker=core,cplusplus,debug.ExprInspection -DTEMPORARY_DTORS -w -analyzer-config cfg-temporary-dtors=true,c++-temp-dtor-inlining=true -analyzer-config eagerly-assume=false %s -std=c++17
// Note: The C++17 run-line doesn't -verify yet - it is a no-crash test. // Note: The C++17 run-line doesn't -verify yet - it is a no-crash test.
extern bool clang_analyzer_eval(bool); extern bool clang_analyzer_eval(bool);
extern bool clang_analyzer_warnIfReached(); extern bool clang_analyzer_warnIfReached();
void clang_analyzer_checkInlined(bool); void clang_analyzer_checkInlined(bool);
#include "Inputs/system-header-simulator-cxx.h"; #include "Inputs/system-header-simulator-cxx.h";
▲ Show 20 Lines • Show All 1,142 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/test-after-div-zero.c

// RUN: %clang_analyze_cc1 -std=c99 -Dbool=_Bool -analyzer-checker=core,alpha.core.TestAfterDivZero -analyzer-output=text -verify %s // RUN: %clang_analyze_cc1 -std=c99 -Dbool=_Bool -analyzer-checker=core,alpha.core.TestAfterDivZero -analyzer-output=text -verify -analyzer-config eagerly-assume=false %s
// RUN: %clang_analyze_cc1 -x c++ -analyzer-checker=core,alpha.core.TestAfterDivZero -analyzer-output=text -verify %s // RUN: %clang_analyze_cc1 -x c++ -analyzer-checker=core,alpha.core.TestAfterDivZero -analyzer-output=text -verify -analyzer-config eagerly-assume=false %s
int var; int var;
void err_eq(int x) { void err_eq(int x) {
var = 77 / x; // expected-note {{Division with compared value made here}} var = 77 / x; // expected-note {{Division with compared value made here}}
if (x == 0) { } // expected-warning {{Value being compared against zero has already been used for division}} if (x == 0) { } // expected-warning {{Value being compared against zero has already been used for division}}
} // expected-note@-1 {{Value being compared against zero has already been used for division}} } // expected-note@-1 {{Value being compared against zero has already been used for division}}
▲ Show 20 Lines • Show All 194 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/unions.cpp

// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,debug.ExprInspection %s -verify // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,debug.ExprInspection %s -analyzer-config eagerly-assume=false -verify
extern void clang_analyzer_eval(bool); extern void clang_analyzer_eval(bool);
extern "C" char *strdup(const char *s); extern "C" char *strdup(const char *s);
namespace PR14054_reduced { namespace PR14054_reduced {
struct Definition; struct Definition;
struct ParseNode { struct ParseNode {
union { union {
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/unix-fns.c

// RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,unix.API,osx.API,optin.portability %s -analyzer-store=region -analyzer-output=plist -analyzer-eagerly-assume -analyzer-config faux-bodies=true -fblocks -verify -o %t.plist // RUN: %clang_analyze_cc1 -triple x86_64-apple-darwin10 -analyzer-checker=core,unix.API,osx.API,optin.portability %s -analyzer-store=region -analyzer-output=plist -analyzer-config faux-bodies=true -fblocks -verify -o %t.plist
// RUN: FileCheck --input-file=%t.plist %s // RUN: FileCheck --input-file=%t.plist %s
// RUN: mkdir -p %t.dir // RUN: mkdir -p %t.dir
// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.API,osx.API,optin.portability -analyzer-output=html -analyzer-config faux-bodies=true -fblocks -o %t.dir %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.API,osx.API,optin.portability -analyzer-output=html -analyzer-config faux-bodies=true -fblocks -o %t.dir %s
// RUN: rm -fR %t.dir // RUN: rm -fR %t.dir
struct _opaque_pthread_once_t { struct _opaque_pthread_once_t {
long __sig; long __sig;
char __opaque[8]; char __opaque[8];
}; };
▲ Show 20 Lines • Show All 3,068 Lines • Show Last 20 Lines

cfe/trunk/test/Analysis/weak-functions.c

// RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.core,debug.ExprInspection,unix.Malloc,unix.cstring,alpha.unix.cstring,unix.API,osx.API,osx.cocoa.RetainCount -Wno-null-dereference -Wno-tautological-compare -analyzer-store=region -fblocks -verify %s // RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.core,debug.ExprInspection,unix.Malloc,unix.cstring,alpha.unix.cstring,unix.API,osx.API,osx.cocoa.RetainCount -Wno-null-dereference -Wno-tautological-compare -analyzer-store=region -fblocks -verify -analyzer-config eagerly-assume=false %s
#define NULL 0 #define NULL 0
void clang_analyzer_eval(int); void clang_analyzer_eval(int);
void myFunc(); void myFunc();
void myWeakFunc() __attribute__((weak_import)); void myWeakFunc() __attribute__((weak_import));
void testWeakFuncIsNull() void testWeakFuncIsNull()
{ {
clang_analyzer_eval(myFunc == NULL); // expected-warning{{FALSE}} clang_analyzer_eval(myFunc == NULL); // expected-warning{{FALSE}}
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines