Your browser does not support JavaScript! Skip to main content
Free 30-day trial DO-178C Handbook RapiCoupling Preview DO-178C Multicore Training Multicore Resources
Rapita Systems
 

Industry leading verification tools & services

Rapita Verification Suite (RVS)

  RapiTest - Unit/system testing  RapiCover - Structural coverage analysis  RapiTime - Timing analysis (inc. WCET)  RapiTask - Scheduling visualization  RapiCoverZero - Zero footprint coverage analysis  RapiTimeZero - Zero footprint timing analysis  RapiTaskZero - Zero footprint scheduling analysis  RapiCouplingPreview - DCCC analysis

Multicore Verification

  MACH178  MACH178 Foundations  Multicore Timing Solution  RapiDaemons

Engineering Services

  V&V Services  Data Coupling & Control Coupling  Object code verification  Qualification  Training  Consultancy  Tool Integration  Support

Industries

  Civil Aviation (DO-178C)   Automotive (ISO 26262)   Military & Defense   Space

Other

RTBx Mx-Suite Software licensing Product life cycle policy RVS Assurance issue policy RVS development roadmap

Latest from Rapita HQ

Latest news

SAIF Autonomy to use RVS to verify their groundbreaking AI platform
RVS 3.22 Launched
Hybrid electric pioneers, Ascendance, join Rapita Systems Trailblazer Partnership Program
Magline joins Rapita Trailblazer Partnership Program to support DO-178 Certification
View News

Latest from the Rapita blog

How to certify multicore processors - what is everyone asking?
Data Coupling Basics in DO-178C
Control Coupling Basics in DO-178C
Components in Data Coupling and Control Coupling
View Blog

Latest discovery pages

control_tower DO-278A Guidance: Introduction to RTCA DO-278 approval
Picture of a car ISO 26262
DCCC Image Data Coupling & Control Coupling
Additional Coe verification thumb Verifying additional code for DO-178C
View Discovery pages

Upcoming events

XPONENTIAL 2025
2025-05-19
Avionics and Testing Innovations 2025
2025-05-20
DASC 2025
2025-09-14
DO-178C Multicore In-person Training (Fort Worth, TX)
2025-10-01
View Events

Technical resources for industry professionals

Latest White papers

Mitigation of interference in multicore processors for A(M)C 20-193
Sysgo WP
Developing DO-178C and ED-12C-certifiable multicore software
DO178C Handbook
Efficient Verification Through the DO-178C Life Cycle
View White papers

Latest Videos

Rapita Systems - Safety Through Quality
Simulation for the Motorola 68020 microprocessor with Sim68020
AI-driven Requirements Traceability for Faster Testing and Certification
Multicore software verification with RVS 3.22
View Videos

Latest Case studies

GMV case study front cover
GMV verify ISO26262 automotive software with RVS
Kappa: Verifying Airborne Video Systems for Air-to-Air Refueling using RVS
Supporting DanLaw with unit testing and code coverage analysis for automotive software
View Case studies

Other Resources

 Webinars

 Brochures

 Product briefs

 Technical notes

 Research projects

 Multicore resources

Discover Rapita

Who we are

The company menu

  • About us
  • Customers
  • Distributors
  • Locations
  • Partners
  • Research projects
  • Contact us

US office

+1 248-957-9801
info@rapitasystems.com
Rapita Systems, Inc.
41131 Vincenti Ct.
Novi
MI 48375
USA

UK office

+44 (0)1904 413945
info@rapitasystems.com
Rapita Systems Ltd.
Atlas House
Osbaldwick Link Road
York, YO10 3JB
UK

Spain office

+34 93 351 02 05
info@rapitasystems.com
Rapita Systems S.L.
Parc UPC, Edificio K2M
c/ Jordi Girona, 1-3
Barcelona 08034
Spain

Working at Rapita

Careers

Careers menu

  • Current opportunities & application process
  • Working at Rapita
Back to Top Contact Us

Breadcrumb

  1. Home
RapiCoverZero

Zero-footprint coverage analysis for critical software

Why choose RapiCoverZero?

  •  Collect coverage from systems that produce branch traces
  •  Save time with efficient merge and mark verification workflow
  •  Simplify verification through integration with your CI tool
  •  Collect coverage for libraries without source code
Request a demo Check PSP compatibility
  • Overview
  • Features
  • Resources
  • RapiCover
  • Compatibility
  • FAQs

Collect coverage from systems that produce branch traces

