To analyze files with Infer you can use the compilers
clang. You can also use Infer with
gcc, however, internally Infer will use
clang to compile your code. So, it may not work if your code does not compile with
Moreover, you can run Infer with a variety of build systems. Notice that you can run infer faster by running the compilation command in parallel, e.g.
infer run -- make -j8.
Please also take into account that if you wish to analyze a project, you should probably do
clean beforehand so that the compiler compiles all the files and so Infer also analyses all the files (see the previous section).
Here is an overview of the build systems supported by Infer. You can
get more information about how a particular build system is supported
by looking at the SYNOPSIS section of the infer-capture manual:
infer capture --help.
1 infer run -- ant
1 infer run -- buck <buck target>
will compute the list of Infer warnings in the targets passed as argument.
1 infer run -- buck --deep <buck target>
will compute the list of Infer warnings in the targets passed as argument and all the transitive dependencies.
The distinction between
--deep and the normal Buck complation mode is only supported for Java projects. For the other kinds of projects, the
--deep option has no effect.
The most robust way is to have
cmake generate a compilation database
that can be then processed by Infer:
1 2 3 4 cd build cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=1 .. cd .. infer run --compilation-database build/compile_commands.json
Alternatively, one can trick
cmake into using infer instead of the system’s compilers:
1 2 3 cd build infer compile -- cmake .. infer run -- make -j 4
1 2 infer run -- gradle <gradle task, e.g. "build"> infer run -- ./gradlew <gradle task, e.g. "build">
Infer can analyze projects that compile with
make by switching the
compilers (for C/C++/Objective-C or Java) called by
make with infer
wrappers. This doesn’t always work, for instance if the Makefiles
hardcode the absolute paths to the compilers (eg, if
/usr/bin/gcc instead of
gcc). This is because this integration
works by modifying
PATH under the hood.
1 infer run -- make <make target>
1 infer run -- mvn <maven target>
The most robust way is to generate a compilation database, then pass that database to Infer:
1 2 3 xcodebuild <your build options> | tee xcodebuild.log xcpretty -r json-compilation-database -o compile_commands.json < xcodebuild.log > /dev/null infer run --skip-analysis-in-path Pods --clang-compilation-db-files-escaped compile_commands.json
See also this comment on GitHub.
Infer also provides a direct integration to xcodebuild that swaps the compiler used by xcodebuild under the hood. For instance, for an iOS app:
1 infer run -- xcodebuild -target <target name> -configuration <build configuration> -sdk iphonesimulator
There is an alternative xcodebuild integration that uses
under the hood; use it by passing
--xcpretty to infer.
xctool to generate a compilation database then pass it to infer:
1 2 xctool.sh <your build options> -reporter json-compilation-database:compile_commands.json infer run --skip-analysis-in-path Pods --clang-compilation-db-files-escaped compile_commands.json
See also this comment on GitHub.
Using a compilation database
Many build systems like cmake, Xcode or Buck generate compilation databases. infer is able to use this database directly, simplifying its usage.
1 infer --compilation-database compile_commands.json
Other build systems
If infer doesn’t recognize your build system, you will get an error like this:
1 2 $ infer run -- foo Usage Error: Unsupported build command foo
If your build system behaves like one of the above, you can tell infer to use the same integration with
--force-integration. For instance this will proceed as if
foo was working the same way as
1 infer run --force-integration make -- foo
If your build system is more exotic, and it doesn’t support outputting compilation databases, please let us know by opening an issue.