Lines Matching full:build

1 Command Line Usage: scan-build and CodeChecker
5 CodeChecker and scan-build are two CLI tools for using CSA on multiple files (translation units).
10 Comparison of CodeChecker and scan-build
26     - Generally much more feature-rich than scan-build.
32 scan-build
35 **scan-build** is a command line utility that enables a user to run the static analyzer over their codebase as part of performing a regular build (from the command line).
40 During a project build, as source files are compiled they are also analyzed in tandem by the static analyzer.
42 Upon completion of the build, results are then presented to the user within a web browser.
44 Will it work with any build system?
47 **scan-build** has little or no knowledge about how you build your code. It works by overriding the ``CC`` and ``CXX`` environment variables to (hopefully) change your build to use a "fake" compiler instead of the one that would normally build your project. This fake compiler executes either ``clang`` or ``gcc`` (depending on the platform) to compile your code and then executes the static analyzer to analyze your code.
49 This "poor man's interposition" works amazingly well in many cases and falls down in others. Please consult the information on this page on making the best use of **scan-build**, which includes getting it to work when the aforementioned hack fails to work.
60 Basic usage of ``scan-build`` is designed to be simple: just place the word "scan-build" in front of your build command::
62   $ scan-build make
63   $ scan-build xcodebuild
65 In the first case ``scan-build`` analyzes the code of a project built with ``make`` and in the second case ``scan-build`` analyzes a project built using ``xcodebuild``.
67 Here is the general format for invoking ``scan-build``::
69   $ scan-build [scan-build options] <command> [command options]
71 Operationally, ``scan-build`` literally runs <command> with all of the subsequent options passed to it. For example, one can pass ``-j4`` to ``make`` get a parallel build over 4 cores::
73   $ scan-build make -j4
75 In almost all cases, ``scan-build`` makes no effort to interpret the options after the build command; it simply passes them through. In general, ``scan-build`` should support parallel builds, but **not distributed builds**.
77 It is also possible to use ``scan-build`` to analyze specific files::
79   $ scan-build gcc -c t1.c t2.c
86 Windows users must have Perl installed to use scan-build.
88 ``scan-build.bat`` script allows you to launch scan-build in the same way as it described in the Basic Usage section above. To invoke scan-build from an arbitrary location, add the path to the folder containing scan-build.bat to your PATH environment variable.
90 If you have unexpected compilation/make problems when running scan-build with MinGW/MSYS the following information may be helpful:
96       $ scan-build [scan-build options] sh -c "make [make options]"
103 As mentioned above, extra options can be passed to ``scan-build``. These options prefix the build command. For example::
105   $ scan-build -k -V make
106   $ scan-build -k -V xcodebuild
111 - **-h** *(or no arguments)*: Display all ``scan-build`` options.
112 - **-k**, **--keep-going**: Add a "keep on going" option to the specified build command. This option currently supports ``make`` and ``xcodebuild``. This is a convenience option; one can specify this behavior directly using build options.
113 - **-v**: Verbose output from scan-build and the analyzer. **A second and third "-v" increases verbosity**, and is useful for filing bug reports against the analyzer.
114 - **-V**: View analysis results in a web browser when the build command completes.
115 - **--use-analyzer Xcode** *(or)* **--use-analyzer [path to clang]**: ``scan-build`` uses the 'clang' executable relative to itself for static analysis. One can override this behavior with this option by using the 'clang' packaged with Xcode (on OS X) or from the PATH.
117 A complete list of options can be obtained by running ``scan-build`` with no arguments.
119 Output of scan-build
122 The output of scan-build is a set of HTML files, each one which represents a separate bug report. A single ``index.html`` file is generated for surveying all of the bugs. You can then just open ``index.html`` in a web browser to view the bug reports.
124 Where the HTML files are generated is specified with a **-o** option to ``scan-build``. If **-o** isn't specified, a directory in ``/tmp`` is created to store the files (``scan-build`` will print a message telling you where they are). If you want to view the reports immediately after the build completes, pass **-V** to ``scan-build``.
136 Another option is to use ``--force-analyze-debug-code`` flag of **scan-build** tool which would enable assertions automatically.
138 Use Verbose Output when Debugging scan-build
141 ``scan-build`` takes a **-v** option to emit verbose output about what it's doing; two **-v** options emit more information. Redirecting the output of ``scan-build`` to a text file (make sure to redirect standard error) is useful for filing bug reports against ``scan-build`` or the analyzer, as we can see the exact options (and files) passed to the analyzer. For more comprehensible logs, don't perform a parallel build.
143 Run './configure' through scan-build
146 If an analyzed project uses an autoconf generated ``configure`` script, you will probably need to run ``configure`` script through ``scan-build`` in order to analyze the project.
150   $ scan-build ./configure
151   $ scan-build --keep-cc make
153 The reason ``configure`` also needs to be run through ``scan-build`` is because ``scan-build`` scans your source files by *interposing* on the compiler. This interposition is currently done by ``scan-build`` temporarily setting the environment variable ``CC`` to ``ccc-analyzer``. The program ``ccc-analyzer`` acts like a fake compiler, forwarding its command line arguments over to the compiler to perform regular compilation and ``clang`` to perform static analysis.
155 Running ``configure`` typically generates makefiles that have hardwired paths to the compiler, and by running ``configure`` through ``scan-build`` that path is set to ``ccc-analyzer``.
160 Conceptually Xcode projects for iPhone applications are nearly the same as their cousins for desktop applications. **scan-build** can analyze these projects as well, but users often encounter problems with just building their iPhone projects from the command line because there are a few extra preparative steps they need to take (e.g., setup code signing).
162 Recommendation: use "Build and Analyze"
169 Using scan-build directly
172 If you wish to use **scan-build** with your iPhone project, keep the following things in mind:
175 - Analyze your project using the ``Simulator`` as your base SDK. It is possible to analyze your code when targeting the device, but this is much easier to do when using Xcode's *Build and Analyze* feature.
178 Note that you can most of this without actually modifying your project. For example, if your application targets iPhoneOS 2.2, you could run **scan-build** in the following manner from the command line::
180   $ scan-build xcodebuild -configuration Debug -sdk iphonesimulator2.2
184   $ scan-build xcodebuild -configuration Debug -sdk iphonesimulator3.0
189 Recall that **scan-build** analyzes your project by using a compiler to compile the project and ``clang`` to analyze your project. The script uses simple heuristics to determine which compiler should be used (it defaults to ``clang`` on Darwin and ``gcc`` on other platforms). When analyzing iPhone projects, **scan-build** may pick the wrong compiler than the one Xcode would use to build your project. For example, this could be because multiple versions of a compiler may be installed on your system, especially if you are developing for the iPhone.
191 When compiling your application to run on the simulator, it is important that **scan-build** finds the correct version of ``gcc/clang``. Otherwise, you may see strange build errors that only happen when you run ``scan-build``.
193 **scan-build** provides the ``--use-cc`` and ``--use-c++`` options to hardwire which compiler scan-build should use for building your code. Note that although you are chiefly interested in analyzing your project, keep in mind that running the analyzer is intimately tied to the build, and not being able to compile your code means it won't get fully analyzed (if at all).
195 If you aren't certain which compiler Xcode uses to build your project, try just running ``xcodebuild`` (without **scan-build**). You should see the full path to the compiler that Xcode is using, and use that as an argument to ``--use-cc``.
206 If you have a Makefile based or similar build system then you can log the build commands with the help of CodeChecker::