llvm-project/clang/lib/Analysis/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
  Support
  )

add_clang_library(clangAnalysis
  AnalysisDeclContext.cpp
  BodyFarm.cpp
  CFG.cpp
  CFGReachabilityAnalysis.cpp
  CFGStmtMap.cpp
  CallGraph.cpp
  CloneDetection.cpp
  CocoaConventions.cpp
  Consumed.cpp
  CodeInjector.cpp
  Dominators.cpp
  FormatString.cpp
  LiveVariables.cpp
  OSLog.cpp
  ObjCNoReturn.cpp
  PostOrderCFGView.cpp
  PrintfFormatString.cpp
  ProgramPoint.cpp
  PseudoConstantAnalysis.cpp
  ReachableCode.cpp
  ScanfFormatString.cpp
  ThreadSafety.cpp
  ThreadSafetyCommon.cpp
  ThreadSafetyLogical.cpp
  ThreadSafetyTIL.cpp
  UninitializedValues.cpp

  LINK_LIBS
  clangAST
  clangBasic
  clangLex
  )
[CMake] clang/lib: Satisfy dependencies to add actually used libraries on target_link_libraries() and LLVM_LINK_COMPONENTS. I will prune redundant dependencies later. llvm-svn: 196800 2013-12-10 03:04:43 +08:00			`set(LLVM_LINK_COMPONENTS`
			`Support`
			`)`

