- 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, if any.
- The 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 Ada entities.
- 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
- 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 a subprogram.
- The implementation should ensure that little or no overhead is
associated with calling intrinsic and machine-code subprograms.
- 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., sin, log.
- String manipulation operations -- e.g., translate and test.
- Vector operations -- e.g., compare vector against thresholds.
- Direct operations on I/O ports.
-- Email comments, additions, corrections, gripes, kudos, etc. to:
Magnus Kempe -- Magnus.Kempe@di.epfl.ch
Page last generated: 95-03-12