6.5.1 Non-returning ProceduresPragma No_Return
Discussion: Aspect Pragma No_Deposit will have to wait for Ada 2020 2017.
For a procedure or generic procedure, the following
language-defined representation aspect may be specified:
The type of aspect No_Return is Boolean. When aspect
No_Return is True for an entity, the entity is said to be non-returning.
If directly specified,
shall be a static expression. [This aspect is never inherited;] if not
directly specified, the aspect is False.
for No_Return: A
procedure will not return normally.
If a generic procedure is non-returning, then so
are its instances. If a procedure declared within a generic unit is non-returning,
then so are the corresponding copies of that procedure in instances.
Aspect No_Return Each
shall denote one or more procedures or generic procedures; the denoted
entities are non-returning. The procedure_local_name shall not be specified for denote a null procedure nor an instance of a generic unit.
Reason: A null
procedure cannot have the appropriate non-returning semantics, as it
does not raise an exception or loop forever.
The procedure can be abstract. The denoted declaration can be a renaming_declaration
if it obeys the usual rules for representation pragmas: the renaming
has to occur immediately within the same declarative region as the renamed
subprogram. If a non-returning procedure
is renamed (anywhere) calls through the new name still have the non-returning
A procedure shall be non-returning if it overrides
a dispatching non-returning procedure. In addition
to the places where Legality Rules normally apply (see 12.3),
this rule applies also in the private part of an instance of a generic
Reason: This ensures
that dispatching calls to non-returning procedures will, in fact, not
If a renaming-as-body completes a non-returning
procedure declaration, then the renamed procedure shall be non-returning.
Reason: This ensures
that no extra code is needed to implement the renames (that is, no wrapper
is needed) as the body has the same property.
8 was deleted.
a generic procedure is non-returning, then so are its instances. If a
procedure declared within a generic unit is non-returning, then so are
the corresponding copies of that procedure in instances.
If the body of a non-returning procedure completes
normally, Program_Error is raised at the point of the call.
that there is no name for suppressing this check, since the check represents
a bug, imposes no time overhead, and minimal space overhead (since it
can usually be statically eliminated as dead code).
If a non-returning procedure tries to return, we raise Program_Error.
This is stated as happening at the call site, because we do not wish
to allow the procedure to handle the exception (and then, perhaps, try
to return again!). However, the expected run-time model is that the compiler
will generate raise Program_Error at the end of the procedure
body (but not handleable by the procedure itself), as opposed to doing
it at the call site. (This is just like the typical run-time model for
functions that fall off the end without returning a value). The reason
is indirect calls: in P.all(...);, the compiler cannot know whether
P designates a non-returning procedure or a normal one. Putting the raise
Program_Error in the procedure's generated code solves this problem neatly.
Similarly, if one passes
a non-returning procedure to a generic formal parameter, the compiler
cannot know this at call sites (in shared code implementations); the
raise-in-body solution deals with this neatly.
procedure Fail(Msg : String); -- raises Fatal_Error exception
with pragma No_Return(Fail);
-- Inform compiler and reader that procedure never returns normally
Extensions to Ada 95
Extensions to Ada 2005
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe