Code Options

Assembler

Property	Description
Additional Assembler Options `asm_additional_options` – StringList	Enables additional options to be supplied to the assembler. This property will have macro expansion applied to it.
Additional Assembler Options From File `asm_additional_options_from_file` – ProjFileName	Enables additional options to be supplied to the assembler from a file. This property will have macro expansion applied to it.
Assembler `arm_assembler_variant` – Enumeration	Specifies which assembler to use. SEGGER Assembler: Technology preview - For test purposes only.
Backup Additional Assembler Options `asm_additional_options_backup` – String	Value of additional assembler options prior to generic options processing.
Run Preprocessor `arm_preprocess_assembly_code` – Boolean	The assembly code file is preprocessed before assembly

Build

Property	Description
Always Rebuild `build_always_rebuild` – Boolean	Specifies whether or not to always rebuild the project/folder/file.
Batch Build Configurations `batch_build_configurations` – StringList	The set of configurations to batch build.
Build Options Generic File Name `build_generic_options_file_name` – ProjFileName	The file name containing the generic options.
Build Quietly `build_quietly` – Boolean	Suppress the display of startup banners and information messages.
Compilation Database File `compilation_database_file` – FileName	The name of the compilation database file
Dependency File Name `build_dependency_file_name` – FileName	The file name to contain the dependencies.
Enable Unused Symbol Removal `build_remove_unused_symbols` – Enumeration	Enable the removal of unused symbols from the executable.
Exclude From Build `build_exclude_from_build` – Boolean	Specifies whether or not to exclude the project/folder/file from the build.
GCC Prefix `gcc_prefix` – String	The string that is prepended to the gcc toolname e.g arm-none-eabi-. The macro $(GCCPrefix) is set to this value for external build command lines.
GCC Target `gcc_target` – String	The macro $(GCCTarget) is set to this value for build command lines.
GCC Version `gcc_version` – String	The macro $(GCCVersion) is set to this value for build command lines.
Generate Compilation Database `generate_compilation_database_file` – Boolean	Generate a JSON formatted file named by the Compilation Database property.
Generate Dependency File `build_generate_dependency_file` – Enumeration	Generate a dependency file
Include Debug Information `build_debug_information` – Boolean	Specifies whether symbolic debug information is generated.
Inputs File `inputs_file` – FileName	Specifies the inputs file to be used for Linking/Archiving. The files listed in this file will be used rather than the outputs of the project.
Inputs Order `inputs_order` – StringList	Specifies the order to supply input files to be used for Linking/Archiving.
Intermediate Directory `build_intermediate_directory` – DirPath	Specifies a relative path to the intermediate file directory. This property will have macro expansion applied to it. The macro $(IntDir) is set to this value.
Is C++ Project `is_cpp_project` – Enumeration	Supply C++ include directories and libraries to the project build.
Object File Name `build_object_file_name` – FileName	Specifies a name to override the default object file name.
Output Directory `build_output_directory` – DirPath	Specifies a relative path to the output file directory. This property will have macro expansion applied to it. The macro $(OutDir) is set to this value. The macro $(RootRelativeOutDir) is set relative to the Root Output Directory if specified.
Preprocess Output File Name `build_preprocess_output_file_name` – FileName	Specifies a name to override the default preprocess output file name.
Project Can Build In Parallel `project_can_build_in_parallel` – Enumeration	Specifies that dependent projects can be built in parallel. Default is No for Staging and Combining project types, Yes for all other project types.
Project Dependencies `project_dependencies` – StringList	Specifies the projects that are built before the current project is built. For Staging project types the dependent projects are built in sequence.
Project Directory `project_directory` – String	Path of the project directory relative to the directory containing the project file. The macro $(ProjectDir) is set to the absolute path of this property.
Project Macros `macros` – StringList	Specifies macro values which are expanded in project properties and for file names in Common configuration only. Each macro is defined as name=value and are seperated by ;.
Project Type `project_type` – Enumeration	Specifies the type of project to build. The options are Executable, Library, Object file, Staging, Combining, Externally Built Executable, Externally Built Library, Externally Built Object file, Preprocess.
Property Groups File `property_groups_file_path` – ProjFileName	The file containing the property groups for this project. This is applicable to Executable and Externally Built Executable project types only.
Root Output Directory `build_root_output_directory` – DirPath	Allows a common root output directory to be specified that can be referenced using the $(RootOutDir) macro.
Suppress Warnings `build_suppress_warnings` – Boolean	Don't report warnings.
Toolchain Directory `build_toolchain_directory` – DirPath	Specify the root of the toolchain directory. This property will have macro expansion applied to it. The macro $(ToolChainDir) is set to this value.
Treat Warnings as Errors `build_treat_warnings_as_errors` – Boolean	Treat all warnings as errors.
Use External GCC `use_external_gcc` – Boolean	The build will issue gcc commands.

Code Analyzer

Property	Description
Analyze After Compile `analyze_after_compile` – Boolean	Run the static code analyzer after compile
Analyze Command `analyze_command` – CommandLine	The command to execute for the Analyze action. This property will have macro expansion applied to it with the additional macros: $(DEFINES) contains a space seperated list of preprocessor definitions as set in the Preprocessor Definitions property. $(INCLUDES) contains a space seperated list of user include directories as set in the User Include Directories property.
Analyze Command Options C `analyze_command_c_options` – StringList	Options to supply to the analyze command for C source files.
Analyze Command Options C++ `analyze_command_cpp_options` – StringList	Options to supply to the analyze command for C++ source files.
Clang Tidy Checks C `clang_tidy_checks_c` – StringList	Checks to supply to clang-tidy for C source files.
Clang Tidy Checks C++ `clang_tidy_checks_cpp` – StringList	Checks to supply to clang-tidy for C++ source files.

Code Generation