By automatically producing coverage results from branch traces, RapiCoverZero reduces the effort needed to verify code coverage. Along with branch traces produced by the system hardware, RapiCoverZero only needs a disassembly of the application, meaning there’s no need for either source code or instrumentation.

RapiCoverZero produces coverage results up to and including Decision coverage, letting you verify systems up to DO-178C DAL B.

Collect coverage
efficient workflow

Save time with efficient merge and mark verification workflow

Reduce your testing effort through an efficient verification workflow. Collect coverage from system tests, automatically merge this with coverage from integration and unit tests, and mark any remaining coverage holes as covered by analysis using RapiCover justifications.

This workflow is ideal for DO-178C testing even when your code changes as RapiCoverZero helps you review which of your coverage results and justifications need to be changed.

Simplify verification through integration with your continuous integration tool

Keep your verification on track by using RapiCoverZero alongside your continuous integration tool. Collect coverage results and track your project’s progress over time with our plugins for Jenkins and Bamboo.

By analyzing your code with RapiCoverZero on every new build, you can easily identify anomalies in your code coverage as they happen.

continuous integration
coverage for libraries

Collect coverage for libraries without source code

RapiCoverZero lets you analyze coverage for third-party libraries or other pieces of software for which you have no access to the source code.

As RapiCoverZero analyzes a branch trace and a disassembly to produce coverage results, it can produce results even when you don’t have access to source code.

Product features

  • Zero footprint verification
  • Integrated testing environment
  • Justifications
  • Project navigation
  • Integration with embedded targets
  • Integration with third party tools
  • Language support
  • Licensing
  • Support and training
  • Zero footprint coverage analysis Zero footprint coverage analysis for critical embedded software.
    Discover this feature
  • Source to object code traceability Trace results collected from analyzing program execution to source code, where available.
    Discover this feature
  • Platform support Supported compilers, instruction sets, trace capture mechanisms and RTOSs.
    Discover this feature
  • Automatically merge coverage Merge coverage from different builds automatically, such as system and unit tests.
    Discover this feature
  • Automate testing on host and target Run tests on host computers and test rigs in continuous build environments.
    Discover this feature
  • Merge Coverage utility Easily merge coverage from multiple test runs.
    Discover this feature
  • Analyze code complexity Analyze the complexity of your source code.
    Discover this feature
  • Efficient integration workflow Efficient integration workflow and inbuilt Platform Support Packages for integrations.
    Discover this feature
  • RVS Project Manager Take your test project from creation to completion with an intuitive user-interface. 
    Discover this feature
  • Shared integration with zero-footprint RVS tools After integrating one zero-footprint RVS tool to work a development environment, it is trivial to use others. 
    Discover this feature
  • Portable test environments Multiple users can share the same test environment.
    Discover this feature
  • Customizable workflow Customize the RVS workflow to best meet your needs.
    Discover this feature
  • Template integrations Create and use template integrations to reduce your effort integrating RVS with your system.
    Discover this feature
  • Compare reports Compare reports from different builds to track project progress over time.
    Discover this feature
  • Configurable export formats Export coverage results in a variety of formats.
    Discover this feature
  • Customizable color scheme Customize the color scheme used to display your results.
    Discover this feature
  • Comprehensive verification toolsuite One tool to meet all your software verification needs.
    Discover this feature
  • Justify untestable code Mark code as covered by manual analysis to justify not covering it during tests.
    Discover this feature
  • Migrate justifications when code changes Justifications migrate; when code changes, automatically or after manual review.
    Discover this feature
  • Portable justification library A single store of justifications can be used by all users working on a project. 
    Discover this feature
  • Multi-justifications Apply a single justification to multiple locations to reduce justification effort.
    Discover this feature
  • Justification templates Create and apply templates to add new justifications more easily.
    Discover this feature
  • Custom fields Apply and use custom fields for your justifications.
    Discover this feature
  • Treemaps View coverage and hierarchy of code at a glance.
    Discover this feature
  • Code viewer View code with syntax highlighting and color-coding of results.
    Discover this feature
  • Easily filter results Easily filter results to focus your analysis.
    Discover this feature
  • Visualize call dependencies Visualize the call dependencies in your code.
    Discover this feature
  • Advanced search function Search reports for specific elements using advanced queries. 
    Discover this feature
  • Filter by scopes Filter results by specific files and functions. 
    Discover this feature
  • Collect coverage across power cycles Stream coverage data to collect it across target power cycles.
    Discover this feature
  • Multicore support Verify critical multicore systems.
    Discover this feature
  • Jenkins Run RVS automatically through Jenkins to collect and archive results.
    Discover this feature
  • Bamboo Run RVS automatically through Bamboo to collect and archive results.
    Discover this feature
  • Software Configuration Management Integration with Software Configuration Management tools ensures that files can be used across a team.
    Discover this feature
  • Comprehensive language support Support for all languages that target machine code through zero-footprint analysis.
    Discover this feature
  • C Support for verification of code written in C.
    Discover this feature
  • C++ Support for verification of C++ code.
    Discover this feature
  • Ada Support for verification of code written in Ada.
    Discover this feature
  • Assembly Support for verification of Assembly code.
    Discover this feature
  • Mixed language support Support for verification of code written in multiple languages. 
    Discover this feature
  • Flexible licensing options Select floating or node-locked licenses with annual or perpetual duration.
    Discover this feature
  • Floating licenses Floating licenses support multiple users and shared working environments.
    Discover this feature
  • Node-locked licenses Node-locked licenses support the use of RVS on a single machine.
    Discover this feature
  • Annual licenses License RVS in annual increments.
    Discover this feature
  • Perpetual licenses License RVS for use indefinitely.
    Discover this feature
  • Easy to get started Integration and learning resources help you get started verifying your code in no time.
    Discover this feature
  • Support Dedicated support service to resolve technical issues quickly.
    Discover this feature
  • Tutorials Learn how to get the most from our verification solutions with simple, interactive tutorials.
    Discover this feature
  • Training Get up to speed with custom training courses delivered by expert engineers.
    Discover this feature
  • Documentation Learn how to use RVS features with comprehensive documentation in both printed and electronic formats.
    Discover this feature
  • Easily migrate to new versions Easily migrate to new RVS versions with guided migration help.
    Discover this feature

Videos

 
Zero footprint coverage analysis with RapiCover Zero Thumbnail
Zero footprint coverage analysis with RapiCover Zero
00:00:50 | Overview
 
Viewing software behavior at a glance with RVS treemaps
00:01:12 | Feature
 
Visualize call dependencies with RVS thumbnail
Visualize call dependencies with RVS
00:00:38 | Feature
 
Justifying untestable code with RapiCover Thumbnail
Justifying untestable code with RapiCover
00:05:00 | Feature
 

Downloads

  Webinar
Unlocking DO-178C Compliance Webinar
 
Seven Roadblocks to 100% Structural Coverage (and how to avoid them)
 
Eight top code coverage questions in embedded avionics systems
  Brochure
Rapita Systems Brochure
  Brochure
Rapita Verification Suite (RVS) Training Brochure
  Product brief
Zero-footprint coverage analysis with RapiCover Zero

News & Blog

News
Zero-footprint verification with RVS 3.12

Requirements

Check PSP compatibility

Software analysis by zero-footprint RVS tools has the following requirements:

  • The platform (target and any external devices e.g. debuggers) must be capable of producing a branch trace without gaps to ensure that the full program trace can be reconstructed.
  • The OS needs to make context switches observable. For some systems, supporting this may require modifications to be made to the OS.
  • A Platform Support Package (PSP) is needed for RVS to interface with the development environment, including the target hardware and trace capture mechanisms, in order to convert the branch trace into a format that the RVS tool understands and disassemble the executable and parse the resulting object code.

PSPs are developed to be compatible with the following:

  • Compilers
  • Instruction sets
  • Branch traces collected from the platform
  • Real-time operating systems
diagram showing hardware support on zero-footprint software

For a list of components that are already supported, see below. Note that we can add support for some components not listed below.

For detailed information on the requirements for zero-footprint tracing, see our Technical note.

For more information, contact info@rapitasystems.com.


 

Compilers

Platform Support Packages (PSPs) must be able to disassemble executables for further analysis. Typically, tools required for this are supplied as part of a toolchain unique to each compiler. The compilers PSPs already support are listed below:

  • Arm Compiler
  • CC-RH850
  • Clang
  • GCC

We can develop support for other compilers. For more information, contact us at info@rapitasystems.com.

Instruction sets

When code has been disassembled, Platform Support Packages (PSPs) must be able to understand the instruction set of the object code so they can parse it before it is used for subsequent analysis by zero-footprint RVS tools. The instruction sets PSPs already support are listed below:

  • 68k
  • AArch64
  • ARM
  • PowerPC
  • RH850
  • VISIUM
  • x86

We can develop support for other instruction sets. For more information, contact us at info@rapitasystems.com.


 

Branch traces

For it to be possible to analyze executables generated by a platform by zero-footprint RVS tools, it must be possible to collect a branch trace from the platform*. Some targets generate branch traces by default, for example:

  • Boards that have been developed to meet at least Class 2 of the Nexus message-based trace protocol
  • ARM boards including an ARM ETM component
  • Custom boards developed to produce branch traces

A debugger may be used to collect these branch traces from the target. Simulators may generate branch traces, or it may be possible to modify them to do so. Each Platform Support Package (PSP) is designed to support branch traces collected by a specific debugger or from a specific simulator. The debuggers and simulators PSPs already support are listed below:

† a modified version is available, which supports zero-footprint analysis

Debuggers

Simulators

Lauterbach TRACE32

QEMU†

PARTNER-Jet2

 

We can develop support for other debuggers and simulators. For more information, contact us at info@rapitasystems.com.

*In some cases, other approaches may be possible, such as using a branch map.


 

Real-time operating systems

For it to be possible to analyze executables generated by a platform by zero-footprint RVS tools, it must be possible to collect information on context switches made during software execution. Whether this is possible or not depends on the real-time operating system (RTOS) used and its configuration. Platform Support Packages must be able to understand context switch information to support further analysis of an executable by zero-footprint RVS tools. The RTOSs PSPs already support are listed below:

  • eMCOS for AUTOSAR Adaptive Platform
  • eMCOS for AUTOSAR Classic Platform (RV850)
  • FreeRTOS
  • SafeRTOS
  • SYSGO PikeOS®
  • Bare Metal (no OS)

We can develop support for other real-time operating systems. For more information, contact us at info@rapitasystems.com.

Operating systems

Zero-footprint RVS tools can be used to analyze software run on any host operating system.

Operating System

Windows 10 and 11

Windows Server 2019+

Variety of Linux distributions (including Ubuntu and Red Hat)

For older operating systems, contact us.


 

Programming languages

Language

Any language that targets machine code

Mixed languages


 

Multicore systems

Zero-footprint RVS tools can be used to analyze software from multicore systems.

Suitable branch trace(s) can be collected in one of two ways:

  1. Collecting a separate branch trace from each core
  2. Collecting a branch trace that includes results from all cores, where it’s possible to derive the core from which each branch was taken

Instrumentation-based vs instrumentation-free analysis

Both RapiCover and RapiCoverZero support on-target structural coverage analysis for critical software. Depending on your project and needs, one or both solutions may be better for you. Consult the table below to determine which is best for your project.

Features

RapiCover RapiCoverZero

Works without source code

No

Yes

Works without Instrumentation

No

Yes

Integration with development environment

Integration needed

No integration needed

MC/DC analysis (e.g. for DO-178C DAL A)

Yes

No

Tool qualification support

Yes

In development - contact us for details

Trace size and data processing time

Depends on applied instrumentation

Typically larger trace and longer data processing times

Supported platforms (target, data collection mechanism)

Flexible, almost any platform supported (see compatibility)

Requirements on platform (branch trace and context switch information must be available), PSP (see compatibility)

Frequently asked questions

  • General
  • Certification and qualification
  • Compatibility
  • Licensing and support
