Simulink® Code Inspector™

User’s Guide

R2014a
How to Contact MathWorks

www.mathworks.com Web
comp.soft-sys.matlab Newsgroup
www.mathworks.com/contact_TS.html Technical Support

[email protected] Product enhancement suggestions

[email protected] Bug reports
[email protected] Documentation error reports
[email protected] Order status, license renewals, passcodes
[email protected] Sales, pricing, and general information

508-647-7000 (Phone)

508-647-7001 (Fax)

The MathWorks, Inc.

3 Apple Hill Drive
Natick, MA 01760-2098
For contact information about worldwide offices, see the MathWorks Web site.
Simulink® Code Inspector™ User’s Guide
© COPYRIGHT 2011–2014 by The MathWorks, Inc.
The software described in this document is furnished under a license agreement. The software may be used
or copied only under the terms of the license agreement. No part of this manual may be photocopied or
reproduced in any form without prior written consent from The MathWorks, Inc.
FEDERAL ACQUISITION: This provision applies to all acquisitions of the Program and Documentation
by, for, or through the federal government of the United States. By accepting delivery of the Program
or Documentation, the government hereby agrees that this software or documentation qualifies as
commercial computer software or commercial computer software documentation as such terms are used
or defined in FAR 12.212, DFARS Part 227.72, and DFARS 252.227-7014. Accordingly, the terms and
conditions of this Agreement and only those rights specified in this Agreement, shall pertain to and govern
the use, modification, reproduction, release, performance, display, and disclosure of the Program and
Documentation by the federal government (or other entity acquiring for or through the federal government)
and shall supersede any conflicting contractual terms or conditions. If this License fails to meet the
government’s needs or is inconsistent in any respect with federal procurement law, the government agrees
to return the Program and Documentation, unused, to The MathWorks, Inc.

Trademarks
MATLAB and Simulink are registered trademarks of The MathWorks, Inc. See
www.mathworks.com/trademarks for a list of additional trademarks. Other product or brand
names may be trademarks or registered trademarks of their respective holders.
Patents
MathWorks products are protected by one or more U.S. patents. Please see
www.mathworks.com/patents for more information.
Revision History
September 2011 Online only New for Version 1.0 (Release 2011b)
March 2012 Online only Revised for Version 1.1 (Release 2012a)
September 2012 Online only Revised for Version 1.2 (Release 2012b)
March 2013 Online only Revised for Version 1.3 (Release 2013a)
September 2013 Online only Revised for Version 2.0 (Release 2013b)
March 2014 Online only Revised for Version 2.1 (Release 2014a)
 Contents

Getting Started
1
Simulink Code Inspector Product Description . . . . . . . 1-2
Key Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1-2

Why Use This Product? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1-3

Code Inspection Limitations . . . . . . . . . . . . . . . . . . . . . . . . 1-4

Approach to Code Inspection . . . . . . . . . . . . . . . . . . . . . . . 1-6

Simulink Code Inspector and DO-178 Workflows . . . . . . . . 1-6
End-to-End General Workflow . . . . . . . . . . . . . . . . . . . . . . . 1-7

Inspect Generated Code for a Sample Model . . . . . . . . . 1-10

Model Compatibility Checking

2
Model Compatibility Checking . . . . . . . . . . . . . . . . . . . . . . 2-2

Check Model Compatibility Using the Graphical User

Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-5

Check Model Compatibility Using the Command-Line

Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-9

Fix or Work Around Incompatibilities . . . . . . . . . . . . . . . 2-10

Fix or Work Around Unsupported Blocks . . . . . . . . . . . . . . 2-10
Fix or Work Around Global Data Store Usage . . . . . . . . . . 2-10

v
 Code Inspection
3
Code Inspection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-2

Inspect Code Using the Graphical User Interface . . . . . 3-4

Inspect Code Using the Command-Line Interface . . . . . 3-8

Code Inspection Reports . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-9

Interpret the Overall Inspection Result . . . . . . . . . . . . . . 3-12

Analyze Code Verification Results .................. 3-14

Model Patterns That Can Result in Code Verification

Failures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-19
Redundant Modeling Patterns . . . . . . . . . . . . . . . . . . . . . . . 3-19
Blocks with Constant Non-Finite Outputs . . . . . . . . . . . . . 3-20
Action Subsystems with Output Not Connected to Merge
Blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-21
Multiport Switch Blocks with Input From Same Local
Signal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-22
Models Triggering Code Optimizations to Avoid Data
Copies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-23

Analyze Traceability Results ....................... 3-24

Traceability Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-28

Prerequisites for Generating a Traceability Matrix . . . 3-30

Generate a Traceability Matrix . . . . . . . . . . . . . . . . . . . . . 3-31

Add Comments to a Traceability Matrix . . . . . . . . . . . . . 3-32

vi Contents
 Retain Comments When Regenerating a Traceability
Matrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-33

Traceability Matrix Limitations . . . . . . . . . . . . . . . . . . . . . 3-34

DO-178C Objectives Compliance

4
Model-Based Design Workflow in DO-178C . . . . . . . . . . . 4-2
Overview of the Model-Based Design Workflow: Software
Development Activities . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-2
Overview of the Model-Based Design Workflow: Verification
and Tracing Activities . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-3

Applicable DO-178C Objectives ..................... 4-6

vii
viii Contents
 1

Getting Started

• “Simulink® Code Inspector™ Product Description” on page 1-2

• “Why Use This Product?” on page 1-3
• “Code Inspection Limitations” on page 1-4
• “Approach to Code Inspection” on page 1-6
• “Inspect Generated Code for a Sample Model” on page 1-10
 1 Getting Started

Simulink Code Inspector Product Description

Automate source code reviews for safety standards
Simulink® Code Inspector™ automatically compares generated code with
its source model to satisfy code-review objectives in DO-178 and other
high-integrity standards. The code inspector systematically examines blocks,
state diagrams, parameters, and settings in a model to determine whether
they are structurally equivalent to operations, operators, and data in the
generated code. Simulink Code Inspector provides detailed model-to-code and
code-to-model traceability analysis. It generates structural equivalence and
traceability reports that you can submit to certification authorities to satisfy
DO-178 software coding verification objectives.

Support for industry standards is available through DO Qualification Kit

(for DO-178).

Key Features
• Structural equivalence analysis and reports
• Bidirectional traceability analysis and reports
• Compatibility checker to restrict model, block, state diagrams, and coder
usage to operations typically used in high-integrity applications
• Tool independence from Simulink code generators
• Tool qualification support (with DO Qualification Kit)

1-2
 Why Use This Product?

Why Use This Product?

Use Simulink Code Inspector tooling to:

• Prepare for code inspection during model development.

• Run inspections on code generated from models and review reported results.
• Automatically generate code verification reports to support software
certification.

While developing a model intended for generating code, you can incrementally
and iteratively check the model for compatibility with Simulink Code
Inspector rules. This process significantly reduces the amount of time to
achieve satisfactory inspection results.

For companies and organizations that must certify software under DO-178C,
the Simulink Code Inspector significantly reduces the time and cost associated
with verifying code against requirements. Instead of completing manual
line-by-line code reviews with a project checklist, which is time intensive and
error prone, you can run the Simulink Code Inspector and review a detailed
inspection report.

1-3
 1 Getting Started

Code Inspection Limitations

The Simulink Code Inspector has the following limitations:

• Simulink Code Inspector supports a subset of Simulink and Stateflow®