Property	Description
ARM ABI Type `arm_abi` – Enumeration	Specifies the ABI type to generate code for. The options are: AAPCS generate calls to the C library to implement floating point operations. None will not specify the ABI.
ARM Advanced SIMD Auto Vectorize `arm_advanced_SIMD_auto_vectorize` – Boolean	Enable automatic code generation for Advanced SIMD.
ARM Advanced SIMD Type `arm_advanced_SIMD_type` – Enumeration	Specifies the Advanced SIMD type to generate code for. The options are: NEON - Cortex-A based processors
ARM Architecture `arm_architecture` – Enumeration	Specifies the version of the instruction set to generate code for. The options are: v4T - ARM7TDMI and ARM920T processors v5TE - ARM9E, Feroceon and XScale processors v6 - ARM11 processors v6M - Cortex-M0/M1 processors v7M - Cortex-M3 processors v7EM - Cortex-M4/M7 processors v7R - Cortex-R4/R5/R8 processors v7A - Cortex-A5/A7/A8/A9/A17 processors v8R - Cortex-R52 processors v8A - Cortex-A32/A35/A53/A55/A57/A72/A73/A75 processors v8M_Baseline - Cortex M23 processor v8M_Mainline - Cortex M33 processor v8.1M_Mainline - Cortex-M55/M85 processors None The corresponding preprocessor definitions: __ARM_ARCH_4T__ __ARM_ARCH_5TE__ __ARM_ARCH_6__ __ARM_ARCH_6M__ __ARM_ARCH_7M__ __ARM_ARCH_7EM__ __ARM_ARCH_7R__ __ARM_ARCH_7A__ __ARM_ARCH_8R__ __ARM_ARCH_8A__ __ARM_ARCH_8M_BASELINE__ __ARM_ARCH_8M_MAINLINE__ __ARM_ARCH_81M_MAINLINE__ are defined.
ARM Core Type `arm_core_type` – Enumeration	Specifies the core to generate code for. The options are: ARM7TDMI, ARM7TDMI-S, ARM720T ARM920T, ARM946E-S, ARM966E-S, ARM968E-S, ARM926EJ-S ARM1136J-S, ARM1136JF-S, ARM1176JZ-S, ARM1176JZF-S Cortex-M0, Cortex-M0+, Cortex-M1, Cortex-M23, Cortex-M3, Cortex-M33, Cortex-M4, Cortex-M55, Cortex-M7, Cortex-M85 Cortex-R4, Cortex-R4F, Cortex-R5, Cortex-R7, Cortex-R8 Cortex-R52 Cortex-A5, Cortex-A7, Cortex-A8, Cortex-A9, Cortex-A15, Cortex-A17 Cortex-A32, Cortex-A35, Cortex-A53, Cortex-A55, Cortex-A57, Cortex-A72, Cortex-A73, Cortex-A75 XScale None If this property is set to None then the architecture property is used
ARM FP ABI Type `arm_fp_abi` – Enumeration	Specifies the FP ABI type to generate code for. The options are: Soft generate calls to the C library to implement floating point operations. SoftFP generate VFP code to implement floating point operations. Hard generate VFP code to implement floating point operations and use VFP registers to pass floating point parameters on function calls. None will not specify the FP ABI or the FPU.
ARM FPU Type `arm_fpu_type` – Enumeration	Specifies the FPU type to generate code for. The options are: VFP - ARM9/ARM11 based processors VFP9 - the same as VFP VFPv3-D32 - Cortex-A/Cortex-R based processors VFPv3-D16 - Cortex-A/Cortex-R based processors VFPv4-D32 - Cortex-A/Cortex-R based processors VFPv4-D16 - Cortex-A/Cortex-R based processors FPv4-SP-D16 - Cortex-M4 processors FPv5-SP-D16 - Cortex-M7/M33/R52 processors FPv5-D16 - Cortex-M7/M55 processors FP-ARMv8 - Cortex-A/Cortex-R processors The corresponding preprocessor definitions: __ARM_ARCH_VFP__ __ARM_ARCH_VFP3_D32__ __ARM_ARCH_VFP3_D16__ __ARM_ARCH_VFP4_D32__ __ARM_ARCH_VFP4_D16__ __ARM_ARCH_FPV4_SP_D16__ __ARM_ARCH_FPV5_SP_D16__ __ARM_ARCH_FPV5_D16__ __ARM_ARCH_FP_ARMv8__ are defined.
Additional C++ Modules `gcc_additional_modules` – StringList	Add additional C++ Modules to the module mapper file of the form name=filename.
Byte Order `arm_endian` – Enumeration	Specify the byte order of the target processor. The options are: Little little endian code and data. Big big endian code and data. BE-8 little endian code and big endian data. None do not specify the endian.
CM0/CM0+/CM1 Has Small Multiplier `arm_cm0_has_small_multiplier` – Boolean	The CM0/CM0+/CM1 core has the small multiplier.
Code Model. `arm64_code_model` – Enumeration	Specify the code model to generate code for.
Data Model. `arm64_abi` – Enumeration	Specify the data model to generate code for.
Data Sections `gcc_data_sections` – Boolean	Place each data item in it's own section.
Debugging Level `gcc_debugging_level` – Enumeration	Specifies the level of debugging information to generate. The options are: None - no debugging information Level 1 - backtrace and line number debugging information Level 2 - Level 1 and variable display debugging information Level 3 - Level 2 and macro display debugging information
Disable Function Inlining `gcc_disable_function_inlining` – Boolean	Disable auto inlining of functions when optimization enables this.
Dwarf Version `gcc_dwarf_version` – Enumeration	Specifies the version of Dwarf debugging information to generate.
Enable Coroutine Support `gcc_enable_coroutines` – Boolean	Specifies whether coroutine support is enabled for C++ programs.
Enable Exception Support `cpp_enable_exceptions` – Enumeration	Specifies whether exception support is enabled for C++ programs.
Enable Linker Relaxation `rv_relax` – Enumeration	If enabled the linker may be able to optimize the instructions used to access symbols.
Enable Modules Support `gcc_enable_modules` – Boolean	Specifies whether modules support is enabled for C++ programs.
Enable Precompiled Header File `gcc_enable_precompiled_header` – Boolean	Enable use of a precompiled header file for the project.
Enable RTTI Support `cpp_enable_rtti` – Enumeration	Specifies whether RTTI support is enabled for C++ programs.
Enable Save Restore `rv_save_restore` – Enumeration	If enabled use smaller but slower prolog and epilog code.
Enable Stack Overflow Prevention `stack_overflow_prevention` – Boolean	Enable Stack Overflow Prevention. For more information read: https://wiki.segger.com/Stack_Overflow_Prevention
Enable Use Of __cxa_atexit `gcc_use_cxa_at_exit` – Boolean	Enable compiler usage of __cxa_atexit.
Enable Use Of __cxa_guard_acquire/release `gcc_thread_safe_statics` – Boolean	Enable compiler usage of __cxa_guard/acquire/release to enable thread-safe initialization of local statics.
Enumeration Size `gcc_short_enum` – Enumeration	Select between minimal container sized enumerations and int sized enumerations.
FP16 Format. `arm_fp16_format` – Enumeration	The format of 16-bit floating point numbers.
Fast Math `gcc_fast_math` – Enumeration	Enable fast-math mode.
Function Sections `gcc_function_sections` – Boolean	Place each function in it's own section.
GNU Tools Prefix `rv_toolchain_prefix` – String	The RISC-V GNU tools prefix e.g andes-, the macro $(GCCTarget) has this value prepended to it.
Generate Dwarf Debug Types `gcc_dwarf_generate_debug_types` – Boolean	Generate Dwarf .debug_types section.
Generate Dwarf Pubnames `gcc_dwarf_generate_pubnames` – Boolean	Generate Dwarf .debug_pubnames and .debug_pubtypes sections.
Generate Listing File `asm_generate_listing_file` – Boolean	An source/assembler listing file is generated which can be found in the output files folder
Instruction Set `arm_instruction_set` – Enumeration	Specifies the instruction set to generate code for.
Instrument Functions `arm_instrument_functions` – Boolean	Specifies whether instrumentation calls are generated for function entry and exit.
Is C++ Module `is_cpp_module` – Enumeration	The file contains an importable C++ module unit.
Keep Link Time Optimization Intermediate Files `link_keep_lto_files` – Boolean	Specifies whether to keep the link time optimization resolution and object files.
Link Time Optimization `link_time_optimization` – Boolean	Specifies whether the project should be built for optimization at link time.
Link Time Optimization Additional Options `lto_additional_options` – StringList	Enables additional options to be supplied to the link time optimization process
Long Calls `arm_long_calls` – Boolean	Specifies whether function calls are made using absolute addresses.
Machine Outliner [segger-cc] `clang_machine_outliner` – Enumeration	Select machine outliner mode. An optimization that reduces code size by identifying identical code sequences across functions and replaces them with a call to a function which contains the identical code sequence.
Math Errno `arm_math_errno` – Enumeration	Set errno after calling math functions that are executed with a single instruction, e.g., sqrt.
Merge Globals [segger-cc] `clang_merge_globals` – Boolean	Select whether global declarations are merged. This may reduce code size and increase execution speed for some applications. However, if functions are not used in an application and are eliminated by the linker, merged globals may increase the data size requirement of an application.
No COMMON `gcc_no_common` – Enumeration	Don't put globals in the common section
Omit Frame Pointer `gcc_omit_frame_pointer` – Enumeration	Specifies whether a frame pointer register is omitted if not required.
Optimization Level `gcc_optimization_level` – Enumeration	Specifies the optimization level to use. The options are: None - don't specify an optimization level Debug - optimize for debug experience. Level 0 - no optimization, fastest compilation and best debug experience. Level 1 - optimize minimally. Level 2 for speed Level 2 balanced Level 2 for size Level 3 for more speed - optimize even more, will take longer to compile and may produce much larger code.
Outline Atomics `arm64_outline_atomics` – Enumeration	Enable or disable calls to out-of-line helpers to implement atomic operations
Precompiled Header File `gcc_precompiled_header` – Boolean	The precompiled header file for the project.
RISC-V ABI `rv_abi` – Enumeration	Specifies the floating point instruction set to generate code for. The options are: Default - select abi based on ISA ilp32 - software floating point ilp32d - hardware double precision floating point ilp32e - embedded abi ilp32f - hardware single precision floating point lp64 - software floating point lp64d - hardware double precision floating point lp64f - hardware single precision floating point None - do not supply an abi command line option
RISC-V ISA `rv_architecture` – Enumeration	Specifies the instruction set to generate code for. The options are: rv32e - RV32E with no extensions rv32ec - RV32E with C extension rv32ea - RV32E with A extension rv32eac - RV32E with A and C extension rv32em - RV32E with M extension rv32emc - RV32E with M and C extensions rv32ema - RV32E with M and A extensions rv32emac - RV32E with M, A and C extensions rv32i - RV32I with no extensions rv32ia - RV32I with A extension rv32ic - RV32I with C extension rv32iac - RV32I with A and C extensions rv32im - RV32I with M extension rv32imc - RV32I with M and C extensions rv32imf - RV32I with M and F extensions rv32imfc - RV32I with M, F and C extensions rv32ima - RV32I with M and A extensions rv32imac - RV32I with M, A and C extensions rv32imaf - RV32I with M, A and F extensions rv32imafc - RV32I with M, A, F and C extensions rv32g - RV32I with M, A, F and D extensions rv32gc - RV32I with M, A, F, D and C extensions rv64i - RV64I with no extensions rv64ia - RV64I with A extension rv64ic - RV64I with C extension rv64im - RV64I with M extension rv64imc - RV64I with M and C extensions rv64imf - RV64I with M, and F and C extensions rv64imfc - RV64I with M, F and C extensions rv64ima - RV64I with M and A extensions rv64imac - RV64I with M, A and C extensions rv64imaf - RV64I with M, A and F extensions rv64imafc - RV64I with M, A, F and C extensions rv64g - RV64I with M, A, F and D extensions rv64gc - RV64I with M, A, F, D and C extensions None - do not supply an architecture command line option
RISC-V ISA Extension `rv_arch_ext` – String	Additional extensions to supply to the tools
RISC-V ISA P Extension `rv_arch_p` – Boolean	Add support for P extension
RISC-V ISA V Extension `rv_arch_v` – Boolean	Add support for V extension
RISC-V ISA Zba Extension `rv_arch_zba` – Boolean	Add support for Zba extension
RISC-V ISA Zbb Extension `rv_arch_zbb` – Boolean	Add support for Zbb extension
RISC-V ISA Zbc Extension `rv_arch_zbc` – Boolean	Add support for Zbc extension
RISC-V ISA Zbkb Extension `rv_arch_zbkb` – Boolean	Add support for Zbkb extension
RISC-V ISA Zbkx Extension `rv_arch_zbkx` – Boolean	Add support for Zbkx extension
RISC-V ISA Zbs Extension `rv_arch_zbs` – Boolean	Add support for Zbs extension
RISC-V ISA Zcb Extension `rv_arch_zcb` – Boolean	Add support for Zcb extension
RISC-V ISA Zcmp Extension `rv_arch_zcmp` – Boolean	Add support for Zcmp extension
RISC-V ISA Zfinx Extension `rv_arch_zfinx` – Boolean	Add support for Zfinx extension
RISC-V ISA Zicond Extension `rv_arch_zicond` – Boolean	Add support for Zicond extension
RISC-V ISA Zicsr Extension `rv_arch_zicsr` – Boolean	Add support for Zicsr extension
RISC-V ISA Zifencei Extension `rv_arch_zifencei` – Boolean	Add support for Zifencei extension
RISC-V ISA Zmmul Extension `rv_arch_zmmul` – Boolean	Add support for Zmmul extension
RISC-V Memory Code Model `rv_mcmodel` – Enumeration	Specifies the 64-bit code model to generate code for. The options are: medlow - memory map has address ranges of -2Gb to +2Gb medany - memory map has address ranges of +2Gb None - do not supply an mcmodel command line option
Relocation Model [segger-cc] `clang_relocation_model` – Enumeration	Select relocation model.
Signed Char `gcc_signed_char` – Enumeration	The char type is considered to be signed char.
Stack Sizes `generate_stack_sizes` – Boolean	Generate stack sizes section
Strict Aliasing `gcc_strict_aliasing` – Enumeration	Strictest aliasing rules are allowed for optimization.
Thread Model [segger-cc] `clang_thread_model` – Enumeration	Select thread model.
Thread-Local Storage Model `gcc_tls_model` – Enumeration	Thread-local storage model.
Thread-Local Storage Pointer `arm_tls_model` – Enumeration	Thread-local storage pointer access model.
Unaligned Access Support `arm_unaligned_access` – Enumeration	Unaligned word and half-words can be accessed. The options are: Yes enable unaligned word and half-words. No disable unaligned word and half-words. Auto disable unaligned word and half-word access for v4T/v5TE/v6M/v8M_Baseline architectures, enable for others.
Unaligned Access Support. `rv_unaligned_access` – Enumeration	Unaligned word and half-words can be accessed. The options are: Yes enable unaligned word and half-words. No disable unaligned word and half-words.
Unwind Tables `arm_unwind_tables` – Enumeration	Generate unwind tables for C code.
Use Builtins `arm_use_builtins` – Enumeration	Use built-in library functions e.g. scanf.
Vector Extension `arm_v81M_mve_type` – Enumeration	Specifies the vector extension type to generate code for. The options are: MVE - integer instructions MVE.FP - integer and single precision floating-point instructions
Wide Character Size `gcc_wchar_size` – Enumeration	Select between standard 32-bit or shorter 16-bit size for wide characters and wchar_t.
v7A/v7R Has Integer Divide Instructions `arm_v7_has_divide_instructions` – Boolean	The v7A architecture has integer divide instructions in both ARM and Thumb instruction sets. The v7R architecture has integer divide instructions in the ARM instruction set. The v7R architecture always has integer divide instructions in the Thumb instruction set.
v8.1M Has PACBTI Instructions `arm_v81M_has_pacbti` – Boolean	The v8.1M architecture has PACBTI instructions.
v8A Architecture Extension `arm_v8A_architecture_extension` – Enumeration	The v8A architecture extension.
v8A Has BF16 Instructions `arm_v8A_has_bf16` – Boolean	The v8A architecture has brain half-precision floating point instructions.
v8A Has CRC Instructions `arm_v8A_has_crc` – Boolean	The v8A architecture has CRC instructions.
v8A Has Crypto Instructions `arm_v8A_has_crypto` – Boolean	The v8A architecture has crypto instructions.
v8A Has FP16 Instructions `arm_v8A_has_fp16` – Boolean	The v8A architecture has half-precision floating point instructions.
v8A Has FP16FML Instructions `arm_v8A_has_fp16fml` – Boolean	The v8A architecture has half-precision floating point fmla instructions.
v8A Has I8MM Instructions `arm_v8A_has_i8mm` – Boolean	The v8A architecture has 8-bit integer maxtrix multiply instructions.
v8M Has CMSE Instructions `arm_v8M_has_cmse` – Boolean	The v8M architecture has CMSE instructions.
v8M Has DSP Instructions `arm_v8M_has_dsp` – Boolean	The v8M architecture has DSP instructions.

