Configure Sources and Build Options

Configure Polyspace to mimic your build closely to improve result precision

If you use a build command such as make or cmake for building your source code or you are able to generate a JSON compilation database using your build system, you can create a Polyspace^® Platform project from the build command or compilation database. The source files and build options in the Polyspace Platform project are determined from the compiler invocations in the build command or compilation database.

Otherwise, set options explicitly in your build configuration. Specifying your compiler for the option Compilation toolchain (Static Analysis) allows the analyzer to recognize compiler-specific keywords. Work around any additional errors using options such as Preprocessor definitions (-D) or Command/script to apply to preprocessed files (-post-preprocessing-command).

Functions

polyspace-configure (System Command) Create Polyspace Platform project, workspace, or options file from build command or compilation database

Polyspace Options

expand all

Sources

`Application source files (-sources, -sources-list-file)`	Add source files to Polyspace Platform project
`Application source folders`	Add source folders to Polyspace Platform project (Since R2024a)
`Include paths (-I)`	Specify paths to folders containing include files
`Include file name patterns`	Specify patterns for file names to be included in Polyspace Platform project (Since R2024a)
`Exclude patterns`	Specify folders or files to be excluded from static analysis or testing (Since R2024a)
`Project variables`	Define environment variables for use as shorthands in Polyspace Platform project (Since R2024a)

Language

`Source code language (-lang)`	Specify language of source files
`C standard version (-c-version)`	Specify C language standard followed in source code
`C++ standard version (-cpp-version)`	Specify C++ language standard followed in source code

Compiler and Processor

`Compilation toolchain for static analysis (-compiler, -compiler -target)`	Specify the compiler that you use to build your source code for static analysis
`Processor (-custom-target)`	Select the processor for the current build configuration
`-target`	Specify size of data types and endianness by selecting a predefined target processor or creating a custom processor
`Stop analysis if a file does not compile (-stop-if-compile-error)`	Specify that a compilation error must stop the analysis
`Implicit C(C++) compiler include paths`	View implicit compiler include paths extracted from your build command (Since R2024b)
`Implicit C(C++) compiler defines`	View implicit compiler defines extracted from your build command (Since R2024b)
`Source code encoding (-sources-encoding)`	Specify the encoding of source files
`Enum type definition (-enum-type-definition)`	Specify how to represent an `enum` with a base type
`-ignore-pragma-pack`	Ignore `#pragma pack` directives
`-sfr-types`	Specify sizes of `sfr` types for code developed with Keil or IAR compilers
`-no-uliterals`	Disable Polyspace definitions for `char16_t` or `char32_t`

Preprocessor Definitions

`Preprocessor definitions (-D)`	Replace macros in preprocessed code
`Disabled preprocessor definitions (-U)`	Undefine macros in preprocessed code
`Command/script to apply to preprocessed files (-post-preprocessing-command)`	Specify command or script to run on source files after preprocessing phase of analysis
`Implicit C(C++) compiler defines`	View implicit compiler defines extracted from your build command (Since R2024b)
`-regex-replace-rgx -regex-replace-fmt`	Make replacements in preprocessor directives
`-dump-preprocessing-info`	Show all macros implicitly defined during a particular analysis

Includes

`Include paths (-I)`	Specify paths to folders containing include files
`Additional include paths (-I)`	Specify build-specific include paths in addition to project-wide include paths (Since R2024a)
`Forced includes (-include)`	Specify files to be #include-d by every source file. (Since R2023b)
`Implicit C(C++) compiler include paths`	View implicit compiler include paths extracted from your build command (Since R2024b)
`Code from DOS or Windows file system (-dos)`	Consider that file paths are in MS-DOS style
`-include`	Specify files to be `#include`-ed by each C file in analysis

Advanced

`Round down results of negative integer division (-div-round-down)`	Specify that your compiler rounds down a negative quotient from dividing two integers (Since R2023b)
`Pack alignment value (-pack-alignment-value)`	Specify default structure packing alignment for code developed in Visual C++
`Shift right on signed integers as arithmetic shift (-logical-signed-right-shift)`	Specify that your compiler implements right shifts on signed integers as arithmetic shifts (Since R2023b)

Project Metadata

Name See name of Polyspace Platform project (Since R2024a)

Topics

Get Started

Configure Sources and Build Options in Project for Polyspace Analysis and Testing
Set build options in Polyspace project configuration, generate source paths and build options using build command or compilation database.
Information Gathered From Build Systems for Polyspace Analysis and Testing
Learn what information is extracted when you trace your build command to create a Polyspace Platform project.

Configure Options Using Build Commands

Create Polyspace Platform Project From Build Command in User Interface
Create a project in the Polyspace Platform user interface from a working build command or compilation database.
Requirements for Polyspace Project Creation from Build Systems
Learn why automatic Polyspace project creation might not work for your build system and how to work around some of the causes.
Select Files for Polyspace Project Using Pattern Matching
Select files to include in Polyspace project or options file using expressions with glob patterns.
Create Polyspace Platform Projects from Builds That Use Makefiles
Reuse build information in makefiles for Polyspace analysis and testing.
Modularize Polyspace Projects by Using Makefile Builds
Create a separate Polyspace project or options file for each binary in makefile build.
Create Polyspace Platform Projects From IDE Builds
Specify source files and configuration options by tracing your Visual Studio^® build.
Create Polyspace Platform Projects from CMake Builds
Reuse build information in CMakeLists files for Polyspace analysis and testing.

Configure Options Manually

Configure Sources and Build Options in Project for Polyspace Analysis and Testing
Set build options in Polyspace project configuration, generate source paths and build options using build command or compilation database.
Provide Standard Library Headers for Polyspace Analysis
Find paths to C or C++ standard library headers from your compiler and specify the paths in your Polyspace project.
Remove or Replace Keywords Before Compilation
Replace or remove keywords from preprocessed code to avoid compilation errors.
Gather Compilation Options Efficiently for Polyspace Analysis
Put workarounds for compilation errors into a single file and include that file in analysis.
Static Analysis Target Specification for Common Processors
This topic lists the target configurations for Polyspace static analysis of C/C++ code tailored for common processor families.

Support for C/C++ Language Standards and Extensions

C/C++ Language Standard Used in Polyspace Analysis
See supported language standards and the default standard used in Polyspace analysis.
C11 Language Elements Supported in Polyspace
Find which C11 language elements are supported for verification.
C++11 Language Elements Supported in Polyspace
Find which C++11 language elements are supported for verification.
C++14 Language Elements Supported in Polyspace
Find which C++14 language elements are supported for verification.
C++17 Language Elements Supported in Polyspace
Find which C++17 language elements are supported for verification.
C++20 Language Elements Supported in Polyspace
Find which C++20 language elements are supported for verification.
Keil or IAR Language Extensions Supported with Polyspace
Find which Keil or IAR-specific extensions of the C language standard are supported for verification.

Troubleshooting

Troubleshoot Compilation and Linking Errors

Learn why Polyspace compilation can fail even if your compiler build succeeds and how to work around the failures.