Optimizes the build for shorter build times.

Optimizes the build for faster running executables.

Optimizes the build for debugging.

Enables the CustomToolchainOptions property for customization of settings for tools in the selected toolchain. If the Toolchain property is set to 'Automatically locate an installed toolchain', then setting BuildConfiguration to 'Specify' changes Toolchain to the located toolchain.

This value is the default value.

Generates C/C++ code that uses default C compiler data type casting. For example:

short addone(short x)
{
  int i;
  i = x + 1;
  if (i > 32767) {
    i = 32767;
  }

  return (short)i;
}

Generates C/C++ code that casts data types to conform to MISRA^® standards. For example:

short addone(short x)
{
  int i;
  i = (int)x + (int)1;
  if (i > (int)32767) {
    i = (int)32767;
  }

  return (short)i;
}

Generates C/C++ code that casts data type values explicitly. For example:

short addone(short x)
{
  int i;
  i = (int)x + 1;
  if (i > 32767) {
    i = 32767;
  }

  return (short)i;
}

This value is the default value.

Disables execution-time profiling during a SIL or PIL execution.

This value is the default value.

Does not use a code replacement library.

Generates calls to a specific platform, compiler, or standards code replacement library. The list of named libraries depends on:

This value is the default value.

The code generator does not convert if-elseif-else patterns to switch-case statements.

This value is the default value.

The code generator produces C++ namespaces for the packages in your MATLAB code. See Organize Generated C++ Code into Namespaces.

The code generator does not produce C++ namespaces for the packages in your MATLAB code.

This value is the default value.

The code generator produces C++ classes for MATLAB classes. See Generate C++ Classes for MATLAB Classes.

The code generator produces C style structures for MATLAB classes.

This value is the default value.

The code generator uses built-in C data types.

This value is the default value.

The code generator allocates memory dynamically on the heap for variable-size arrays whose size (in bytes) is greater than or equal to DynamicMemoryAllocationThreshold.

The code generator statically allocates memory for variable-size arrays on the stack.

This is the default value. If you set the TargetLang parameter to 'C++' or 'C', this value correspondingly behaves as the same flag.

The generated code uses the C style emxArray data structure to implement dynamically allocated arrays. See Use C Arrays in the Generated Function Interfaces.

If you set the TargetLang parameter to 'C', this value is disabled.

The generated code uses the coder::array class template to implement dynamically allocated arrays. See Use Dynamically Allocated C++ Arrays in the Generated Function Interfaces.

This value is the default value.

The code generator treats some common visualization functions as extrinsic functions. You do not have to declare these functions as extrinsic by using coder.extrinsic. This capability reduces the amount of time that you spend making your code suitable for code generation.

This value is the default value.

Custom names for the MATLAB data types are not allowed.

Custom names for the MATLAB data types are allowed. Specify custom names by using ReplacementTypes. Setting EnableCustomReplacementTypes to true enables the ReplacementTypes parameter.

This value is the default value.

If possible, the code generator uses the memcpy optimization. To optimize code that copies consecutive array elements, the memcpy optimization replaces the code with a memcpy call. When the number of elements to copy is known at compile time, the code generator uses the MemcpyThreshold property to determine whether to use the optimization. See memcpy Optimization.

The code generator does not use the memcpy optimization.

This value is the default value.

If possible, the code generator uses the OpenMP library to produce loop iterations that run in parallel.

The code generator treats parfor-loops as for-loops.

This value is the default value.

Recursive functions are allowed in the generated code.

Recursive functions are not allowed in the generated code.

This value is the default value.

The code generator uses signed left shifts for multiplication by powers of two. An example of generated C code that uses signed left shift for multiplication by eight is:

i <<= 3;

The code generator does not use signed left shifts for multiplication by powers of two. An example of generated C code that does not use signed left shift for multiplication by eight is:

i = i * 8;

This value is the default value.

The code generator uses signed right shifts. An example of generated C code that uses a signed right shift is:

i >>= 3

The code generator replaces right shifts on signed integers with a function call in the generated code. For example:

i = asr_s32(i, 3U);

This value is the default value.

The code generator does not use the strength reduction optimization.

The code generator tries to use the strength reduction optimization to simplify array indexing in loops in the generated code. When possible, for array indices in loops, the code generator replaces multiply operations with add operations. Multiply operations can be expensive. When the C/C++ compiler on the target platform does not optimize the array indexing, the strength reduction optimization is useful. Even when the optimization replaces the multiply operations in the generated code, it is possible that the C/C++ compiler can generate multiply instructions.

This value is the default value.

The code generation report includes code traceability. See Interactively Trace Between MATLAB Code and Generated C/C++ Code (Embedded Coder).

The code generation report does not include code traceability.

This value is the default value.

Variable-size arrays are allowed for code generation.

Variable-size arrays are not allowed for code generation.

This value is the default value.

The code generator produces separate C/C++ files for each MATLAB language file.

This value is the default value.

The code generator does not run static code metrics analysis at code generation time. You can run the analysis and produce the report later by clicking Code Metrics on the Summary tab of the code generation report.