Combining

Property	Description
Combine Command `combine_command` – CommandLine	The command to execute. This property will have macro expansion applied to it with the macro $(CombiningOutputFilePath) set to the output filepath of the combine command and the macro $(CombiningRelInputPaths) is set to the (project relative) names of all of the files in the project.
Combine Command Working Directory `combine_command_wd` – String	The working directory in which the combine command is run. This property will have macro expansion applied to it.
Output File Path `combine_output_filepath` – String	The output file path the stage command will create. This property will have macro expansion applied to it.
Set To Read-only `combine_set_readonly` – Enumeration	Set the output file to read only or read/write.

Compiler

Property	Description
Additional C Compiler Only Options `c_only_additional_options` – StringList	Enables additional options to be supplied to the C compiler only. This property will have macro expansion applied to it.
Additional C Compiler Only Options From File `c_only_additional_options_from_file` – ProjFileName	Enables additional options to be supplied to the C compiler only from a file. This property will have macro expansion applied to it.
Additional C++ Compiler Only Options `cpp_only_additional_options` – StringList	Enables additional options to be supplied to the C++ compiler only. This property will have macro expansion applied to it.
Additional C++ Compiler Only Options From File `cpp_only_additional_options_from_file` – ProjFileName	Enables additional options to be supplied to the C++ compiler only from a file. This property will have macro expansion applied to it.
Additional C/C++ Assembler Options `c_asm_additional_options` – StringList	Enables additional options to be supplied to the assembler when used by the C/C++ compiler. This property will have macro expansion applied to it.
Additional C/C++ Compiler Options `c_additional_options` – StringList	Enables additional options to be supplied to the C/C++ compiler. This property will have macro expansion applied to it.
Additional C/C++ Compiler Options From File `c_additional_options_from_file` – ProjFileName	Enables additional options to be supplied to the C/C++ compiler from a file. This property will have macro expansion applied to it.
Backup Additional C Compiler Only Options `c_only_additional_options_backup` – String	Value of additional C compiler options prior to generic options processing
Backup Additional C++ Compiler Only Options `cpp_only_additional_options_backup` – String	Value of additional C++ compiler options prior to generic options processing
Backup Additional Compiler Options `c_additional_options_backup` – String	Value of additional compiler options prior to generic options processing
C Language Standard `gcc_c_language_standard` – Enumeration	Specifies the language standard to use when compiling C files. The options are: None - don't specify a language standard c89/gnu89 c90/gnu90 c99/gnu99 c11/gnu11 c17/gnu17
C++ Language Standard `gcc_cplusplus_language_standard` – Enumeration	Specifies the language standard to use when compiling C files. The options are: None - don't specify a language standard c++98/gnu++98 c++11/gnu++11 c++14/gnu++14 c++20/gnu++20 c++17/gnu++17
Color Diagnostics `compiler_color_diagnostics` – Enumeration	Specifies whether to enable color diagnostic output.
Compile C Files As C++ `c_files_are_cpp` – Boolean	Compile files that have the .c extension with the C++ compiler.
Compiler `arm_compiler_variant` – Enumeration	Specifies which compiler to use.
Compiler Has -Oz `gcc_has_Oz_optimization_level` – Boolean	The compiler support the -Oz optization level.
Enable All Warnings `gcc_enable_all_warnings` – Boolean	Enables the compiler warnings that are specified in the Enable All Warnings (C Compiler Only) Command Line Options properties.
Enable All Warnings C Compiler Only Command Line Options `gcc_c_only_all_warnings_command_line_options` – StringList	The command line options supplied to the C compiler when Enable All Warnings is enabled.
Enable All Warnings C++ Compiler Only Command Line Options `gcc_cpp_only_all_warnings_command_line_options` – StringList	The command line options supplied to the C++ compiler when Enable All Warnings is enabled.
Enable All Warnings Command Line Options `gcc_all_warnings_command_line_options` – StringList	The command line options supplied to the compiler when Enable All Warnings is enabled.
Enforce ANSI Checking `c_enforce_ansi_checking` – Boolean	Perform additional checks for ensure strict conformance to the selected ISO (ANSI) C or C++ standard.
Enforce ANSI Checking C Command Line Options `gcc_c_only_enforce_ansi_checking_command_line_options` – StringList	The command line options supplied to the C compiler when Enforce ANSI Checking is enabled.
Enforce ANSI Checking C++ Command Line Options `gcc_cpp_only_enforce_ansi_checking_command_line_options` – StringList	The command line options supplied to the C++ compiler when Enforce ANSI Checking is enabled.
Enforce ANSI Checking Command Line Options `gcc_enforce_ansi_checking_command_line_options` – StringList	The command line options supplied to the compiler when Enforce ANSI Checking is enabled.
GNU Version [segger-cc] `clang_gnu_version` – Enumeration	Specifies value of __GNU__ and related macros
Keep Assembly Source `arm_keep_assembly` – Boolean	Specifies whether assembly code generated by the compiler is kept.
Keep Preprocessor Output `arm_keep_preprocessor_output` – Boolean	Specifies whether preprocessor output generated by the compiler is kept.
No Unsupported Architecture [segger-cc] `segger_cc_no_unsupported_architecture` – Boolean	Disable unsupported architecture warning.
Show Caret `compiler_diagnostics_show_caret` – Enumeration	Specifies whether caret is displayed in compiler diagnostics.
Supply Absolute File Path `arm_supply_absolute_file_path` – Boolean	Specifies whether absolute file paths are supplied to the compiler.
Supply Execution Character Set `compiler_supply_editor_execute_charset` – Boolean	Specifies whether to supply the editor file encoding as the execution character set.
Supply Input Character Set `compiler_supply_editor_input_charset` – Boolean	Specifies whether to supply the editor file encoding as the input character set.
Use Compiler Driver `use_compiler_driver` – Boolean	The build will issue cc commands.

