Contents Index Search Previous Next
C.1 Access to Machine Operations
This clause specifies rules regarding access to
machine instructions from within an Ada program.
The implementation shall support
machine code insertions (see 13.8
) or intrinsic
subprograms (see 6.3.1
) (or both). Implementation-defined
attributes shall be provided to allow the use of Ada entities as operands.
The machine code or intrinsics support should
allow access to all operations normally available to assembly language
programmers for the target environment, including privileged instructions,
interfacing pragmas (see Annex B
) should support
interface to assembler; the default assembler should be associated with
the convention identifier Assembler.
If an entity is exported to assembly language,
then the implementation should allocate it at an addressable location,
and should ensure that it is retained by the linking process, even if
not otherwise referenced from the Ada code. The implementation should
assume that any call to a machine code or assembler subprogram is allowed
to read or update every object that is specified as exported.
The implementation shall document the overhead
associated with calling machine-code or intrinsic subprograms, as compared
to a fully-inlined call, and to a regular out-of-line call.
The implementation shall document the types of
the package System.Machine_Code usable for machine code insertions, and
the attributes to be used in machine code insertions for references to
The implementation shall document the subprogram
calling conventions associated with the convention identifiers available
for use with the interfacing pragmas (Ada and Assembler, at a minimum),
including register saving, exception propagation, parameter passing,
and function value returning.
For exported and imported subprograms, the implementation
shall document the mapping between the Link_Name string, if specified,
or the Ada designator, if not, and the external link name used for such
The implementation should ensure that little
or no overhead is associated with calling intrinsic and machine-code
It is recommended
that intrinsic subprograms be provided for convenient access to any machine
operations that provide special capabilities or efficiency and that are
not otherwise available through the language constructs. Examples of
such instructions include:
- Atomic read-modify-write operations
-- e.g., test and set, compare and swap, decrement and test, enqueue/dequeue.
- Standard numeric functions -- e.g.,
- String manipulation operations --
e.g., translate and test.
- Vector operations -- e.g., compare
vector against thresholds.
- Direct operations on I/O ports.
Contents Index Search Previous Next Legal