Expand All
  • What is RapiCover Zero?  
  • How does RapiCover Zero work?  
  • Which coverage criteria can I measure using RapiCover Zero?  
  • Can RapiCover Zero collect MC/DC results?  
  • Why is it not possible to obtain MC/DC from object code in the general case? 
  • Can I add manual configurations that flag my code as being exempt/uncoverable? 
  • What happens when I change my code? 
  • How are my results presented? 
  • Can I view my results in the context of my project source code?  
  • How is RapiCover Zero optimized to support my industry? 
  • How can RVS help me understand my code base? 
  • How long has RVS been used for software verification? 
  • Is instrumentation-based or instrumentation-free analysis best for me? 
  • How do I learn more about RapiCover Zero?  
  • Which certification standards and guidelines can RVS help me to achieve? 
  • Which platforms and data collection mechanisms do zero-footprint RVS tools support?  
  • What are Platform Support Packages and why are they needed? 
  • Is a Platform Support Package available for my platform? 
  • Can I use RVS tools with my continuous integration environment? 
  • How large a code base can RVS tools handle? 
  • Can I collect RapiCover Zero results from tests run by a third-party test framework? 
  • Which languages does RapiCover Zero support?  
  • Can I collect coverage data across power cycles and reset sequences?  
  • How does RVS support the analysis of shared code compiled by build systems with multiple executables? 
  • How are RVS products licensed? 
  • How does RVS support Enterprise licensing? 
  • Can I create and manage groups for my floating RVS licenses? 
  • What happens if I encounter an issue while using an RVS tool? 
  • How do you support RVS users? 
  • What is RapiCover Zero?

    RapiCoverZero is a structural coverage analysis tool that requires no project source code or modification of the development environment being used. To extract coverage information, RapiCoverZero analyzes branch trace information collected from a compatible target or data collection mechanism.

    As part of the RVS toolsuite, RapiCoverZero forms part of a software verification solution that also includes tools for functional testing and worst-case execution time analysis.

  • How large a code base can RVS tools handle?

    RVS tools are designed to handle very large code bases. Because of the efficient algorithms used by RVS tools, there is no fundamental limitation to the number of lines of code that RVS can process, and our RVS tools have been used on projects with millions of lines of code.

  • How are RVS products licensed?

    We offer both “Node-locked” and “Floating” licenses, and a license server to support use of our tools in your specific development environment. 

    For more information on our licensing models, see our RVS licensing FAQs.

  • What happens if I encounter an issue while using an RVS tool?

    All RVS licenses include access to our dedicated in-house support team, who will work with you to provide a rapid fix to your issue. This is a critical part of our vision. During 2021, we resolved 63% of our support requests within 7 working days and 93% within 30 working days. We also inform our customers of known issues via our website and email.

  • How do you support RVS users?

    We provide an extensive set of RVS documentation with each of our products, and offer training courses guiding you through the most effective use of RVS tools. All our users can benefit from privileged access to our website, which includes downloads for new product releases. 

  • Can I add manual configurations that flag my code as being exempt/uncoverable?

    RapiCover and RapiCoverZero include a powerful “justification” mechanism that lets you mark code as covered. Using this feature, you can provide a rationale for justifying the code and create templates to justify code more easily. When your code changes, justifications are automatically migrated to represent the new location of your justified code.

    For more information on using justifications, see our white paper.

     

  • What happens when I change my code?

    RapiCover and RapiCoverZero retain information about the revision of your code it used to generate results. The tool will report an error if you try to merge coverage from incompatible revisions. RapiCover includes an Optimal Dataset Calculator feature you can use to calculate the least expensive tests you need to run again when your code changes, saving you valuable testing effort.

  • How are my results presented?

    All RVS tools include a friendly user-interface that presents your results in both tabular and graphical formats. Using this interface, you can filter your results to zoom in on target functions, making it easy to find the information you are looking for.

    Treemaps provide a high-level overview of your code base and help you understand the coverage of your code at a glance.

    You can view RapiCover and RapiCoverZero results in continuous integration software, allowing you to track your verification progress over time. 

  • How do I learn more about RapiCover Zero?

    You can request a trial version of RVS, which includes RapiCoverZero. You can also arrange a demonstration, where a member of our team will work with you to show the benefits that RapiCoverZero can offer you.

  • Can RapiCover Zero collect MC/DC results?

    RapiCoverZero produces coverage results by analyzing a branch trace produced during program execution. While coverage metrics up to decision coverage can be inferred from branch traces, most branch traces do not include sufficient information from which to produce MC/DC results.

    If you need to collect MC/DC results, you can do so using RapiCover.

  • Which coverage criteria can I measure using RapiCover Zero?

    You can measure function, call, statement, branch and decision coverage using RapiCoverZero.

  • Which platforms and data collection mechanisms do zero-footprint RVS tools support?

    Software analysis by zero-footprint RVS tools has the following requirements:

    • The platform (target and any external devices e.g. debuggers) must be capable of producing a branch trace without gaps to ensure that the full program trace can be reconstructed.
    • The OS needs to make context switches observable. For some systems, supporting this may require modifications to be made to the OS.
    • A Platform Support Package (PSP) is needed for RVS to interface with the platform, including the target hardware and trace capture mechanisms, in order to convert the branch trace into a format that the RVS tool understands and disassemble the executable and parse the resulting object code. PSPs are developed to be compatible with four components of the platform: Compilers, Instruction sets, Branch traces and Real-time operating systems.

    For more information on the requirements for software analysis by zero-footprint RVS tools and a list of currently supported platforms, see our Platform support page.

    For more detailed information on the requirements, see our Technical note.

  • How does RapiCover Zero work?

    RapiCoverZero uses two types of inputs from which to produce structural coverage results. The first is the executable file and a disassembly of it, and the second is a branch trace* collected while the program under analysis is executed. From these inputs, RapiCoverZero can understand both the program structure and the events that occurred during the program execution, allowing it to perform structural coverage analysis and produce coverage results.

    *In some circumstances, other data collection methods such as using a branch map may be possible.

  • Can I view my results in the context of my project source code?

    If your source code is available, yes. By importing your source code and debug symbols into your RVS project, you can view your results in the context of both your object and source code, and trace between them.

  • Can I collect coverage data across power cycles and reset sequences?

    If you are using an external device to collect branch trace information, the data will remain in place while your system reboots, after which you can begin data collection again. This means that you can collect coverage data across a shutdown or reset sequence. This may be subject to your target hardware architecture and the device you use to collect branch trace information.

  • Which languages does RapiCover Zero support?

    As RapiCoverZero analyzes object code directly to produce results, it supports any language that targets machine code.

  • Can I use RVS tools with my continuous integration environment?

    RVS integrates with a range of continuous integration tools, allowing you to collect unit test, coverage and execution time results with every new build, track your verification progress over time and easily identify anomalies in your software's behavior as they are introduced.

    RapiTest, RapiCover and RapiTime (including zero-footprint versions) include custom plugins to integrate with Jenkins and Bamboo. RapiTest and RapiCover results can also be displayed in a range of other continuous integration tools through the JUnit and Cobertura plugins, which are compatible with most continuous integration software. 

  • How long has RVS been used for software verification?

    The Rapita Verification Suite (RVS) has been used in the critical embedded industry for over 15 years and supported a number of avionics projects globally. Qualification kits for qualified RVS products have supported more than 20 DO-178B and C certification projects up to and including DAL A.

  • Can I collect RapiCover Zero results from tests run by a third-party test framework?

    Yes, you do not need to use RapiTest to collect coverage results. As long as you have a compatible execution environment, RapiCoverZero can collect coverage results from your system.

  • How does RVS support Enterprise licensing?

    Floating RVS licenses follow an “Enterprise” model. You can use them across geographical boundaries*, in different projects, with different users, and share them with suppliers working on the same project.

    *Some floating licenses may be restricted to use within a specific geographical region. Where this is the case, this is agreed before licenses are issued.

  • What are Platform Support Packages and why are they needed?

    Platform Support Packages are required to support software analysis by zero-footprint RVS tools. They interface between the tools and the platform in order to do the following:

    • Convert the specific format of native branch traces generated by the platform into a format that the RVS tool understands and can use for subsequent analysis.
    • Disassemble the object code to understand the structure and control flow of the code so this can be used for subsequent analysis.

    Each PSP is designed to support various components of a platform. These include:

    • The compiler(s) used to generate executables
    • The instruction set of object code to be analyzed
    • The native branch trace format generated from the platform – this depends on the mechanism used to generate branch traces, which may be the target hardware (or simulator) or a third-party device e.g. debugger.
    • The real-time operating system.

    Different PSPs are needed to support analysis by zero-footprint RVS tools when any of the above items are different between two platforms. For more information on how PSPs support analysis by zero-footprint RVS tools, see our Requirements for zero-footprint RVS analysis Technical note.

  • Is a Platform Support Package available for my platform?

    To see whether we have already developed PSPs compatible with the components on your platform, see our zero-footprint Platform support.

    If we have not yet developed PSPs compatible with one or more components of your platform, we may be able to develop them. For more information, contact us at info@rapitasystems.com.

    Check PSP compatibility

  • Can I create and manage groups for my floating RVS licenses?

    Yes, you can create and manage groups of users for your floating RVS licenses. You can restrict each group to only serve licenses to specific hostnames or IP addresses. This allows you to reserve licenses for specific groups or specific purposes such as supporting the use of RVS on a continuous integration server.

    Any licenses that you don’t reserve will remain available as floating licenses that can be shared among different users and geographic locations.

  • How does RVS support the analysis of shared code compiled by build systems with multiple executables?

    RVS supports the analysis of shared code compiled by build systems with multiple executables by letting you specify the source files that will be compiled in each executable. 

    If you have functions that are declared in multiple components with the same name but have different definitions, RVS can treat each such function uniquely, for example to provide separate coverage in RapiCover and separate execution time results in RapiTime.

  • How can RVS help me understand my code base?

    RVS analyzes the structure of your code and presents information on your code’s structure, helping you understand your code and its dependencies in a variety of forms such as the following:

    • RVS analyzes the McCabe complexity of your code and presents the complexity of each code element, letting you easily identify code with high complexity. 
    • RVS Treemaps present the hierarchy of your code’s components and source files graphically.
    • RVS lets you view and explore the call dependencies in your code.  
  • How is RapiCover Zero optimized to support my industry?

    How is RapiCover Zero optimized to support my industry?

    Different variants of RapiCover Zero are available, each of which is optimized to best meet the verification needs of specific software industries:

    • RapiCover Zero - Aero includes example projects, tutorials and analysis profiles optimized for engineers working on DO-178C/ED-12C projects. Coverage analysis profiles are available based on verification requirements for DAL A-C software.
    • RapiCover Zero - Auto includes example projects, tutorials and analysis profiles optimized for engineers working on ISO 26262 projects. Coverage analysis profiles are available based on verification requirements for ASIL A-D software.
    • RapiCover Zero - Space includes example projects, tutorials and analysis profiles optimized for engineers working on NASA NPR 7150.2D and ECSS-E-ST-40C projects. For ECSS-E-ST-40C, coverage analysis profiles are available based on verification requirements for software Criticality Category.
  • Which certification standards and guidelines can RVS help me to achieve?

    RVS supports meeting standards and guidelines for verification of mission and safety-critical applications including:

    • Civil aerospace software guidelines DO-178C (ED-12C), DO-278A (ED-109), AC 20-193 & AMC 20-193
    • Military & defense aerospace standards MIL-HDBK-516C, AA-22-01 AMACC, EMACC, ADSM, Def Stan 00-55 & Def Stan 00-56
    • Automotive standard ISO 26262
    • Space software standards NASA NPR 7150.2D, ECSS-E-ST-40C
    • Other standards based on IEC 61508, including IEC 62279, EN50128 & EN 50657 (rail), IEC 61511 (industrial processes), IEC 61513 (power), IEC 60880 (nuclear) & IEC 62061 (machinery)
  • Is instrumentation-based or instrumentation-free analysis best for me?

    Both RapiCover and RapiCoverZero support on-target structural coverage analysis for critical software. 

    Depending on your project and needs, one or both solutions may be better for you. Consult the table below to determine which is best for your project.

    Feature

    RapiCover

    RapiCoverZero

    Works without source code

    No

    Yes

    Works without instrumentation

    No

    Yes

    Integration with development environment

    Integration needed

    No integration needed

    MC/DC analysis (e.g. for DO-178C DAL A)

    Yes

    No

    Tool qualification support

    Yes

    In development - contact us for details

    Trace size and data processing time

    Depends on applied instrumentation

    Typically larger trace and longer data processing times

    Supported platforms (target, data collection mechanism)

    Flexible, almost any platform supported (see compatibility)

    Requirements on platform (branch trace and context switch information must be available), PSP needed (see compatibility)

  • Why is it not possible to obtain MC/DC from object code in the general case?

    MC/DC - "Modified Condition/Decision Coverage" - is defined in terms of source code level constructs such as conditions and decisions. These don't directly exist in the object code as it only contains branch statements. Object level code coverage can thus only tell you which branches were or were not covered.

    In order to infer MC/DC coverage from branch coverage you would need a way of mapping branch statements back to conditions/decisions in the source code. This might be possible in some circumstances, but is not possible in the general case using off the shelf compilers, which try to remove branch statements where possible as they are bad for performance (branch misprediction can cause an entire pipeline to be invalidated).

    For example, consider the following source code, which returns the value of bit n in the input value:

    int check_bit_is_set(int value, int n) {
      if (value & (0x1 << n))
        return 1;
      else
        return 0;
    }

    It contains a decision which means MC/DC is required (even though there is only one condition). Using the GCC compiler for Arm at optimization level 1, this compiles down to a series of instructions with no branches:

    check_bit_is_set(int, int):
    asrs   r0, r0, r1
    and   r0, r0, #1
    bx    lr

    It is thus impossible to infer MC/DC coverage of the source code from branch coverage in this case.

 