External Build

Property	Description
Archive Command `external_archive_command` – CommandLine	The command line to archive object files. This property will have macro expansion applied to it with the additional macros: $(TargetPath) contains the full file name of the Library File Name property . $(RelTargePath) contains the project directory relative file name of the Object File Name property. $(Objects) a space seperated list of files to archive, generated from the source files of the project OR. $(ObjectsFilePath) contains the full file name of the file containing the list of files to archive $(RelObjectsFilePath) contains the project directory relative file name of the file containing the list of files to link
Assemble Command `external_assemble_command` – CommandLine	The command line to assemble an assembly source file. This property will have macro expansion applied to it with the additional macros: $(TargetPath) contains the full file name of the Object File Name property. $(RelTargePath) contains the project directory relative file name of the Object File Name property. $(AsmOptions) contains a space seperated list of options as set in the Additional Assembler Options property. $(DependencyPath) contains the filename of the .d file that is required to be output by the compilation for dependency support. $(RelDependencyPath) contains the relative filename of the .d file that is required to be output by the compilation for dependency support. $(Defines) contains a space seperated list of preprocessor definitions as set in the Preprocessor Definitions property. $(Undefines) contains a space seperated list of preprocessor undefinitions as set in the Preprocessor Definitions property. $(Includes) contains a space seperated list of user include directories as set in the User Include Directories property. $(IncludeFiles) contains a space seperated list of include files as set in the Include Files property.
Build Command `external_build_command` – CommandLine	The command line to build the executable e.g. make. This property will have macro expansion applied to it.
C Compile Command `external_c_compile_command` – CommandLine	The command line to compile a C source file. This property will have macro expansion applied to it with the additional macros: $(TargetPath) contains the full file name of the Object File Name property. $(RelTargePath) contains the project directory relative file name of the Object File Name property. $(COptions) contains a space seperated list of options as set in the C Additional C/C++ Compiler Options property. $(COnlyOptions) contains a space seperated list of options as set in the C Additional C Compiler Only Options property. $(DependencyPath) contains the filename of the .d file that is required to be output by the compilation for dependency support. $(RelDependencyPath) contains the relative filename of the .d file that is required to be output by the compilation for dependency support. $(Defines) contains a space seperated list of preprocessor definitions as set in the Preprocessor Definitions property. $(Undefines) contains a space seperated list of preprocessor undefinitions as set in the Preprocessor Definitions property. $(Includes) contains a space seperated list of user include directories as set in the User Include Directories property. $(IncludeFiles) contains a space seperated list of include files as set in the Include Files property.
C++ Compile Command `external_cpp_compile_command` – CommandLine	The command line to compile a C++ source file. This property will have macro expansion applied to it with the additional macros: $(TargetPath) contains the full file name of the Object File Name property. $(RelTargePath) contains the project directory relative file name of the Object File Name property. $(COptions) contains a space seperated list of options as set in the C Additional C/C++ Compiler Options property. $(CppOnlyOptions) contains a space seperated list of options as set in the C Additional C++ Compiler Only Options property. $(DependencyPath) contains the filename of the .d file that is required to be output by the compilation for dependency support. $(RelDependencyPath) contains the relative filename of the .d file that is required to be output by the compilation for dependency support. $(Defines) contains a space seperated list of preprocessor definitions as set in the Preprocessor Definitions property $(Undefines) contains a space seperated list of preprocessor undefinitions as set in the Preprocessor Definitions property. $(Includes) contains a space seperated list of user include directories as set in the User Include Directories property. $(IncludeFiles) contains a space seperated list of include files as set in the Include Files property.
C++ Link Command `external_cpp_link_command` – CommandLine	The command line to link an executable. This property will have macro expansion applied to it with the additional macros: $(TargetPath) contains the full file name of the Executable File Name property. $(RelTargePath) contains the project directory relative file name of the Executable File Name property. $(LinkOptions) contains a space seperated list of options as set in the Additional Linker Options property. $(Objects) a space seperated list of files to link, generated from the source files of the project and the outputs of any dependent projects OR. $(ObjectsFilePath) contains the full file name of the file containing the list of files to link $(RelObjectsFilePath) contains the project directory relative file name of the file containing the list of files to link $(LinkerScriptPath) contains the full file name of the Linker Script File property. $(RelLinkerScriptPath) contains the project directory relative file name of the Linker Script File property. $(MapPath) contains the full file name of the required map file. $(RelMapPath) contains the project directory relative file name of the required map file.
Clean Command `external_clean_command` – CommandLine	The command line to clean the executable e.g. make clean. This property will have macro expansion applied to it.
Link Command `external_link_command` – CommandLine	The command line to link an executable. This property will have macro expansion applied to it with the additional macros: $(TargetPath) contains the full file name of the Executable File Name property. $(RelTargePath) contains the project directory relative file name of the Executable File Name property. $(LinkOptions) contains a space seperated list of options as set in the Additional Linker Options property. $(Objects) a space seperated list of files to link, generated from the source files of the project and the outputs of any dependent projects OR. $(ObjectsFilePath) contains the full file name of the file containing the list of files to link $(RelObjectsFilePath) contains the project directory relative file name of the file containing the list of files to link $(LinkerScriptPath) contains the full file name of the Linker Script File property. $(RelLinkerScriptPath) contains the project directory relative file name of the Linker Script File property. $(MapPath) contains the full file name of the required map file. $(RelMapPath) contains the project directory relative file name of the required map file.
Objects File `external_objects_file_name` – CommandLine	The name of the file containing the list of files to archive or link, generated from the source files of the project.This property will have macro expansion applied to it. The macro $(ObjectsFilePath) is set to this value.