modeling capability. You can use the compatibility checks to verify model
compatibility with code inspection. However, there are instances when the
compatibility checks do not detect model incompatibilities with Simulink
Code Inspector. For example, models with:
- Blocks that have tunable parameter expressions. For more information,
see “Tunable Parameters and Expressions”.
- Non-ASCII characters for model element or folder names. Code
inspection is supported only for models that use ASCII characters for:
• Model element names. For example, a model named model_itèr.slx
is not compatible with code inspection.
• Folder names. For example, a model in folder C:/Modèles is not
compatible with code inspection.
- Stateflow objects that are not used in a Stateflow chart. For example,
Simulink Code Inspector does not inspect local variables or parameters
defined in a chart scope if they are not used in the Stateflow chart.
• Simulink Code Inspector supports a subset of Simulink Coder™ code
generation capability. You can use the compatibility checks to verify that
your model is configured to generate code compatible with code inspection.
However, there are some instances when the compatibility checks do
not detect models configured to generate code that is incompatible with
Simulink Code Inspector. For example:
- Models that contain step functions with the function argument
real-time model are not compatible with code inspection. Step
functions using the function argument real-time model with a
simplified call interface, however, are compatible with code inspection.
- If blocks eliminated during model compilation have non-auto storage
class and are not testpointed, the generated code will not verify. Blocks
can be eliminated during compilation through block reduction.
- If models generate code with separate output and update functions, the
code will not verify.

1-4
 Code Inspection Limitations

- If a signal size exceeds the MaxStackVariableSize default value, the

code generated from the model will not verify. If you increase the value
of MaxStackVariableSize, the model will fail compatibility check
Check code generation settings > Verify ‘TLC options’ setting.
However, Simulink Code Inspector can verify the generated code.
- Models with Assignment, Selector, or two-inport Multiport Switch blocks
can trigger optimizations that change index selection to avoid data
copies in the generated code. The generated code will not verify. For
an example, see “Models Triggering Code Optimizations to Avoid Data
Copies” on page 3-23.
- Models with Constant blocks that use constant sample times and
matrix data can trigger optimizations that eliminate blocks during code
generation. The generated code will not verify.
- In the generated code, if the model’s initialize function passes timing
information to a referenced model, the initialize function will not
verify. For example, the following initialize function will not verify.
<topModelName> is the name of the model and <subModelName> is the
name of the referenced model.

{
<topModelName>_TimingBridge.nTasks = 1;
<topModelName>_TimingBridge.clockTick = (NULL);
<topModelName>_TimingBridge.clockTickH = (NULL);
}

/* Model Initialize fcn for ModelReference Block: '<Root>/Model' */

<subModelName>_initialize(&<topModelName>_TimingBridge);

• If you modify a model by replacing blocks and inspect the code without first
regenerating it, code inspection can fail. For example:
- If you replace inports or outports, and inspect the code without first
regenerating it, your model might contain a root-level inport or outport
with a “Simulink Identifier” (SID) that does not match the SID of the
inport or outport block in the model. As a result, code inspection fails.
• Some modeling patterns can result in code inspection failures. For
examples, see “Model Patterns That Can Result in Code Verification
Failures” on page 3-19.

1-5
 1 Getting Started

Approach to Code Inspection

In this section...
“Simulink® Code Inspector™ and DO-178 Workflows” on page 1-6
“End-to-End General Workflow” on page 1-7

Simulink Code Inspector and DO-178 Workflows

The overall workflow for Simulink Code Inspector and meeting DO-178
objectives encompasses the following subworkflows:

• Model compatibility checking: Check a Simulink model for

compatibility with Simulink Code Inspector rules.
Model compatibility checking can significantly reduce the amount of time
to achieve satisfactory code inspection results by exposing issues early in
the model development process. The compatibility checks also promote
model, block, and coder usage patterns that tend to align with the needs
of high-integrity applications, such as maintaining a high degree of
traceability. Model compatibility checking is an incremental and iterative
process. For more detail on the model compatibility checking, see “Model
Compatibility Checking” on page 2-2.
• Code inspection: Run the Simulink Code Inspector to compare generated
C code with its source model.
During code inspection, Simulink Code Inspector systematically examines
blocks, parameters, and settings in a model to determine whether they are
structurally equivalent to operations, operators, and data in the generated
code, and generates structural equivalence and traceability reports that
can be used to support software certification. Code inspection is an
incremental and iterative process. For more detail on code inspection, see
“Code Inspection” on page 3-2.
• Software certification: Use the code inspection reports as part of
a certification package to satisfy DO-178 software coding verification
objectives.
The DO Qualification Kit product provides an artifacts explorer that allows
you to manage a certification package for your DO-178C project. The kit
also provides detailed information on how to apply Model-Based Design to

1-6
 Approach to Code Inspection

DO-178C. For more information, see “Model-Based Design Workflow in

DO-178C” on page 4-2 and http://www.mathworks.com/products/do-178/.
• Tool qualification: Use the code inspection reports as part of qualifying
Simulink Code Inspector for projects based on the DO-178C standard.
MathWorks® provides a DO Qualification Kit product that supports
you in qualifying Simulink Code Inspector and other MathWorks
verification tools for projects based on the DO-178C standard. For
more information, see “Model-Based Design Workflow in DO-178C”
on page 4-2, “Applicable DO-178C Objectives” on page 4-6, and
http://www.mathworks.com/products/do-178/.

End-to-End General Workflow

The end-to-end general workflow for Simulink Code Inspector is as follows:

1 Open a model. If you want to operate on a working copy of the model,

save a copy of the model to a working folder, and change directory to the
work folder.

2 Configure model compatibility checks.

a Set the model parameter AdvancedOptControl to the value '-SLCI',

if it is not already set. This setting constrains the code optimizations
that Embedded Coder® uses to a subset that is compatible with code
inspection. When you use this setting, the generated code can differ from
code generated without the '-SLCI' setting. However, the differences do
not affect the behavior of the generated code.

With the top model window selected, issue the following command:

>> set_param(gcs, 'AdvancedOptControl', '-SLCI')

b From the top model window, select Code > Simulink Code Inspector.
This opens the Simulink Code Inspector dialog box.
c Examine the dialog box parameters that apply to model compatibility
checking. If you are checking a model that references other models, you
can choose to check only the top model or the entire model reference
hierarchy. Selecting the option Inspect all referenced models
includes referenced models in model compatibility checking as well as
code inspection.

1-7
 1 Getting Started

3 Run model compatibility checks. Click Check this model or Check all
models. The compatibility checker displays a progress bar.

4 Analyze the model compatibility check results.

a If you opted to check only the top model, results are displayed directly in
the Model Advisor dialog box. You can use the dialog box to explore and
rerun individual checks and save the results.
b If you opted to check all models, results are displayed in the command
window and in an HTML summary report window. You can click links in
the HTML summary report to view the detailed Model Advisor Report
for each model and referenced model that was checked.

If the checks pass, the model is ready for code inspection. If

incompatibilities are reported, fix or work around the issues and recheck
the model for compatibility.

5 Verify the run-time functionality of the model. If you modified the model
to address incompatibilities, reverify model functionality using simulation
test cases. Before proceeding with code inspection, your model should
simulate with no errors.

6 Generate C code for the model, if it has not already been generated. You can
generate code implicitly as part of code inspection (using the Simulink Code
Inspector dialog box option Generate code before code inspection), or
use Embedded Coder separately to generate the model code. If code was
generated previously and placed in a configuration management system,
make sure the code is available and ready for inspection.

7 Configure code inspection.

a Open the Simulink Code Inspector dialog box, if it is not already open.