Request Demo

Times are in GMT

What happens next?
We aim to respond to demo requests within 1 working day. 

 

Check PSP compatibility

Zero-footprint Platform Support Packages (PSPs) are needed to support the analysis of object code by zero-footprint RVS tools. Each PSP is compatible with a specific platform. 

 

Enter your platform details below to check whether a PSP compatible with your platform is available.

Which compiler does your platform use?
Which instruction set does your platform use?
If your platform includes physical hardware, which debugger are you using?
If your platform includes a simulator, which simulator are you using?
Which real-time operating system are you using?

Check compatibility

 

A PSP compatible with your platform is already available. For more information, contact us at info@rapitasystems.com.

A PSP compatible with some (but not all) of the components of your platform is already available. We may be able to develop a PSP compatible with your exact platform. For more information, contact us at info@rapitasystems.com.

No PSP is currently available that is compatible with your platform, but we may be able to develop one. For more information, contact us at at info@rapitasystems.com.

Compiler,TI Compiler,Roadmap
Compiler,Diab,Roadmap
Simulator,ARM Fast Models Generic/TarmacTrace,Roadmap
Simulator,TRACE32 Simulator,Roadmap
Simulator,Gremlin,Roadmap
Compiler,Arm Compiler,Already available
Compiler,CC-RH850 ,Already available
Compiler,Clang,Roadmap
Compiler,Code Composer,Roadmap
Compiler,GCC,Already available
Compiler,GNAT,Roadmap
Compiler,Tasking,Roadmap
Compiler,Other compiler,Not on the roadmap
Instruction set,AArch64,Already available
Instruction set,ARM,Already available
Instruction set,AURIX TriCore,Roadmap
Instruction set,PowerPC,Roadmap
Instruction set,RH850,Already available
Instruction set,RISC-V,Roadmap
Instruction set,VISIUM,Already available
Instruction set,x86,Already available
Instruction set,Other instruction set,Not on the roadmap
Debugger,Intel Processor Trace,Roadmap
Debugger,iSystem,Roadmap
Debugger,Lauterbach TRACE32,Already available
Debugger,PARTNER-Jet2,Already available
Debugger,Other debugger,Not on the roadmap
Simulator,ASTC VLAB,Roadmap
Simulator,MachineWare SIM-V,Roadmap
Simulator,QEMU* AArch64,Already available
Simulator,QEMU* Arm,Already available
Simulator,QEMU* x86,Already available
Simulator,Other simulator,Not on the roadmap
RTOS,None (Bare Metal),Already available
RTOS,DDC-I Deos,Roadmap
RTOS,eMCOS for AUTOSAR Adaptive Platform,Already available
RTOS,eMCOS for AUTOSAR Classic Platform (RV850),Already available
RTOS,FreeRTOS,Already available
RTOS,Green Hills INTEGRITY,Roadmap
RTOS,Lynx Software LynxOS,Roadmap
RTOS,SYSGO PikeOS,Roadmap
RTOS,SafeRTOS,Roadmap
RTOS,Wind River VxWorks,Roadmap
RTOS,Other RTOS,Not on the roadmap
  • Solutions
    • Rapita Verification Suite
    • RapiTest
    • RapiCover
    • RapiTime
    • RapiTask
    • MACH178

    • Verification and Validation Services
    • Qualification
    • Training
    • Integration
  • Latest
  • Latest menu

    • News
    • Blog
    • Events
    • Videos
  • Downloads
  • Downloads menu

    • Brochures
    • Webinars
    • White Papers
    • Case Studies
    • Product briefs
    • Technical notes
    • Software licensing
  • Company
  • Company menu

    • About Rapita
    • Careers
    • Customers
    • Distributors
    • Industries
    • Locations
    • Partners
    • Research projects
    • Contact
  • Discover
    • Multicore Timing Analysis
    • Embedded Software Testing Tools
    • Worst Case Execution Time
    • WCET Tools
    • Code coverage for Ada, C & C++
    • MC/DC Coverage
    • Verifying additional code for DO-178C
    • Timing analysis (WCET) & Code coverage for MATLAB® Simulink®
    • Data Coupling & Control Coupling
    • Aerospace Software Testing
    • Automotive Software Testing
    • Certifying eVTOL
    • DO-178C
    • AC 20-193 and AMC 20-193
    • ISO 26262
    • What is CAST-32A?

All materials © Rapita Systems Ltd. 2025 - All rights reserved | Privacy information | Trademark notice Subscribe to our newsletter