File

Property	Description
File Encoding `file_codec` – Enumeration	Specifies the encoding to use when reading and writing the file.
File Name `file_name` – String	The name of the file. This property will have global macro expansion applied to it. The following macros are set based on the value: $(InputDir) relative directory of file, $(InputName) file name without directory or extension, $(InputFileName) file name, $(InputExt) file name extension, $(InputPath) absolute path to the file name, $(RelInputPath) relative path from project directory to the file name.
File Open Action `file_open_with` – Enumeration	Specifies how to open the file when it is double clicked.
File Type `file_type` – Enumeration	The type of file. Default setting uses the file extension to determine file type.
Flag `file_flag` – Enumeration	Flag which you can use to draw attention to important files in your project.

Folder

Property	Description
Dynamic Folder Directory `path` – DirPath	Dynamic folder directory specification - ; seperated directory names that will have global macro expansion applied to them.
Dynamic Folder Exclude `exclude` – StringList	Dynamic folder exclude specification - ; seperated wildcards.
Dynamic Folder Filter `filter` – String	Dynamic folder filter specification - ; seperated wildcards.
Dynamic Folder Recurse `recurse` – Boolean	Dynamic folder recurse into subdirectories.
Unity Build Exclude Filter `unity_build_exclude_filter` – String	The filter specification to exclude from the unity build - ; seperated wildcards.
Unity Build File Name `unity_build_file_name` – FileName	The file name created that #includes all files in the folder for the unity build.

General

Property	Description
Environment Variables `environment_variables` – StringList	Environment variables to set on solution load.
Inherited Configurations `inherited_configurations` – StringList	The list of configurations that are inherited by this configuration.

Library

Property	Description
DSO Handle Value `link_dso_handle_value` – String	The value to set the __dso_handle symbol to, an empty value will not set the symbol
Debug I/O Implementation `arm_link_debugio_type` – Enumeration	Specifies which Debug I/O mechanism to use for I/O operations. Options are: Breakpoint: Hardware breakpoint instruction and memory locations are used DCC: ARM debug communication channel is used Memory Poll: Memory locations are polled
Enable Locales `LIBRARY_LOCALES` – Enumeration	Enable localization for input/output functions and character classification and conversion. Options are: Minimal: small implementation for functions such as isupper() and tolower().. Full: locale support.
Exclude Default Library Helper Functions `link_use_multi_threaded_libraries` – Boolean	Specifies whether to exclude default library helper functions.
Include Standard Libraries `link_include_standard_libraries` – Boolean	Specifies whether the standard libraries should be linked into your application.
Library ARM Architecture `arm_library_architecture` – Enumeration	Specifies the architecture variant of the library to link with. The default uses the ARM Architecture value
Library Extension Suffix `link_libext_suffix` – String	Specifies a suffix to add to the $(LibExt) macro
Library File Name `build_output_file_name` – FileName	Specifies a name to override the default library file name.
Library Heap `LIBRARY_HEAP_TYPE` – Enumeration	Specifies how the library heap is implemented. Options are: Basic: Use low-overhead heap allocator. Minimal: Use alloc-only heap allocator. Real-Time: Use real-time heap allocator. None: Do not implement heap allocator. (Use application-supplied allocator).
Library Heap Locking `LIBRARY_HEAP_LOCKING` – Enumeration	Specifies how the library heap locking is implemented. Options are: Disable Interrupts: Disable global interrupts. User: Call user supplied __heap_lock/__heap_unlock functions.
Library I/O `LIBRARY_IO_TYPE` – Enumeration	Specifies how the library does I/O. Options are: RTT: Use SEGGER Real-Time Transfer for I/O operations without halting the system. Recommended for maximum speed. SEMIHOST: Format output and write to RAM buffer. Halt CPU for I/O operation. Provides hosted file I/O. SEMIHOST (host-formatted): Halt CPU for I/O operation. Recommended for minimum size. SWO: Format output and write to RAM buffer. Use SWO for Output operation. Use CMSIS ITM_RxBuffer/ITM_RXBUFFER_EMPTY memory access for Input Operation. SWO (Interrupts Disabled): Format output and write to RAM buffer. Use SWO for Output operation with interrupts disabled. Use CMSIS ITM_RxBuffer/ITM_RXBUFFER_EMPTY memory access for Input Operation. None: Do not include I/O implementation. Use user-supplied I/O Mechanism. For more information read: https://wiki.segger.com/Embedded_Studio_Library_IO
Library Instruction Set `arm_library_instruction_set` – Enumeration	Specifies the instruction set variant of the libraries to link with, Default will use the Instruction Set value.
Library Optimization `arm_library_optimization` – Enumeration	Specifies whether to link with libraries optimized for speed or size.
Library Optimization `rv_library_optimization` – Enumeration	Specifies whether to link with libraries optimized for speed or size.
Standard Libraries Configuration Prefix `link_standard_libraries_configuration_prefix` – String	Specifies the prefix to prepend to the library build configuration.
Standard Libraries Directory `link_standard_libraries_directory` – String	Specifies where to find the standard libraries

Linker

Property	Description
Additional Input Files `linker_additional_files` – StringList	Enables additional object and library files to be supplied to the linker.
Additional Linker Options `linker_additional_options` – StringList	Enables additional options to be supplied to the linker.
Additional Linker Options From File `linker_additional_options_from_file` – ProjFileName	Enables additional options to be supplied to the linker from a file.
Additional Linker Script Generator Options `arm_additional_mkld_options` – StringList	Enables additional options to be supplied to the linker script generator.
Additional Output Format `linker_output_format` – Enumeration	The format used when creating an additional linked output file.The options are: None do not create an additional output file. bin create a binary file. srec create a Motorola S-Record file. hex create an Intel Hex file.
Additional System Libraries `linker_additional_system_libraries` – StringList	Enables additional system libraries to be supplied to the linker.
Align ro Section [segger-ld] `link_align_ro` – Enumeration	Specifies the linker byte alignment of the ro section
Align rw Section [segger-ld] `link_align_rw` – Enumeration	Specifies the linker byte alignment of the rw section
Align rx Section [segger-ld] `link_align_rx` – Enumeration	Specifies the linker byte alignment of the rx section
Align zi Section [segger-ld] `link_align_zi` – Enumeration	Specifies the linker byte alignment of the zi section
Allow Multiple Symbol Definition `arm_linker_allow_multiple_definition` – Boolean	Do not report error if the same symbol is defined more than once in object files/libraries.
Backup Additional Linker Options `link_additional_options_backup` – String	Value of additional linker options prior to generic options processing
Breakpad Symbols Directory `linker_breakpad_symbols_directory` – String	Specifies location of the breakpad symbols directory.
CMSE Import Library File `arm_linker_cmse_import_library_file_name` – FileName	Specifies the name of the CMSE import library to generate.
Check CMSE Import Library File `arm_linker_check_cmse_import_library_file_name` – FileName	Specifies the name of the file to check the generated CMSE import library with.
Check For Memory Section Overflow `arm_library_check_memory_section_overflow` – Boolean	Specifies whether the linker should check whether program sections exceed their specified size.
Check For Memory Segment Overflow `arm_library_check_memory_segment_overflow` – Boolean	Specifies whether the linker should check whether program sections fit in their memory segments.
Deduplicate Code Sections [segger-ld] `link_dedupe_code` – Boolean	Specifies whether the linker finds readonly code sections that are identical and discard duplicates.
Deduplicate Data Sections [segger-ld] `link_dedupe_data` – Boolean	Specifies whether the linker finds readonly data sections that are identical and discard duplicates.
Default Fill Pattern `arm_linker_script_generator_default_fill_pattern` – String	Specifies the default pattern used to fill unspecified regions of memory in a generated linker script. This pattern maybe overidden by the fill attribute of a program section in the section placement file.
Emit Relocations `arm_linker_emit_relocations` – Enumeration	Output relocation information into the executable.
Enable Call Springboarding [segger-ld] `rv_spring_board` – Enumeration	If enabled the linker may be able to optimize the instructions used for function calls.
Enable Outline Optimization [segger-ld] `rv_outline` – Enumeration	If enabled the linker may be able to reduce code size by extracting common code into subroutines.
Enable Tail Merging [segger-ld] `rv_tail_merge` – Enumeration	If enabled the linker may be able to reduce code size by extracting common code immediately before function return.
Entry Point `gcc_entry_point` – String	Specifies the entry point of the program. None will not supply an entry point to the linker.
Gap Fill Value [segger-ld] `arm_linker_additional_output_file_gap_fill` – String	The value to fill unused space between sections. This is supplied to segger-ld and the additional output file creation build step.
Generate Breakpad Symbols `linker_generate_breakpad_symbols` – Boolean	Specifies whether to generate breakpad symbols from the linked image.
Generate Linker Map File `linker_map_file` – Boolean	Specifies whether to generate a linkage map file.
Generate Linker Script `arm_generate_linker_script` – Boolean	Specifies whether a linker script file should be generated from the section placement and/or memory map files.
Generate Log File [segger-ld] `linker_log_file` – Boolean	Specifies whether to generate a linkage log file.
Generate Map File [segger-ld] `link_map_file` – Enumeration	Specifies whether to generate a linkage map file.
Indirect File Name `linker_indirect_file_name` – String	The name of the generated indirect file.
Indirect File Supported `linker_use_indirect_files` – Boolean	Linker can use @indirect file for input files.
Inline Small Functions [segger-ld] `link_inline` – Boolean	Specifies whether the linker inlines small functions at the call site rather than calling the function.
Keep Indirect Files `linker_keep_indirect_files` – Boolean	Keep generated linker indirect files.
Keep Symbols `linker_keep_symbols` – StringList	Specifies the symbols that should be kept by the linker even if they are not reachable.
Link Dependent Projects `link_dependent_projects` – Boolean	Specifies whether to link the output of dependent library projects.
Link Whole Archive `arm_linker_whole_archive` – StringList	List the archives that require to be linked in whole.
Linker `arm_linker_variant` – Enumeration	Specifies which linker to use.
Linker Map File Name `linker_map_file_name` – FileName	The file name to contain the linkage map file.
Linker Script File `link_linker_script_file` – ProjFileName	The name of the manual linker script file.
Linker Search Path `arm_linker_search_path` – StringList	Specify the linker script search path.
Linker Symbol Definitions `link_symbol_definitions` – StringList	Specifies one or more linker symbol definitions.
Map File Format [segger-ld] `link_map_file_format` – Enumeration	Specifies map file format generated by the linker.
Memory Map File `linker_memory_map_file` – ProjFileName	The name of the file containing the memory map description.
Memory Map Macros `linker_memory_map_macros` – StringList	Macro values to substitue in memory map nodes. Each macro is defined as name=value and are seperated by ;.
Memory Segments `linker_section_placements_segments` – StringList	The start, access and size of named segments in the target, these are used when no memory map file is available.Each segment is specified by NAME RWX HEXSTART HEXSIZE for example FLASH RX 0x08000000 0x00010000
Merge Sections [segger-ld] `link_merge_sections` – Boolean	Specifies whether the linker merges compatible sections.
Merge String Constants [segger-ld] `link_merge_strings` – Boolean	Specifies whether the linker merges duplicate string constants.
No Enum Size Warning `arm_linker_no_enum_size_warning` – Boolean	Do not generate warnings when object files have different ARM EABI enum size attributes.
No Start File `arm_linker_no_start_files` – Boolean	Do not use startup files when linking.
No Wide Char Size Warning `arm_linker_no_wchar_size_warning` – Boolean	Do not generate warnings when object files have different ARM EABI wide character size attributes.
Pad ro Section [segger-ld] `link_pad_ro` – Boolean	Specifies whether the linker pads the ro section
Pad rw Section [segger-ld] `link_pad_rw` – Boolean	Specifies whether the linker pads the rw section
Pad rx Section [segger-ld] `link_pad_rx` – Boolean	Specifies whether the linker pads the rx section
Pad zi Section [segger-ld] `link_pad_zi` – Boolean	Specifies whether the linker pads the zi section
Section Placement File `linker_section_placement_file` – ProjFileName	The name of the file containing section placement description.
Section Placement Macros `linker_section_placement_macros` – StringList	Macro values to substitue in section placement nodes - MACRO1=value1;MACRO2=value2.
Start/End Group Required `linker_requires_start_group` – Boolean	Linker requires --start-group and --end-group for input files.
Strip Debug Information `linker_strip_debug_information` – Boolean	Specifies whether debug information should be stripped from the linked image.
Strip Symbols `gcc_strip_symbols` – Boolean	Specifies whether symbols should be stripped.
Supply Library Linker Symbols `link_supply_library_linker_symbols` – Boolean	Specifies whether the library symbols are supplied to the linker command line.
Supply Memory Segments To Linker [segger-ld] `linker_supply_memory_segments` – Boolean	Specifies whether to supply memory segments on the linker command line.
Suppress Warning on Executable Stack `arm_linker_no_warn_on_executable_stack` – Boolean	No warning on executable stack.
Suppress Warning on Mismatch `arm_linker_no_warn_on_mismatch` – Boolean	No warning on mismatched object files/libraries.
Suppress Warning on RWX Segments `arm_linker_no_warn_on_rwx_segments` – Boolean	No warning on RWX segments.
Symbols File `arm_linker_symbols_files` – FileName	Specify the name of a symbols file to link.
Thread Pointer Model [segger-ld] `rv_thread_pointer_model` – Enumeration	Controls how the thread pointer register is used.
Treat Libraries As Object Files `linker_treat_libraries_as_object_files` – Boolean	Specifies whether the linker treats libraries as a set of object files.
Treat Linker Warnings as Errors `arm_linker_treat_warnings_as_errors` – Boolean	Treat linker warnings as errors.
Use Manual Linker Script `link_use_linker_script_file` – Boolean	Specifies whether to use a manual linker script.