b Examine and configure the dialog box parameters that apply to code
inspection.
• If you are inspecting a model that references other models, you can
choose to inspect only the top model or the entire model reference
hierarchy. Selecting the option Inspect all referenced models
includes referenced models in model compatibility checking as well
as code inspection.

1-8
 Approach to Code Inspection

• If your generated code does not use the default Embedded Coder folder
structure created by code generation, update the Code placement
parameter appropriately.
• Optionally, you can change the location to which code inspection
writes the code inspection report, using the dialog box parameter
Report folder.

8 Inspect the generated code. Click Inspect Code or Generate and inspect
code. The Simulink Code Inspector displays a progress bar.

9 Analyze the code inspection results.

a If you opted to inspect only the top model, results are displayed directly
in the detailed code inspection report for the top model.
b If you opted to inspect all models, results are displayed in an HTML
summary report window. You can click links in the HTML summary
report to view the detailed code inspection report for each model and
referenced model that was inspected.

If all models get the overall inspection result Passed, the code inspection is
complete. If Warning or Failed status is returned for a model, fix or work
around the reported conditions and reinspect the model.

10 If you are using the code inspection reports as part of a certification

package to satisfy DO-178 software coding verification objectives,
further steps will be determined by the larger certification process.
For information on how to apply Model-Based Design to meeting
DO-178C objectives, see “Model-Based Design Workflow in DO-178C”
on page 4-2, “Applicable DO-178C Objectives” on page 4-6, and
http://www.mathworks.com/products/do-178/.

1-9
 1 Getting Started

Inspect Generated Code for a Sample Model

The following example shows how to use the Simulink Code Inspector dialog
box to perform key tasks in the code verification workflow. In this example,
you:

• Prepare a model hierarchy for code generation and code inspection.

• Automatically generate code for the model hierarchy.
• Verify the generated code independently of the code generation tool.
• Purposely introduce an error into the generated code and inspect for failure.

Note The example slcidemo_intro illustrates the same code verification

workflow using MATLAB® commands.

1 Open the example model slcidemo_roll_orig using the following

command:

>> slcidemo_roll_orig

Save a copy of the model, renaming it to slcidemo_roll, and change the

MATLAB current working folder to the location of the saved model. The
top level of the model appears as follows.

1-10
 Inspect Generated Code for a Sample Model

This model represents a basic roll axis autopilot with two operating modes:
roll attitude hold and heading hold. The mode logic for these modes is
external to this model. The model architecture represents the heading hold
mode and basic roll attitude function as referenced models. The model
includes:
• Virtual subsystem RollAngleReference, which implements the basic
roll angle reference calculation. Embedded Coder code generation inlines
this calculation directly into the main function for slcidemo_roll.
• Model block HeadingMode, referencing a separate model that computes
the roll command to track the heading.
• Model block BasicRollMode, referencing a separate model that computes
the roll attitude control function.

2 Prepare the model for code generation and code inspection.

1-11
 1 Getting Started

Note If you try this example with a model other than slcidemo_roll, set
the model parameter AdvancedOptControl to the value '-SLCI'. This
setting constrains the code optimizations that Embedded Coder uses
to a subset that is compatible with code inspection. When you use this
setting, the generated code can differ from code generated without the
'-SLCI' setting. However, the differences do not affect the behavior of
the generated code.

With the top model window selected, issue the following command:

>> set_param(gcs, 'AdvancedOptControl', '-SLCI')

a From the top model window, select Code > Simulink Code Inspector.
The Simulink Code Inspector dialog box opens.
b Configure model compatibility checks. For this example, select Inspect
all referenced models and click Apply. This setting includes
referenced models in model compatibility checking as well as code
inspection. The dialog box should appear as follows:

c Run the model compatibility checks by clicking Check all models. The
compatibility checker displays a progress bar.

1-12
 Inspect Generated Code for a Sample Model

Results appear in the command window and in an HTML summary

report window.
• The MATLAB Command Window displays results similar to the
following:

• The HTML summary report window displays results similar to the

following.

Note This HTML report also is linked from the command window
results. It is saved as file summaryReport.html in subfolder
/slprj/modeladvisor under the current working folder.

1-13
 1 Getting Started

3 Verify the run-time functionality of the model. For this example, you can
verify run-time functionality by simulating the model. Before proceeding
with code inspection, your model should simulate with no errors.

4 Generate code for the model. You can generate code implicitly as part
of code inspection (using the Simulink Code Inspector dialog box option
Generate code before code inspection), or perform code generation
and code inspection as separate steps. This example separates the code
generation step from the code inspection step.
a In the top model window, select Simulation > Model Configuration
Parameters to open the Configuration Parameters dialog box. In the
Code Generation > Report pane, select the option Open report
automatically. (If you try this example with a model other than
slcidemo_roll, also select Code-to-model, Model-to-code, and the
four Traceability Report Contents options in the Report pane.) Click
Apply and save the model changes.
b Go to the Code Generation main pane and click Generate code. (If
the Generate code button does not appear for your model, select the
Generate code only option to enable the button.) Progress is displayed
in the MATLAB Command Window.
c Embedded Coder code generation displays results in an HTML report
window.

1-14
 Inspect Generated Code for a Sample Model

5 Inspect the generated code.

a Open the Simulink Code Inspector dialog box if it is not already

open, and examine the code inspection parameter settings. The Code
placement parameter is set to Embedded Coder default, which

1-15
 1 Getting Started

configures code inspection to use the default Embedded Coder folder

structure created by code generation.
b Optionally, you can change the location to which code inspection writes
the code inspection report, using the dialog box parameter Report
folder. For example, enter the path string ./report and click Apply.

c To inspect the generated code, click Inspect Code. The Simulink Code
Inspector displays a progress bar.
d The Simulink Code Inspector displays a summary in an HTML report
window.

The summary report links to detailed code inspection reports for the top
model and each referenced model. For example, here is the topmost
portion of the code inspection report for the top model, slcidemo_roll.

1-16
 Inspect Generated Code for a Sample Model

The summary report and the detailed code inspection reports are saved
as HTML files in the Report folder location that you specified.

6 Insert an error into the generated code and inspect for failure.

To show a failed result, this example inserts an intentional error in the

generated code. The Logical Operator block inside the RollAngleReference

1-17
 1 Getting Started

subsystem is changed in the generated code from an OR operation

(||) to an AND operation (&&), using the example utility function
slcidemo_modifycode.
a To highlight the block for which corresponding code is modified, issue
the following command:

>> hilite_system('slcidemo_roll/RollAngleReference/Or');

b To modify the OR to an AND, issue the following commands:

>> cfile = fullfile('.','slcidemo_roll_ert_rtw','slcidemo_roll.c');

>> slcidemo_modifycode(cfile,'<S1>/Or','||','&&')

The slcidemo_modifycode utility function displays the following output:

Modified line 52 of file .\slcidemo_roll_ert_rtw\slcidemo_roll.c.

