Sjoerd van der Zwaan, CPO at Solid Sands, discusses compilers and libraries, and how they are essential to the performance of ADAS software platforms. He details how these tools work, the unseen risks that need to be overcome, and how to ensure reliability through verification
Advanced driver assistance systems bring increasingly sophisticated software into vehicles. Functions such as lane keeping, adaptive cruise control, automated emergency braking and sensor fusion rely on complex algorithms operating under tight real-time constraints. Consequently, automotive development organizations invest substantial effort to ensure that application software and hardware platforms comply with functional safety standards such as ISO 26262.
Yet one critical layer of the software stack often receives far less attention: the compilers and libraries that silently transform our software code into reliable, high-performance executable behavior. These tools operate largely out of sight, but they play a decisive role in determining how ADAS software performs on the road. In fact, no ADAS function can exist without them.
The silent force behind ADAS software
Compilers translate high-level source code into machine instructions, while standard libraries provide essential functionality for numerical computation, data handling and timing. Together, they form the foundation on which application software is built, and their correctness is often taken for granted throughout the development lifecycle.
In practice, this assumption can be risky. Even when application code complies with coding guidelines and the target hardware is safety-certified, deficiencies in the toolchain can still undermine system behavior. These issues typically do not originate in the application logic itself, but in lower layers that are difficult to observe directly.
Unseen risks in the toolchain
Compiler optimization is a prominent example. Optimization is essential for meeting performance and power consumption requirements in automotive systems, but it also introduces significant complexity. Changes in optimization paths can alter control flow, numerical precision or timing in ways that are not apparent from source code inspection. As a result, a compiler update or a change in optimization options may introduce new behaviors (and even errors) while the application code remains unchanged.
Standard libraries present similar risks. Library functions are widely assumed to be robust and well tested, yet they are subject to implementation choices and corner cases like any other software. In ADAS, where libraries are statically or tightly linked into the final executable, subtle deviations from expected behavior can propagate directly into system-level effects.
Because these problems originate below the application layer, they are not easily detected using conventional testing approaches. Integration testing may expose symptoms, but it rarely provides systematic coverage of toolchain behavior. As a result, determining whether the root cause lies in the application logic, the compiler or a library implementation can require extensive investigation. When such issues surface late in development, the associated cost and disruption can be substantial. Even more concerning, if they remain undetected until deployment, they may manifest as safety-critical failures, with potentially severe consequences.
Ensuring reliability through verification
Managing these risks requires systematic verification of compilers and libraries. This involves demonstrating conformance to relevant programming language standards and consistent behavior across configurations, optimization levels and target platforms.
Structured test suites are central to this effort. By exercising both front-end language features and back-end optimization paths, they can reveal defects that would otherwise remain latent. Problems are not confined to parsing or semantic analysis; changes deep within the optimization pipeline or the code generator can also introduce unintended effects. Comprehensive testing helps surface these issues early, before they impact product development.
Supporting qualification and long-term confidence
Beyond identifying defects, verification provides the objective evidence needed to support tool qualification. The ISO 26262 safety standard for automotive software requires confidence in the correct operation of the compiler and evidence that the standard library meets the requirements on which the application relies. By testing the compiler against the programming language specification, it is possible to verify that source code is translated into machine code in a well-defined and predictable manner. Likewise, requirements-based testing of the standard library demonstrates that its functionality conforms to the requirements relied upon by the software. Together, these activities provide objective evidence that the generated object code faithfully represents the source code.
Furthermore, the goal of qualification is not to prove that the compiler or library is completely free of errors – an unrealistic expectation for any complex software tool. Instead, the objective is to understand their limitations and known deviations, and to manage them in a controlled way so that they do not compromise functional safety. This understanding is captured in a safety manual that complements the verification results and defines the constraints, assumptions and usage rules for the compiler and library, ensuring they can be applied safely within the software development process.
This approach also supports long-term maintainability. Automotive platforms often have lifecycles spanning decades, during which compilers and libraries inevitably evolve. Systematic validation of updates enables controlled transitions without the need to re-qualify entire systems from scratch.
This benefit has been demonstrated in practice, where early identification of compiler issues has significantly reduced the effort associated with toolchain updates. By understanding tool behavior upfront, organizations can make informed decisions about changes and avoid costly surprises later.
Standard libraries follow similar principles. When assessing a new library implementation, behavioral comparison against a known baseline helps ensure that replacements do not introduce unintended or system-relevant changes.
The role of collaboration
ADAS development involves many stakeholders: software engineers, functional safety engineers, validation teams and certification bodies. Ensuring that compilers and libraries behave as expected requires collaboration across all these roles.
Verification cannot be treated as an isolated activity, it must be an integral part of a broader safety strategy. When toolchain behavior is well understood and documented, communication between teams becomes clearer, assumptions are explicit and decisions can be justified with evidence rather than intuition.
Strong partnerships between tool providers, system integrators and safety experts further support this process. By sharing knowledge and aligning on verification practices, organizations can reduce duplication of effort and improve overall confidence in their development environment.
Conclusion
Compilers and libraries may operate invisibly, but their impact on ADAS safety is substantial. Treating them as implicit assumptions rather than explicit verification targets introduces avoidable risk. As ADAS functionality grows increasingly complex, this risk will only increase.
By recognizing the role of the toolchain early and subjecting it to the same rigor as application software, automotive developers can build a stronger foundation for safety. Verification and qualification of compilers and libraries are not optional extras; they are essential steps to ensure that software behaves as intended – from code to road.
A feature in the next issue of Automotive Testing Technology International will investigate the challenges of continuous testing for software, the stages of a typical DevOps pipeline, how companies are measuring software readiness, and more. Read the March 2026 edition here.
Related news, Software test specialists Solid Sands and Plum Hall team up