Package

Property	Description
Package Dependencies `package_dependencies` – StringList	Specifies the packages the current project depends upon.
Package Directory `package_directory` – DirPath	Specifies the directory packages are installed to. If no directory is specified, the default package directory is used.

Preprocessor

Property	Description
Add Property Group Options `add_property_group_includes_defines` – Boolean	Supply the defines and includes that are selected by the property group.
Ignore Includes `c_ignore_includes` – Boolean	Ignore the include directories properties.
Include Files `c_include_files` – StringList	Specifies the list of files to include before preprocessing. This property will have macro expansion applied to it.
Include Files Assembler Only `c_include_files_asm_only` – StringList	Specifies the list of files to include before preprocessing. This property will have macro expansion applied to it.
Include Files C Compiler Only `c_include_files_c_only` – StringList	Specifies the list of files to include before preprocessing. This property will have macro expansion applied to it.
Include Files C++ Compiler Only `c_include_files_cpp_only` – StringList	Specifies the list of files to include before preprocessing. This property will have macro expansion applied to it.
Macro Files `c_macros_files` – StringList	Specifies the list of macro files to include before preprocessing. This property will have macro expansion applied to it.
Macro Files Assembler Only `c_macros_files_asm_only` – StringList	Specifies the list of macro files to include before preprocessing. This property will have macro expansion applied to it.
Macro Files C Compiler Only `c_macros_files_c_only` – StringList	Specifies the list of macro files to include before preprocessing. This property will have macro expansion applied to it.
Macro Files C++ Compiler Only `c_macros_files_cpp_only` – StringList	Specifies the list of macro files to include before preprocessing. This property will have macro expansion applied to it.
Preprocessor Definitions `c_preprocessor_definitions` – StringList	Specifies one or more preprocessor definitions. This property will have macro expansion applied to it.
Preprocessor Definitions Assembler Only `c_preprocessor_definitions_asm_only` – StringList	Specifies one or more preprocessor definitions. This property will have macro expansion applied to it.
Preprocessor Definitions C Compiler Only `c_preprocessor_definitions_c_only` – StringList	Specifies one or more preprocessor definitions. This property will have macro expansion applied to it.
Preprocessor Definitions C++ Compiler Only `c_preprocessor_definitions_cpp_only` – StringList	Specifies one or more preprocessor definitions. This property will have macro expansion applied to it.
Preprocessor Undefinitions `c_preprocessor_undefinitions` – StringList	Specifies one or more preprocessor undefinitions. This property will have macro expansion applied to it.
Preprocessor Undefinitions Assembler Only `c_preprocessor_undefinitions_asm_only` – StringList	Specifies one or more preprocessor undefinitions. This property will have macro expansion applied to it.
Preprocessor Undefinitions C Compiler Only `c_preprocessor_undefinitions_c_only` – StringList	Specifies one or more preprocessor undefinitions. This property will have macro expansion applied to it.
Preprocessor Undefinitions C++ Compiler Only `c_preprocessor_undefinitions_cpp_only` – StringList	Specifies one or more preprocessor undefinitions. This property will have macro expansion applied to it.
System Include Directories `c_system_include_directories` – StringList	Specifies the system include path. This property will have macro expansion applied to it.
Undefine All Preprocessor Definitions `c_undefine_all_preprocessor_definitions` – Boolean	Does not define any standard preprocessor definitions.
User Include Directories `c_user_include_directories` – StringList	Specifies the user include path. This property will have macro expansion applied to it.
User Include Directories Assembler Only `c_user_include_directories_asm_only` – StringList	Specifies the user include path. This property will have macro expansion applied to it.
User Include Directories C Compiler Only `c_user_include_directories_c_only` – StringList	Specifies the user include path. This property will have macro expansion applied to it.
User Include Directories C++ Compiler Only `c_user_include_directories_cpp_only` – StringList	Specifies the user include path. This property will have macro expansion applied to it.

Printf/Scanf

