428 lines
16 KiB
Ada
428 lines
16 KiB
Ada
------------------------------------------------------------------------------
|
|
-- --
|
|
-- GNAT COMPILER COMPONENTS --
|
|
-- --
|
|
-- G N A T . A L T I V E C --
|
|
-- --
|
|
-- S p e c --
|
|
-- --
|
|
-- Copyright (C) 2004-2011, Free Software Foundation, Inc. --
|
|
-- --
|
|
-- GNAT is free software; you can redistribute it and/or modify it under --
|
|
-- terms of the GNU General Public License as published by the Free Soft- --
|
|
-- ware Foundation; either version 3, or (at your option) any later ver- --
|
|
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
|
|
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
|
|
-- or FITNESS FOR A PARTICULAR PURPOSE. --
|
|
-- --
|
|
-- As a special exception under Section 7 of GPL version 3, you are granted --
|
|
-- additional permissions described in the GCC Runtime Library Exception, --
|
|
-- version 3.1, as published by the Free Software Foundation. --
|
|
-- --
|
|
-- You should have received a copy of the GNU General Public License and --
|
|
-- a copy of the GCC Runtime Library Exception along with this program; --
|
|
-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
|
|
-- <http://www.gnu.org/licenses/>. --
|
|
-- --
|
|
-- GNAT was originally developed by the GNAT team at New York University. --
|
|
-- Extensive contributions were provided by Ada Core Technologies Inc. --
|
|
-- --
|
|
------------------------------------------------------------------------------
|
|
|
|
-------------------------
|
|
-- General description --
|
|
-------------------------
|
|
|
|
-- This is the root of a package hierarchy offering an Ada binding to the
|
|
-- PowerPC AltiVec extensions, a set of 128bit vector types together with a
|
|
-- set of subprograms operating on them. Relevant documents are:
|
|
|
|
-- o AltiVec Technology, Programming Interface Manual (1999-06)
|
|
-- to which we will refer as [PIM], describes the data types, the
|
|
-- functional interface and the ABI conventions.
|
|
|
|
-- o AltiVec Technology, Programming Environments Manual (2002-02)
|
|
-- to which we will refer as [PEM], describes the hardware architecture
|
|
-- and instruction set.
|
|
|
|
-- These documents, as well as a number of others of general interest on the
|
|
-- AltiVec technology, are available from the Motorola/AltiVec Web site at:
|
|
|
|
-- http://www.freescale.com/altivec
|
|
|
|
-- The binding interface is structured to allow alternate implementations:
|
|
-- for real AltiVec capable targets, and for other targets. In the latter
|
|
-- case, everything is emulated in software. The two versions are referred
|
|
-- to as:
|
|
|
|
-- o The Hard binding for AltiVec capable targets (with the appropriate
|
|
-- hardware support and corresponding instruction set)
|
|
|
|
-- o The Soft binding for other targets (with the low level primitives
|
|
-- emulated in software).
|
|
|
|
-- In addition, interfaces that are not strictly part of the base AltiVec API
|
|
-- are provided, such as vector conversions to and from array representations,
|
|
-- which are of interest for client applications (e.g. for vector
|
|
-- initialization purposes).
|
|
|
|
-- Only the soft binding is available today
|
|
|
|
-----------------------------------------
|
|
-- General package architecture survey --
|
|
-----------------------------------------
|
|
|
|
-- The various vector representations are all "containers" of elementary
|
|
-- values, the possible types of which are declared in this root package to
|
|
-- be generally accessible.
|
|
|
|
-- From the user standpoint, the binding materializes as a consistent
|
|
-- hierarchy of units:
|
|
|
|
-- GNAT.Altivec
|
|
-- (component types)
|
|
-- |
|
|
-- o----------------o----------------o-------------o
|
|
-- | | | |
|
|
-- Vector_Types Vector_Operations Vector_Views Conversions
|
|
|
|
-- The user can manipulate vectors through two families of types: Vector
|
|
-- types and View types.
|
|
|
|
-- Vector types are defined in the GNAT.Altivec.Vector_Types package
|
|
|
|
-- On these types, users can apply the Altivec operations defined in
|
|
-- GNAT.Altivec.Vector_Operations. Their layout is opaque and may vary across
|
|
-- configurations, for it is typically target-endianness dependant.
|
|
|
|
-- Vector_Types and Vector_Operations implement the core binding to the
|
|
-- AltiVec API, as described in [PIM-2.1 data types] and [PIM-4 AltiVec
|
|
-- operations and predicates].
|
|
|
|
-- View types are defined in the GNAT.Altivec.Vector_Views package
|
|
|
|
-- These types do not represent Altivec vectors per se, in the sense that the
|
|
-- Altivec_Operations are not available for them. They are intended to allow
|
|
-- Vector initializations as well as access to the Vector component values.
|
|
|
|
-- The GNAT.Altivec.Conversions package is provided to convert a View to the
|
|
-- corresponding Vector and vice-versa.
|
|
|
|
---------------------------
|
|
-- Underlying principles --
|
|
---------------------------
|
|
|
|
-- Internally, the binding relies on an abstraction of the Altivec API, a
|
|
-- rich set of functions around a core of low level primitives mapping to
|
|
-- AltiVec instructions. See for instance "vec_add" in [PIM-4.4 Generic and
|
|
-- Specific AltiVec operations], with no less than six result/arguments
|
|
-- combinations of byte vector types that map to "vaddubm".
|
|
|
|
-- The "soft" version is a software emulation of the low level primitives.
|
|
|
|
-- The "hard" version would map to real AltiVec instructions via GCC builtins
|
|
-- and inlining.
|
|
|
|
-------------------
|
|
-- Example usage --
|
|
-------------------
|
|
|
|
-- Here is a sample program declaring and initializing two vectors, 'add'ing
|
|
-- them and displaying the result components:
|
|
|
|
-- with GNAT.Altivec.Vector_Types; use GNAT.Altivec.Vector_Types;
|
|
-- with GNAT.Altivec.Vector_Operations; use GNAT.Altivec.Vector_Operations;
|
|
-- with GNAT.Altivec.Vector_Views; use GNAT.Altivec.Vector_Views;
|
|
-- with GNAT.Altivec.Conversions; use GNAT.Altivec.Conversions;
|
|
|
|
-- use GNAT.Altivec;
|
|
|
|
-- with Ada.Text_IO; use Ada.Text_IO;
|
|
|
|
-- procedure Sample is
|
|
-- Va : Vector_Unsigned_Int := To_Vector ((Values => (1, 2, 3, 4)));
|
|
-- Vb : Vector_Unsigned_Int := To_Vector ((Values => (1, 2, 3, 4)));
|
|
|
|
-- Vs : Vector_Unsigned_Int;
|
|
-- Vs_View : VUI_View;
|
|
-- begin
|
|
-- Vs := Vec_Add (Va, Vb);
|
|
-- Vs_View := To_View (Vs);
|
|
|
|
-- for I in Vs_View.Values'Range loop
|
|
-- Put_Line (Unsigned_Int'Image (Vs_View.Values (I)));
|
|
-- end loop;
|
|
-- end;
|
|
|
|
-- $ gnatmake sample.adb
|
|
-- [...]
|
|
-- $ ./sample
|
|
-- 2
|
|
-- 4
|
|
-- 6
|
|
-- 8
|
|
|
|
------------------------------------------------------------------------------
|
|
|
|
with System;
|
|
|
|
package GNAT.Altivec is
|
|
|
|
-- Definitions of constants and vector/array component types common to all
|
|
-- the versions of the binding.
|
|
|
|
-- All the vector types are 128bits
|
|
|
|
VECTOR_BIT : constant := 128;
|
|
|
|
-------------------------------------------
|
|
-- [PIM-2.3.1 Alignment of vector types] --
|
|
-------------------------------------------
|
|
|
|
-- "A defined data item of any vector data type in memory is always
|
|
-- aligned on a 16-byte boundary. A pointer to any vector data type always
|
|
-- points to a 16-byte boundary. The compiler is responsible for aligning
|
|
-- vector data types on 16-byte boundaries."
|
|
|
|
VECTOR_ALIGNMENT : constant := Natural'Min (16, Standard'Maximum_Alignment);
|
|
-- This value is used to set the alignment of vector datatypes in both the
|
|
-- hard and the soft binding implementations.
|
|
--
|
|
-- We want this value to never be greater than 16, because none of the
|
|
-- binding implementations requires larger alignments and such a value
|
|
-- would cause useless space to be allocated/wasted for vector objects.
|
|
-- Furthermore, the alignment of 16 matches the hard binding leading to
|
|
-- a more faithful emulation.
|
|
--
|
|
-- It needs to be exactly 16 for the hard binding, and the initializing
|
|
-- expression is just right for this purpose since Maximum_Alignment is
|
|
-- expected to be 16 for the real Altivec ABI.
|
|
--
|
|
-- The soft binding doesn't rely on strict 16byte alignment, and we want
|
|
-- the value to be no greater than Standard'Maximum_Alignment in this case
|
|
-- to ensure it is supported on every possible target.
|
|
|
|
-------------------------------------------------------
|
|
-- [PIM-2.1] Data Types - Interpretation of contents --
|
|
-------------------------------------------------------
|
|
|
|
---------------------
|
|
-- char components --
|
|
---------------------
|
|
|
|
CHAR_BIT : constant := 8;
|
|
SCHAR_MIN : constant := -2 ** (CHAR_BIT - 1);
|
|
SCHAR_MAX : constant := 2 ** (CHAR_BIT - 1) - 1;
|
|
UCHAR_MAX : constant := 2 ** CHAR_BIT - 1;
|
|
|
|
type unsigned_char is mod UCHAR_MAX + 1;
|
|
for unsigned_char'Size use CHAR_BIT;
|
|
|
|
type signed_char is range SCHAR_MIN .. SCHAR_MAX;
|
|
for signed_char'Size use CHAR_BIT;
|
|
|
|
subtype bool_char is unsigned_char;
|
|
-- ??? There is a difference here between what the Altivec Technology
|
|
-- Programming Interface Manual says and what GCC says. In the manual,
|
|
-- vector_bool_char is a vector_unsigned_char, while in altivec.h it
|
|
-- is a vector_signed_char.
|
|
|
|
bool_char_True : constant bool_char := bool_char'Last;
|
|
bool_char_False : constant bool_char := 0;
|
|
|
|
----------------------
|
|
-- short components --
|
|
----------------------
|
|
|
|
SHORT_BIT : constant := 16;
|
|
SSHORT_MIN : constant := -2 ** (SHORT_BIT - 1);
|
|
SSHORT_MAX : constant := 2 ** (SHORT_BIT - 1) - 1;
|
|
USHORT_MAX : constant := 2 ** SHORT_BIT - 1;
|
|
|
|
type unsigned_short is mod USHORT_MAX + 1;
|
|
for unsigned_short'Size use SHORT_BIT;
|
|
|
|
subtype unsigned_short_int is unsigned_short;
|
|
|
|
type signed_short is range SSHORT_MIN .. SSHORT_MAX;
|
|
for signed_short'Size use SHORT_BIT;
|
|
|
|
subtype signed_short_int is signed_short;
|
|
|
|
subtype bool_short is unsigned_short;
|
|
-- ??? See bool_char
|
|
|
|
bool_short_True : constant bool_short := bool_short'Last;
|
|
bool_short_False : constant bool_short := 0;
|
|
|
|
subtype bool_short_int is bool_short;
|
|
|
|
--------------------
|
|
-- int components --
|
|
--------------------
|
|
|
|
INT_BIT : constant := 32;
|
|
SINT_MIN : constant := -2 ** (INT_BIT - 1);
|
|
SINT_MAX : constant := 2 ** (INT_BIT - 1) - 1;
|
|
UINT_MAX : constant := 2 ** INT_BIT - 1;
|
|
|
|
type unsigned_int is mod UINT_MAX + 1;
|
|
for unsigned_int'Size use INT_BIT;
|
|
|
|
type signed_int is range SINT_MIN .. SINT_MAX;
|
|
for signed_int'Size use INT_BIT;
|
|
|
|
subtype bool_int is unsigned_int;
|
|
-- ??? See bool_char
|
|
|
|
bool_int_True : constant bool_int := bool_int'Last;
|
|
bool_int_False : constant bool_int := 0;
|
|
|
|
----------------------
|
|
-- float components --
|
|
----------------------
|
|
|
|
FLOAT_BIT : constant := 32;
|
|
FLOAT_DIGIT : constant := 6;
|
|
FLOAT_MIN : constant := -16#0.FFFF_FF#E+32;
|
|
FLOAT_MAX : constant := 16#0.FFFF_FF#E+32;
|
|
|
|
type C_float is digits FLOAT_DIGIT range FLOAT_MIN .. FLOAT_MAX;
|
|
for C_float'Size use FLOAT_BIT;
|
|
-- Altivec operations always use the standard native floating-point
|
|
-- support of the target. Note that this means that there may be
|
|
-- minor differences in results between targets when the floating-
|
|
-- point implementations are slightly different, as would happen
|
|
-- with normal non-Altivec floating-point operations. In particular
|
|
-- the Altivec simulations may yield slightly different results
|
|
-- from those obtained on a true hardware Altivec target if the
|
|
-- floating-point implementation is not 100% compatible.
|
|
|
|
----------------------
|
|
-- pixel components --
|
|
----------------------
|
|
|
|
subtype pixel is unsigned_short;
|
|
|
|
-----------------------------------------------------------
|
|
-- Subtypes for variants found in the GCC implementation --
|
|
-----------------------------------------------------------
|
|
|
|
subtype c_int is signed_int;
|
|
subtype c_short is c_int;
|
|
|
|
LONG_BIT : constant := 32;
|
|
-- Some of the GCC builtins are built with "long" arguments and
|
|
-- expect SImode to come in.
|
|
|
|
SLONG_MIN : constant := -2 ** (LONG_BIT - 1);
|
|
SLONG_MAX : constant := 2 ** (LONG_BIT - 1) - 1;
|
|
ULONG_MAX : constant := 2 ** LONG_BIT - 1;
|
|
|
|
type signed_long is range SLONG_MIN .. SLONG_MAX;
|
|
type unsigned_long is mod ULONG_MAX + 1;
|
|
|
|
subtype c_long is signed_long;
|
|
|
|
subtype c_ptr is System.Address;
|
|
|
|
---------------------------------------------------------
|
|
-- Access types, for the sake of some argument passing --
|
|
---------------------------------------------------------
|
|
|
|
type signed_char_ptr is access all signed_char;
|
|
type unsigned_char_ptr is access all unsigned_char;
|
|
|
|
type short_ptr is access all c_short;
|
|
type signed_short_ptr is access all signed_short;
|
|
type unsigned_short_ptr is access all unsigned_short;
|
|
|
|
type int_ptr is access all c_int;
|
|
type signed_int_ptr is access all signed_int;
|
|
type unsigned_int_ptr is access all unsigned_int;
|
|
|
|
type long_ptr is access all c_long;
|
|
type signed_long_ptr is access all signed_long;
|
|
type unsigned_long_ptr is access all unsigned_long;
|
|
|
|
type float_ptr is access all Float;
|
|
|
|
--
|
|
|
|
type const_signed_char_ptr is access constant signed_char;
|
|
type const_unsigned_char_ptr is access constant unsigned_char;
|
|
|
|
type const_short_ptr is access constant c_short;
|
|
type const_signed_short_ptr is access constant signed_short;
|
|
type const_unsigned_short_ptr is access constant unsigned_short;
|
|
|
|
type const_int_ptr is access constant c_int;
|
|
type const_signed_int_ptr is access constant signed_int;
|
|
type const_unsigned_int_ptr is access constant unsigned_int;
|
|
|
|
type const_long_ptr is access constant c_long;
|
|
type const_signed_long_ptr is access constant signed_long;
|
|
type const_unsigned_long_ptr is access constant unsigned_long;
|
|
|
|
type const_float_ptr is access constant Float;
|
|
|
|
-- Access to const volatile arguments need specialized types
|
|
|
|
type volatile_float is new Float;
|
|
pragma Volatile (volatile_float);
|
|
|
|
type volatile_signed_char is new signed_char;
|
|
pragma Volatile (volatile_signed_char);
|
|
|
|
type volatile_unsigned_char is new unsigned_char;
|
|
pragma Volatile (volatile_unsigned_char);
|
|
|
|
type volatile_signed_short is new signed_short;
|
|
pragma Volatile (volatile_signed_short);
|
|
|
|
type volatile_unsigned_short is new unsigned_short;
|
|
pragma Volatile (volatile_unsigned_short);
|
|
|
|
type volatile_signed_int is new signed_int;
|
|
pragma Volatile (volatile_signed_int);
|
|
|
|
type volatile_unsigned_int is new unsigned_int;
|
|
pragma Volatile (volatile_unsigned_int);
|
|
|
|
type volatile_signed_long is new signed_long;
|
|
pragma Volatile (volatile_signed_long);
|
|
|
|
type volatile_unsigned_long is new unsigned_long;
|
|
pragma Volatile (volatile_unsigned_long);
|
|
|
|
type constv_char_ptr is access constant volatile_signed_char;
|
|
type constv_signed_char_ptr is access constant volatile_signed_char;
|
|
type constv_unsigned_char_ptr is access constant volatile_unsigned_char;
|
|
|
|
type constv_short_ptr is access constant volatile_signed_short;
|
|
type constv_signed_short_ptr is access constant volatile_signed_short;
|
|
type constv_unsigned_short_ptr is access constant volatile_unsigned_short;
|
|
|
|
type constv_int_ptr is access constant volatile_signed_int;
|
|
type constv_signed_int_ptr is access constant volatile_signed_int;
|
|
type constv_unsigned_int_ptr is access constant volatile_unsigned_int;
|
|
|
|
type constv_long_ptr is access constant volatile_signed_long;
|
|
type constv_signed_long_ptr is access constant volatile_signed_long;
|
|
type constv_unsigned_long_ptr is access constant volatile_unsigned_long;
|
|
|
|
type constv_float_ptr is access constant volatile_float;
|
|
|
|
private
|
|
|
|
-----------------------
|
|
-- Various constants --
|
|
-----------------------
|
|
|
|
CR6_EQ : constant := 0;
|
|
CR6_EQ_REV : constant := 1;
|
|
CR6_LT : constant := 2;
|
|
CR6_LT_REV : constant := 3;
|
|
|
|
end GNAT.Altivec;
|