1. AdaCore GNAT Pro 25 Roadmap¶

This roadmap represents the current stage of AdaCore plans for its technology. It is not binding, and can change without notice. Products marks as “Beta” can be made available to customers supported on the corresponding products by contacting AdaCore support (https://www.adacore.com/support). Customers interested in trying out capabilities that they don’t have access to yet, or who are interested in discussing a more detailed status update can contact info@adacore.com

1.1. Toolchain¶

1.1.1. End of Life Schedule¶

The following products will switch from Long Term Support to Baselined. Customers that wish to retain the ability to perform critical fixes can subscribe to the Assurance product.

GNAT Pro Ada and C for VxWorks 6
GNAT Pro Ada and C for VxWorks 7 up to SR 540 (recent releases remain in standard support)
GNAT Pro Ada and C for VxWorks 7 on PowerPC e500v2
GNAT Pro Ada and C Bare Metal P55 / e500v2

The following changes will also take place:

GNAT Pro 25 will not support RedHat Enterprise 7 and Ubuntu 18.04

1.1.2. Linux-hosted embedded Morello support¶

Capability Hardware Enhanced RISC Instructions (CHERI) is a processor instruction set architecture (ISA) extension that provides fine-grained memory protection and compartmentalization at the hardware level. GNAT Pro will support multi-layered memory protection on bare-metal Morello targets.

1.2. Ada Support and Extensions¶

1.2.1. Deep Delta Aggregates¶

Delta aggregates will be generalized to allow the update of individual subcomponents rather than only entire components. Delta aggregates allow the construction of a new object of a composite type by taking a base object, and specifying new values for some of the components. This extension will allow the specification of a new value for a subcomponent, rather than an entire component, using a generalization of the current syntax, such as:

(X with delta A.B => 42)

This would be approximately equivalent to:

(X with delta A => (X.A with delta B => 42))

See the Deep Delta Aggregate RFC for more details.

1.2.2. Fixed size for arrays¶

Arrays marked “definite” will be of the maximum size permitted by their index type, so that objects of class wide types can be used in places where definite size is needed (for example as a component or a local variable). For example:

declare
   type Index is 1 .. 32;
   type Static_Array is array (Index range <>) of Natural with Definite;
   A : Static_Array := (1, 2, 3, 4);
   B : Static_Array := (2, 3);
begin
   A := B;
   A := A & S;
   A := A & (8, 9);

   pragma Assert (A'Capacity = 8);
   A := (0, 1, 2, 3, 4, 5, 6, 7, 8); -- forbidden as it exceeds the array capacity
end;

This feature will be made available as beta, not intended for production.

1.2.3. Fixed size for tagged types¶

A tagged type can be provided with a maximum size so that objects of class wide types can be used in places where definite size is needed (for example as a component or a local variable). For example:

type Foo is tagged abstract null record
with Size'Class => 16 * 8; -- Size is in bits

type Bar is new Foo with record
   S : String (1 .. 128);
end record; -- ERROR: Record doesn't fit in 16 bytes

type Baz is new Foo with record
   A, B : Integer;
end record; -- Valid

-- Valid use cases
Inst : Foo'Class;
Inst := Foo'(null record);
Inst := Baz'(12, 15);

type Foo_Array is array (Positive range <>) of Foo'Class;
Arr : Foo_Array := (Foo'(null record), Baz'(12, 15));

See the Class Size RFC for more details.

This feature will be made available as beta, not intended for production.

1.2.4. Statically embed content at compile time¶

It will be possible to statically embed content at compile time coming from external data files, for example:

package body Some_Package is
  type Byte is mod 256;
  type Byte_Array is (Integer range <>) of Byte;
  Some_File_Data : Byte_Array with External_Initialization => "/some/file/data.raw";

  type Some_Record is record
    X : Integer;
    Y : Char;
  end record;

  Some_Other_Data : Some_Record with External_Initialization => "/some/data.raw";
end Some_Package;

This feature will be made available as beta, not intended for production.

1.3. Embedded and Real-Time OS Support¶

1.3.1. AWS and GNATColl Support for VxWorks 7¶

GNATcoll is a library of Ada capabilities, and AWS (Ada Web Server) is a library that allows an Ada application to interact through a web interface and services. They will both be ported to VxWorks 7 on all supported architectures.

This feature will be made available as beta, not intended for production.

1.3.2. FreeRTOS experimental Support¶

FreeRTOS is a real time operating system for microcontrollers. This release will include an experimental port to FreeRTOS targeting ARM.

This feature will be made available as beta, not intended for production.

1.3.3. VxWorks 7 Ada Bindings¶

This release will include an Ada API that allows access directly to the VxWorks 7 C APIs.

This feature will be made available as beta, not intended for production.

1.4. GCC Compiler¶

1.4.1. C Header to Ada specification generation¶

The -fdump-ada-spec functionality available from GCC is being rewritten as a new tool, accessible through the h2ads command line. It will be more configurable and support a larger set of header files as input.

1.4.2. Migration to GCC 13¶

The GNAT Pro Ada, C and C++ compilers will migrate to GCC 13. See the GCC 13 changes for information on changes.

1.5. LLVM Compiler¶

1.5.1. GNAT for LLVM support for Windows platforms¶

GNAT Pro for Ada for Windows native platforms will be provided with alternate LLVM back-end, on top of the usual GCC back-end.

1.5.2. GNAT for LLVM support for cross ARM 64 platforms¶

GNAT Pro for Ada for ARM 64 cross Linux and bare metal will be provided with alternate LLVM back-end, on top of the usual GCC back-end.

1.6. IDE¶

1.6.1. Breakpoint while Application is Running¶

GNATstudio and Visual Studio Code will support inserting a breakpoint while the application is running

1.6.2. GNAT Project File Language Support¶

GNATstudio will support advanced editing of GNAT Project Files sources with features such as navigation and outline.

1.6.3. Improved GNATtest Integration¶

GNATtest integration in GNATstudio will be extended, including support for viewing test results, and an interface for relaunching individual tests and opening code for a given test.

1.6.4. Revamp of Code Formatter¶

The automatic code formatter used by GNATstudio will be replaced with the gnatpp engine. This involves converging the GNATstudio preferences with the gnatpp project properties.

1.7. GNAT Project File Support¶

1.7.1. Extensibility of GNAT Project Files¶

Users will be able to add their own attributes and packages to GNAT Project Files . This will come with an API that allows querying contents of the project files and developing custom tools.

This feature will be made available as beta, not intended for production.

1.7.2. GPRbuild reimplementation¶

A new implementation of GPRbuild will be made available. While functionally will be equivalent to the current version of the tool, it should run faster and will allow for future extensibility and better dependency management.

This feature will be made available as beta, not intended for production.

1.7.3. Pre and Post build phases in GPRbuild¶

GPRbuild is currently limited to compiler / bind / link phases. It will be extended to also support pre- and post- compilation and build steps.

This feature will be made available as beta, not intended for production.

1.8. DevOps¶

1.8.1. Integration of the Alire package manager¶

Alire is a package manager for managing Ada projects, source code and dependencies. It will be integrated into the AdaCore product suite, allowing customers to retrieve libraries that are provided by AdaCore through this mechanism, and to build them locally. It will also support creating local indexes, for customers with air-gapping requirements.

This feature will be made available as beta, not intended for production.

1.9. GNAT SAS¶

1.9.1. Towards implementation of TOP 25 CWE analysis¶

MITRE’s Common Weakness Enumeration (CWE) is a list of cyber security coding issues that are found in code. This release of GNAT SAS will improve coverage for the 25 most common ones.

1.10. Libadalang¶

1.10.1. Automatic code fixes in GNATcheck and Diagnostics¶

Errors that are reported either by the libadalang diagnostics or by GNATcheck rules will be corrected using automatic fixes when applicable.

This feature will be made available as beta, not intended for production.

1.10.2. Implementation of Code Rewriting¶

The LangKit Query Language (LKQL) will be extended to script automatic code rewriting.

This feature will be made available as beta, not intended for production.

1.10.3. Semi-Automatic C to Ada Thick Binding Generator¶

AdaCore already provides low-level tools to generate an Ada specification from a C header file. However, this specification is at the same semantic level as C. For example, a pointer in C is an access type in Ada, while, depending on the context, it could instead be mapped to an array or an out parameter. This version of the technology will feature a way to script an automatic wrapping around a low level C binding, to provide higher-level semantics based on the context.

This feature will be made available as beta, not intended for production.

1.10.4. Static Typing in LKQL¶

The LangKit Query Language will be enhanced to support the use of static typing in the script. This will improve LKQL scripts maintainability over time.

1.10.5. Support for Ada Experimental Features (-gnatX)¶

-gnatX is the GNAT switch enabling experimental features that are being developed for the new version of the Ada programming language (Ada 22). Libadalang will support this language feature set.

1.11. GNATcoverage¶

1.11.1. New “subprogram and call” coverage level¶

GNATcoverage will support a new coverage assessment level, which tracks both the execution of subprograms (function coverage) and the evaluation of calls to subprograms (call coverage).

1.11.2. Out-of-source annotations for coverage analysis¶

GNATcoverage will introduce a mechanism to define annotations influencing instrumentation and coverage analysis without requiring the insertion of pragmas or comments in the source file. The annotations will be stored in companion files; GNATcoverage will provide mechanisms to attempt to re-locate the annotations in case of file modification, or invalidate them if it is not possible to re-locate them.

This feature will be made available as beta, not intended for production.

1.11.3. Selective instrumentation for coverage analysis¶

GNATcoverage will support fine grain coverage instrumentation deactivation, to either skip regions expanded differently in header files, or as workaround to skip regions which cause the instrumenter to crash or emit invalid code.

1.11.4. Support for pre-processing in GNATcoverage¶

GNATcoverage will support preprocessing directives in Ada source files.

1.12. GNATtest¶

1.12.1. Ada Test Case Generation from Structural Data¶

GNATtest will be able to automatically generate values as input to test cases based on the structure of subprogram parameters.

This feature will be made available as beta, not intended for production.

1.13. GNATfuzz¶

1.13.1. Symbolic execution to retrieve input values¶

GNATfuzz will analyze conditional in code and, through symbolic execution, will attempt deducing which input value may influence the outcome of these conditionals. This is done through the integration of the SymCC tool.

This feature will be made available as beta, not intended for production.