Property	Description
Printf Floating Point Supported `linker_printf_fp_enabled` – Enumeration	Are floating point numbers supported by the printf function group.
Printf Integer Support `linker_printf_fmt_level` – Enumeration	The largest integer type supported by the printf function group.
Printf Width/Precision Supported `linker_printf_width_precision_supported` – Boolean	Enables support for width and precision specification in the printf function group.
Scanf Classes Supported `linker_scanf_character_group_matching_enabled` – Boolean	Enables support for %[...] and %[^...] character class matching in the scanf functions.
Scanf Floating Point Supported `linker_scanf_fp_enabled` – Boolean	Are floating point numbers supported by the scanf function group.
Scanf Integer Support `linker_scanf_fmt_level` – Enumeration	The largest integer type supported by the scanf function group.
Wide Characters Supported `linker_printf_wchar_enabled` – Boolean	Are wide characters supported by the printf function group.

Project

Property	Description
Flag `project_flag` – Enumeration	Flag which you can use to draw attention to important projects in your solution.

Runtime Memory Area

Property	Description
Heap Size `arm_linker_heap_size` – IntegerRange	The size of the heap in bytes. The size must be a multiple of 8. The preprocessor define __HEAP_SIZE__ is set to this value.
Heap Size `heap_size` – IntegerRange	The size of the heap in bytes. The size must be a multiple of 16.
Main Stack Size `arm_linker_stack_size` – IntegerRange	The size of the main stack in bytes. The size must be a multiple of 8.
Process Stack Size `arm_linker_process_stack_size` – IntegerRange	The size of the process stack in bytes. The size must be a multiple of 8.
Stack Size `stack_size` – IntegerRange	The size of the stack in bytes. The size must be a multiple of 16.
Stack Size (Abort Mode) `arm_linker_abt_stack_size` – IntegerRange	The size of the Abort mode stack in bytes. The size must be a multiple of 8.
Stack Size (FIQ Mode) `arm_linker_fiq_stack_size` – IntegerRange	The size of the FIQ mode stack in bytes. The size must be a multiple of 8.
Stack Size (IRQ Mode) `arm_linker_irq_stack_size` – IntegerRange	The size of the IRQ mode stack in bytes. The size must be a multiple of 8.
Stack Size (Supervisor Mode) `arm_linker_svc_stack_size` – IntegerRange	The size of the Supervisor mode stack in bytes. The size must be a multiple of 8.
Stack Size (Undefined Mode) `arm_linker_und_stack_size` – IntegerRange	The size of the Undefined mode stack in bytes. The size must be a multiple of 8.

Section

Property	Description
Code Section Name `default_code_section` – String	Specifies the default name to use for the program code section.
Constant Section Name `default_const_section` – String	Specifies the default name to use for the read-only constant section.
Data Section Name `default_data_section` – String	Specifies the default name to use for the initialized, writable data section.
ISR Section Name `default_isr_section` – String	Specifies the default name to use for the ISR code.
Vector Section Name `default_vector_section` – String	Specifies the default name to use for the interrupt vector section.
Zeroed Section Name `default_zeroed_section` – String	Specifies the default name to use for the zero-initialized, writable data section.

Solution

Property	Description
Flag `solution_flag` – Enumeration	Flag which you can use to draw attention to important projects in your solution.
Properties Filter `properties_filter` – StringList	The names of project properties that can be displayed at the solution

Source Code

Property	Description
Additional Code Completion Compiler Options `code_completion_options` – StringList	Additional source indexing and code completion compiler options.
Inhibit Source Indexing `project_inhibit_indexing` – Boolean	Disable source indexing and code completion for files/folders/projects that would normally be indexed (C/C++ files in executable and library projects).
Source Code Control Directory `source_code_control_directory` – DirPath	Source code control directory root.

Staging

Property	Description
Output File Path `stage_output_filepath` – String	The output file path the stage command will create. This property will have macro expansion applied to it.
Set To Read-only `stage_set_readonly` – Enumeration	Set the output file permissions to read only or read/write.
Stage Command `stage_command` – CommandLine	The command to execute. This property will have macro expansion applied to it with the additional $(StageOutputFilePath) macro set to the output filepath of the stage command.
Stage Command Working Directory `stage_command_wd` – String	The working directory in which the stage command is run. This property will have macro expansion applied to it.
Stage Project Command `stage_post_build_command` – CommandLine	The command to execute after staging commands have executed. This property will have macro expansion applied to it.
Stage Project Command Working Directory `stage_post_build_command_wd` – String	The working directory where the post build command runs. This property will have macro expansion applied to it.

User Build Step

Property	Description
Link Patch Command `linker_patch_build_command` – CommandLine	A command to run after the link but prior to additional binary file generation. This property will have macro expansion applied to it with the additional $(TargetPath) macro set to the output filepath of the linker command.
Link Patch Working Directory `linker_patch_build_command_wd` – DirPath	The working directory where the link patch command is run. This property will have macro expansion applied to it.
Post-Archive Command `archive_post_build_command` – CommandLine	A command to run after the archive command has completed.This property will have macro expansion applied to it with the additional $(TargetPath) macro set to the output filepath of the archive command.
Post-Archive Working Directory `archive_post_build_command_wd` – DirPath	The working directory where the post-archive command is run. This property will have macro expansion applied to it.
Post-Build Command `post_build_command` – CommandLine	The command to execute after a project build. This property will have macro expansion applied to it.
Post-Build Command Control `post_build_command_control` – Enumeration	Controls when the post-build command is run, either Always Run or when Run When Build Has Occurred.
Post-Build Command Working Directory `post_build_command_wd` – String	The working directory in which the post-build command is run. This property will have macro expansion applied to it.
Post-Compile Command `compile_post_build_command` – CommandLine	A command to run after the compile command has completed. This property will have macro expansion applied to it with the additional $(TargetPath) macro set to the output filepath of the compiler command.
Post-Compile Working Directory `compile_post_build_command_wd` – DirPath	The working directory where the post-compile command is run. This property will have macro expansion applied to it.
Post-Link Command `linker_post_build_command` – CommandLine	A command to run after the link command has completed.This property will have macro expansion applied to it with the additional $(TargetPath) macro set to the output filepath of the linker command and $(PostLinkOutputFilePath) set to the value of the output filepath of the post link command.
Post-Link Output File `linker_post_build_command_output_file` – String	The name of the file created by the post-link command. This property will have macro expansion applied to it.
Post-Link Working Directory `linker_post_build_command_wd` – DirPath	The working directory where the post-link command is run. This property will have macro expansion applied to it.
Pre-Build Command `pre_build_command` – CommandLine	The command to execute before a project build. This property will have macro expansion applied to it.
Pre-Build Command Control `pre_build_command_control` – Enumeration	Controls when the pre-build command is run, either Always Run or when Run When Build Required.
Pre-Build Command Working Directory `pre_build_command_wd` – String	The working directory in which the pre-build command is run. This property will have macro expansion applied to it.
Pre-Compile Command `compile_pre_build_command` – CommandLine	A command to run before the compile command. This property will have macro expansion applied to it.
Pre-Compile Command Output File Path `compile_pre_build_command_output_file_name` – String	The pre-compile generated file name. This property will have macro expansion applied to it.
Pre-Compile Working Directory `compile_pre_build_command_wd` – DirPath	The working directory where the pre-compile command is run. This property will have macro expansion applied to it.
Pre-Link Command `linker_pre_build_command` – CommandLine	A command to run before the link command. This property will have macro expansion applied to it.
Pre-Link Working Directory `linker_pre_build_command_wd` – DirPath	The working directory where the pre-link command is run. This property will have macro expansion applied to it.