CMake: Builds and installs clang binary and libs (no docs yet). It must be under the `tools' subdirectory of the LLVM source tree. llvm-svn: 58180 2008-10-26 08:56:18 +08:00			`add_clang_library(clangAnalysis`
Rename AnalysisContext to AnalysisDeclContext. Not only is this name more accurate, but it frees up the name AnalysisContext for other uses. llvm-svn: 142782 2011-10-24 09:32:45 +08:00			`AnalysisDeclContext.cpp`
Implement faux-body-synthesis of well-known functions in the static analyzer when their implementations are unavailable. Start by simulating dispatch_sync(). This change is largely a bunch of plumbing around something very simple. We use AnalysisDeclContext to conjure up a fake function body (using the current ASTContext) when one does not exist. This is controlled under the analyzer-config option "faux-bodies", which is off by default. The plumbing in this patch is largely to pass the necessary machinery around. CallEvent needs the AnalysisDeclContextManager to get the function definition, as one may get conjured up lazily. BugReporter and PathDiagnosticLocation needed to be relaxed to handle invalid locations, as the conjured body has no real source locations. We do some primitive recovery in diagnostic generation to generate some reasonable locations (for arrows and events), but it can be improved. llvm-svn: 164339 2012-09-21 08:09:11 +08:00			`BodyFarm.cpp`
Move the source-level CFG from libAST to libAnalysis. llvm-svn: 76092 2009-07-17 02:13:04 +08:00			`CFG.cpp`
Migrate CFGReachabilityAnalysis out of the IdempotentOperationsChecker and into its own analysis file. llvm-svn: 126289 2011-02-23 09:51:59 +08:00			`CFGReachabilityAnalysis.cpp`
Add CFGStmtMap, which defines a mapping from Stmt* to CFGBlock*. The immediate intended use is in the unreachable code analysis. llvm-svn: 110230 2010-08-05 02:23:15 +08:00			`CFGStmtMap.cpp`
Refactor logic in ExprEngine for detecting 'noreturn' methods in NSException to a helper object in libAnalysis that can also be used by Sema. Not sure if the predicate name 'isImplicitNoReturn' is the best one, but we can massage that later. No functionality change. llvm-svn: 163759 2012-09-13 08:21:31 +08:00			`CallGraph.cpp`
[analyzer] Add basic capabilities to detect source code clones. This patch adds the CloneDetector class which allows searching source code for clones. For every statement or group of statements within a compound statement, CloneDetector computes a hash value, and finds clones by detecting identical hash values. This initial patch only provides a simple hashing mechanism that hashes the kind of each sub-statement. This patch also adds CloneChecker - a simple static analyzer checker that uses CloneDetector to report copy-pasted code. Patch by Raphael Isemann! Differential Revision: https://reviews.llvm.org/D20795 llvm-svn: 276782 2016-07-27 02:13:12 +08:00			`CloneDetection.cpp`
Move CocoaConventions.[h,cpp] from libChecker to libAnalysis. Similar to Format (format string checking), CocoaConventions has the potential to serve clients other than the static analyzer. llvm-svn: 122040 2010-12-17 13:21:58 +08:00			`CocoaConventions.cpp`
Patch by Chris Wailes <chris.wailes@gmail.com>. Reviewed by delesley, dblaikie. Add the annotations and code needed to support a basic 'consumed' analysis. Summary: This new analysis is based on academic literature on linear types. It tracks the state of a value, either as unconsumed, consumed, or unknown. Methods are then annotated as CallableWhenUnconsumed, and when an annotated method is called while the value is in the 'consumed' state a warning is issued. A value may be tested in the conditional statement of an if-statement; when this occurs we know the state of the value in the different branches, and this information is added to our analysis. The code is still highly experimental, and the names of annotations or the algorithm may be subject to change. llvm-svn: 188206 2013-08-13 05:20:55 +08:00			`Consumed.cpp`
Add support for the static analyzer to synthesize function implementations from external model files. Currently the analyzer lazily models some functions using 'BodyFarm', which constructs a fake function implementation that the analyzer can simulate that approximates the semantics of the function when it is called. BodyFarm does this by constructing the AST for such definitions on-the-fly. One strength of BodyFarm is that all symbols and types referenced by synthesized function bodies are contextual adapted to the containing translation unit. The downside is that these ASTs are hardcoded in Clang's own source code. A more scalable model is to allow these models to be defined as source code in separate "model" files and have the analyzer use those definitions lazily when a function body is needed. Among other things, it will allow more customization of the analyzer for specific APIs and platforms. This patch provides the initial infrastructure for this feature. It extends BodyFarm to use an abstract API 'CodeInjector' that can be used to synthesize function bodies. That 'CodeInjector' is implemented using a new 'ModelInjector' in libFrontend, which lazily parses a model file and injects the ASTs into the current translation unit. Models are currently found by specifying a 'model-path' as an analyzer option; if no path is specified the CodeInjector is not used, thus defaulting to the current behavior in the analyzer. Models currently contain a single function definition, and can be found by finding the file <function name>.model. This is an initial starting point for something more rich, but it bootstraps this feature for future evolution. This patch was contributed by Gábor Horváth as part of his Google Summer of Code project. Some notes: - This introduces the notion of a "model file" into FrontendAction and the Preprocessor. This nomenclature is specific to the static analyzer, but possibly could be generalized. Essentially these are sources pulled in exogenously from the principal translation. Preprocessor gets a 'InitializeForModelFile' and 'FinalizeForModelFile' which could possibly be hoisted out of Preprocessor if Preprocessor exposed a new API to change the PragmaHandlers and some other internal pieces. This can be revisited. FrontendAction gets a 'isModelParsingAction()' predicate function used to allow a new FrontendAction to recycle the Preprocessor and ASTContext. This name could probably be made something more general (i.e., not tied to 'model files') at the expense of losing the intent of why it exists. This can be revisited. - This is a moderate sized patch; it has gone through some amount of offline code review. Most of the changes to the non-analyzer parts are fairly small, and would make little sense without the analyzer changes. - Most of the analyzer changes are plumbing, with the interesting behavior being introduced by ModelInjector.cpp and ModelConsumer.cpp. - The new functionality introduced by this change is off-by-default. It requires an analyzer config option to enable. llvm-svn: 216550 2014-08-27 23:14:15 +08:00			`CodeInjector.cpp`
Update the CMake build for r146959's new files. llvm-svn: 146967 2011-12-20 16:42:15 +08:00			`Dominators.cpp`
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500 2010-07-16 10:11:22 +08:00			`FormatString.cpp`
CMake: Builds and installs clang binary and libs (no docs yet). It must be under the `tools' subdirectory of the LLVM source tree. llvm-svn: 58180 2008-10-26 08:56:18 +08:00			`LiveVariables.cpp`
Add support for __builtin_os_log_format[_buffer_size] This reverts commit r285007 and reapply r284990, with a fix for the opencl test that I broke. Original commit message follows: These new builtins support a mechanism for logging OS events, using a printf-like format string to specify the layout of data in a buffer. The _buffer_size version of the builtin can be used to determine the size of the buffer to allocate to hold the data, and then __builtin_os_log_format can write data into that buffer. This implements format checking to report mismatches between the format string and the data arguments. Most of this code was written by Chris Willmore. Differential Revision: https://reviews.llvm.org/D25888 llvm-svn: 285019 2016-10-25 04:39:34 +08:00			`OSLog.cpp`
Refactor logic in ExprEngine for detecting 'noreturn' methods in NSException to a helper object in libAnalysis that can also be used by Sema. Not sure if the predicate name 'isImplicitNoReturn' is the best one, but we can massage that later. No functionality change. llvm-svn: 163759 2012-09-13 08:21:31 +08:00			`ObjCNoReturn.cpp`
Pull TopologicallySortedCFG out of LiveVariables into its own analysis: PostOrderCFGView. llvm-svn: 142713 2011-10-22 10:14:23 +08:00			`PostOrderCFGView.cpp`
Add skeleton for a more structured way to analyzing pring format strings than what we currently have in Sema. This is both an experiment and a WIP. The idea is simple: parse the format string incrementally, constructing a well-structure representation of each format specifier. Each format specifier is then handed back one-by-one to a client via a callback. Malformed format strings are also handled with callbacks. The idea is to separate the parsing of the format string from the emission of diagnostics. Currently what we have in Sema for handling format strings is a mongrel of both that is hard to follow and difficult to modify (I can apply this label since I'm the original author of that code). This is in libAnalysis as it is reasonable generic and can potentially be used both by libSema and libChecker. Comments welcome. llvm-svn: 94702 2010-01-28 07:43:25 +08:00			`PrintfFormatString.cpp`
[analyzer] change "tag" in ProgramPoint from "void" to a ProgramPointTag. Having a notion of an actual ProgramPointTag will aid in introspection of the analyzer's behavior. For example, the GraphViz output of the analyzer will pretty-print the tags in a useful manner. llvm-svn: 137529 2011-08-13 07:04:46 +08:00			`ProgramPoint.cpp`
Several small changes to PseudoConstantAnalysis and the way IdempotentOperationChecker uses it. - Psuedo -> Pseudo (doh...) - C++ reference support - Added pseudoconstant test case for __block vars - Separated out static local checking from pseudoconstant analysis and generalized to non-local checking - Added missing test cases for storage false positives llvm-svn: 111832 2010-08-24 03:51:57 +08:00			`PseudoConstantAnalysis.cpp`
Start moving some of the logic for the unreachable code analysis out of libSema and into libAnalysis. llvm-svn: 96872 2010-02-23 10:39:16 +08:00			`ReachableCode.cpp`
Add most of the boilerplate support for scanf format string checking. This includes handling the parsing of scanf format strings and hooking the checking into Sema. Most of this checking logic piggybacks on what was already there for checking printf format strings, but the checking logic has been refactored to support both. What is left to be done is to support argument type checking in format strings and of course fix the usual tail of bugs that will follow. llvm-svn: 108500 2010-07-16 10:11:22 +08:00			`ScanfFormatString.cpp`
Thread Safety: Moving the analysis to a new file llvm-svn: 139369 2011-09-10 00:11:56 +08:00			`ThreadSafety.cpp`
Add the ability to use logical expressions for capability attributes. This is to allow requirements to be expressed not just in terms of lists, but in terms of logical expressions. Eg) void foo(void) __attribute__((requires_capability((FlightControl \|\| Worker) && !Logger))); This is WIP code. llvm-svn: 208439 2014-05-10 02:26:23 +08:00			`ThreadSafetyCommon.cpp`
			`ThreadSafetyLogical.cpp`
Thread Safety Analysis: add new node types to thread safety TIL. This fills in a few missing gaps in functionality. llvm-svn: 208830 2014-05-15 08:50:36 +08:00			`ThreadSafetyTIL.cpp`
Rename UninitializedValuesV2 to UninitializedValues. llvm-svn: 127657 2011-03-15 11:17:07 +08:00			`UninitializedValues.cpp`
Build system changes to use TableGen to generate the various diagnostics. This builds on the patch that Sebastian committed and then revert. Major differences are: - We don't remove or use the current ".def" files. Instead, for now, we just make sure that we're building the ".inc" files. - Fixed CMake makefiles to run TableGen and build the ".inc" files when needed. Tested with both the Xcode and Makefile generators provided by CMake, so it should be solid. - Fixed normal makefiles to handle out-of-source builds that involve the ".inc" files. I'll send a separate patch to the list with Sebastian's changes that eliminate the use of the .def files. llvm-svn: 67058 2009-03-17 07:06:59 +08:00
[CMake] Use LINK_LIBS instead of target_link_libraries(). llvm-svn: 202238 2014-02-26 14:41:29 +08:00			`LINK_LIBS`
Remove a goofy CMake hack and use the standard CMake facilities to express library-level dependencies within Clang. This is no more verbose really, and plays nicer with the rest of the CMake facilities. It should also have no change in functionality. llvm-svn: 158888 2012-06-21 09:30:21 +08:00			`clangAST`
[CMake] Reorder libdeps by alphabetical order. llvm-svn: 212919 2014-07-14 12:59:27 +08:00			`clangBasic`
[CMake] Update libdeps. llvm-svn: 212920 2014-07-14 13:01:53 +08:00			`clangLex`
Remove a goofy CMake hack and use the standard CMake facilities to express library-level dependencies within Clang. This is no more verbose really, and plays nicer with the rest of the CMake facilities. It should also have no change in functionality. llvm-svn: 158888 2012-06-21 09:30:21 +08:00			`)`