AdaCore - The GNAT Pro Company

Coverage and Free Software

AdaCore — Wed, 04 Jun 2008 07:00:16 +0000

A recent paper by Franco Gasperoni describing how a Free Software toolset (Coverage) and virtualization technology (QEMU) can be used effectively to assure code coverage in the development of software applications. While an important target use of the coverage toolset is safety-critical embedded applications, the design of the tools allows its use in non safety-critical projects.

Abstract Interface Types in GNAT: Conversions, Discriminants, and C++

AdaCore — Wed, 21 Mar 2007 16:06:16 +0000

Ada 2005 Abstract Interface Types provide a limited and practical form of multiple inheritance of specifications. In this paper we cover the following aspects of their implementation in the GNAT compiler: interface type conversions, the layout of variable sized tagged objects with interface progenitors, and the use of the GNAT compiler for interfacing with C++ classes with compatible inheritance trees.

Multi-Language Programming: The Challenge and Promise of Class-Level Interfacing

AdaCore — Thu, 20 Jul 2006 09:08:04 +0000

Many computer applications today involve modules written in different programming languages, and integrating these modules together is a delicate operation. This first requires the availability of formalisms to let programmers denote “foreign” entities like objects and subprograms as well as their associated types. Then, proper translation of what programmers express often calls for significant implementation effort, possibly down to the specification of very precise ABIs (Application Binary Interfaces). Meta-language based approaches a la CORBA/IDL are very powerful in this respect but typically aim at addressing distributed systems issues as well, hence entail support infrastructure that not every target environment needs or can afford. When component distribution over a network is not a concern, straight interfacing at the binary object level is much more efficient. It however relies on numerous low level details and in practice is most often only possible for a limited set of constructs.

Binary level interaction between foreign modules is traditionally achieved through subprogram calls, exchanging simple data types and relying on the target environment’s core ABI. Object Oriented features in modern languages motivate specific additional capabilities in this area, such as class-level interfacing to allow reuse and extension of class hierarchies across languages with minimal constraints. This paper describes work we have conducted in this context, allowing direct binding of Ada extensible tagged types with C++ classes. Motivated by extensions to the Ada typing system made as part of the very recent language standard revision, this work leverages the GCC multi-language infrastructure and implementation of the Itanium C++ ABI. We will first survey the issues and mechanisms related to basic inter-language operations, then present the interfacing challenges posed by modern object oriented features after a brief overview of the Ada, C++, and Java object models. We will continue with a description of our work on Ada/C++ class-level interfacing facilities, illustrated by an example.

Exposing Uninitialized Variables: Strengthening and Extending Run-Time Checks in Ada

AdaCore — Fri, 02 Jun 2006 16:05:04 +0000

Since its inception, a main ob jective of the Ada language has been to assist in the development of large and robust applications. In addition to that, the language also provides support for building safety- critical applications, e.g. by facilitating validation and verification of such programs. The latest revision of the language has brought some addi- tional improvements in the safety area, such as the Normalize Scalars pragma, which ensures an automatic initialization of the non-explicitly initialized scalars. This paper presents Initialize Scalars, an enrichment of the Normalize Scalars concept, and an extended mode to verify at run-time the validity of scalars, both designed for easy use in existing large applications. Their implementation in GNAT Pro (the GNU Ada 95 compiler) is discussed. The practical results obtained on a large Air Traffic Flow Management application are presented.

The Implementation of Ada 2005 Interface Types in the GNAT Compiler

AdaCore — Fri, 02 Jun 2006 12:49:25 +0000

One of the most important ob ject-oriented features of the new revision of the Ada Programming Language is the introduction of Abstract Interfaces to provide a form of multiple inheritance. Ada 2005 Abstract Interface Types are based on Java interfaces, and as such support inheritance of operation specifications, rather than the general complexity of inheritance of implementations as in full multiple inheritance. Real-time uses of Ada demand efficient and bounded worst-case execution time for interface calls. In addition, modern systems require mixed-language programming. This paper summarizes part of the work done by the GNAT Development Team to provide an efficient implementation of this language feature and simplifies interfacing with C++.

Safety, Security, and Object-Oriented Programming

AdaCore — Thu, 30 Mar 2006 09:35:40 +0000

When safety-critical software malfunctions people lives are in danger. When security-critical software is cracked national security or economic activity may be at risk. As more and more software embraces object-oriented programming (OOP) safety-critical and security-critical projects feel compelled to use object-orientation. But what are the guarantees of OOP in terms of safety and security? Are the design goals of OOP aligned with those of safe and secure software (S3) systems? In the following sections we look at key OOP aspects and analyze some of the hazards they introduce with respect to S3 and outline a possible way of addressing these vulnerabilities. Specifically, after a quick overview of OOP in section 2, section 3 deals with inheritance and shows some of its hazards in terms of S3 along with possible remedies. Section 4 focuses on dynamic binding and suggests a safer and more secure implementation than what is conventionally done. Finally, section 5 looks at testing programs with dynamic binding.

Certification & Object Orientation: The New Ada Answer

AdaCore — Wed, 08 Mar 2006 13:40:58 +0000

The object model of Ada 2005 is well-suited for applications that have to meet certification at various levels. We review the use of Ada in the context of certification, and show that the object-oriented facilities of the current language standard, properly restricted to avoid dynamic dispatching, can already be used without problems under current DO-178B guidelines. We then examine the complications to certification that are presented by dynamic dispatching in a single inheritance model, and show implementation-specific ways of addressing these complications. Finally, we discuss the problems introduced by the use of multiple inheritance. We conclude by showing how, regardless of the extent to which object-oriented idioms are used, Ada provides a safe and efficient vehicle to create certifiable systems.

Ada 2005 Rationale - Epilogue

AdaCore — Mon, 06 Mar 2006 09:24:11 +0000

This is the last of a number of papers describing the rationale for Ada 2005. In due course it is anticipated that the papers will be combined (after appropriate reformatting and editing) into a single volume for formal publication.

This last paper summarizes a small number of general issues of importance to the user such as compatibility between Ada 2005 and Ada 95. It also briefly considers a few potential changes that were considered for Ada 2005 but rejected for various reasons.

Ada 2005 for Mission-Critical Systems

AdaCore — Thu, 02 Feb 2006 12:53:24 +0000

For the development of mission-critical software, the choice of programming language makes a significant difference in meeting the requirements of exacting safety standards and, ultimately, high-reliability applications.

Ada has a long history of success in the safety-critical domain, with features such as strong typing, that help early error detection, and well-defined semantics. The language has evolved based on user experience, and the forthcoming Ada 2005 standard includes a number of enhancements that will be of particular benefit to developers of high-integrity real-time systems. Relevant features include support for run-time profiles, flexible task-dispatching policies, execution-time clocks and timers, and a unification of concurrency and object-oriented features.

Ada 2005 Rationale - Introduction (pt 1 of 8)

AdaCore — Thu, 02 Feb 2006 10:10:46 +0000

This is the first of a number of papers describing the rationale for Ada 2005.

This first paper covers the background to the development of Ada 2005 and gives a brief overview of the main changes from Ada 95. Other papers will then look at the changes in more detail.

These papers are being published in the Ada User Journal. An earlier version of this first paper appeared in the Ada User Journal, Vol. 25, Number 4, December 2004. Other papers in this series will be found in later issues of the Journal or elsewhere on this website.