Modern safety- and security-critical systems demand more than just correct functionality: they must also be built upon well-structured, analyzable architectures. All major functional safety standards—such as ISO 26262, IEC 61508, DO-178C, EN 50128, IEC 62304, and ISO/SAE 21434—require developers to prove properties like independence, freedom from interference, and isolation between software components of different criticalities.
Failing to prove these properties means applying the most rigorous development process to all components, regardless of their actual safety level, significantly increasing effort, time, and cost.
Software decomposition is a common strategy to manage system complexity: dividing the software into coherent, modular components. However, decomposition alone is not enough. What truly matters is controlling the interactions between components. If every part can access every other part, the architecture collapses into unmanageable complexity (commonly referred to as spaghetti code).
To enforce architectural boundaries and demonstrate isolation, automated verification is key. Manual reviews are time-consuming, error-prone, and difficult to repeat during continuous development.
ECLAIR Independence Checker provides a powerful and unique capability: formal, automated verification of architectural constraints using static analysis. This enables your development team to move from architectural design to enforceable implementation automatically, reliably, and continuously.
ECLAIR Independence Checker allows you to define:
Components in terms of files, functions, and variables
Allowed dependencies via user-defined relationships (e.g., layering, whitelisting, call permissions)
Exceptions and special rules for permitted bypasses
Static dependencies (like header inclusion and macro expansion)
Dynamic dependencies (like function calls, pointer dereferences, variable accesses)
Using these definitions, ECLAIR automatically checks that the implementation complies with the intended architecture flagging any violations of layering, encapsulation, or dependency rules.
Precise and expressive constraints: from strict OSI-style layering to more flexible whitelisting
Fully automated verification: ideal for integration into CI/CD pipelines
Verifiable independence: supports documentation for safety and security assessments
Deep semantic analysis: understands the full behavior of the code, including macro-based indirection
Simultaneous enforcement of coding guidelines (e.g., MISRA C/C++) and architectural constraints
ECLAIR’s architectural verification capabilities directly support requirements in:
ISO 26262, including freedom from interference between ASIL components
DO-178C/ED-12C, including the enforcement of independence between software levels
IEC 61508, including partitioning across SILs
ISO/SAE 21434, especially for isolation between cybersecurity functions (CALs)
EN 50128, IEC 62304, and others
By making architectural compliance provable and repeatable, ECLAIR significantly reduces the burden of certification, even in late development stages.
Imagine a network stack with clearly separated data link, network, and transport layers. With ECLAIR, you can:
Specify which components may call which others (e.g., only the transport layer may call the network layer)
Define exceptions (e.g., allow the application to query link_status() directly)
link_status()
Track function calls, variable usage, macro expansion, and header inclusions
Verify that the layering is respected throughout the entire codebase
All of this happens automatically, across thousands of source files, as part of your existing build and integration workflow.
Architectural constraints are not just design-time documentation, they are essential safety and security properties. With ECLAIR, your intended architecture becomes a verifiable, enforced reality, ensuring maintainability, modularity, and certifiability throughout the software lifecycle.
Book a demo