Before: if ((rtU_Phi >= 6.0F) || (rtU_Phi <= -6.0F)) {
After : if ((rtU_Phi >= 6.0F) && (rtU_Phi <= -6.0F)) {

c To reinspect the generated code, open the Simulink Code Inspector

dialog box if it is not already open, and click Inspect code.
d View the code inspection reports.

The summary report displays a failure for the top model.

The code inspection report for the top model contains several indications
of a failed comparison between the Logical Operator block and the
corresponding code. The top of the report shows the following.

1-18
Inspect Generated Code for a Sample Model

1-19
 1 Getting Started

Further down in the report, under Code Verification

Details > Model-to Code Verification, the mismatch between block
and code is flagged.

Additionally, under Traceability Details > Model-to Code

Traceability, the mismatch between block and code is flagged.

7 Optionally, try modifying the model or other aspects of the generated code
to see how code inspection results are affected.

1-20
 2

Model Compatibility
Checking

• “Model Compatibility Checking” on page 2-2

• “Check Model Compatibility Using the Graphical User Interface” on page
2-5
• “Check Model Compatibility Using the Command-Line Interface” on page
2-9
• “Fix or Work Around Incompatibilities” on page 2-10
 2 Model Compatibility Checking

Model Compatibility Checking

When developing a model from which you intend to generate code that will be
verified using Simulink Code Inspector, you can incrementally and iteratively
check the model for compatibility with Simulink Code Inspector rules. Model
compatibility checking can significantly reduce the amount of time to achieve
satisfactory code inspection results by exposing issues early in the model
development process. The compatibility checks also promote model, block,
and coder usage patterns that tend to align with the needs of high-integrity
applications, such as maintaining a high degree of traceability.

During a model compatibility check, the software checks for model and block
configuration settings that help produce an in-memory representation of the
model that is compatible with Simulink Code Inspector rules. You can set
model and block configuration parameters many different ways and produce
a compatible in-memory representation. Compatibility checks scan for a
subset of those ways. Although a model can fail a compatibility check and
still pass inspection, passing compatibility checks increases the likelihood of
satisfactory code inspection.

The compatibility checks look for conditions that violate Simulink Code
Inspector constraints on model configuration parameters, other model-wide
attributes, and block usage. Items affected by Simulink Code Inspector
constraints include:

• Model parameters for

- Solver use
- Data import/export
- Optimization
- Diagnostics
- Hardware implementation
- Model referencing
- Code generation
• Model-wide attributes
- Unconnected objects

2-2
 Model Compatibility Checking

- Function specifications
- Model arguments
- Unsupported blocks
- Tunable workspace variables
- Sample times
- Global data stores
- Fixed-point instrumentation
- Root outport usage
- Bus usage
• Block usage
- Data types and ports
- Block parameters
• Stateflow object usage
- Charts
- Data and Events
- Junctions
- States
- Transitions

For detailed description of Simulink Code Inspector constraints and the

corresponding model compatibility checks, see:

• “Configuration Parameter Constraints”

• “Model-Wide Attribute Constraints”
• “Supported Block Constraints”
• “Stateflow Object Constraints”
• “Simulink Code Inspector Checks”

2-3
 2 Model Compatibility Checking

To initiate compatibility checking for your model, you can do any of the
following:

• From the model window, select Code > Simulink Code Inspector, and
use the Simulink Code Inspector dialog box to control model compatibility
checking. For more information, see “Check Model Compatibility Using the
Graphical User Interface” on page 2-5.
• Use the slci.Configuration interface to programmatically control model
compatibility checking. For more information, see “Check Model
Compatibility Using the Command-Line Interface” on page 2-9.
• Use the slciadvisor interface to open an SLCI Advisor session (equivalent to
Model Advisor preloaded with Simulink Code Inspector checks) for the open
model. This function provides direct access to SLCI model compatibility
checking that can streamline iterative checking of a model.

If your model might be used as a referenced model, in the SLCI Advisor

window, consider selecting Settings > Treat as Referenced Model.
Referenced models compile differently than non-referenced models. The
compatibility checks provide setting recommendations based on the different
compilation methods.

Model compatibility checking generates a detailed HTML report for each

model checked. If you checked models in a model reference hierarchy, the
software reports summary status at the MATLAB command line and displays
a summary HTML report. You can click links in the HTML summary report
to view the detailed Model Advisor Report for each model and referenced
model that was checked. If you checked only one model, the detailed model
results are displayed directly in a Model Advisor dialog box.

The Simulink Code Inspector does not run custom Model Advisor checks that
you add to the compatibility checks.

In the detailed results, the result of each check is explained, and if you need
to fix your model, recommended actions are provided. The available model
compatibility checks are listed in report order and described in the “Simulink
Code Inspector Checks” reference.

2-4
 Check Model Compatibility Using the Graphical User Interface

Check Model Compatibility Using the Graphical User

Interface
1 Open a model that you want to check for compatibility with Simulink Code
Inspector. To use an example model, you can do the following:
a Open the example model slcidemo_roll_orig using the following
command:

>> slcidemo_roll_orig

b Save a copy of the model to a work folder, renaming it to slcidemo_roll.

Change directory to the work folder.

2 Open the Simulink Code Inspector dialog box and configure model
compatibility checks.
a From the top model window, select Code > Simulink Code Inspector.

b Examine the parameters that apply to model compatibility checking. If

you are checking a model that references other models, consider whether
to select the option Inspect all referenced models. This option
includes referenced models in model compatibility checking as well as
code inspection. If you select this option, the button Check this model
changes to Check all models.

2-5
 2 Model Compatibility Checking

3 To run model compatibility checks, click Check this model or Check all
models. The compatibility checker displays a progress bar.

4 If you opted to check only the top model, results are displayed directly in
the Model Advisor dialog box. You can use the dialog box to explore and
rerun individual checks and save the results.

If you opted to check all models, results are displayed in the command
window and in an HTML summary report window.
• The MATLAB Command Window displays results similar to the
following:

2-6
 Check Model Compatibility Using the Graphical User Interface

• The HTML summary report window displays results similar to the

following:

Note This HTML report also is linked from the command window
results. It is saved as file summaryReport.html in subfolder
/slprj/modeladvisor under the current working folder.

To view the detailed Model Advisor Report for a model listed in the
HTML summary report, go to the Systems Run table, and click the
corresponding link in the Model Advisor Report column.

2-7
 2 Model Compatibility Checking

5 If the checks pass, the model is ready for inspection. If incompatibilities

are reported, fix the issues and recheck the model for compatibility.

Tip If you want to run compatibility checks on a subsystem:

1 From the Model Editor, select Analysis > Model Advisor > Model
Advisor.

2 In the System Selector window, select the subsystem.

3 Click OK.

You can use the Model Advisor window to select and run the Simulink Code
Inspector compatibility checks on your subsystem. See “Consult the Model
Advisor”.

2-8
 Check Model Compatibility Using the Command-Line Interface

Check Model Compatibility Using the Command-Line

Interface
To programmatically control model compatibility checking, use the
slci.Configuration interface.

In the MATLAB Command Window or within a script, you issue a

call to slci.Configuration.checkCompatibility, specifying the
handle to a Simulink Code Inspector configuration object for the model,
previously returned by cfgObj = slci.Configuration(modelName);. The
checkCompatibility function returns objects containing results information.

The following example shows how to programmatically run the compatibility

checker and report results.

fprintf('\nInvoking compatibility checker ...\n');

config = slci.Configuration('slcidemo_roll');
result = config.checkCompatibility('DisplayResults','None');

for i = 1:length(result)
fprintf('\nModel ''%s'' passed %d checks with %d issues.',...
result{i}.system,...
result{i}.numPass, result{i}.numWarn + result{i}.numFail)
end

If the checks pass, the model is ready for inspection. If incompatibilities are
reported, fix the issues and recheck the model for compatibility.

For an example of using the command-line interface to control the complete

code inspection workflow, see the example slcidemo_intro.

2-9
 2 Model Compatibility Checking

Fix or Work Around Incompatibilities

In this section...
“Fix or Work Around Unsupported Blocks” on page 2-10
“Fix or Work Around Global Data Store Usage” on page 2-10

Fix or Work Around Unsupported Blocks

If the compatibility checker identifies one or more unsupported blocks in
your model, possible actions include:

• Replace an unsupported block with a supported block. Supported blocks

are listed in “Supported Blocks — By Category”, and also can be viewed in
the slcilib block library. Parameters for blocks in the slcilib library
are configured for code inspection. The slcilib block library also includes
mask blocks that use supported blocks.
• Replace an unsupported block with an equivalent combination of supported
blocks.
• Replace an unsupported block with an S-Function block created using the
Legacy Code Tool.
• If one or more unsupported blocks cannot be removed, use referenced
models to isolate the unsupported block(s), and/or use a partial verification
work flow that omits the unsupported block(s).

Fix or Work Around Global Data Store Usage

If the compatibility checker identifies one or more externally defined signal
objects that are being referenced as global data stores by Data Store Read or
Write blocks in the model, possible actions include:

• If possible, avoid use of externally defined signal objects that are referenced
as global data stores by Data Store Read or Data Store Write blocks. This
usage causes Simulink software to create hidden Data Store memory blocks
at root level, which is incompatible with code inspection.
• Move the affected Data Store Read or Data Store Write blocks into Model
blocks.

2-10
 3

Code Inspection

• “Code Inspection” on page 3-2

• “Inspect Code Using the Graphical User Interface” on page 3-4
• “Inspect Code Using the Command-Line Interface” on page 3-8
• “Code Inspection Reports” on page 3-9
• “Interpret the Overall Inspection Result” on page 3-12
• “Analyze Code Verification Results” on page 3-14
• “Model Patterns That Can Result in Code Verification Failures” on page
3-19
• “Analyze Traceability Results” on page 3-24
• “Traceability Matrices” on page 3-28
• “Prerequisites for Generating a Traceability Matrix” on page 3-30
• “Generate a Traceability Matrix” on page 3-31
• “Add Comments to a Traceability Matrix” on page 3-32
• “Retain Comments When Regenerating a Traceability Matrix” on page 3-33
• “Traceability Matrix Limitations” on page 3-34
 3 Code Inspection

Code Inspection
Code inspection automatically compares generated code with its source
model to satisfy code-review objectives in DO-178C and other high-integrity
standards. The code inspection process builds an in-memory representation of
the model that is independent of the code generation process. The Simulink
Code Inspector systematically examines blocks, parameters, and settings in a
model to determine whether they are structurally equivalent to operations,
operators, and data in the generated code, and generates reports that can be
used to support software certification.

The aspects of a Simulink model that are analyzed by code inspection include
the following:

• Model interface
• Block behavior
• Stateflow behavior
• Block connectivity and execution order
• Data and file packaging
• Local variables

When developing a model from which you intend to generate code that will be
verified using Simulink Code Inspector, you can incrementally and iteratively
check the model for compatibility with Simulink Code Inspector rules. Model
compatibility checking can significantly reduce the amount of time to achieve
satisfactory code inspection results by exposing issues early in the model
development process. Before inspecting the code for a model, you should
check that the model passes Simulink Code Inspector compatibility checks.
For more information, see “Model Compatibility”.

You can generate the model code to be inspected as part of code inspection, or
perform code generation and code inspection as separate steps.

To initiate code inspection for a model that has passed Simulink Code
Inspector compatibility checks, you can do either of the following:

3-2
 Code Inspection

• From the model window, select Code > Simulink Code Inspector, and
use the Simulink Code Inspector dialog box to control code inspection. For
more information, see “Inspect Code Using the Graphical User Interface”
on page 3-4.
• Use the slci.Configuration interface to programmatically control
code inspection. For more information, see “Inspect Code Using the
Command-Line Interface” on page 3-8.

Code inspection generates a detailed HTML report for each model inspected.
If you inspected all models in a model reference hierarchy, the software
displays a summary HTML report. You can click links in the HTML
summary report to view the detailed code inspection report for each model
and referenced model that was inspected. If you inspected only one model, the
model results are displayed directly in a detailed code inspection report.

The detailed report for a model documents code verification and traceability
results. The code inspection report contains the following major sections:

• Code Verification — Summary and detailed reports on verification of

structural equivalence between model and code elements.
• Traceability — Summary and detailed reports on model-to-code and
code-to-model traceability

For companies and organizations that must certify software under DO-178C,
the Simulink Code Inspector significantly reduces the time and cost associated
with verifying code against requirements. Instead of completing manual
line-by-line code reviews with a project checklist, which is time intensive and
error prone, you can run the Simulink Code Inspector and review a detailed
inspection report. For more information about the code inspection report, see
“Code Inspection Reports” on page 3-9.

3-3
 3 Code Inspection

Inspect Code Using the Graphical User Interface

1 Open a model for which you want to generate and inspect code using
Simulink Code Inspector. To use an example model, you can do the
following:
a Open the example model slcidemo_roll_orig using the following
command:

>> slcidemo_roll_orig

b Save a copy of the model to a work folder, renaming it to slcidemo_roll.

Change directory to the work folder.

2 If the model has not previously passed model compatibility checking,

follow the procedure in “Check Model Compatibility Using the Graphical
User Interface” on page 2-5. When the model passes the Simulink Code
Inspector compatibility checks, return to this procedure.

3 Verify the run-time functionality of the model. If you modified the model
to address incompatibilities, reverify model functionality using simulation
test cases. For example model slcidemo_roll_orig, you can verify
run-time functionality by simulating the model. Before proceeding with
code inspection, your model should simulate with no errors.

4 Generate code for the model. You can generate code implicitly as part
of code inspection (using the Simulink Code Inspector dialog box option
Generate code before code inspection), or perform code generation
and code inspection as separate steps. This example separates the code
generation step from the code inspection step.
a In the top model window, select Simulation > Model Configuration
Parameters to open the Configuration Parameters dialog box. If you
want to generate an HTML code generation report for later reference
(recommended), go to the Code Generation > Report pane, and select
the option Open report automatically. (If you try this example with a
model other than slcidemo_roll, it is recommended to select all options
in the Report pane.) Click OK and save the model changes.
b Go to the Code Generation main pane and click Generate code. (If
the Generate code button does not appear for your model, select the

3-4
 Inspect Code Using the Graphical User Interface

Generate code only option to enable the button.) Progress is displayed

in the MATLAB Command Window.
c Embedded Coder code generation displays results in an HTML report
window.

5 Inspect the generated code.

a Open the Simulink Code Inspector dialog box if it is not already

open, and examine the code inspection parameter settings. The Code
placement parameter is set to Embedded Coder default, which
configures code inspection to use the default Embedded Coder folder
structure created by code generation.
b Optionally, you can change the location to which code inspection writes
the code inspection report, using the dialog box parameter Report
folder. For example, enter the path string ./report and click Apply.

c To inspect the generated code, click Inspect Code. The Simulink Code
Inspector displays a progress bar.
d The Simulink Code Inspector displays a summary in an HTML report
window:

3-5
 3 Code Inspection

The summary report links to detailed code inspection reports for the top
model and each referenced model. For example, here is the topmost
portion of the code inspection report for the top model, slcidemo_roll:

3-6
 Inspect Code Using the Graphical User Interface

The summary report and the detailed code inspection reports are
saved as HTML files in the Report folder location you specified. If
you reinspect the generated code, the report in the Report folder is
automatically updated.

3-7
 3 Code Inspection

Inspect Code Using the Command-Line Interface

To programmatically control code inspection, use the slci.Configuration
interface.

In the MATLAB Command Window or within a script, you issue a call to

slci.Configuration.inspect, specifying the handle to a Simulink Code
Inspector configuration object for the model, previously returned by cfgObj =
slci.Configuration(modelName);. The inspect function returns objects
containing results information.

The following example shows how to programmatically run the Simulink

Code Inspector and report results. The model is assumed to have
previously passed Simulink Code Inspector compatibility checks (see
slci.Configuration.checkCompatibility) and simulated (see sim) with
no errors.

config = slci.Configuration('slcidemo_roll');
config.setTopModel(true);
config.setReportFolder(fullfile('.','report'));
result = config.inspect('DisplayResults','None');
fprintf('Model %s status: %s\n',result.ModelName, result.Status);

The inspection report is placed at the location specified in the call to

slci.Configuration.SetReportFolder, which is the report subfolder of the
current working folder. If you reinspect the generated code, the report is
automatically updated. To display the generated report, issue the following
command:

web(fullfile('.', 'report','slcidemo_roll_report.html'));

For an example of using the command-line interface to control the complete

code inspection workflow, see the example slcidemo_intro.

3-8
 Code Inspection Reports

Code Inspection Reports

Code inspection generates an HTML code inspection report for a Simulink
model and its generated code. The report provides detailed analysis of
structural equivalence and bidirectional traceability between the model and
the code generated from the model.

Code inspection automatically compares generated code with its source

model to satisfy code-review objectives in DO-178C and other high-integrity
standards. The code inspection process builds an in-memory representation of
the model that is independent of the code generation process. The Simulink
Code Inspector systematically examines blocks, parameters, and settings in a
model to determine whether they are structurally equivalent to operations,
operators, and data in the generated code, and generates reports that can be
used to support software certification.

Simulink Code Inspector code inspection carries out a translation validation.

Inputs to the Simulink Code Inspector are a Simulink model and the C
source code generated by the Embedded Coder code generator for the model.
The Simulink Code Inspector processes these two inputs into internal
representations (IRs), called model IR and code IR. These IRs are transformed
into normalized representations to facilitate further analysis. In this process,
the model IR represents the expected pattern, and the code IR constitutes the
actual pattern to be verified. To verify the generated code, the Simulink Code
Inspector attempts to match the normalized model IR with the normalized
code IR.

Note Simulink Code Inspector code inspection has been implemented

independently of Embedded Coder code generation. In particular, the IRs
used by Simulink Code Inspector are different from the IRs used by the
code generator.

3-9
 3 Code Inspection

Use of normalization techniques allows the Simulink Code Inspector to

inspect code generated by an highly-optimizing code generator. The results of
this matching process are reported to the user by means of a code verification
report and a traceability report. When code inspection completes, the code
verification report documents the translation validation process, and the
traceability report provides a bidirectional mapping between model elements
and their counterparts in the generated code. The model elements are
Simulink blocks, Stateflow charts, Stateflow states, and Stateflow transitions.

The code inspection results are presented in a hierarchical manner. A

summary report lists the top model and, if the code inspection encompassed
referenced models, each model in the model reference hierarchy. For each
model, the summary report provides aggregated status information and a link
to a detailed code inspection report for the model.

3-10
 Code Inspection Reports

The detailed code inspection reports provide the following information for
each model:

• Overall Inspection Result — Passed, Warning, or Failed — based on

aggregated status of the code verification and traceability results
• Code Verification Results — Summary and detailed reports on verification
of structural equivalence between model and code elements
• Traceability Results — Summary and detailed reports on bidirectional
model-to-code mapping

3-11
 3 Code Inspection

Interpret the Overall Inspection Result

The detailed code inspection report for a model or submodel provides a header
section that includes the Overall Inspection Result value for the model
— Passed, Warning, or Failed — based on aggregated status of the code
verification and traceability results.

The Overall Inspection Result value is aggregated from the following

values:

• Code Verification Results — The overall code verification result

aggregated from the code verification report subsections. Possible
values are Verified, Partially verified, or Failed to verify. For
more information about how the Code Verification Results value is
aggregated, see “Analyze Code Verification Results” on page 3-14.
• Traceability Results — The overall traceability result aggregated
from the traceability report subsections. Possible values are Traced,
Partially traced, or Failed to trace. For more information about how
the Traceability Results value is aggregated, see “Analyze Traceability
Results” on page 3-24.

The following table shows how code verification and traceability results are
aggregated into the Overall Inspection Result.

Verified Partially verified Failed to verify

Traced Passed Warning Failed

3-12
 Interpret the Overall Inspection Result

Partially traced Warning Warning Failed

Failed to trace Failed Failed Failed

3-13
 3 Code Inspection

Analyze Code Verification Results

The detailed code inspection report for a model or referenced model provides
sections named Code Verification Results and Code Verification
Details, which provide summary and detailed reports on verification of
structural equivalence between the model and code generated from the model.
The code verification report provides information about:

• Verification of the interfaces of generated code functions

• Verification of structural equivalence between model and code
• Verification of executable lines of generated code within each function
• Temporary variable usage
• Verification of data type replacements

The following sample report excerpt shows summary code verification results
for generated code that is structurally equivalent to its corresponding model.
Model elements that are outside of the supported language subset and
corresponding code fragments are indicated as “Unable to process” in the
code verification report.

3-14
 Analyze Code Verification Results

The Code Verification Results contain:

• The overall code verification result value aggregated from the code
verification report subsections. Possible values for Code Verification
Results are Verified, Partially verified, or Failed to verify.
• Subsection-level verification results:
- Function Interface Verification

3-15
 3 Code Inspection

- Model To Code Verification

- Code To Model Verification
- Temporary Variable Usage
- Data Type Replacement Verification
The subsection-level verification result values are aggregated from the
verification status of every object (function interface, model element, code
line, temporary variable, or type usage) in the subsection. Each subsection
returns the value Verified, Partially verified, or Failed to verify.
• Object level verification results. Each function interface, model element,
code line, temporary variable, or type usage within a subsection returns
a verification status value.

Model Element, Code Line, Possible Verification Status

Function Interface, Temporary
Variable, or Type Usage
Model elements: Verified
Partially processed
- Simulink blocks
Unable to process
- Stateflow charts Failed to verify
- Stateflow states
- Stateflow transitions
Code lines
Function interfaces Verified
Failed to verify
Temporary variables
Type usage

When the object-level verification status is aggregated to produce the

subsection-level status value, the most severe object status becomes the
subsection status.

3-16
 Analyze Code Verification Results

Most Severe Object-Level Status Resulting Subsection-Level

Status
Failed to verify Failed to verify
Partially processed or Unable to Partially verified
process
Verified Verified

Correspondingly, when the section-level verification status is aggregated to

produce the Code Verification Results value, the most severe subsection
status becomes the overall code verification status.

Most Severe Subsection-Level Resulting Overall Code

Status Verification Status
Failed to verify Failed to verify
Partially verified Partially verified
Verified Verified

The following sample report excerpt illustrates how code verification status is
aggregated when one or more objects fails to verify.

3-17
 3 Code Inspection

3-18
 Model Patterns That Can Result in Code Verification Failures

Model Patterns That Can Result in Code Verification

Failures
In this section...
“Redundant Modeling Patterns” on page 3-19
“Blocks with Constant Non-Finite Outputs” on page 3-20
“Action Subsystems with Output Not Connected to Merge Blocks” on page
3-21
“Multiport Switch Blocks with Input From Same Local Signal” on page 3-22
“Models Triggering Code Optimizations to Avoid Data Copies” on page 3-23

Redundant Modeling Patterns

Models with redundant modeling patterns fail code verification. When
generating the code, Simulink Coder eliminates the redundant functionality
of the block. If this elimination results in a structural change of the generated
code, inspection fails. For example:

• Switch blocks with inputs from the same local signals. The switch 3 block
is eliminated in the generated code. Switch blocks switch 1 and switch
2 are not eliminated because they connect to root inports. Simulink Code
Inspector reports it as Failed to verify.

3-19
 3 Code Inspection

• Data store read block connected to data store write block. Both the
Data Store Read and Data Store Write1 blocks are eliminated in the
generated code. Simulink Code Inspector reports a Warning status.

• Minmax blocks with inputs from the same local signals. The block compares
two equivalent values, resulting in an if statement with an empty body in
the generated code. Simulink Code Inspector reports it as Failed to verify.

Blocks with Constant Non-Finite Outputs

If your model contains blocks with constant non-finite outputs, the model can
fail code verification. The result is Failed to verify.

In this example, the Math Function block is fixed at infinity. Although the
Simulink Coder generates code for the model, code verification fails.

3-20
 Model Patterns That Can Result in Code Verification Failures

Action Subsystems with Output Not Connected to

Merge Blocks
If your model contains action subsystems and the outputs are not connected
to a single merge block, the model can fail code verification. The result is
Failed to verify.

In this example, there are two action subsystems, each with output connected
to a gain block. Code verification fails.

To pass code verification, consider connecting the output of all action

subsystems to a single merge block, as shown below. Simulink Code Inspector
can then verify the model.

3-21
 3 Code Inspection

Multiport Switch Blocks with Input From Same Local

Signal
Your model can fail code verification if it contains a multiport switch block
with both:

• More than one input from the same local signal.

• Output to a local signal.

The generated code might have switch case statements with fall through case
statements. The result is Failed to verify.

In this example, Multiport Switch block input ports 1 and 3 are connected
to the same local signal. Code verification fails.

3-22
 Model Patterns That Can Result in Code Verification Failures

Models Triggering Code Optimizations to Avoid Data

Copies
Models with Assignment, Selector, or two-inport Multiport Switch blocks can
trigger optimizations that change index selection to avoid data copies in the
generated code. In this example, the OneBased Multiport Switch block has
two inports. The Gain5 block multiplies the signal to inport 2:

During code generation, optimization moves the Gain5 to avoid data copies
in the generated code:

Code verification fails.

3-23
 3 Code Inspection

Analyze Traceability Results

The detailed code inspection report for a model or referenced model provides
sections named Traceability Results and Traceability Details sections.
These sections provide summary and detailed reports on bidirectional
model-to-code mapping. The overall traceability report documents the code
lines that implement a particular model element and the model elements that
contributed to the generation of a line of code.

The following report excerpt shows summary traceability results for generated
code that is structurally equivalent to its corresponding model.

The Traceability Results section displays:

• The overall traceability result value aggregated from the traceability

report subsections. Possible values for Traceability Results are Traced,
Partially traced, or Failed to trace.

3-24
 Analyze Traceability Results

• Subsection-level traceability results:

- Model To Code Traceability Results
- Code To Model Traceability Results
The subsection-level traceability result values are aggregated from the
traceability status of every object (model element or code line) in the
subsection. Each subsection returns the value Traced, Partially traced,
or Failed to trace.
• Object level traceability results. Each model element or code line within a
subsection returns a status value.

Model Element or Code Line Possible Status Value

Model elements: Traced
Partially processed
• Simulink blocks Unable to process
Failed to trace
- Stateflow charts
- Stateflow states
- Stateflow transitions
Code lines Traced
Partially processed
Unable to process
Failed to trace
Nonfunctional
Not processed

- Not processed — C code lines that were not processed for code-to-model
traceability. For example, code that is located outside the scope of
verified functions. An #include statement that is located outside of
the scope of a model step or initialize function is not processed for
code-to-model traceability.
- Nonfunctional — C code lines that are:
• Empty
• Contain only comments
• Opening or closing brackets ({ and })

3-25
 3 Code Inspection

- Unable to process — C code lines that are one of the following:

• Do not match with any model objects
• One of these tokens: ';', ')', '(', '[', ']'

When the object-level traceability status is aggregated to produce the

subsection-level status value, the most severe object status becomes the
subsection status.

Most Severe Object-Level Status Resulting Subsection-Level

Status
Failed to trace Failed to trace
Partially processed or Unable to Partially traced
process
Traced, Nonfunctional, or Not Traced
processed

Correspondingly, when the section-level traceability status is aggregated to

produce the Traceability Results value, the most severe subsection status
becomes the overall traceability status.

Most Severe Subsection-Level Resulting Overall Traceability

Status Status
Failed to trace Failed to trace
Partially traced Partially traced
Traced Traced

The following sample report excerpt illustrates how traceability status is

aggregated when one or more objects fails to trace.

3-26
Analyze Traceability Results

3-27
 3 Code Inspection

Traceability Matrices
When you use Model-Based Design and production code generation to develop
application software components, you can generate a traceability matrix. The
traceability matrix provides traceability among model objects, generated code,
and model requirements. You can add comments to the generated traceability
matrix. If you change the model and regenerate the traceability matrix, the
software retains your comments.

For a given model, the generated traceability matrix can provide information
about:

• Model objects that are traceable between the model and generated code,
such as Simulink blocks, Stateflow objects, and MATLAB functions.
• Model objects that are untraceable between the model and generated code,
such as eliminated and virtual blocks.
• Requirements documents that you link to model objects using the Simulink
Verification and Validation™ Requirements Management Interface (RMI).

Generate the traceability matrix using the slci.ExportTraceReport function

from the MATLAB Command Window. The function creates an XLS file that
contains the following worksheets:

• Model Information — Summary of the model configuration and

checksum. The summary includes the model name, version, author,
creation date, last saved by, last updated date, checksum, and the selection
of Traceability Report Contents parameters.
• Code Interface — Information about the generated code interface, such
as function prototype and timing information for the model initialize and
step functions.
• Code Files — File folders and names of the generated code files.
• Report — Traceability information for each model object, including model,
generated code, and requirements. Each row in the worksheet pertains to a
single occurrence of a model object. The information for a model object is
in more than one row if the object:
- Appears more than once in the generated code.

3-28
 Traceability Matrices

- Links to more than one requirement.

3-29
 3 Code Inspection

Prerequisites for Generating a Traceability Matrix

Before generating a traceability matrix for model objects, generated code, and
model requirements, perform the following steps:

1 Optionally, attach requirements documents. For more information, see

“Link to Requirements Document Using Selection-Based Linking” in the
Simulink Verification and Validation documentation.

2 In the Configuration Parameters dialog box, on the Code

Generation > Report pane, select:
a “Create code generation report”

b At least one of the following Traceability Report Contents

parameters:
• “Eliminated / virtual blocks”
• “Traceable Simulink blocks”
• “Traceable Stateflow objects”
• “Traceable MATLAB functions”

3 Create an object of class slci.Configuration and return a handle

to the model. For example, enter the MATLAB command cfgObj =
slci.Configuration('slcidemo_roll');.

4 Generate and inspect the model code using MATLAB commands. For
example:
• To generate code, enter rtwbuild('slcidemo_roll').
• To inspect the code, enter cfgObj.inspect.

3-30
 Generate a Traceability Matrix

Generate a Traceability Matrix

To generate a traceability matrix:

1 Open the model if it is not already open.

2 Verify that you have completed the “Prerequisites for Generating a

Traceability Matrix” on page 3-30. This includes selecting report options
and generating and inspecting model code.

3 In the MATLAB Command Window, enter the following command, where

cfgobj is a handle to a configuration object previously returned by cfgObj
= slci.Configuration(modelName); and file_name is the name of the
XLS file to be created:

slci.ExportTraceReport(cfgObj,'file_name')

For example:

slci.ExportTraceReport(cfgObj,'slcidemo_roll_tracereport')

The software generates the traceability matrix.

4 Open the traceability matrix file, review the traceability matrix, and add
comments in new columns. For more information, see “Add Comments to a
Traceability Matrix” on page 3-32.

3-31
 3 Code Inspection

Add Comments to a Traceability Matrix

You can add comments to the traceability matrix that you generated using
the slci.ExportTraceReport function.

To add comments to the traceability matrix, you must:

• Create new columns for your comments.

• Use unique column headings. Columns that you add must have headings.
• Add at least one entry to the column, other than the column heading.
• Retain the following columns:
- Model Object Name
- Model Object Path
- Model Object Subsystem
- Code File Location
- Code File Name
- Code Function
- Code Line Number
- Model Object Unique ID
- Model Object Optimized
- Code Comment Checksum

Note Comments must resolve to a text string. For example, a link to an

image resolves to a text string, but a copy of the image does not.

3-32
 Retain Comments When Regenerating a Traceability Matrix

Retain Comments When Regenerating a Traceability

Matrix
To regenerate a traceability matrix and retain your comments:

1 Navigate to the working folder of the model.

2 Optionally, regenerate and reinspect code for your model. Regenerating

and reinspecting code before generating the traceability matrix ensures
that you have the latest model-to-code traceability information.

3 In the MATLAB Command Window, enter the following command.

file_name is the name of the existing traceability matrix that you are
regenerating. If the existing traceability matrix is in a different folder,
include the full path to that folder in path.

slci.ExportTraceReport(cfgObj, 'file_name', 'path')

The traceability matrix regenerates.

3-33
 3 Code Inspection

Traceability Matrix Limitations

The traceability matrix generation capability has the following limitations:

• Does not support generating a traceability matrix for referenced models.

When you generate a traceability matrix for a model that contains
referenced models, the traceability matrix contains information about the
Model block only. The traceability matrix does not contain information
about the contents of the referenced model. If your model contains
referenced models, generate a traceability matrix for the top-level model
and each referenced model separately.
• Works with the Microsoft® Windows® platform only.
• In most cases, identifies comments that you add to the traceability matrix,
but when comments cannot be identified, the traceability matrix includes
the text:

Row is not unique: comment

• Does not support information stored in external .req files. For example,
when you generate a traceability matrix for a model with externally stored
requirements information, the traceability matrix does not include the
requirements information.

3-34
 4

DO-178C Objectives
Compliance

• “Model-Based Design Workflow in DO-178C” on page 4-2

• “Applicable DO-178C Objectives” on page 4-6
 4 DO-178C Objectives Compliance

Model-Based Design Workflow in DO-178C

Applying Model-Based Design to a safety-critical system requires extra
consideration and rigor so that the system adheres to defined safety
standards. DO-178C, Software Considerations in Airborne Systems and
Equipment Certification, is such a standard.

MathWorks provides a DO Qualification Kit product that supports you

in qualifying MathWorks verification tools for projects based on the
DO-178C standard. The kit also provides detailed information on how
to apply Model-Based Design to DO-178C. For more information, see
http://www.mathworks.com/products/do-178/.

The DO-178C software life cycle consists of objectives that must be met for
each of the life cycle stages. In Annex A of the DO-178C standard, these
objectives are summarized in tables. The DO Qualification Kit document
Model-Based Design Workflow for DO-178C summarizes those tables and
provides recommendations on meeting the objectives using a Model-Based
Design process.

Overview of the Model-Based Design Workflow:

Software Development Activities
The following figure illustrates core software development artifacts and
activities along with corresponding objectives from DO-331 Table MB.A-2.
Solid, horizontal arrows indicate the succession of software development
activities.

4-2
 Model-Based Design Workflow in DO-178C

Core Software Development Artifacts and Activities

The following table lists MathWorks products and capabilities that can be
used to support the core software development activities in the workflow.

Workflow Activity Available Products and Capabilities for Model-Based Design

Requirements Third-party requirements management tool
development
Model development MATLAB, Simulink, Stateflow
Source code Embedded Coder
development
Executable object code Third-party IDE or compiler, IDE Link
development

Overview of the Model-Based Design Workflow:

Verification and Tracing Activities
The following illustrates verification and traceability activities and objectives
that correspond to the core software development artifacts and activities
shown in Core Software Development Artifacts and Activities.

4-3
 4 DO-178C Objectives Compliance

Verification and Traceability Activities and Objectives

The following table lists MathWorks products and capabilities that can be
used to support the core verification and tracing activities of the workflow.

Workflow Activity Available Products and Capabilities for Model-Based Design

Requirements Manual review
verification
Requirements Third-party requirements management tool
traceability

4-4
 Model-Based Design Workflow in DO-178C

Workflow Activity Available Products and Capabilities for Model-Based Design

Model verification Simulink Verification and Validation — DO-178C/DO-331 checks*,
SystemTest™ — Limit Check element*, Simulink Design Verifier™ —
Property Proving (optional), Simulink Design Verifier — Design Error
Detection (optional), Simulink Verification and Validation — Model
Coverage*, Simulink Report Generator™ — System Design Description
report*
Model traceability Simulink Verification and Validation — Requirements Management
Interface, Simulink Report Generator — System Design Description
report*
Source code Simulink Code Inspector — Code Verification Report*
verification
Source code Simulink Code Inspector — Traceability Report*
traceability
Executable object code SystemTest — Limit Check element*, Simulink Design Verifier — Test
verification case generation, Embedded Coder — PIL test, Embedded Coder — Code
coverage tool link (requires third-party code coverage tool), Polyspace®
Code Prover™
Object code Embedded Coder — Code generation report, Third-party IDE or
traceability compiler — Object code listing
*The DO Qualification Kit can be used to support DO-178C tool qualification.

4-5
 4 DO-178C Objectives Compliance

Applicable DO-178C Objectives

The following table summarizes anticipated certification credits for Simulink
Code Inspector, along with additional credits for other code verification
products.

Annex Objectives DO-331 Software Anticipated Certification Credit

A or C Reference* Levels
Table
Table (1) Source code Section A, B, C Full — Simulink Code Inspector
MB.A-5 complies with low-level MB.6.3.4.a
requirements
Table (2) Source code complies Section A, B, C Full — Simulink Code Inspector
MB.A-5 with software architecture MB.6.3.4.b
Table (3) Source code is verifiable Section A, B Full — Simulink Code Inspector
MB.A-5 MB.6.3.4.c
Table (4) Source code conforms to Section A, B, C Full — Polyspace Bug Finder™
MB.A-5 standards MB.6.3.4.d MISRA-AC ACG rules checker
Table (5) Source code is traceable Section A, B, C Full — Simulink Code Inspector
MB.A-5 to low-level requirements MB.6.3.4.e
Table (6) Source code is accurate Section A, B, C Partial — Simulink Code
MB.A-5 and consistent MB.6.3.4.f Inspector can detect uninitialized
or unused variables or constants
in the generated C code. Polyspace
Bug Finder and Polyspace Code
Prover can identify run-time
errors, such as potential
underflow, overflow, and divide by
zero. Other issues, such as stack
usage, resource contention, worst
case execution time, and exception
handling must be assessed by
other means.
*DO-331, Model-Based Development and Verification Supplement to DO-178C and DO-278A

4-6