The code generator runs static code metrics analysis and produces the report at code generation time.

This value is the default value.

The code generator produces C/C++ source code and builds object code.

The code generator produces C/C++ source code, but does not invoke the make command or build object code. When you iterate between modifying MATLAB code and generating C/C++ code, generating only code can save time.

This value is the default value.

The code generator does not produce a code replacements report.

The code generator produces a code replacements report that summarizes the replacements from the selected code replacement library. The report provides a mapping between each code replacement instance and the line of MATLAB code that triggered the replacement.

This value is the default value.

The code generator places comments in the generated code.

This value is the default value.

The code generator might not generate a default case for some switch statements.

This value is the default value.

The code generator generates an example C/C++ main function but does not compile it.

The code generator does not generate an example C/C++ main function.

The code generator generates an example C/C++ main function and compiles it to create a test executable. This executable does not return output.

If the GenCodeOnly parameter is true, the code generator does not compile the C/C++ main function.

This value is the default value.

The code generator generates a makefile during the build process.

This value is the default value.

The code generator produces the support files for nonfinite data (Inf and NaN) only if the generated code uses nonfinite data.

The code generator always produces the support files for nonfinite data (Inf and NaN).

This value is the default value.

The code generator produces a report only if error or warning messages occur, or if you set LaunchReport to true.

The code generator produces #ifndef style #include guards.

This value is the default value.

This code generation report does not highlight potential data type issues.

The code generation report highlights MATLAB code that results in single-precision or double-precision operations in the generated C/C++ code. If you have Fixed-Point Designer™, the report also highlights expressions in the MATLAB code that result in expensive fixed-point operations in the generated code.

The code generation report displays potential efficiency issues due to row-major layout. (This value is the default value.)

This value is the default value.

The code generator produces an initialize function.

The code generator does not produce an initialize function. If you set IncludeInitializeFcn to false and an initialize function is required, for example, to call supporting code for nonfinite data (Inf or NaN), the code generator produces an error message.

See MATLAB Code Patterns That Require a Nonempty Initialize Function in Generated Code (Embedded Coder).

This value is the default value.

The code generator produces a terminate function.

The code generator does not produce a terminate function. If you set IncludeTerminateFcn to false and a terminate function is required, for example, to free memory, the code generator issues a warning.

This value is the default value.

For blocks within a function, an opening brace is on the same line as its control statement. For example:

void addone(const double x[6], double z[6])
{
  int i0;
  for (i0 = 0; i0 < 6; i0++) {
    z[i0] = x[i0] + 1.0;
  }
}

For blocks within a function, an opening brace is on its own line at the same indentation level as its control statement. For example:

void addone(const double x[6], double z[6])
{
  int i0;
  for (i0 = 0; i0 < 6; i0++)
  {
    z[i0] = x[i0] + 1.0;
  }
}

This value is the default value.

If possible, the code generator uses the memset optimization for assignment of floating-point zero to consecutive array elements. To assign consecutive array elements, the memset optimization uses a memset call. When the number of elements to assign is known at compile time, the code generator uses the MemcpyThreshold property to determine whether to use the optimization. See memset Optimization.

The code generator does not use the memset optimization for assignment of float and double zero to consecutive array elements.

This value is the default value.

Uses internal heuristics to determine whether to perform inlining at a call site. This setting usually leads to highly optimized code.

Always performs inlining at a call site.

Almost never inlines function calls, except for calls to very small functions. Preserves modularity of code without sacrificing too much speed, whenever possible. Results in highly readable code.

Never inlines function calls. Results in maximum readability. This setting might significantly reduce the performance of the generated code.

This value is the default value.

Uses internal heuristics to determine whether to perform inlining at a call site. This setting usually leads to highly optimized code.

Always performs inlining at a call site.

Almost never inlines function calls, except for calls to very small functions. Preserves modularity of code without sacrificing too much speed, whenever possible. Results in highly readable code.

Never inlines function calls. Results in maximum readability. This setting might significantly reduce the performance of the generated code.

This value is the default value.

Uses internal heuristics to determine whether to perform inlining at a call site. This setting usually leads to highly optimized code.

Always performs inlining at a call site.

Almost never inlines function calls, except for calls to very small functions. Preserves modularity of code without sacrificing too much speed, whenever possible. Results in highly readable code.

Never inlines function calls. Results in maximum readability. This setting might significantly reduce the performance of the generated code.

This value is the default value.

If errors or warnings occur, or if GenerateReport is true, the code generator produces a report, but does not open the report.

This value is the default value.

The code generator includes MATLAB function help text in the function banner in the generated code.

The code generator treats the help text as a user comment.

This value is the default value.

The code generator does not insert MATLAB source code as comments in the generated code. The code generator does not include the MATLAB function signature in the function banner.

The code generator inserts MATLAB source code as comments in the generated code. A traceability tag immediately precedes each line of source code. The traceability tag helps you to locate the corresponding MATLAB source code. See Tracing Generated C/C++ Code to MATLAB Source Code.

If you have Embedded Coder, in the code generation report, the traceability tag links to the source code.

The code generator also includes the MATLAB function signature in the function banner.

This value is the default value.

The code generator does not produce multi-instance, reentrant code.

The code generator produces reusable, multi-instance code that is reentrant.

This value is the default value.

The code generator inserts parentheses to balance readability and visual complexity. For example:

Out = ((In2 - In1 > 1.0) && (In2 > 2.0));

The code generator includes parentheses to specify meaning without relying on operator precedence. Code generated with this setting conforms to MISRA requirements. For example:

 Out = (((In2 - In1) > 1.0) && (In2 > 2.0));

The code generator inserts parentheses where required by ANSI^® C or C++, or to override default precedence. For example:

Out = In2 - In1 > 1.0 && In2 > 2.0;

If you generate C/C++ code that uses the minimum level, for certain settings in some compilers, you can receive compiler warnings. To eliminate these warnings, try the nominal level.

This value is the default value.

The generated code passes structures by reference, which reduces memory usage and execution time by minimizing the number of copies of parameters at entry-point function boundaries.

This value is the default value.

The code generator includes the extern keyword in declarations for external functions.

The code generator removes the extern keyword from function declarations.

Generate code that uses one-dimensional indexing. (This value is the default value.)

This value is the default value.

The code generator does not have to preserve any variable names. It can reuse any variables that meet the requirements for variable reuse.

If your code uses large structures or arrays, setting PreserveVariableNames to 'None' can reduce memory usage or improve execution speed.

The code generator preserves names that correspond to variables that you define in the MATLAB code. It does not replace your variable name with another name and does not use your name for another variable. To improve readability, set PreserveVariableNames to 'UserNames'. Then, you can more easily trace the variables in the generated code back to the variables in your MATLAB code.

Setting PreserveVariableNames to 'UserNames' does not prevent an optimization from removing your variables from the generated code or prevent the C/C++ compiler from reusing the variables in the generated binary code.

Preserve all variable names. This parameter value disables variable reuse. Use it only for testing or debugging, not for production code.

This value is the default value.

The code generator allows floating-point data and operations.

The code generator does not allow floating-point data or operations. If the code generator detects floating-point data or operations, code generation ends with an error.

Generate code that uses column-major array layout. (This value is the default value.)

This value is the default value.

A call to the initialize function is included at the beginning of the generated entry-point functions. The generated code includes checks to make sure that the initialize function is called only once, even if there are multiple entry-point functions.

The generated entry-point functions do not include calls to the initialize function.

This value is the default value.

The generated code does not check for errors such as out-of-bounds array indexing.

The generated code checks for errors such as out-of-bounds array indexing.

The error-reporting software uses fprintf to write error messages to stderr. It uses abort to terminate the application. If fprintf and abort are not available, you must provide them. The abort function abruptly terminates the program. If your system supports signals, you can catch the abort signal (SIGABRT) so that you can control the program termination.

Error messages are in English.

This value is the default value.

The code generator produces code to handle integer overflow. Overflows saturate to either the minimum or maximum value that the data type can represent.

The code generator does not produce code to handle integer overflow. Do not set SaturateOnIntegerOverflow to false unless you are sure that your code does not depend on integer overflow support. If you disable integer overflow support and run-time error checking is enabled, the generated code produces an error for overflows. If you disable integer overflow support and you disable run-time error checking, the overflow behavior depends on your target C compiler. In the C standard, the behavior for integer overflow is undefined. However, most C compilers wrap on overflow.

This value is the default value.

Disables debugging of generated code during a SIL execution.

Enables the debugger to observe code behavior during a software-in-the-loop (SIL) execution.

Supported debuggers:

This value is the default value.

The SIL or PIL execution compares the value that a test file provides for a constant input argument with the value specified at code generation time. If the values do not match, an error occurs.

The SIL or PIL execution does not compare the value that a test file provides for a constant input argument with the value specified at code generation time. The SIL or PIL execution uses the value specified at code generation time. If the test file uses a different value, then the results in MATLAB might differ from the results in the SIL or PIL execution.

It is possible to speed up a SIL or PIL execution by setting SILPILCheckConstantInputs to false.

This value is the default value.

A SIL or PIL execution synchronizes the values of global variables in the SIL or PIL execution environment with the values in the MATLAB workspace. If a global variable is constant and its value in the SIL or PIL execution environment differs from its value in the MATLAB workspace, an error occurs.

The SIL or PIL execution does not synchronize the values of global variables in the SIL or PIL execution environment with the values in the MATLAB workspace. If the values are not synchronized, the results in MATLAB might differ from the results in the SIL or PIL execution.

It is possible to speed up a SIL or PIL execution by setting SILPILSyncGlobalData to false.

This value is the default value.

If GenerateNonFiniteFilesIfUsed is set to true, the code generator produces code to support nonfinite values (Inf and NaN) only if they are used.

If GenerateNonFiniteFilesIfUsed is set to false, the code generator always produces code to support nonfinite values (Inf and NaN).

The code generator does not produce code to support nonfinite values.

This value is the default value.

The code generator does not display code generation progress.

The code generator displays code generation progress, including code generation stages and compiler output.