8363 lines
200 KiB
Ada
8363 lines
200 KiB
Ada
------------------------------------------------------------------------------
|
|
-- --
|
|
-- GNAT COMPILER COMPONENTS --
|
|
-- --
|
|
-- G N A T . A L T I V E C . V E C T O R _ O P E R A T I O N S --
|
|
-- --
|
|
-- S p e c --
|
|
-- --
|
|
-- Copyright (C) 2004-2015, 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. --
|
|
-- --
|
|
------------------------------------------------------------------------------
|
|
|
|
-- This unit is the user-level Ada interface to AltiVec operations on vector
|
|
-- objects. It is common to both the Soft and the Hard bindings.
|
|
|
|
with GNAT.Altivec.Vector_Types; use GNAT.Altivec.Vector_Types;
|
|
with GNAT.Altivec.Low_Level_Vectors; use GNAT.Altivec.Low_Level_Vectors;
|
|
|
|
------------------------------------
|
|
-- GNAT.Altivec.Vector_Operations --
|
|
------------------------------------
|
|
|
|
------------------------------------
|
|
-- GNAT.Altivec.Vector_Operations --
|
|
------------------------------------
|
|
|
|
package GNAT.Altivec.Vector_Operations is
|
|
|
|
-------------------------------------
|
|
-- Different Flavors of Interfaces --
|
|
-------------------------------------
|
|
|
|
-- The vast majority of the user visible functions are just neutral type
|
|
-- conversion wrappers around calls to low level primitives. For instance:
|
|
|
|
-- function vec_sll
|
|
-- (A : vector_signed_int;
|
|
-- B : vector_unsigned_char) return vector_signed_int is
|
|
-- begin
|
|
-- return To_VSI (vsl (To_VSI (A), To_VSI (B)));
|
|
-- end vec_sll;
|
|
|
|
-- We actually don't always need an explicit wrapper and can bind directly
|
|
-- with a straight Import of the low level routine, or a renaming of such
|
|
-- instead.
|
|
|
|
-- A direct binding is not possible (that is, a wrapper is mandatory) in
|
|
-- a number of cases:
|
|
|
|
-- o When the high-level/low-level types don't match, in which case a
|
|
-- straight import would risk wrong code generation or compiler blowups in
|
|
-- the Hard binding case. This is the case for 'B' in the example above.
|
|
|
|
-- o When the high-level/low-level argument lists differ, as is the case
|
|
-- for most of the AltiVec predicates, relying on a low-level primitive
|
|
-- which expects a control code argument, like:
|
|
|
|
-- function vec_any_ne
|
|
-- (A : vector_signed_int;
|
|
-- B : vector_signed_int) return c_int is
|
|
-- begin
|
|
-- return vcmpequw_p (CR6_LT_REV, To_VSI (A), To_VSI (B));
|
|
-- end vec_any_ne;
|
|
|
|
-- o When the high-level/low-level arguments order don't match, as in:
|
|
|
|
-- function vec_cmplt
|
|
-- (A : vector_unsigned_char;
|
|
-- B : vector_unsigned_char) return vector_bool_char is
|
|
-- begin
|
|
-- return To_VBC (vcmpgtub (To_VSC (B), To_VSC (A)));
|
|
-- end vec_cmplt;
|
|
|
|
-----------------------------
|
|
-- Inlining Considerations --
|
|
-----------------------------
|
|
|
|
-- The intent in the hard binding case is to eventually map operations to
|
|
-- hardware instructions. Needless to say, intermediate function calls do
|
|
-- not fit this purpose, so all user visible subprograms need to be marked
|
|
-- Inline_Always. Some of the builtins we eventually bind to expect literal
|
|
-- arguments. Wrappers to such builtins are made Convention Intrinsic as
|
|
-- well so we don't attempt to compile the bodies on their own.
|
|
|
|
-- In the soft case, the bulk of the work is performed by the low level
|
|
-- routines, and those exported by this unit are short enough for the
|
|
-- inlining to make sense and even be beneficial.
|
|
|
|
-------------------------------------------------------
|
|
-- [PIM-4.4 Generic and Specific AltiVec operations] --
|
|
-------------------------------------------------------
|
|
|
|
-------------
|
|
-- vec_abs --
|
|
-------------
|
|
|
|
function vec_abs
|
|
(A : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_abs
|
|
(A : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_abs
|
|
(A : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_abs
|
|
(A : vector_float) return vector_float;
|
|
|
|
--------------
|
|
-- vec_abss --
|
|
--------------
|
|
|
|
function vec_abss
|
|
(A : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_abss
|
|
(A : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_abss
|
|
(A : vector_signed_int) return vector_signed_int;
|
|
|
|
-------------
|
|
-- vec_add --
|
|
-------------
|
|
|
|
function vec_add
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_add
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return vector_signed_char;
|
|
|
|
function vec_add
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_add
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_add
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return vector_unsigned_char;
|
|
|
|
function vec_add
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_add
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_add
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return vector_signed_short;
|
|
|
|
function vec_add
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_add
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_add
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return vector_unsigned_short;
|
|
|
|
function vec_add
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_add
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_add
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return vector_signed_int;
|
|
|
|
function vec_add
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_add
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_add
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return vector_unsigned_int;
|
|
|
|
function vec_add
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_add
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float;
|
|
|
|
----------------
|
|
-- vec_vaddfp --
|
|
----------------
|
|
|
|
function vec_vaddfp
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float;
|
|
|
|
-----------------
|
|
-- vec_vadduwm --
|
|
-----------------
|
|
|
|
function vec_vadduwm
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_vadduwm
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return vector_signed_int;
|
|
|
|
function vec_vadduwm
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_vadduwm
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_vadduwm
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return vector_unsigned_int;
|
|
|
|
function vec_vadduwm
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
-----------------
|
|
-- vec_vadduhm --
|
|
-----------------
|
|
|
|
function vec_vadduhm
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_vadduhm
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return vector_signed_short;
|
|
|
|
function vec_vadduhm
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_vadduhm
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_vadduhm
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return vector_unsigned_short;
|
|
|
|
function vec_vadduhm
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
-----------------
|
|
-- vec_vaddubm --
|
|
-----------------
|
|
|
|
function vec_vaddubm
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_vaddubm
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return vector_signed_char;
|
|
|
|
function vec_vaddubm
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_vaddubm
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_vaddubm
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return vector_unsigned_char;
|
|
|
|
function vec_vaddubm
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
--------------
|
|
-- vec_addc --
|
|
--------------
|
|
|
|
function vec_addc
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
--------------
|
|
-- vec_adds --
|
|
--------------
|
|
|
|
function vec_adds
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_adds
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return vector_unsigned_char;
|
|
|
|
function vec_adds
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_adds
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_adds
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return vector_signed_char;
|
|
|
|
function vec_adds
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_adds
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_adds
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return vector_unsigned_short;
|
|
|
|
function vec_adds
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_adds
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_adds
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return vector_signed_short;
|
|
|
|
function vec_adds
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_adds
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_adds
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return vector_unsigned_int;
|
|
|
|
function vec_adds
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_adds
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_adds
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return vector_signed_int;
|
|
|
|
function vec_adds
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
-----------------
|
|
-- vec_vaddsws --
|
|
-----------------
|
|
|
|
function vec_vaddsws
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_vaddsws
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return vector_signed_int;
|
|
|
|
function vec_vaddsws
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
-----------------
|
|
-- vec_vadduws --
|
|
-----------------
|
|
|
|
function vec_vadduws
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_vadduws
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return vector_unsigned_int;
|
|
|
|
function vec_vadduws
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
-----------------
|
|
-- vec_vaddshs --
|
|
-----------------
|
|
|
|
function vec_vaddshs
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_vaddshs
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return vector_signed_short;
|
|
|
|
function vec_vaddshs
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
-----------------
|
|
-- vec_vadduhs --
|
|
-----------------
|
|
|
|
function vec_vadduhs
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_vadduhs
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return vector_unsigned_short;
|
|
|
|
function vec_vadduhs
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
-----------------
|
|
-- vec_vaddsbs --
|
|
-----------------
|
|
|
|
function vec_vaddsbs
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_vaddsbs
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return vector_signed_char;
|
|
|
|
function vec_vaddsbs
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
-----------------
|
|
-- vec_vaddubs --
|
|
-----------------
|
|
|
|
function vec_vaddubs
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_vaddubs
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return vector_unsigned_char;
|
|
|
|
function vec_vaddubs
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
-------------
|
|
-- vec_and --
|
|
-------------
|
|
|
|
function vec_and
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float;
|
|
|
|
function vec_and
|
|
(A : vector_float;
|
|
B : vector_bool_int) return vector_float;
|
|
|
|
function vec_and
|
|
(A : vector_bool_int;
|
|
B : vector_float) return vector_float;
|
|
|
|
function vec_and
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int) return vector_bool_int;
|
|
|
|
function vec_and
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_and
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return vector_signed_int;
|
|
|
|
function vec_and
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_and
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_and
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return vector_unsigned_int;
|
|
|
|
function vec_and
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_and
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short) return vector_bool_short;
|
|
|
|
function vec_and
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_and
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return vector_signed_short;
|
|
|
|
function vec_and
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_and
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_and
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return vector_unsigned_short;
|
|
|
|
function vec_and
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_and
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_and
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char) return vector_bool_char;
|
|
|
|
function vec_and
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return vector_signed_char;
|
|
|
|
function vec_and
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_and
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_and
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return vector_unsigned_char;
|
|
|
|
function vec_and
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
--------------
|
|
-- vec_andc --
|
|
--------------
|
|
|
|
function vec_andc
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float;
|
|
|
|
function vec_andc
|
|
(A : vector_float;
|
|
B : vector_bool_int) return vector_float;
|
|
|
|
function vec_andc
|
|
(A : vector_bool_int;
|
|
B : vector_float) return vector_float;
|
|
|
|
function vec_andc
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int) return vector_bool_int;
|
|
|
|
function vec_andc
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_andc
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return vector_signed_int;
|
|
|
|
function vec_andc
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_andc
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_andc
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return vector_unsigned_int;
|
|
|
|
function vec_andc
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_andc
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short) return vector_bool_short;
|
|
|
|
function vec_andc
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_andc
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return vector_signed_short;
|
|
|
|
function vec_andc
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_andc
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_andc
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return vector_unsigned_short;
|
|
|
|
function vec_andc
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_andc
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_andc
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char) return vector_bool_char;
|
|
|
|
function vec_andc
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return vector_signed_char;
|
|
|
|
function vec_andc
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_andc
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_andc
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return vector_unsigned_char;
|
|
|
|
function vec_andc
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
-------------
|
|
-- vec_avg --
|
|
-------------
|
|
|
|
function vec_avg
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_avg
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_avg
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_avg
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_avg
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_avg
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
----------------
|
|
-- vec_vavgsw --
|
|
----------------
|
|
|
|
function vec_vavgsw
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
----------------
|
|
-- vec_vavguw --
|
|
----------------
|
|
|
|
function vec_vavguw
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
----------------
|
|
-- vec_vavgsh --
|
|
----------------
|
|
|
|
function vec_vavgsh
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
----------------
|
|
-- vec_vavguh --
|
|
----------------
|
|
|
|
function vec_vavguh
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
----------------
|
|
-- vec_vavgsb --
|
|
----------------
|
|
|
|
function vec_vavgsb
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
----------------
|
|
-- vec_vavgub --
|
|
----------------
|
|
|
|
function vec_vavgub
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
--------------
|
|
-- vec_ceil --
|
|
--------------
|
|
|
|
function vec_ceil
|
|
(A : vector_float) return vector_float;
|
|
|
|
--------------
|
|
-- vec_cmpb --
|
|
--------------
|
|
|
|
function vec_cmpb
|
|
(A : vector_float;
|
|
B : vector_float) return vector_signed_int;
|
|
|
|
function vec_cmpeq
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_bool_char;
|
|
|
|
function vec_cmpeq
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_bool_char;
|
|
|
|
function vec_cmpeq
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_bool_short;
|
|
|
|
function vec_cmpeq
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_bool_short;
|
|
|
|
function vec_cmpeq
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_bool_int;
|
|
|
|
function vec_cmpeq
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_bool_int;
|
|
|
|
function vec_cmpeq
|
|
(A : vector_float;
|
|
B : vector_float) return vector_bool_int;
|
|
|
|
------------------
|
|
-- vec_vcmpeqfp --
|
|
------------------
|
|
|
|
function vec_vcmpeqfp
|
|
(A : vector_float;
|
|
B : vector_float) return vector_bool_int;
|
|
|
|
------------------
|
|
-- vec_vcmpequw --
|
|
------------------
|
|
|
|
function vec_vcmpequw
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_bool_int;
|
|
|
|
function vec_vcmpequw
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_bool_int;
|
|
|
|
------------------
|
|
-- vec_vcmpequh --
|
|
------------------
|
|
|
|
function vec_vcmpequh
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_bool_short;
|
|
|
|
function vec_vcmpequh
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_bool_short;
|
|
|
|
------------------
|
|
-- vec_vcmpequb --
|
|
------------------
|
|
|
|
function vec_vcmpequb
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_bool_char;
|
|
|
|
function vec_vcmpequb
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_bool_char;
|
|
|
|
---------------
|
|
-- vec_cmpge --
|
|
---------------
|
|
|
|
function vec_cmpge
|
|
(A : vector_float;
|
|
B : vector_float) return vector_bool_int;
|
|
|
|
---------------
|
|
-- vec_cmpgt --
|
|
---------------
|
|
|
|
function vec_cmpgt
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_bool_char;
|
|
|
|
function vec_cmpgt
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_bool_char;
|
|
|
|
function vec_cmpgt
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_bool_short;
|
|
|
|
function vec_cmpgt
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_bool_short;
|
|
|
|
function vec_cmpgt
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_bool_int;
|
|
|
|
function vec_cmpgt
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_bool_int;
|
|
|
|
function vec_cmpgt
|
|
(A : vector_float;
|
|
B : vector_float) return vector_bool_int;
|
|
|
|
------------------
|
|
-- vec_vcmpgtfp --
|
|
------------------
|
|
|
|
function vec_vcmpgtfp
|
|
(A : vector_float;
|
|
B : vector_float) return vector_bool_int;
|
|
|
|
------------------
|
|
-- vec_vcmpgtsw --
|
|
------------------
|
|
|
|
function vec_vcmpgtsw
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_bool_int;
|
|
|
|
------------------
|
|
-- vec_vcmpgtuw --
|
|
------------------
|
|
|
|
function vec_vcmpgtuw
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_bool_int;
|
|
|
|
------------------
|
|
-- vec_vcmpgtsh --
|
|
------------------
|
|
|
|
function vec_vcmpgtsh
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_bool_short;
|
|
|
|
------------------
|
|
-- vec_vcmpgtuh --
|
|
------------------
|
|
|
|
function vec_vcmpgtuh
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_bool_short;
|
|
|
|
------------------
|
|
-- vec_vcmpgtsb --
|
|
------------------
|
|
|
|
function vec_vcmpgtsb
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_bool_char;
|
|
|
|
------------------
|
|
-- vec_vcmpgtub --
|
|
------------------
|
|
|
|
function vec_vcmpgtub
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_bool_char;
|
|
|
|
---------------
|
|
-- vec_cmple --
|
|
---------------
|
|
|
|
function vec_cmple
|
|
(A : vector_float;
|
|
B : vector_float) return vector_bool_int;
|
|
|
|
---------------
|
|
-- vec_cmplt --
|
|
---------------
|
|
|
|
function vec_cmplt
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_bool_char;
|
|
|
|
function vec_cmplt
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_bool_char;
|
|
|
|
function vec_cmplt
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_bool_short;
|
|
|
|
function vec_cmplt
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_bool_short;
|
|
|
|
function vec_cmplt
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_bool_int;
|
|
|
|
function vec_cmplt
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_bool_int;
|
|
|
|
function vec_cmplt
|
|
(A : vector_float;
|
|
B : vector_float) return vector_bool_int;
|
|
|
|
---------------
|
|
-- vec_vcfsx --
|
|
---------------
|
|
|
|
function vec_vcfsx
|
|
(A : vector_signed_int;
|
|
B : c_int) return vector_float
|
|
renames Low_Level_Vectors.vcfsx;
|
|
|
|
---------------
|
|
-- vec_vcfux --
|
|
---------------
|
|
|
|
function vec_vcfux
|
|
(A : vector_unsigned_int;
|
|
B : c_int) return vector_float
|
|
renames Low_Level_Vectors.vcfux;
|
|
|
|
----------------
|
|
-- vec_vctsxs --
|
|
----------------
|
|
|
|
function vec_vctsxs
|
|
(A : vector_float;
|
|
B : c_int) return vector_signed_int
|
|
renames Low_Level_Vectors.vctsxs;
|
|
|
|
----------------
|
|
-- vec_vctuxs --
|
|
----------------
|
|
|
|
function vec_vctuxs
|
|
(A : vector_float;
|
|
B : c_int) return vector_unsigned_int
|
|
renames Low_Level_Vectors.vctuxs;
|
|
|
|
-------------
|
|
-- vec_dss --
|
|
-------------
|
|
|
|
procedure vec_dss
|
|
(A : c_int)
|
|
renames Low_Level_Vectors.dss;
|
|
|
|
----------------
|
|
-- vec_dssall --
|
|
----------------
|
|
|
|
procedure vec_dssall
|
|
renames Low_Level_Vectors.dssall;
|
|
|
|
-------------
|
|
-- vec_dst --
|
|
-------------
|
|
|
|
procedure vec_dst
|
|
(A : const_vector_unsigned_char_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dst
|
|
(A : const_vector_signed_char_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dst
|
|
(A : const_vector_bool_char_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dst
|
|
(A : const_vector_unsigned_short_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dst
|
|
(A : const_vector_signed_short_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dst
|
|
(A : const_vector_bool_short_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dst
|
|
(A : const_vector_pixel_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dst
|
|
(A : const_vector_unsigned_int_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dst
|
|
(A : const_vector_signed_int_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dst
|
|
(A : const_vector_bool_int_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dst
|
|
(A : const_vector_float_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dst
|
|
(A : const_unsigned_char_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dst
|
|
(A : const_signed_char_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dst
|
|
(A : const_unsigned_short_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dst
|
|
(A : const_short_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dst
|
|
(A : const_unsigned_int_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dst
|
|
(A : const_int_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dst
|
|
(A : const_unsigned_long_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dst
|
|
(A : const_long_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dst
|
|
(A : const_float_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
pragma Inline_Always (vec_dst);
|
|
pragma Convention (Intrinsic, vec_dst);
|
|
|
|
---------------
|
|
-- vec_dstst --
|
|
---------------
|
|
|
|
procedure vec_dstst
|
|
(A : const_vector_unsigned_char_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstst
|
|
(A : const_vector_signed_char_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstst
|
|
(A : const_vector_bool_char_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstst
|
|
(A : const_vector_unsigned_short_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstst
|
|
(A : const_vector_signed_short_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstst
|
|
(A : const_vector_bool_short_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstst
|
|
(A : const_vector_pixel_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstst
|
|
(A : const_vector_unsigned_int_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstst
|
|
(A : const_vector_signed_int_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstst
|
|
(A : const_vector_bool_int_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstst
|
|
(A : const_vector_float_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstst
|
|
(A : const_unsigned_char_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstst
|
|
(A : const_signed_char_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstst
|
|
(A : const_unsigned_short_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstst
|
|
(A : const_short_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstst
|
|
(A : const_unsigned_int_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstst
|
|
(A : const_int_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstst
|
|
(A : const_unsigned_long_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstst
|
|
(A : const_long_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstst
|
|
(A : const_float_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
pragma Inline_Always (vec_dstst);
|
|
pragma Convention (Intrinsic, vec_dstst);
|
|
|
|
----------------
|
|
-- vec_dststt --
|
|
----------------
|
|
|
|
procedure vec_dststt
|
|
(A : const_vector_unsigned_char_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dststt
|
|
(A : const_vector_signed_char_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dststt
|
|
(A : const_vector_bool_char_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dststt
|
|
(A : const_vector_unsigned_short_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dststt
|
|
(A : const_vector_signed_short_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dststt
|
|
(A : const_vector_bool_short_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dststt
|
|
(A : const_vector_pixel_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dststt
|
|
(A : const_vector_unsigned_int_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dststt
|
|
(A : const_vector_signed_int_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dststt
|
|
(A : const_vector_bool_int_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dststt
|
|
(A : const_vector_float_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dststt
|
|
(A : const_unsigned_char_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dststt
|
|
(A : const_signed_char_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dststt
|
|
(A : const_unsigned_short_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dststt
|
|
(A : const_short_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dststt
|
|
(A : const_unsigned_int_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dststt
|
|
(A : const_int_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dststt
|
|
(A : const_unsigned_long_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dststt
|
|
(A : const_long_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dststt
|
|
(A : const_float_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
pragma Inline_Always (vec_dststt);
|
|
pragma Convention (Intrinsic, vec_dststt);
|
|
|
|
--------------
|
|
-- vec_dstt --
|
|
--------------
|
|
|
|
procedure vec_dstt
|
|
(A : const_vector_unsigned_char_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstt
|
|
(A : const_vector_signed_char_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstt
|
|
(A : const_vector_bool_char_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstt
|
|
(A : const_vector_unsigned_short_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstt
|
|
(A : const_vector_signed_short_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstt
|
|
(A : const_vector_bool_short_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstt
|
|
(A : const_vector_pixel_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstt
|
|
(A : const_vector_unsigned_int_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstt
|
|
(A : const_vector_signed_int_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstt
|
|
(A : const_vector_bool_int_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstt
|
|
(A : const_vector_float_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstt
|
|
(A : const_unsigned_char_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstt
|
|
(A : const_signed_char_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstt
|
|
(A : const_unsigned_short_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstt
|
|
(A : const_short_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstt
|
|
(A : const_unsigned_int_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstt
|
|
(A : const_int_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstt
|
|
(A : const_unsigned_long_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstt
|
|
(A : const_long_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
|
|
procedure vec_dstt
|
|
(A : const_float_ptr;
|
|
B : c_int;
|
|
C : c_int);
|
|
pragma Inline_Always (vec_dstt);
|
|
pragma Convention (Intrinsic, vec_dstt);
|
|
|
|
---------------
|
|
-- vec_expte --
|
|
---------------
|
|
|
|
function vec_expte
|
|
(A : vector_float) return vector_float;
|
|
|
|
---------------
|
|
-- vec_floor --
|
|
---------------
|
|
|
|
function vec_floor
|
|
(A : vector_float) return vector_float;
|
|
|
|
------------
|
|
-- vec_ld --
|
|
------------
|
|
|
|
function vec_ld
|
|
(A : c_long;
|
|
B : const_vector_float_ptr) return vector_float;
|
|
|
|
function vec_ld
|
|
(A : c_long;
|
|
B : const_float_ptr) return vector_float;
|
|
|
|
function vec_ld
|
|
(A : c_long;
|
|
B : const_vector_bool_int_ptr) return vector_bool_int;
|
|
|
|
function vec_ld
|
|
(A : c_long;
|
|
B : const_vector_signed_int_ptr) return vector_signed_int;
|
|
|
|
function vec_ld
|
|
(A : c_long;
|
|
B : const_int_ptr) return vector_signed_int;
|
|
|
|
function vec_ld
|
|
(A : c_long;
|
|
B : const_long_ptr) return vector_signed_int;
|
|
|
|
function vec_ld
|
|
(A : c_long;
|
|
B : const_vector_unsigned_int_ptr) return vector_unsigned_int;
|
|
|
|
function vec_ld
|
|
(A : c_long;
|
|
B : const_unsigned_int_ptr) return vector_unsigned_int;
|
|
|
|
function vec_ld
|
|
(A : c_long;
|
|
B : const_unsigned_long_ptr) return vector_unsigned_int;
|
|
|
|
function vec_ld
|
|
(A : c_long;
|
|
B : const_vector_bool_short_ptr) return vector_bool_short;
|
|
|
|
function vec_ld
|
|
(A : c_long;
|
|
B : const_vector_pixel_ptr) return vector_pixel;
|
|
|
|
function vec_ld
|
|
(A : c_long;
|
|
B : const_vector_signed_short_ptr) return vector_signed_short;
|
|
|
|
function vec_ld
|
|
(A : c_long;
|
|
B : const_short_ptr) return vector_signed_short;
|
|
|
|
function vec_ld
|
|
(A : c_long;
|
|
B : const_vector_unsigned_short_ptr) return vector_unsigned_short;
|
|
|
|
function vec_ld
|
|
(A : c_long;
|
|
B : const_unsigned_short_ptr) return vector_unsigned_short;
|
|
|
|
function vec_ld
|
|
(A : c_long;
|
|
B : const_vector_bool_char_ptr) return vector_bool_char;
|
|
|
|
function vec_ld
|
|
(A : c_long;
|
|
B : const_vector_signed_char_ptr) return vector_signed_char;
|
|
|
|
function vec_ld
|
|
(A : c_long;
|
|
B : const_signed_char_ptr) return vector_signed_char;
|
|
|
|
function vec_ld
|
|
(A : c_long;
|
|
B : const_vector_unsigned_char_ptr) return vector_unsigned_char;
|
|
|
|
function vec_ld
|
|
(A : c_long;
|
|
B : const_unsigned_char_ptr) return vector_unsigned_char;
|
|
|
|
-------------
|
|
-- vec_lde --
|
|
-------------
|
|
|
|
function vec_lde
|
|
(A : c_long;
|
|
B : const_signed_char_ptr) return vector_signed_char;
|
|
|
|
function vec_lde
|
|
(A : c_long;
|
|
B : const_unsigned_char_ptr) return vector_unsigned_char;
|
|
|
|
function vec_lde
|
|
(A : c_long;
|
|
B : const_short_ptr) return vector_signed_short;
|
|
|
|
function vec_lde
|
|
(A : c_long;
|
|
B : const_unsigned_short_ptr) return vector_unsigned_short;
|
|
|
|
function vec_lde
|
|
(A : c_long;
|
|
B : const_float_ptr) return vector_float;
|
|
|
|
function vec_lde
|
|
(A : c_long;
|
|
B : const_int_ptr) return vector_signed_int;
|
|
|
|
function vec_lde
|
|
(A : c_long;
|
|
B : const_unsigned_int_ptr) return vector_unsigned_int;
|
|
|
|
function vec_lde
|
|
(A : c_long;
|
|
B : const_long_ptr) return vector_signed_int;
|
|
|
|
function vec_lde
|
|
(A : c_long;
|
|
B : const_unsigned_long_ptr) return vector_unsigned_int;
|
|
|
|
---------------
|
|
-- vec_lvewx --
|
|
---------------
|
|
|
|
function vec_lvewx
|
|
(A : c_long;
|
|
B : float_ptr) return vector_float;
|
|
|
|
function vec_lvewx
|
|
(A : c_long;
|
|
B : int_ptr) return vector_signed_int;
|
|
|
|
function vec_lvewx
|
|
(A : c_long;
|
|
B : unsigned_int_ptr) return vector_unsigned_int;
|
|
|
|
function vec_lvewx
|
|
(A : c_long;
|
|
B : long_ptr) return vector_signed_int;
|
|
|
|
function vec_lvewx
|
|
(A : c_long;
|
|
B : unsigned_long_ptr) return vector_unsigned_int;
|
|
|
|
---------------
|
|
-- vec_lvehx --
|
|
---------------
|
|
|
|
function vec_lvehx
|
|
(A : c_long;
|
|
B : short_ptr) return vector_signed_short;
|
|
|
|
function vec_lvehx
|
|
(A : c_long;
|
|
B : unsigned_short_ptr) return vector_unsigned_short;
|
|
|
|
---------------
|
|
-- vec_lvebx --
|
|
---------------
|
|
|
|
function vec_lvebx
|
|
(A : c_long;
|
|
B : signed_char_ptr) return vector_signed_char;
|
|
|
|
function vec_lvebx
|
|
(A : c_long;
|
|
B : unsigned_char_ptr) return vector_unsigned_char;
|
|
|
|
-------------
|
|
-- vec_ldl --
|
|
-------------
|
|
|
|
function vec_ldl
|
|
(A : c_long;
|
|
B : const_vector_float_ptr) return vector_float;
|
|
|
|
function vec_ldl
|
|
(A : c_long;
|
|
B : const_float_ptr) return vector_float;
|
|
|
|
function vec_ldl
|
|
(A : c_long;
|
|
B : const_vector_bool_int_ptr) return vector_bool_int;
|
|
|
|
function vec_ldl
|
|
(A : c_long;
|
|
B : const_vector_signed_int_ptr) return vector_signed_int;
|
|
|
|
function vec_ldl
|
|
(A : c_long;
|
|
B : const_int_ptr) return vector_signed_int;
|
|
|
|
function vec_ldl
|
|
(A : c_long;
|
|
B : const_long_ptr) return vector_signed_int;
|
|
|
|
function vec_ldl
|
|
(A : c_long;
|
|
B : const_vector_unsigned_int_ptr) return vector_unsigned_int;
|
|
|
|
function vec_ldl
|
|
(A : c_long;
|
|
B : const_unsigned_int_ptr) return vector_unsigned_int;
|
|
|
|
function vec_ldl
|
|
(A : c_long;
|
|
B : const_unsigned_long_ptr) return vector_unsigned_int;
|
|
|
|
function vec_ldl
|
|
(A : c_long;
|
|
B : const_vector_bool_short_ptr) return vector_bool_short;
|
|
|
|
function vec_ldl
|
|
(A : c_long;
|
|
B : const_vector_pixel_ptr) return vector_pixel;
|
|
|
|
function vec_ldl
|
|
(A : c_long;
|
|
B : const_vector_signed_short_ptr) return vector_signed_short;
|
|
|
|
function vec_ldl
|
|
(A : c_long;
|
|
B : const_short_ptr) return vector_signed_short;
|
|
|
|
function vec_ldl
|
|
(A : c_long;
|
|
B : const_vector_unsigned_short_ptr) return vector_unsigned_short;
|
|
|
|
function vec_ldl
|
|
(A : c_long;
|
|
B : const_unsigned_short_ptr) return vector_unsigned_short;
|
|
|
|
function vec_ldl
|
|
(A : c_long;
|
|
B : const_vector_bool_char_ptr) return vector_bool_char;
|
|
|
|
function vec_ldl
|
|
(A : c_long;
|
|
B : const_vector_signed_char_ptr) return vector_signed_char;
|
|
|
|
function vec_ldl
|
|
(A : c_long;
|
|
B : const_signed_char_ptr) return vector_signed_char;
|
|
|
|
function vec_ldl
|
|
(A : c_long;
|
|
B : const_vector_unsigned_char_ptr) return vector_unsigned_char;
|
|
|
|
function vec_ldl
|
|
(A : c_long;
|
|
B : const_unsigned_char_ptr) return vector_unsigned_char;
|
|
|
|
--------------
|
|
-- vec_loge --
|
|
--------------
|
|
|
|
function vec_loge
|
|
(A : vector_float) return vector_float;
|
|
|
|
--------------
|
|
-- vec_lvsl --
|
|
--------------
|
|
|
|
function vec_lvsl
|
|
(A : c_long;
|
|
B : constv_unsigned_char_ptr) return vector_unsigned_char;
|
|
|
|
function vec_lvsl
|
|
(A : c_long;
|
|
B : constv_signed_char_ptr) return vector_unsigned_char;
|
|
|
|
function vec_lvsl
|
|
(A : c_long;
|
|
B : constv_unsigned_short_ptr) return vector_unsigned_char;
|
|
|
|
function vec_lvsl
|
|
(A : c_long;
|
|
B : constv_short_ptr) return vector_unsigned_char;
|
|
|
|
function vec_lvsl
|
|
(A : c_long;
|
|
B : constv_unsigned_int_ptr) return vector_unsigned_char;
|
|
|
|
function vec_lvsl
|
|
(A : c_long;
|
|
B : constv_int_ptr) return vector_unsigned_char;
|
|
|
|
function vec_lvsl
|
|
(A : c_long;
|
|
B : constv_unsigned_long_ptr) return vector_unsigned_char;
|
|
|
|
function vec_lvsl
|
|
(A : c_long;
|
|
B : constv_long_ptr) return vector_unsigned_char;
|
|
|
|
function vec_lvsl
|
|
(A : c_long;
|
|
B : constv_float_ptr) return vector_unsigned_char;
|
|
|
|
--------------
|
|
-- vec_lvsr --
|
|
--------------
|
|
|
|
function vec_lvsr
|
|
(A : c_long;
|
|
B : constv_unsigned_char_ptr) return vector_unsigned_char;
|
|
|
|
function vec_lvsr
|
|
(A : c_long;
|
|
B : constv_signed_char_ptr) return vector_unsigned_char;
|
|
|
|
function vec_lvsr
|
|
(A : c_long;
|
|
B : constv_unsigned_short_ptr) return vector_unsigned_char;
|
|
|
|
function vec_lvsr
|
|
(A : c_long;
|
|
B : constv_short_ptr) return vector_unsigned_char;
|
|
|
|
function vec_lvsr
|
|
(A : c_long;
|
|
B : constv_unsigned_int_ptr) return vector_unsigned_char;
|
|
|
|
function vec_lvsr
|
|
(A : c_long;
|
|
B : constv_int_ptr) return vector_unsigned_char;
|
|
|
|
function vec_lvsr
|
|
(A : c_long;
|
|
B : constv_unsigned_long_ptr) return vector_unsigned_char;
|
|
|
|
function vec_lvsr
|
|
(A : c_long;
|
|
B : constv_long_ptr) return vector_unsigned_char;
|
|
|
|
function vec_lvsr
|
|
(A : c_long;
|
|
B : constv_float_ptr) return vector_unsigned_char;
|
|
|
|
--------------
|
|
-- vec_madd --
|
|
--------------
|
|
|
|
function vec_madd
|
|
(A : vector_float;
|
|
B : vector_float;
|
|
C : vector_float) return vector_float;
|
|
|
|
---------------
|
|
-- vec_madds --
|
|
---------------
|
|
|
|
function vec_madds
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short;
|
|
C : vector_signed_short) return vector_signed_short;
|
|
|
|
-------------
|
|
-- vec_max --
|
|
-------------
|
|
|
|
function vec_max
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_max
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return vector_unsigned_char;
|
|
|
|
function vec_max
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_max
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_max
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return vector_signed_char;
|
|
|
|
function vec_max
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_max
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_max
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return vector_unsigned_short;
|
|
|
|
function vec_max
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_max
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_max
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return vector_signed_short;
|
|
|
|
function vec_max
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_max
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_max
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return vector_unsigned_int;
|
|
|
|
function vec_max
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_max
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_max
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return vector_signed_int;
|
|
|
|
function vec_max
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_max
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float;
|
|
|
|
----------------
|
|
-- vec_vmaxfp --
|
|
----------------
|
|
|
|
function vec_vmaxfp
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float;
|
|
|
|
----------------
|
|
-- vec_vmaxsw --
|
|
----------------
|
|
|
|
function vec_vmaxsw
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_vmaxsw
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return vector_signed_int;
|
|
|
|
function vec_vmaxsw
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
----------------
|
|
-- vec_vmaxuw --
|
|
----------------
|
|
|
|
function vec_vmaxuw
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_vmaxuw
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return vector_unsigned_int;
|
|
|
|
function vec_vmaxuw
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
----------------
|
|
-- vec_vmaxsh --
|
|
----------------
|
|
|
|
function vec_vmaxsh
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_vmaxsh
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return vector_signed_short;
|
|
|
|
function vec_vmaxsh
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
----------------
|
|
-- vec_vmaxuh --
|
|
----------------
|
|
|
|
function vec_vmaxuh
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_vmaxuh
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return vector_unsigned_short;
|
|
|
|
function vec_vmaxuh
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
----------------
|
|
-- vec_vmaxsb --
|
|
----------------
|
|
|
|
function vec_vmaxsb
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_vmaxsb
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return vector_signed_char;
|
|
|
|
function vec_vmaxsb
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
----------------
|
|
-- vec_vmaxub --
|
|
----------------
|
|
|
|
function vec_vmaxub
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_vmaxub
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return vector_unsigned_char;
|
|
|
|
function vec_vmaxub
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
----------------
|
|
-- vec_mergeh --
|
|
----------------
|
|
|
|
function vec_mergeh
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char) return vector_bool_char;
|
|
|
|
function vec_mergeh
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_mergeh
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_mergeh
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short) return vector_bool_short;
|
|
|
|
function vec_mergeh
|
|
(A : vector_pixel;
|
|
B : vector_pixel) return vector_pixel;
|
|
|
|
function vec_mergeh
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_mergeh
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_mergeh
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float;
|
|
|
|
function vec_mergeh
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int) return vector_bool_int;
|
|
|
|
function vec_mergeh
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_mergeh
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
----------------
|
|
-- vec_vmrghw --
|
|
----------------
|
|
|
|
function vec_vmrghw
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float;
|
|
|
|
function vec_vmrghw
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int) return vector_bool_int;
|
|
|
|
function vec_vmrghw
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_vmrghw
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
----------------
|
|
-- vec_vmrghh --
|
|
----------------
|
|
|
|
function vec_vmrghh
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short) return vector_bool_short;
|
|
|
|
function vec_vmrghh
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_vmrghh
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_vmrghh
|
|
(A : vector_pixel;
|
|
B : vector_pixel) return vector_pixel;
|
|
|
|
----------------
|
|
-- vec_vmrghb --
|
|
----------------
|
|
|
|
function vec_vmrghb
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char) return vector_bool_char;
|
|
|
|
function vec_vmrghb
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_vmrghb
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
----------------
|
|
-- vec_mergel --
|
|
----------------
|
|
|
|
function vec_mergel
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char) return vector_bool_char;
|
|
|
|
function vec_mergel
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_mergel
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_mergel
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short) return vector_bool_short;
|
|
|
|
function vec_mergel
|
|
(A : vector_pixel;
|
|
B : vector_pixel) return vector_pixel;
|
|
|
|
function vec_mergel
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_mergel
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_mergel
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float;
|
|
|
|
function vec_mergel
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int) return vector_bool_int;
|
|
|
|
function vec_mergel
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_mergel
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
----------------
|
|
-- vec_vmrglw --
|
|
----------------
|
|
|
|
function vec_vmrglw
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float;
|
|
|
|
function vec_vmrglw
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_vmrglw
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_vmrglw
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int) return vector_bool_int;
|
|
|
|
----------------
|
|
-- vec_vmrglh --
|
|
----------------
|
|
|
|
function vec_vmrglh
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short) return vector_bool_short;
|
|
|
|
function vec_vmrglh
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_vmrglh
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_vmrglh
|
|
(A : vector_pixel;
|
|
B : vector_pixel) return vector_pixel;
|
|
|
|
----------------
|
|
-- vec_vmrglb --
|
|
----------------
|
|
|
|
function vec_vmrglb
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char) return vector_bool_char;
|
|
|
|
function vec_vmrglb
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_vmrglb
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
----------------
|
|
-- vec_mfvscr --
|
|
----------------
|
|
|
|
function vec_mfvscr return vector_unsigned_short;
|
|
|
|
-------------
|
|
-- vec_min --
|
|
-------------
|
|
|
|
function vec_min
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_min
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return vector_unsigned_char;
|
|
|
|
function vec_min
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_min
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_min
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return vector_signed_char;
|
|
|
|
function vec_min
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_min
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_min
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return vector_unsigned_short;
|
|
|
|
function vec_min
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_min
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_min
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return vector_signed_short;
|
|
|
|
function vec_min
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_min
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_min
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return vector_unsigned_int;
|
|
|
|
function vec_min
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_min
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_min
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return vector_signed_int;
|
|
|
|
function vec_min
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_min
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float;
|
|
|
|
----------------
|
|
-- vec_vminfp --
|
|
----------------
|
|
|
|
function vec_vminfp
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float;
|
|
|
|
----------------
|
|
-- vec_vminsw --
|
|
----------------
|
|
|
|
function vec_vminsw
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_vminsw
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return vector_signed_int;
|
|
|
|
function vec_vminsw
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
----------------
|
|
-- vec_vminuw --
|
|
----------------
|
|
|
|
function vec_vminuw
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_vminuw
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return vector_unsigned_int;
|
|
|
|
function vec_vminuw
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
----------------
|
|
-- vec_vminsh --
|
|
----------------
|
|
|
|
function vec_vminsh
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_vminsh
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return vector_signed_short;
|
|
|
|
function vec_vminsh
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
----------------
|
|
-- vec_vminuh --
|
|
----------------
|
|
|
|
function vec_vminuh
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_vminuh
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return vector_unsigned_short;
|
|
|
|
function vec_vminuh
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
----------------
|
|
-- vec_vminsb --
|
|
----------------
|
|
|
|
function vec_vminsb
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_vminsb
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return vector_signed_char;
|
|
|
|
function vec_vminsb
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
----------------
|
|
-- vec_vminub --
|
|
----------------
|
|
|
|
function vec_vminub
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_vminub
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return vector_unsigned_char;
|
|
|
|
function vec_vminub
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
---------------
|
|
-- vec_mladd --
|
|
---------------
|
|
|
|
function vec_mladd
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short;
|
|
C : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_mladd
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_short;
|
|
C : vector_unsigned_short) return vector_signed_short;
|
|
|
|
function vec_mladd
|
|
(A : vector_unsigned_short;
|
|
B : vector_signed_short;
|
|
C : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_mladd
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short;
|
|
C : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
----------------
|
|
-- vec_mradds --
|
|
----------------
|
|
|
|
function vec_mradds
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short;
|
|
C : vector_signed_short) return vector_signed_short;
|
|
|
|
--------------
|
|
-- vec_msum --
|
|
--------------
|
|
|
|
function vec_msum
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char;
|
|
C : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_msum
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_char;
|
|
C : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_msum
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short;
|
|
C : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_msum
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short;
|
|
C : vector_signed_int) return vector_signed_int;
|
|
|
|
------------------
|
|
-- vec_vmsumshm --
|
|
------------------
|
|
|
|
function vec_vmsumshm
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short;
|
|
C : vector_signed_int) return vector_signed_int;
|
|
|
|
------------------
|
|
-- vec_vmsumuhm --
|
|
------------------
|
|
|
|
function vec_vmsumuhm
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short;
|
|
C : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
------------------
|
|
-- vec_vmsummbm --
|
|
------------------
|
|
|
|
function vec_vmsummbm
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_char;
|
|
C : vector_signed_int) return vector_signed_int;
|
|
|
|
------------------
|
|
-- vec_vmsumubm --
|
|
------------------
|
|
|
|
function vec_vmsumubm
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char;
|
|
C : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
---------------
|
|
-- vec_msums --
|
|
---------------
|
|
|
|
function vec_msums
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short;
|
|
C : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_msums
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short;
|
|
C : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_vmsumshs
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short;
|
|
C : vector_signed_int) return vector_signed_int;
|
|
|
|
------------------
|
|
-- vec_vmsumuhs --
|
|
------------------
|
|
|
|
function vec_vmsumuhs
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short;
|
|
C : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
----------------
|
|
-- vec_mtvscr --
|
|
----------------
|
|
|
|
procedure vec_mtvscr
|
|
(A : vector_signed_int);
|
|
|
|
procedure vec_mtvscr
|
|
(A : vector_unsigned_int);
|
|
|
|
procedure vec_mtvscr
|
|
(A : vector_bool_int);
|
|
|
|
procedure vec_mtvscr
|
|
(A : vector_signed_short);
|
|
|
|
procedure vec_mtvscr
|
|
(A : vector_unsigned_short);
|
|
|
|
procedure vec_mtvscr
|
|
(A : vector_bool_short);
|
|
|
|
procedure vec_mtvscr
|
|
(A : vector_pixel);
|
|
|
|
procedure vec_mtvscr
|
|
(A : vector_signed_char);
|
|
|
|
procedure vec_mtvscr
|
|
(A : vector_unsigned_char);
|
|
|
|
procedure vec_mtvscr
|
|
(A : vector_bool_char);
|
|
|
|
--------------
|
|
-- vec_mule --
|
|
--------------
|
|
|
|
function vec_mule
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_short;
|
|
|
|
function vec_mule
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_short;
|
|
|
|
function vec_mule
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_int;
|
|
|
|
function vec_mule
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_int;
|
|
|
|
-----------------
|
|
-- vec_vmulesh --
|
|
-----------------
|
|
|
|
function vec_vmulesh
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_int;
|
|
|
|
-----------------
|
|
-- vec_vmuleuh --
|
|
-----------------
|
|
|
|
function vec_vmuleuh
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_int;
|
|
|
|
-----------------
|
|
-- vec_vmulesb --
|
|
-----------------
|
|
|
|
function vec_vmulesb
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_short;
|
|
|
|
-----------------
|
|
-- vec_vmuleub --
|
|
-----------------
|
|
|
|
function vec_vmuleub
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_short;
|
|
|
|
--------------
|
|
-- vec_mulo --
|
|
--------------
|
|
|
|
function vec_mulo
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_short;
|
|
|
|
function vec_mulo
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_short;
|
|
|
|
function vec_mulo
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_int;
|
|
|
|
function vec_mulo
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_int;
|
|
|
|
-----------------
|
|
-- vec_vmulosh --
|
|
-----------------
|
|
|
|
function vec_vmulosh
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_int;
|
|
|
|
-----------------
|
|
-- vec_vmulouh --
|
|
-----------------
|
|
|
|
function vec_vmulouh
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_int;
|
|
|
|
-----------------
|
|
-- vec_vmulosb --
|
|
-----------------
|
|
|
|
function vec_vmulosb
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_short;
|
|
|
|
-----------------
|
|
-- vec_vmuloub --
|
|
-----------------
|
|
|
|
function vec_vmuloub
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_short;
|
|
|
|
---------------
|
|
-- vec_nmsub --
|
|
---------------
|
|
|
|
function vec_nmsub
|
|
(A : vector_float;
|
|
B : vector_float;
|
|
C : vector_float) return vector_float;
|
|
|
|
-------------
|
|
-- vec_nor --
|
|
-------------
|
|
|
|
function vec_nor
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float;
|
|
|
|
function vec_nor
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_nor
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_nor
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int) return vector_bool_int;
|
|
|
|
function vec_nor
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_nor
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_nor
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short) return vector_bool_short;
|
|
|
|
function vec_nor
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_nor
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_nor
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char) return vector_bool_char;
|
|
|
|
------------
|
|
-- vec_or --
|
|
------------
|
|
|
|
function vec_or
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float;
|
|
|
|
function vec_or
|
|
(A : vector_float;
|
|
B : vector_bool_int) return vector_float;
|
|
|
|
function vec_or
|
|
(A : vector_bool_int;
|
|
B : vector_float) return vector_float;
|
|
|
|
function vec_or
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int) return vector_bool_int;
|
|
|
|
function vec_or
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_or
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return vector_signed_int;
|
|
|
|
function vec_or
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_or
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_or
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return vector_unsigned_int;
|
|
|
|
function vec_or
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_or
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short) return vector_bool_short;
|
|
|
|
function vec_or
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_or
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return vector_signed_short;
|
|
|
|
function vec_or
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_or
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_or
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return vector_unsigned_short;
|
|
|
|
function vec_or
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_or
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_or
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char) return vector_bool_char;
|
|
|
|
function vec_or
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return vector_signed_char;
|
|
|
|
function vec_or
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_or
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_or
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return vector_unsigned_char;
|
|
|
|
function vec_or
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
--------------
|
|
-- vec_pack --
|
|
--------------
|
|
|
|
function vec_pack
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_char;
|
|
|
|
function vec_pack
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_char;
|
|
|
|
function vec_pack
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short) return vector_bool_char;
|
|
|
|
function vec_pack
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_short;
|
|
|
|
function vec_pack
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_short;
|
|
|
|
function vec_pack
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int) return vector_bool_short;
|
|
|
|
-----------------
|
|
-- vec_vpkuwum --
|
|
-----------------
|
|
|
|
function vec_vpkuwum
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int) return vector_bool_short;
|
|
|
|
function vec_vpkuwum
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_short;
|
|
|
|
function vec_vpkuwum
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_short;
|
|
|
|
-----------------
|
|
-- vec_vpkuhum --
|
|
-----------------
|
|
|
|
function vec_vpkuhum
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short) return vector_bool_char;
|
|
|
|
function vec_vpkuhum
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_char;
|
|
|
|
function vec_vpkuhum
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_char;
|
|
|
|
----------------
|
|
-- vec_packpx --
|
|
----------------
|
|
|
|
function vec_packpx
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_pixel;
|
|
|
|
---------------
|
|
-- vec_packs --
|
|
---------------
|
|
|
|
function vec_packs
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_char;
|
|
|
|
function vec_packs
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_char;
|
|
|
|
function vec_packs
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_short;
|
|
|
|
function vec_packs
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_short;
|
|
|
|
-----------------
|
|
-- vec_vpkswss --
|
|
-----------------
|
|
|
|
function vec_vpkswss
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_short;
|
|
|
|
-----------------
|
|
-- vec_vpkuwus --
|
|
-----------------
|
|
|
|
function vec_vpkuwus
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_short;
|
|
|
|
-----------------
|
|
-- vec_vpkshss --
|
|
-----------------
|
|
|
|
function vec_vpkshss
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_char;
|
|
|
|
-----------------
|
|
-- vec_vpkuhus --
|
|
-----------------
|
|
|
|
function vec_vpkuhus
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_char;
|
|
|
|
----------------
|
|
-- vec_packsu --
|
|
----------------
|
|
|
|
function vec_packsu
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_char;
|
|
|
|
function vec_packsu
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_unsigned_char;
|
|
|
|
function vec_packsu
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_short;
|
|
|
|
function vec_packsu
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_unsigned_short;
|
|
|
|
-----------------
|
|
-- vec_vpkswus --
|
|
-----------------
|
|
|
|
function vec_vpkswus
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_unsigned_short;
|
|
|
|
-----------------
|
|
-- vec_vpkshus --
|
|
-----------------
|
|
|
|
function vec_vpkshus
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_unsigned_char;
|
|
|
|
--------------
|
|
-- vec_perm --
|
|
--------------
|
|
|
|
function vec_perm
|
|
(A : vector_float;
|
|
B : vector_float;
|
|
C : vector_unsigned_char) return vector_float;
|
|
|
|
function vec_perm
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int;
|
|
C : vector_unsigned_char) return vector_signed_int;
|
|
|
|
function vec_perm
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int;
|
|
C : vector_unsigned_char) return vector_unsigned_int;
|
|
|
|
function vec_perm
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int;
|
|
C : vector_unsigned_char) return vector_bool_int;
|
|
|
|
function vec_perm
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short;
|
|
C : vector_unsigned_char) return vector_signed_short;
|
|
|
|
function vec_perm
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short;
|
|
C : vector_unsigned_char) return vector_unsigned_short;
|
|
|
|
function vec_perm
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short;
|
|
C : vector_unsigned_char) return vector_bool_short;
|
|
|
|
function vec_perm
|
|
(A : vector_pixel;
|
|
B : vector_pixel;
|
|
C : vector_unsigned_char) return vector_pixel;
|
|
|
|
function vec_perm
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char;
|
|
C : vector_unsigned_char) return vector_signed_char;
|
|
|
|
function vec_perm
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char;
|
|
C : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_perm
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char;
|
|
C : vector_unsigned_char) return vector_bool_char;
|
|
|
|
------------
|
|
-- vec_re --
|
|
------------
|
|
|
|
function vec_re
|
|
(A : vector_float) return vector_float;
|
|
|
|
------------
|
|
-- vec_rl --
|
|
------------
|
|
|
|
function vec_rl
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_char) return vector_signed_char;
|
|
|
|
function vec_rl
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_rl
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_short) return vector_signed_short;
|
|
|
|
function vec_rl
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_rl
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_int) return vector_signed_int;
|
|
|
|
function vec_rl
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
--------------
|
|
-- vec_vrlw --
|
|
--------------
|
|
|
|
function vec_vrlw
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_int) return vector_signed_int;
|
|
|
|
function vec_vrlw
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
--------------
|
|
-- vec_vrlh --
|
|
--------------
|
|
|
|
function vec_vrlh
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_short) return vector_signed_short;
|
|
|
|
function vec_vrlh
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
--------------
|
|
-- vec_vrlb --
|
|
--------------
|
|
|
|
function vec_vrlb
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_char) return vector_signed_char;
|
|
|
|
function vec_vrlb
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
---------------
|
|
-- vec_round --
|
|
---------------
|
|
|
|
function vec_round
|
|
(A : vector_float) return vector_float;
|
|
|
|
----------------
|
|
-- vec_rsqrte --
|
|
----------------
|
|
|
|
function vec_rsqrte
|
|
(A : vector_float) return vector_float;
|
|
|
|
-------------
|
|
-- vec_sel --
|
|
-------------
|
|
|
|
function vec_sel
|
|
(A : vector_float;
|
|
B : vector_float;
|
|
C : vector_bool_int) return vector_float;
|
|
|
|
function vec_sel
|
|
(A : vector_float;
|
|
B : vector_float;
|
|
C : vector_unsigned_int) return vector_float;
|
|
|
|
function vec_sel
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int;
|
|
C : vector_bool_int) return vector_signed_int;
|
|
|
|
function vec_sel
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int;
|
|
C : vector_unsigned_int) return vector_signed_int;
|
|
|
|
function vec_sel
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int;
|
|
C : vector_bool_int) return vector_unsigned_int;
|
|
|
|
function vec_sel
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int;
|
|
C : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_sel
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int;
|
|
C : vector_bool_int) return vector_bool_int;
|
|
|
|
function vec_sel
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int;
|
|
C : vector_unsigned_int) return vector_bool_int;
|
|
|
|
function vec_sel
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short;
|
|
C : vector_bool_short) return vector_signed_short;
|
|
|
|
function vec_sel
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short;
|
|
C : vector_unsigned_short) return vector_signed_short;
|
|
|
|
function vec_sel
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short;
|
|
C : vector_bool_short) return vector_unsigned_short;
|
|
|
|
function vec_sel
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short;
|
|
C : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_sel
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short;
|
|
C : vector_bool_short) return vector_bool_short;
|
|
|
|
function vec_sel
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short;
|
|
C : vector_unsigned_short) return vector_bool_short;
|
|
|
|
function vec_sel
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char;
|
|
C : vector_bool_char) return vector_signed_char;
|
|
|
|
function vec_sel
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char;
|
|
C : vector_unsigned_char) return vector_signed_char;
|
|
|
|
function vec_sel
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char;
|
|
C : vector_bool_char) return vector_unsigned_char;
|
|
|
|
function vec_sel
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char;
|
|
C : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_sel
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char;
|
|
C : vector_bool_char) return vector_bool_char;
|
|
|
|
function vec_sel
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char;
|
|
C : vector_unsigned_char) return vector_bool_char;
|
|
|
|
------------
|
|
-- vec_sl --
|
|
------------
|
|
|
|
function vec_sl
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_char) return vector_signed_char;
|
|
|
|
function vec_sl
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_sl
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_short) return vector_signed_short;
|
|
|
|
function vec_sl
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_sl
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_int) return vector_signed_int;
|
|
|
|
function vec_sl
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
--------------
|
|
-- vec_vslw --
|
|
--------------
|
|
|
|
function vec_vslw
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_int) return vector_signed_int;
|
|
|
|
function vec_vslw
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
--------------
|
|
-- vec_vslh --
|
|
--------------
|
|
|
|
function vec_vslh
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_short) return vector_signed_short;
|
|
|
|
function vec_vslh
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
--------------
|
|
-- vec_vslb --
|
|
--------------
|
|
|
|
function vec_vslb
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_char) return vector_signed_char;
|
|
|
|
function vec_vslb
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
-------------
|
|
-- vec_sld --
|
|
-------------
|
|
|
|
function vec_sld
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int;
|
|
C : c_int) return vector_unsigned_int;
|
|
|
|
function vec_sld
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int;
|
|
C : c_int) return vector_bool_int;
|
|
|
|
function vec_sld
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short;
|
|
C : c_int) return vector_unsigned_short;
|
|
|
|
function vec_sld
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short;
|
|
C : c_int) return vector_bool_short;
|
|
|
|
function vec_sld
|
|
(A : vector_pixel;
|
|
B : vector_pixel;
|
|
C : c_int) return vector_pixel;
|
|
|
|
function vec_sld
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char;
|
|
C : c_int) return vector_unsigned_char;
|
|
|
|
function vec_sld
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char;
|
|
C : c_int) return vector_bool_char;
|
|
pragma Inline_Always (vec_sld);
|
|
pragma Convention (Intrinsic, vec_sld);
|
|
|
|
function vec_sld
|
|
(A : vector_float;
|
|
B : vector_float;
|
|
C : c_int) return vector_float
|
|
renames Low_Level_Vectors.vsldoi_4sf;
|
|
|
|
function vec_sld
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int;
|
|
C : c_int) return vector_signed_int
|
|
renames Low_Level_Vectors.vsldoi_4si;
|
|
|
|
function vec_sld
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short;
|
|
C : c_int) return vector_signed_short
|
|
renames Low_Level_Vectors.vsldoi_8hi;
|
|
|
|
function vec_sld
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char;
|
|
C : c_int) return vector_signed_char
|
|
renames Low_Level_Vectors.vsldoi_16qi;
|
|
|
|
-------------
|
|
-- vec_sll --
|
|
-------------
|
|
|
|
function vec_sll
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_int) return vector_signed_int;
|
|
|
|
function vec_sll
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_short) return vector_signed_int;
|
|
|
|
function vec_sll
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_char) return vector_signed_int;
|
|
|
|
function vec_sll
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_sll
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_short) return vector_unsigned_int;
|
|
|
|
function vec_sll
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_char) return vector_unsigned_int;
|
|
|
|
function vec_sll
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_bool_int;
|
|
|
|
function vec_sll
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_short) return vector_bool_int;
|
|
|
|
function vec_sll
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_char) return vector_bool_int;
|
|
|
|
function vec_sll
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_int) return vector_signed_short;
|
|
|
|
function vec_sll
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_short) return vector_signed_short;
|
|
|
|
function vec_sll
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_char) return vector_signed_short;
|
|
|
|
function vec_sll
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_int) return vector_unsigned_short;
|
|
|
|
function vec_sll
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_sll
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_char) return vector_unsigned_short;
|
|
|
|
function vec_sll
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_int) return vector_bool_short;
|
|
|
|
function vec_sll
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_bool_short;
|
|
|
|
function vec_sll
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_char) return vector_bool_short;
|
|
|
|
function vec_sll
|
|
(A : vector_pixel;
|
|
B : vector_unsigned_int) return vector_pixel;
|
|
|
|
function vec_sll
|
|
(A : vector_pixel;
|
|
B : vector_unsigned_short) return vector_pixel;
|
|
|
|
function vec_sll
|
|
(A : vector_pixel;
|
|
B : vector_unsigned_char) return vector_pixel;
|
|
|
|
function vec_sll
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_int) return vector_signed_char;
|
|
|
|
function vec_sll
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_short) return vector_signed_char;
|
|
|
|
function vec_sll
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_char) return vector_signed_char;
|
|
|
|
function vec_sll
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_int) return vector_unsigned_char;
|
|
|
|
function vec_sll
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_short) return vector_unsigned_char;
|
|
|
|
function vec_sll
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_sll
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_int) return vector_bool_char;
|
|
|
|
function vec_sll
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_short) return vector_bool_char;
|
|
|
|
function vec_sll
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_bool_char;
|
|
|
|
-------------
|
|
-- vec_slo --
|
|
-------------
|
|
|
|
function vec_slo
|
|
(A : vector_float;
|
|
B : vector_signed_char) return vector_float;
|
|
|
|
function vec_slo
|
|
(A : vector_float;
|
|
B : vector_unsigned_char) return vector_float;
|
|
|
|
function vec_slo
|
|
(A : vector_signed_int;
|
|
B : vector_signed_char) return vector_signed_int;
|
|
|
|
function vec_slo
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_char) return vector_signed_int;
|
|
|
|
function vec_slo
|
|
(A : vector_unsigned_int;
|
|
B : vector_signed_char) return vector_unsigned_int;
|
|
|
|
function vec_slo
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_char) return vector_unsigned_int;
|
|
|
|
function vec_slo
|
|
(A : vector_signed_short;
|
|
B : vector_signed_char) return vector_signed_short;
|
|
|
|
function vec_slo
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_char) return vector_signed_short;
|
|
|
|
function vec_slo
|
|
(A : vector_unsigned_short;
|
|
B : vector_signed_char) return vector_unsigned_short;
|
|
|
|
function vec_slo
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_char) return vector_unsigned_short;
|
|
|
|
function vec_slo
|
|
(A : vector_pixel;
|
|
B : vector_signed_char) return vector_pixel;
|
|
|
|
function vec_slo
|
|
(A : vector_pixel;
|
|
B : vector_unsigned_char) return vector_pixel;
|
|
|
|
function vec_slo
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_slo
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_char) return vector_signed_char;
|
|
|
|
function vec_slo
|
|
(A : vector_unsigned_char;
|
|
B : vector_signed_char) return vector_unsigned_char;
|
|
|
|
function vec_slo
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
----------------
|
|
-- vec_vspltw --
|
|
----------------
|
|
|
|
function vec_vspltw
|
|
(A : vector_float;
|
|
B : c_int) return vector_float;
|
|
|
|
function vec_vspltw
|
|
(A : vector_unsigned_int;
|
|
B : c_int) return vector_unsigned_int;
|
|
|
|
function vec_vspltw
|
|
(A : vector_bool_int;
|
|
B : c_int) return vector_bool_int;
|
|
pragma Inline_Always (vec_vspltw);
|
|
pragma Convention (Intrinsic, vec_vspltw);
|
|
|
|
function vec_vspltw
|
|
(A : vector_signed_int;
|
|
B : c_int) return vector_signed_int
|
|
renames Low_Level_Vectors.vspltw;
|
|
|
|
----------------
|
|
-- vec_vsplth --
|
|
----------------
|
|
|
|
function vec_vsplth
|
|
(A : vector_bool_short;
|
|
B : c_int) return vector_bool_short;
|
|
|
|
function vec_vsplth
|
|
(A : vector_unsigned_short;
|
|
B : c_int) return vector_unsigned_short;
|
|
|
|
function vec_vsplth
|
|
(A : vector_pixel;
|
|
B : c_int) return vector_pixel;
|
|
pragma Inline_Always (vec_vsplth);
|
|
pragma Convention (Intrinsic, vec_vsplth);
|
|
|
|
function vec_vsplth
|
|
(A : vector_signed_short;
|
|
B : c_int) return vector_signed_short
|
|
renames Low_Level_Vectors.vsplth;
|
|
|
|
----------------
|
|
-- vec_vspltb --
|
|
----------------
|
|
|
|
function vec_vspltb
|
|
(A : vector_unsigned_char;
|
|
B : c_int) return vector_unsigned_char;
|
|
|
|
function vec_vspltb
|
|
(A : vector_bool_char;
|
|
B : c_int) return vector_bool_char;
|
|
pragma Inline_Always (vec_vspltb);
|
|
pragma Convention (Intrinsic, vec_vspltb);
|
|
|
|
function vec_vspltb
|
|
(A : vector_signed_char;
|
|
B : c_int) return vector_signed_char
|
|
renames Low_Level_Vectors.vspltb;
|
|
|
|
------------------
|
|
-- vec_vspltisb --
|
|
------------------
|
|
|
|
function vec_vspltisb
|
|
(A : c_int) return vector_signed_char
|
|
renames Low_Level_Vectors.vspltisb;
|
|
|
|
------------------
|
|
-- vec_vspltish --
|
|
------------------
|
|
|
|
function vec_vspltish
|
|
(A : c_int) return vector_signed_short
|
|
renames Low_Level_Vectors.vspltish;
|
|
|
|
------------------
|
|
-- vec_vspltisw --
|
|
------------------
|
|
|
|
function vec_vspltisw
|
|
(A : c_int) return vector_signed_int
|
|
renames Low_Level_Vectors.vspltisw;
|
|
|
|
------------
|
|
-- vec_sr --
|
|
------------
|
|
|
|
function vec_sr
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_char) return vector_signed_char;
|
|
|
|
function vec_sr
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_sr
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_short) return vector_signed_short;
|
|
|
|
function vec_sr
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_sr
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_int) return vector_signed_int;
|
|
|
|
function vec_sr
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
--------------
|
|
-- vec_vsrw --
|
|
--------------
|
|
|
|
function vec_vsrw
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_int) return vector_signed_int;
|
|
|
|
function vec_vsrw
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
--------------
|
|
-- vec_vsrh --
|
|
--------------
|
|
|
|
function vec_vsrh
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_short) return vector_signed_short;
|
|
|
|
function vec_vsrh
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
--------------
|
|
-- vec_vsrb --
|
|
--------------
|
|
|
|
function vec_vsrb
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_char) return vector_signed_char;
|
|
|
|
function vec_vsrb
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
-------------
|
|
-- vec_sra --
|
|
-------------
|
|
|
|
function vec_sra
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_char) return vector_signed_char;
|
|
|
|
function vec_sra
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_sra
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_short) return vector_signed_short;
|
|
|
|
function vec_sra
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_sra
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_int) return vector_signed_int;
|
|
|
|
function vec_sra
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
---------------
|
|
-- vec_vsraw --
|
|
---------------
|
|
|
|
function vec_vsraw
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_int) return vector_signed_int;
|
|
|
|
function vec_vsraw
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_vsrah
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_short) return vector_signed_short;
|
|
|
|
function vec_vsrah
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_vsrab
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_char) return vector_signed_char;
|
|
|
|
function vec_vsrab
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
-------------
|
|
-- vec_srl --
|
|
-------------
|
|
|
|
function vec_srl
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_int) return vector_signed_int;
|
|
|
|
function vec_srl
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_short) return vector_signed_int;
|
|
|
|
function vec_srl
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_char) return vector_signed_int;
|
|
|
|
function vec_srl
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_srl
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_short) return vector_unsigned_int;
|
|
|
|
function vec_srl
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_char) return vector_unsigned_int;
|
|
|
|
function vec_srl
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_bool_int;
|
|
|
|
function vec_srl
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_short) return vector_bool_int;
|
|
|
|
function vec_srl
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_char) return vector_bool_int;
|
|
|
|
function vec_srl
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_int) return vector_signed_short;
|
|
|
|
function vec_srl
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_short) return vector_signed_short;
|
|
|
|
function vec_srl
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_char) return vector_signed_short;
|
|
|
|
function vec_srl
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_int) return vector_unsigned_short;
|
|
|
|
function vec_srl
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_srl
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_char) return vector_unsigned_short;
|
|
|
|
function vec_srl
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_int) return vector_bool_short;
|
|
|
|
function vec_srl
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_bool_short;
|
|
|
|
function vec_srl
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_char) return vector_bool_short;
|
|
|
|
function vec_srl
|
|
(A : vector_pixel;
|
|
B : vector_unsigned_int) return vector_pixel;
|
|
|
|
function vec_srl
|
|
(A : vector_pixel;
|
|
B : vector_unsigned_short) return vector_pixel;
|
|
|
|
function vec_srl
|
|
(A : vector_pixel;
|
|
B : vector_unsigned_char) return vector_pixel;
|
|
|
|
function vec_srl
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_int) return vector_signed_char;
|
|
|
|
function vec_srl
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_short) return vector_signed_char;
|
|
|
|
function vec_srl
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_char) return vector_signed_char;
|
|
|
|
function vec_srl
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_int) return vector_unsigned_char;
|
|
|
|
function vec_srl
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_short) return vector_unsigned_char;
|
|
|
|
function vec_srl
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_srl
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_int) return vector_bool_char;
|
|
|
|
function vec_srl
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_short) return vector_bool_char;
|
|
|
|
function vec_srl
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_bool_char;
|
|
|
|
function vec_sro
|
|
(A : vector_float;
|
|
B : vector_signed_char) return vector_float;
|
|
|
|
function vec_sro
|
|
(A : vector_float;
|
|
B : vector_unsigned_char) return vector_float;
|
|
|
|
function vec_sro
|
|
(A : vector_signed_int;
|
|
B : vector_signed_char) return vector_signed_int;
|
|
|
|
function vec_sro
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_char) return vector_signed_int;
|
|
|
|
function vec_sro
|
|
(A : vector_unsigned_int;
|
|
B : vector_signed_char) return vector_unsigned_int;
|
|
|
|
function vec_sro
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_char) return vector_unsigned_int;
|
|
|
|
function vec_sro
|
|
(A : vector_signed_short;
|
|
B : vector_signed_char) return vector_signed_short;
|
|
|
|
function vec_sro
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_char) return vector_signed_short;
|
|
|
|
function vec_sro
|
|
(A : vector_unsigned_short;
|
|
B : vector_signed_char) return vector_unsigned_short;
|
|
|
|
function vec_sro
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_char) return vector_unsigned_short;
|
|
|
|
function vec_sro
|
|
(A : vector_pixel;
|
|
B : vector_signed_char) return vector_pixel;
|
|
|
|
function vec_sro
|
|
(A : vector_pixel;
|
|
B : vector_unsigned_char) return vector_pixel;
|
|
|
|
function vec_sro
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_sro
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_char) return vector_signed_char;
|
|
|
|
function vec_sro
|
|
(A : vector_unsigned_char;
|
|
B : vector_signed_char) return vector_unsigned_char;
|
|
|
|
function vec_sro
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
procedure vec_st
|
|
(A : vector_float;
|
|
B : c_int;
|
|
C : vector_float_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_float;
|
|
B : c_int;
|
|
C : float_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_signed_int;
|
|
B : c_int;
|
|
C : vector_signed_int_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_signed_int;
|
|
B : c_int;
|
|
C : int_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_unsigned_int;
|
|
B : c_int;
|
|
C : vector_unsigned_int_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_unsigned_int;
|
|
B : c_int;
|
|
C : unsigned_int_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_bool_int;
|
|
B : c_int;
|
|
C : vector_bool_int_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_bool_int;
|
|
B : c_int;
|
|
C : unsigned_int_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_bool_int;
|
|
B : c_int;
|
|
C : int_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_signed_short;
|
|
B : c_int;
|
|
C : vector_signed_short_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_signed_short;
|
|
B : c_int;
|
|
C : short_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_unsigned_short;
|
|
B : c_int;
|
|
C : vector_unsigned_short_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_unsigned_short;
|
|
B : c_int;
|
|
C : unsigned_short_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_bool_short;
|
|
B : c_int;
|
|
C : vector_bool_short_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_bool_short;
|
|
B : c_int;
|
|
C : unsigned_short_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_pixel;
|
|
B : c_int;
|
|
C : vector_pixel_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_pixel;
|
|
B : c_int;
|
|
C : unsigned_short_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_pixel;
|
|
B : c_int;
|
|
C : short_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_bool_short;
|
|
B : c_int;
|
|
C : short_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_signed_char;
|
|
B : c_int;
|
|
C : vector_signed_char_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_signed_char;
|
|
B : c_int;
|
|
C : signed_char_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_unsigned_char;
|
|
B : c_int;
|
|
C : vector_unsigned_char_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_unsigned_char;
|
|
B : c_int;
|
|
C : unsigned_char_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_bool_char;
|
|
B : c_int;
|
|
C : vector_bool_char_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_bool_char;
|
|
B : c_int;
|
|
C : unsigned_char_ptr);
|
|
|
|
procedure vec_st
|
|
(A : vector_bool_char;
|
|
B : c_int;
|
|
C : signed_char_ptr);
|
|
|
|
-------------
|
|
-- vec_ste --
|
|
-------------
|
|
|
|
procedure vec_ste
|
|
(A : vector_signed_char;
|
|
B : c_int;
|
|
C : signed_char_ptr);
|
|
|
|
procedure vec_ste
|
|
(A : vector_unsigned_char;
|
|
B : c_int;
|
|
C : unsigned_char_ptr);
|
|
|
|
procedure vec_ste
|
|
(A : vector_bool_char;
|
|
B : c_int;
|
|
C : signed_char_ptr);
|
|
|
|
procedure vec_ste
|
|
(A : vector_bool_char;
|
|
B : c_int;
|
|
C : unsigned_char_ptr);
|
|
|
|
procedure vec_ste
|
|
(A : vector_signed_short;
|
|
B : c_int;
|
|
C : short_ptr);
|
|
|
|
procedure vec_ste
|
|
(A : vector_unsigned_short;
|
|
B : c_int;
|
|
C : unsigned_short_ptr);
|
|
|
|
procedure vec_ste
|
|
(A : vector_bool_short;
|
|
B : c_int;
|
|
C : short_ptr);
|
|
|
|
procedure vec_ste
|
|
(A : vector_bool_short;
|
|
B : c_int;
|
|
C : unsigned_short_ptr);
|
|
|
|
procedure vec_ste
|
|
(A : vector_pixel;
|
|
B : c_int;
|
|
C : short_ptr);
|
|
|
|
procedure vec_ste
|
|
(A : vector_pixel;
|
|
B : c_int;
|
|
C : unsigned_short_ptr);
|
|
|
|
procedure vec_ste
|
|
(A : vector_float;
|
|
B : c_int;
|
|
C : float_ptr);
|
|
|
|
procedure vec_ste
|
|
(A : vector_signed_int;
|
|
B : c_int;
|
|
C : int_ptr);
|
|
|
|
procedure vec_ste
|
|
(A : vector_unsigned_int;
|
|
B : c_int;
|
|
C : unsigned_int_ptr);
|
|
|
|
procedure vec_ste
|
|
(A : vector_bool_int;
|
|
B : c_int;
|
|
C : int_ptr);
|
|
|
|
procedure vec_ste
|
|
(A : vector_bool_int;
|
|
B : c_int;
|
|
C : unsigned_int_ptr);
|
|
|
|
----------------
|
|
-- vec_stvewx --
|
|
----------------
|
|
|
|
procedure vec_stvewx
|
|
(A : vector_float;
|
|
B : c_int;
|
|
C : float_ptr);
|
|
|
|
procedure vec_stvewx
|
|
(A : vector_signed_int;
|
|
B : c_int;
|
|
C : int_ptr);
|
|
|
|
procedure vec_stvewx
|
|
(A : vector_unsigned_int;
|
|
B : c_int;
|
|
C : unsigned_int_ptr);
|
|
|
|
procedure vec_stvewx
|
|
(A : vector_bool_int;
|
|
B : c_int;
|
|
C : int_ptr);
|
|
|
|
procedure vec_stvewx
|
|
(A : vector_bool_int;
|
|
B : c_int;
|
|
C : unsigned_int_ptr);
|
|
|
|
procedure vec_stvehx
|
|
(A : vector_signed_short;
|
|
B : c_int;
|
|
C : short_ptr);
|
|
|
|
procedure vec_stvehx
|
|
(A : vector_unsigned_short;
|
|
B : c_int;
|
|
C : unsigned_short_ptr);
|
|
|
|
procedure vec_stvehx
|
|
(A : vector_bool_short;
|
|
B : c_int;
|
|
C : short_ptr);
|
|
|
|
procedure vec_stvehx
|
|
(A : vector_bool_short;
|
|
B : c_int;
|
|
C : unsigned_short_ptr);
|
|
|
|
procedure vec_stvehx
|
|
(A : vector_pixel;
|
|
B : c_int;
|
|
C : short_ptr);
|
|
|
|
procedure vec_stvehx
|
|
(A : vector_pixel;
|
|
B : c_int;
|
|
C : unsigned_short_ptr);
|
|
|
|
procedure vec_stvebx
|
|
(A : vector_signed_char;
|
|
B : c_int;
|
|
C : signed_char_ptr);
|
|
|
|
procedure vec_stvebx
|
|
(A : vector_unsigned_char;
|
|
B : c_int;
|
|
C : unsigned_char_ptr);
|
|
|
|
procedure vec_stvebx
|
|
(A : vector_bool_char;
|
|
B : c_int;
|
|
C : signed_char_ptr);
|
|
|
|
procedure vec_stvebx
|
|
(A : vector_bool_char;
|
|
B : c_int;
|
|
C : unsigned_char_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_float;
|
|
B : c_int;
|
|
C : vector_float_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_float;
|
|
B : c_int;
|
|
C : float_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_signed_int;
|
|
B : c_int;
|
|
C : vector_signed_int_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_signed_int;
|
|
B : c_int;
|
|
C : int_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_unsigned_int;
|
|
B : c_int;
|
|
C : vector_unsigned_int_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_unsigned_int;
|
|
B : c_int;
|
|
C : unsigned_int_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_bool_int;
|
|
B : c_int;
|
|
C : vector_bool_int_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_bool_int;
|
|
B : c_int;
|
|
C : unsigned_int_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_bool_int;
|
|
B : c_int;
|
|
C : int_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_signed_short;
|
|
B : c_int;
|
|
C : vector_signed_short_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_signed_short;
|
|
B : c_int;
|
|
C : short_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_unsigned_short;
|
|
B : c_int;
|
|
C : vector_unsigned_short_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_unsigned_short;
|
|
B : c_int;
|
|
C : unsigned_short_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_bool_short;
|
|
B : c_int;
|
|
C : vector_bool_short_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_bool_short;
|
|
B : c_int;
|
|
C : unsigned_short_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_bool_short;
|
|
B : c_int;
|
|
C : short_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_pixel;
|
|
B : c_int;
|
|
C : vector_pixel_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_pixel;
|
|
B : c_int;
|
|
C : unsigned_short_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_pixel;
|
|
B : c_int;
|
|
C : short_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_signed_char;
|
|
B : c_int;
|
|
C : vector_signed_char_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_signed_char;
|
|
B : c_int;
|
|
C : signed_char_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_unsigned_char;
|
|
B : c_int;
|
|
C : vector_unsigned_char_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_unsigned_char;
|
|
B : c_int;
|
|
C : unsigned_char_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_bool_char;
|
|
B : c_int;
|
|
C : vector_bool_char_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_bool_char;
|
|
B : c_int;
|
|
C : unsigned_char_ptr);
|
|
|
|
procedure vec_stl
|
|
(A : vector_bool_char;
|
|
B : c_int;
|
|
C : signed_char_ptr);
|
|
|
|
-------------
|
|
-- vec_sub --
|
|
-------------
|
|
|
|
function vec_sub
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_sub
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return vector_signed_char;
|
|
|
|
function vec_sub
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_sub
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_sub
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return vector_unsigned_char;
|
|
|
|
function vec_sub
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_sub
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_sub
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return vector_signed_short;
|
|
|
|
function vec_sub
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_sub
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_sub
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return vector_unsigned_short;
|
|
|
|
function vec_sub
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_sub
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_sub
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return vector_signed_int;
|
|
|
|
function vec_sub
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_sub
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_sub
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return vector_unsigned_int;
|
|
|
|
function vec_sub
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_sub
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float;
|
|
|
|
----------------
|
|
-- vec_vsubfp --
|
|
----------------
|
|
|
|
function vec_vsubfp
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float;
|
|
|
|
-----------------
|
|
-- vec_vsubuwm --
|
|
-----------------
|
|
|
|
function vec_vsubuwm
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_vsubuwm
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return vector_signed_int;
|
|
|
|
function vec_vsubuwm
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_vsubuwm
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_vsubuwm
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return vector_unsigned_int;
|
|
|
|
function vec_vsubuwm
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
-----------------
|
|
-- vec_vsubuhm --
|
|
-----------------
|
|
|
|
function vec_vsubuhm
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_vsubuhm
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return vector_signed_short;
|
|
|
|
function vec_vsubuhm
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_vsubuhm
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_vsubuhm
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return vector_unsigned_short;
|
|
|
|
function vec_vsubuhm
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
-----------------
|
|
-- vec_vsububm --
|
|
-----------------
|
|
|
|
function vec_vsububm
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_vsububm
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return vector_signed_char;
|
|
|
|
function vec_vsububm
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_vsububm
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_vsububm
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return vector_unsigned_char;
|
|
|
|
function vec_vsububm
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
--------------
|
|
-- vec_subc --
|
|
--------------
|
|
|
|
function vec_subc
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
--------------
|
|
-- vec_subs --
|
|
--------------
|
|
|
|
function vec_subs
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_subs
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return vector_unsigned_char;
|
|
|
|
function vec_subs
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_subs
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_subs
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return vector_signed_char;
|
|
|
|
function vec_subs
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_subs
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_subs
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return vector_unsigned_short;
|
|
|
|
function vec_subs
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_subs
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_subs
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return vector_signed_short;
|
|
|
|
function vec_subs
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_subs
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_subs
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return vector_unsigned_int;
|
|
|
|
function vec_subs
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_subs
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_subs
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return vector_signed_int;
|
|
|
|
function vec_subs
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
-----------------
|
|
-- vec_vsubsws --
|
|
-----------------
|
|
|
|
function vec_vsubsws
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_vsubsws
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return vector_signed_int;
|
|
|
|
function vec_vsubsws
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
-----------------
|
|
-- vec_vsubuws --
|
|
-----------------
|
|
|
|
function vec_vsubuws
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_vsubuws
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return vector_unsigned_int;
|
|
|
|
function vec_vsubuws
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
-----------------
|
|
-- vec_vsubshs --
|
|
-----------------
|
|
|
|
function vec_vsubshs
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_vsubshs
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return vector_signed_short;
|
|
|
|
function vec_vsubshs
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
-----------------
|
|
-- vec_vsubuhs --
|
|
-----------------
|
|
|
|
function vec_vsubuhs
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_vsubuhs
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return vector_unsigned_short;
|
|
|
|
function vec_vsubuhs
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
-----------------
|
|
-- vec_vsubsbs --
|
|
-----------------
|
|
|
|
function vec_vsubsbs
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_vsubsbs
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return vector_signed_char;
|
|
|
|
function vec_vsubsbs
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
-----------------
|
|
-- vec_vsububs --
|
|
-----------------
|
|
|
|
function vec_vsububs
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_vsububs
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return vector_unsigned_char;
|
|
|
|
function vec_vsububs
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
---------------
|
|
-- vec_sum4s --
|
|
---------------
|
|
|
|
function vec_sum4s
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_sum4s
|
|
(A : vector_signed_char;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_sum4s
|
|
(A : vector_signed_short;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
------------------
|
|
-- vec_vsum4shs --
|
|
------------------
|
|
|
|
function vec_vsum4shs
|
|
(A : vector_signed_short;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
------------------
|
|
-- vec_vsum4sbs --
|
|
------------------
|
|
|
|
function vec_vsum4sbs
|
|
(A : vector_signed_char;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
------------------
|
|
-- vec_vsum4ubs --
|
|
------------------
|
|
|
|
function vec_vsum4ubs
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
---------------
|
|
-- vec_sum2s --
|
|
---------------
|
|
|
|
function vec_sum2s
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
--------------
|
|
-- vec_sums --
|
|
--------------
|
|
|
|
function vec_sums
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_trunc
|
|
(A : vector_float) return vector_float;
|
|
|
|
function vec_unpackh
|
|
(A : vector_signed_char) return vector_signed_short;
|
|
|
|
function vec_unpackh
|
|
(A : vector_bool_char) return vector_bool_short;
|
|
|
|
function vec_unpackh
|
|
(A : vector_signed_short) return vector_signed_int;
|
|
|
|
function vec_unpackh
|
|
(A : vector_bool_short) return vector_bool_int;
|
|
|
|
function vec_unpackh
|
|
(A : vector_pixel) return vector_unsigned_int;
|
|
|
|
function vec_vupkhsh
|
|
(A : vector_bool_short) return vector_bool_int;
|
|
|
|
function vec_vupkhsh
|
|
(A : vector_signed_short) return vector_signed_int;
|
|
|
|
function vec_vupkhpx
|
|
(A : vector_pixel) return vector_unsigned_int;
|
|
|
|
function vec_vupkhsb
|
|
(A : vector_bool_char) return vector_bool_short;
|
|
|
|
function vec_vupkhsb
|
|
(A : vector_signed_char) return vector_signed_short;
|
|
|
|
function vec_unpackl
|
|
(A : vector_signed_char) return vector_signed_short;
|
|
|
|
function vec_unpackl
|
|
(A : vector_bool_char) return vector_bool_short;
|
|
|
|
function vec_unpackl
|
|
(A : vector_pixel) return vector_unsigned_int;
|
|
|
|
function vec_unpackl
|
|
(A : vector_signed_short) return vector_signed_int;
|
|
|
|
function vec_unpackl
|
|
(A : vector_bool_short) return vector_bool_int;
|
|
|
|
function vec_vupklpx
|
|
(A : vector_pixel) return vector_unsigned_int;
|
|
|
|
-----------------
|
|
-- vec_vupklsh --
|
|
-----------------
|
|
|
|
function vec_vupklsh
|
|
(A : vector_bool_short) return vector_bool_int;
|
|
|
|
function vec_vupklsh
|
|
(A : vector_signed_short) return vector_signed_int;
|
|
|
|
-----------------
|
|
-- vec_vupklsb --
|
|
-----------------
|
|
|
|
function vec_vupklsb
|
|
(A : vector_bool_char) return vector_bool_short;
|
|
|
|
function vec_vupklsb
|
|
(A : vector_signed_char) return vector_signed_short;
|
|
|
|
-------------
|
|
-- vec_xor --
|
|
-------------
|
|
|
|
function vec_xor
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float;
|
|
|
|
function vec_xor
|
|
(A : vector_float;
|
|
B : vector_bool_int) return vector_float;
|
|
|
|
function vec_xor
|
|
(A : vector_bool_int;
|
|
B : vector_float) return vector_float;
|
|
|
|
function vec_xor
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int) return vector_bool_int;
|
|
|
|
function vec_xor
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_xor
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return vector_signed_int;
|
|
|
|
function vec_xor
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int;
|
|
|
|
function vec_xor
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_xor
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return vector_unsigned_int;
|
|
|
|
function vec_xor
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int;
|
|
|
|
function vec_xor
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short) return vector_bool_short;
|
|
|
|
function vec_xor
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_xor
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return vector_signed_short;
|
|
|
|
function vec_xor
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short;
|
|
|
|
function vec_xor
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_xor
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return vector_unsigned_short;
|
|
|
|
function vec_xor
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short;
|
|
|
|
function vec_xor
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_xor
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char) return vector_bool_char;
|
|
|
|
function vec_xor
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return vector_signed_char;
|
|
|
|
function vec_xor
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char;
|
|
|
|
function vec_xor
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
function vec_xor
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return vector_unsigned_char;
|
|
|
|
function vec_xor
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char;
|
|
|
|
-- vec_all_eq --
|
|
|
|
function vec_all_eq
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_pixel;
|
|
B : vector_pixel) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_all_eq
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
----------------
|
|
-- vec_all_ge --
|
|
----------------
|
|
|
|
function vec_all_ge
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_all_ge
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_all_ge
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_all_ge
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_all_ge
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_all_ge
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_all_ge
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_all_ge
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_all_ge
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_all_ge
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_all_ge
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_all_ge
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_all_ge
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_all_ge
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_all_ge
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_all_ge
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_all_ge
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_all_ge
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_all_ge
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
----------------
|
|
-- vec_all_gt --
|
|
----------------
|
|
|
|
function vec_all_gt
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_all_gt
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_all_gt
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_all_gt
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_all_gt
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_all_gt
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_all_gt
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_all_gt
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_all_gt
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_all_gt
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_all_gt
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_all_gt
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_all_gt
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_all_gt
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_all_gt
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_all_gt
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_all_gt
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_all_gt
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_all_gt
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
----------------
|
|
-- vec_all_in --
|
|
----------------
|
|
|
|
function vec_all_in
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
----------------
|
|
-- vec_all_le --
|
|
----------------
|
|
|
|
function vec_all_le
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_all_le
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_all_le
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_all_le
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_all_le
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_all_le
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_all_le
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_all_le
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_all_le
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_all_le
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_all_le
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_all_le
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_all_le
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_all_le
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_all_le
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_all_le
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_all_le
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_all_le
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_all_le
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
----------------
|
|
-- vec_all_lt --
|
|
----------------
|
|
|
|
function vec_all_lt
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_all_lt
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_all_lt
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_all_lt
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_all_lt
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_all_lt
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_all_lt
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_all_lt
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_all_lt
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_all_lt
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_all_lt
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_all_lt
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_all_lt
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_all_lt
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_all_lt
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_all_lt
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_all_lt
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_all_lt
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_all_lt
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
-----------------
|
|
-- vec_all_nan --
|
|
-----------------
|
|
|
|
function vec_all_nan
|
|
(A : vector_float) return c_int;
|
|
|
|
----------------
|
|
-- vec_all_ne --
|
|
----------------
|
|
|
|
function vec_all_ne
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_pixel;
|
|
B : vector_pixel) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_all_ne
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
-----------------
|
|
-- vec_all_nge --
|
|
-----------------
|
|
|
|
function vec_all_nge
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
-----------------
|
|
-- vec_all_ngt --
|
|
-----------------
|
|
|
|
function vec_all_ngt
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
-----------------
|
|
-- vec_all_nle --
|
|
-----------------
|
|
|
|
function vec_all_nle
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
-----------------
|
|
-- vec_all_nlt --
|
|
-----------------
|
|
|
|
function vec_all_nlt
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
---------------------
|
|
-- vec_all_numeric --
|
|
---------------------
|
|
|
|
function vec_all_numeric
|
|
(A : vector_float) return c_int;
|
|
|
|
----------------
|
|
-- vec_any_eq --
|
|
----------------
|
|
|
|
function vec_any_eq
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_pixel;
|
|
B : vector_pixel) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_any_eq
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
----------------
|
|
-- vec_any_ge --
|
|
----------------
|
|
|
|
function vec_any_ge
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_any_ge
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_any_ge
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_any_ge
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_any_ge
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_any_ge
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_any_ge
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_any_ge
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_any_ge
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_any_ge
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_any_ge
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_any_ge
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_any_ge
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_any_ge
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_any_ge
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_any_ge
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_any_ge
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_any_ge
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_any_ge
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
----------------
|
|
-- vec_any_gt --
|
|
----------------
|
|
|
|
function vec_any_gt
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_any_gt
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_any_gt
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_any_gt
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_any_gt
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_any_gt
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_any_gt
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_any_gt
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_any_gt
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_any_gt
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_any_gt
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_any_gt
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_any_gt
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_any_gt
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_any_gt
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_any_gt
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_any_gt
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_any_gt
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_any_gt
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
function vec_any_le
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_any_le
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_any_le
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_any_le
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_any_le
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_any_le
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_any_le
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_any_le
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_any_le
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_any_le
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_any_le
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_any_le
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_any_le
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_any_le
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_any_le
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_any_le
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_any_le
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_any_le
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_any_le
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
function vec_any_lt
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_any_lt
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_any_lt
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_any_lt
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_any_lt
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_any_lt
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_any_lt
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_any_lt
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_any_lt
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_any_lt
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_any_lt
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_any_lt
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_any_lt
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_any_lt
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_any_lt
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_any_lt
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_any_lt
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_any_lt
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_any_lt
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
function vec_any_nan
|
|
(A : vector_float) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_pixel;
|
|
B : vector_pixel) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return c_int;
|
|
|
|
function vec_any_ne
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
-----------------
|
|
-- vec_any_nge --
|
|
-----------------
|
|
|
|
function vec_any_nge
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
function vec_any_ngt
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
function vec_any_nle
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
function vec_any_nlt
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
function vec_any_numeric
|
|
(A : vector_float) return c_int;
|
|
|
|
function vec_any_out
|
|
(A : vector_float;
|
|
B : vector_float) return c_int;
|
|
|
|
function vec_splat_s8
|
|
(A : c_int) return vector_signed_char
|
|
renames vec_vspltisb;
|
|
|
|
-------------------
|
|
-- vec_splat_s16 --
|
|
-------------------
|
|
|
|
function vec_splat_s16
|
|
(A : c_int) return vector_signed_short
|
|
renames vec_vspltish;
|
|
|
|
-------------------
|
|
-- vec_splat_s32 --
|
|
-------------------
|
|
|
|
function vec_splat_s32
|
|
(A : c_int) return vector_signed_int
|
|
renames vec_vspltisw;
|
|
|
|
function vec_splat
|
|
(A : vector_signed_char;
|
|
B : c_int) return vector_signed_char
|
|
renames vec_vspltb;
|
|
|
|
function vec_splat
|
|
(A : vector_unsigned_char;
|
|
B : c_int) return vector_unsigned_char
|
|
renames vec_vspltb;
|
|
|
|
function vec_splat
|
|
(A : vector_bool_char;
|
|
B : c_int) return vector_bool_char
|
|
renames vec_vspltb;
|
|
|
|
function vec_splat
|
|
(A : vector_signed_short;
|
|
B : c_int) return vector_signed_short
|
|
renames vec_vsplth;
|
|
|
|
function vec_splat
|
|
(A : vector_unsigned_short;
|
|
B : c_int) return vector_unsigned_short
|
|
renames vec_vsplth;
|
|
|
|
function vec_splat
|
|
(A : vector_bool_short;
|
|
B : c_int) return vector_bool_short
|
|
renames vec_vsplth;
|
|
|
|
function vec_splat
|
|
(A : vector_pixel;
|
|
B : c_int) return vector_pixel
|
|
renames vec_vsplth;
|
|
|
|
function vec_splat
|
|
(A : vector_float;
|
|
B : c_int) return vector_float
|
|
renames vec_vspltw;
|
|
|
|
function vec_splat
|
|
(A : vector_signed_int;
|
|
B : c_int) return vector_signed_int
|
|
renames vec_vspltw;
|
|
|
|
function vec_splat
|
|
(A : vector_unsigned_int;
|
|
B : c_int) return vector_unsigned_int
|
|
renames vec_vspltw;
|
|
|
|
function vec_splat
|
|
(A : vector_bool_int;
|
|
B : c_int) return vector_bool_int
|
|
renames vec_vspltw;
|
|
|
|
------------------
|
|
-- vec_splat_u8 --
|
|
------------------
|
|
|
|
function vec_splat_u8
|
|
(A : c_int) return vector_unsigned_char;
|
|
pragma Inline_Always (vec_splat_u8);
|
|
pragma Convention (Intrinsic, vec_splat_u8);
|
|
|
|
-------------------
|
|
-- vec_splat_u16 --
|
|
-------------------
|
|
|
|
function vec_splat_u16
|
|
(A : c_int) return vector_unsigned_short;
|
|
pragma Inline_Always (vec_splat_u16);
|
|
pragma Convention (Intrinsic, vec_splat_u16);
|
|
|
|
-------------------
|
|
-- vec_splat_u32 --
|
|
-------------------
|
|
|
|
function vec_splat_u32
|
|
(A : c_int) return vector_unsigned_int;
|
|
pragma Inline_Always (vec_splat_u32);
|
|
pragma Convention (Intrinsic, vec_splat_u32);
|
|
|
|
-------------
|
|
-- vec_ctf --
|
|
-------------
|
|
|
|
function vec_ctf
|
|
(A : vector_unsigned_int;
|
|
B : c_int) return vector_float
|
|
renames vec_vcfux;
|
|
|
|
function vec_ctf
|
|
(A : vector_signed_int;
|
|
B : c_int) return vector_float
|
|
renames vec_vcfsx;
|
|
|
|
-------------
|
|
-- vec_cts --
|
|
-------------
|
|
|
|
function vec_cts
|
|
(A : vector_float;
|
|
B : c_int) return vector_signed_int
|
|
renames vec_vctsxs;
|
|
|
|
function vec_ctu
|
|
(A : vector_float;
|
|
B : c_int) return vector_unsigned_int
|
|
renames vec_vctuxs;
|
|
|
|
function vec_vaddcuw
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int
|
|
renames vec_addc;
|
|
|
|
function vec_vand
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_float;
|
|
B : vector_bool_int) return vector_float
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_bool_int;
|
|
B : vector_float) return vector_float
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int) return vector_bool_int
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return vector_signed_int
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return vector_signed_int
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return vector_unsigned_int
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short) return vector_bool_short
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return vector_signed_short
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return vector_signed_short
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return vector_unsigned_short
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return vector_signed_char
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char) return vector_bool_char
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return vector_signed_char
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return vector_unsigned_char
|
|
renames vec_and;
|
|
|
|
function vec_vand
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char
|
|
renames vec_and;
|
|
|
|
---------------
|
|
-- vec_vandc --
|
|
---------------
|
|
|
|
function vec_vandc
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_float;
|
|
B : vector_bool_int) return vector_float
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_bool_int;
|
|
B : vector_float) return vector_float
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int) return vector_bool_int
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return vector_signed_int
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return vector_signed_int
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return vector_unsigned_int
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short) return vector_bool_short
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return vector_signed_short
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return vector_signed_short
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return vector_unsigned_short
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return vector_signed_char
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char) return vector_bool_char
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return vector_signed_char
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return vector_unsigned_char
|
|
renames vec_andc;
|
|
|
|
function vec_vandc
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char
|
|
renames vec_andc;
|
|
|
|
---------------
|
|
-- vec_vrfip --
|
|
---------------
|
|
|
|
function vec_vrfip
|
|
(A : vector_float) return vector_float
|
|
renames vec_ceil;
|
|
|
|
-----------------
|
|
-- vec_vcmpbfp --
|
|
-----------------
|
|
|
|
function vec_vcmpbfp
|
|
(A : vector_float;
|
|
B : vector_float) return vector_signed_int
|
|
renames vec_cmpb;
|
|
|
|
function vec_vcmpgefp
|
|
(A : vector_float;
|
|
B : vector_float) return vector_bool_int
|
|
renames vec_cmpge;
|
|
|
|
function vec_vexptefp
|
|
(A : vector_float) return vector_float
|
|
renames vec_expte;
|
|
|
|
---------------
|
|
-- vec_vrfim --
|
|
---------------
|
|
|
|
function vec_vrfim
|
|
(A : vector_float) return vector_float
|
|
renames vec_floor;
|
|
|
|
function vec_lvx
|
|
(A : c_long;
|
|
B : const_vector_float_ptr) return vector_float
|
|
renames vec_ld;
|
|
|
|
function vec_lvx
|
|
(A : c_long;
|
|
B : const_float_ptr) return vector_float
|
|
renames vec_ld;
|
|
|
|
function vec_lvx
|
|
(A : c_long;
|
|
B : const_vector_bool_int_ptr) return vector_bool_int
|
|
renames vec_ld;
|
|
|
|
function vec_lvx
|
|
(A : c_long;
|
|
B : const_vector_signed_int_ptr) return vector_signed_int
|
|
renames vec_ld;
|
|
|
|
function vec_lvx
|
|
(A : c_long;
|
|
B : const_int_ptr) return vector_signed_int
|
|
renames vec_ld;
|
|
|
|
function vec_lvx
|
|
(A : c_long;
|
|
B : const_long_ptr) return vector_signed_int
|
|
renames vec_ld;
|
|
|
|
function vec_lvx
|
|
(A : c_long;
|
|
B : const_vector_unsigned_int_ptr) return vector_unsigned_int
|
|
renames vec_ld;
|
|
|
|
function vec_lvx
|
|
(A : c_long;
|
|
B : const_unsigned_int_ptr) return vector_unsigned_int
|
|
renames vec_ld;
|
|
|
|
function vec_lvx
|
|
(A : c_long;
|
|
B : const_unsigned_long_ptr) return vector_unsigned_int
|
|
renames vec_ld;
|
|
|
|
function vec_lvx
|
|
(A : c_long;
|
|
B : const_vector_bool_short_ptr) return vector_bool_short
|
|
renames vec_ld;
|
|
|
|
function vec_lvx
|
|
(A : c_long;
|
|
B : const_vector_pixel_ptr) return vector_pixel
|
|
renames vec_ld;
|
|
|
|
function vec_lvx
|
|
(A : c_long;
|
|
B : const_vector_signed_short_ptr) return vector_signed_short
|
|
renames vec_ld;
|
|
|
|
function vec_lvx
|
|
(A : c_long;
|
|
B : const_short_ptr) return vector_signed_short
|
|
renames vec_ld;
|
|
|
|
function vec_lvx
|
|
(A : c_long;
|
|
B : const_vector_unsigned_short_ptr) return vector_unsigned_short
|
|
renames vec_ld;
|
|
|
|
function vec_lvx
|
|
(A : c_long;
|
|
B : const_unsigned_short_ptr) return vector_unsigned_short
|
|
renames vec_ld;
|
|
|
|
function vec_lvx
|
|
(A : c_long;
|
|
B : const_vector_bool_char_ptr) return vector_bool_char
|
|
renames vec_ld;
|
|
|
|
function vec_lvx
|
|
(A : c_long;
|
|
B : const_vector_signed_char_ptr) return vector_signed_char
|
|
renames vec_ld;
|
|
|
|
function vec_lvx
|
|
(A : c_long;
|
|
B : const_signed_char_ptr) return vector_signed_char
|
|
renames vec_ld;
|
|
|
|
function vec_lvx
|
|
(A : c_long;
|
|
B : const_vector_unsigned_char_ptr) return vector_unsigned_char
|
|
renames vec_ld;
|
|
|
|
function vec_lvx
|
|
(A : c_long;
|
|
B : const_unsigned_char_ptr) return vector_unsigned_char
|
|
renames vec_ld;
|
|
|
|
function vec_lvxl
|
|
(A : c_long;
|
|
B : const_vector_float_ptr) return vector_float
|
|
renames vec_ldl;
|
|
|
|
function vec_lvxl
|
|
(A : c_long;
|
|
B : const_float_ptr) return vector_float
|
|
renames vec_ldl;
|
|
|
|
function vec_lvxl
|
|
(A : c_long;
|
|
B : const_vector_bool_int_ptr) return vector_bool_int
|
|
renames vec_ldl;
|
|
|
|
function vec_lvxl
|
|
(A : c_long;
|
|
B : const_vector_signed_int_ptr) return vector_signed_int
|
|
renames vec_ldl;
|
|
|
|
function vec_lvxl
|
|
(A : c_long;
|
|
B : const_int_ptr) return vector_signed_int
|
|
renames vec_ldl;
|
|
|
|
function vec_lvxl
|
|
(A : c_long;
|
|
B : const_long_ptr) return vector_signed_int
|
|
renames vec_ldl;
|
|
|
|
function vec_lvxl
|
|
(A : c_long;
|
|
B : const_vector_unsigned_int_ptr) return vector_unsigned_int
|
|
renames vec_ldl;
|
|
|
|
function vec_lvxl
|
|
(A : c_long;
|
|
B : const_unsigned_int_ptr) return vector_unsigned_int
|
|
renames vec_ldl;
|
|
|
|
function vec_lvxl
|
|
(A : c_long;
|
|
B : const_unsigned_long_ptr) return vector_unsigned_int
|
|
renames vec_ldl;
|
|
|
|
function vec_lvxl
|
|
(A : c_long;
|
|
B : const_vector_bool_short_ptr) return vector_bool_short
|
|
renames vec_ldl;
|
|
|
|
function vec_lvxl
|
|
(A : c_long;
|
|
B : const_vector_pixel_ptr) return vector_pixel
|
|
renames vec_ldl;
|
|
|
|
function vec_lvxl
|
|
(A : c_long;
|
|
B : const_vector_signed_short_ptr) return vector_signed_short
|
|
renames vec_ldl;
|
|
|
|
function vec_lvxl
|
|
(A : c_long;
|
|
B : const_short_ptr) return vector_signed_short
|
|
renames vec_ldl;
|
|
|
|
function vec_lvxl
|
|
(A : c_long;
|
|
B : const_vector_unsigned_short_ptr) return vector_unsigned_short
|
|
renames vec_ldl;
|
|
|
|
function vec_lvxl
|
|
(A : c_long;
|
|
B : const_unsigned_short_ptr) return vector_unsigned_short
|
|
renames vec_ldl;
|
|
|
|
function vec_lvxl
|
|
(A : c_long;
|
|
B : const_vector_bool_char_ptr) return vector_bool_char
|
|
renames vec_ldl;
|
|
|
|
function vec_lvxl
|
|
(A : c_long;
|
|
B : const_vector_signed_char_ptr) return vector_signed_char
|
|
renames vec_ldl;
|
|
|
|
function vec_lvxl
|
|
(A : c_long;
|
|
B : const_signed_char_ptr) return vector_signed_char
|
|
renames vec_ldl;
|
|
|
|
function vec_lvxl
|
|
(A : c_long;
|
|
B : const_vector_unsigned_char_ptr) return vector_unsigned_char
|
|
renames vec_ldl;
|
|
|
|
function vec_lvxl
|
|
(A : c_long;
|
|
B : const_unsigned_char_ptr) return vector_unsigned_char
|
|
renames vec_ldl;
|
|
|
|
function vec_vlogefp
|
|
(A : vector_float) return vector_float
|
|
renames vec_loge;
|
|
|
|
-----------------
|
|
-- vec_vmaddfp --
|
|
-----------------
|
|
|
|
function vec_vmaddfp
|
|
(A : vector_float;
|
|
B : vector_float;
|
|
C : vector_float) return vector_float
|
|
renames vec_madd;
|
|
|
|
-------------------
|
|
-- vec_vmhaddshs --
|
|
-------------------
|
|
|
|
function vec_vmhaddshs
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short;
|
|
C : vector_signed_short) return vector_signed_short
|
|
renames vec_madds;
|
|
|
|
-------------------
|
|
-- vec_vmladduhm --
|
|
-------------------
|
|
|
|
function vec_vmladduhm
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short;
|
|
C : vector_signed_short) return vector_signed_short
|
|
renames vec_mladd;
|
|
|
|
function vec_vmladduhm
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_short;
|
|
C : vector_unsigned_short) return vector_signed_short
|
|
renames vec_mladd;
|
|
|
|
function vec_vmladduhm
|
|
(A : vector_unsigned_short;
|
|
B : vector_signed_short;
|
|
C : vector_signed_short) return vector_signed_short
|
|
renames vec_mladd;
|
|
|
|
function vec_vmladduhm
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short;
|
|
C : vector_unsigned_short) return vector_unsigned_short
|
|
renames vec_mladd;
|
|
|
|
--------------------
|
|
-- vec_vmhraddshs --
|
|
--------------------
|
|
|
|
function vec_vmhraddshs
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short;
|
|
C : vector_signed_short) return vector_signed_short
|
|
renames vec_mradds;
|
|
|
|
------------------
|
|
-- vec_vnmsubfp --
|
|
------------------
|
|
|
|
function vec_vnmsubfp
|
|
(A : vector_float;
|
|
B : vector_float;
|
|
C : vector_float) return vector_float
|
|
renames vec_nmsub;
|
|
|
|
--------------
|
|
-- vec_vnor --
|
|
--------------
|
|
|
|
function vec_vnor
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float
|
|
renames vec_nor;
|
|
|
|
function vec_vnor
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int
|
|
renames vec_nor;
|
|
|
|
function vec_vnor
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int
|
|
renames vec_nor;
|
|
|
|
function vec_vnor
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int) return vector_bool_int
|
|
renames vec_nor;
|
|
|
|
function vec_vnor
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short
|
|
renames vec_nor;
|
|
|
|
function vec_vnor
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short
|
|
renames vec_nor;
|
|
|
|
function vec_vnor
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short) return vector_bool_short
|
|
renames vec_nor;
|
|
|
|
function vec_vnor
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char
|
|
renames vec_nor;
|
|
|
|
function vec_vnor
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char
|
|
renames vec_nor;
|
|
|
|
function vec_vnor
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char) return vector_bool_char
|
|
renames vec_nor;
|
|
|
|
-------------
|
|
-- vec_vor --
|
|
-------------
|
|
|
|
function vec_vor
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_float;
|
|
B : vector_bool_int) return vector_float
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_bool_int;
|
|
B : vector_float) return vector_float
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int) return vector_bool_int
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return vector_signed_int
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return vector_signed_int
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return vector_unsigned_int
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short) return vector_bool_short
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return vector_signed_short
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return vector_signed_short
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return vector_unsigned_short
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return vector_signed_char
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char) return vector_bool_char
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return vector_signed_char
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return vector_unsigned_char
|
|
renames vec_or;
|
|
|
|
function vec_vor
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char
|
|
renames vec_or;
|
|
|
|
---------------
|
|
-- vec_vpkpx --
|
|
---------------
|
|
|
|
function vec_vpkpx
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_pixel
|
|
renames vec_packpx;
|
|
|
|
---------------
|
|
-- vec_vperm --
|
|
---------------
|
|
|
|
function vec_vperm
|
|
(A : vector_float;
|
|
B : vector_float;
|
|
C : vector_unsigned_char) return vector_float
|
|
renames vec_perm;
|
|
|
|
function vec_vperm
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int;
|
|
C : vector_unsigned_char) return vector_signed_int
|
|
renames vec_perm;
|
|
|
|
function vec_vperm
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int;
|
|
C : vector_unsigned_char) return vector_unsigned_int
|
|
renames vec_perm;
|
|
|
|
function vec_vperm
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int;
|
|
C : vector_unsigned_char) return vector_bool_int
|
|
renames vec_perm;
|
|
|
|
function vec_vperm
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short;
|
|
C : vector_unsigned_char) return vector_signed_short
|
|
renames vec_perm;
|
|
|
|
function vec_vperm
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short;
|
|
C : vector_unsigned_char) return vector_unsigned_short
|
|
renames vec_perm;
|
|
|
|
function vec_vperm
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short;
|
|
C : vector_unsigned_char) return vector_bool_short
|
|
renames vec_perm;
|
|
|
|
function vec_vperm
|
|
(A : vector_pixel;
|
|
B : vector_pixel;
|
|
C : vector_unsigned_char) return vector_pixel
|
|
renames vec_perm;
|
|
|
|
function vec_vperm
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char;
|
|
C : vector_unsigned_char) return vector_signed_char
|
|
renames vec_perm;
|
|
|
|
function vec_vperm
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char;
|
|
C : vector_unsigned_char) return vector_unsigned_char
|
|
renames vec_perm;
|
|
|
|
function vec_vperm
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char;
|
|
C : vector_unsigned_char) return vector_bool_char
|
|
renames vec_perm;
|
|
|
|
---------------
|
|
-- vec_vrefp --
|
|
---------------
|
|
|
|
function vec_vrefp
|
|
(A : vector_float) return vector_float
|
|
renames vec_re;
|
|
|
|
---------------
|
|
-- vec_vrfin --
|
|
---------------
|
|
|
|
function vec_vrfin
|
|
(A : vector_float) return vector_float
|
|
renames vec_round;
|
|
|
|
function vec_vrsqrtefp
|
|
(A : vector_float) return vector_float
|
|
renames vec_rsqrte;
|
|
|
|
function vec_vsel
|
|
(A : vector_float;
|
|
B : vector_float;
|
|
C : vector_bool_int) return vector_float
|
|
renames vec_sel;
|
|
|
|
function vec_vsel
|
|
(A : vector_float;
|
|
B : vector_float;
|
|
C : vector_unsigned_int) return vector_float
|
|
renames vec_sel;
|
|
|
|
function vec_vsel
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int;
|
|
C : vector_bool_int) return vector_signed_int
|
|
renames vec_sel;
|
|
|
|
function vec_vsel
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int;
|
|
C : vector_unsigned_int) return vector_signed_int
|
|
renames vec_sel;
|
|
|
|
function vec_vsel
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int;
|
|
C : vector_bool_int) return vector_unsigned_int
|
|
renames vec_sel;
|
|
|
|
function vec_vsel
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int;
|
|
C : vector_unsigned_int) return vector_unsigned_int
|
|
renames vec_sel;
|
|
|
|
function vec_vsel
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int;
|
|
C : vector_bool_int) return vector_bool_int
|
|
renames vec_sel;
|
|
|
|
function vec_vsel
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int;
|
|
C : vector_unsigned_int) return vector_bool_int
|
|
renames vec_sel;
|
|
|
|
function vec_vsel
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short;
|
|
C : vector_bool_short) return vector_signed_short
|
|
renames vec_sel;
|
|
|
|
function vec_vsel
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short;
|
|
C : vector_unsigned_short) return vector_signed_short
|
|
renames vec_sel;
|
|
|
|
function vec_vsel
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short;
|
|
C : vector_bool_short) return vector_unsigned_short
|
|
renames vec_sel;
|
|
|
|
function vec_vsel
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short;
|
|
C : vector_unsigned_short) return vector_unsigned_short
|
|
renames vec_sel;
|
|
|
|
function vec_vsel
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short;
|
|
C : vector_bool_short) return vector_bool_short
|
|
renames vec_sel;
|
|
|
|
function vec_vsel
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short;
|
|
C : vector_unsigned_short) return vector_bool_short
|
|
renames vec_sel;
|
|
|
|
function vec_vsel
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char;
|
|
C : vector_bool_char) return vector_signed_char
|
|
renames vec_sel;
|
|
|
|
function vec_vsel
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char;
|
|
C : vector_unsigned_char) return vector_signed_char
|
|
renames vec_sel;
|
|
|
|
function vec_vsel
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char;
|
|
C : vector_bool_char) return vector_unsigned_char
|
|
renames vec_sel;
|
|
|
|
function vec_vsel
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char;
|
|
C : vector_unsigned_char) return vector_unsigned_char
|
|
renames vec_sel;
|
|
|
|
function vec_vsel
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char;
|
|
C : vector_bool_char) return vector_bool_char
|
|
renames vec_sel;
|
|
|
|
function vec_vsel
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char;
|
|
C : vector_unsigned_char) return vector_bool_char
|
|
renames vec_sel;
|
|
|
|
----------------
|
|
-- vec_vsldoi --
|
|
----------------
|
|
|
|
function vec_vsldoi
|
|
(A : vector_float;
|
|
B : vector_float;
|
|
C : c_int) return vector_float
|
|
renames vec_sld;
|
|
|
|
function vec_vsldoi
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int;
|
|
C : c_int) return vector_signed_int
|
|
renames vec_sld;
|
|
|
|
function vec_vsldoi
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int;
|
|
C : c_int) return vector_unsigned_int
|
|
renames vec_sld;
|
|
|
|
function vec_vsldoi
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int;
|
|
C : c_int) return vector_bool_int
|
|
renames vec_sld;
|
|
|
|
function vec_vsldoi
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short;
|
|
C : c_int) return vector_signed_short
|
|
renames vec_sld;
|
|
|
|
function vec_vsldoi
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short;
|
|
C : c_int) return vector_unsigned_short
|
|
renames vec_sld;
|
|
|
|
function vec_vsldoi
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short;
|
|
C : c_int) return vector_bool_short
|
|
renames vec_sld;
|
|
|
|
function vec_vsldoi
|
|
(A : vector_pixel;
|
|
B : vector_pixel;
|
|
C : c_int) return vector_pixel
|
|
renames vec_sld;
|
|
|
|
function vec_vsldoi
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char;
|
|
C : c_int) return vector_signed_char
|
|
renames vec_sld;
|
|
|
|
function vec_vsldoi
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char;
|
|
C : c_int) return vector_unsigned_char
|
|
renames vec_sld;
|
|
|
|
function vec_vsldoi
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char;
|
|
C : c_int) return vector_bool_char
|
|
renames vec_sld;
|
|
|
|
-------------
|
|
-- vec_vsl --
|
|
-------------
|
|
|
|
function vec_vsl
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_int) return vector_signed_int
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_short) return vector_signed_int
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_char) return vector_signed_int
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_short) return vector_unsigned_int
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_char) return vector_unsigned_int
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_bool_int
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_short) return vector_bool_int
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_char) return vector_bool_int
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_int) return vector_signed_short
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_short) return vector_signed_short
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_char) return vector_signed_short
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_int) return vector_unsigned_short
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_char) return vector_unsigned_short
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_int) return vector_bool_short
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_bool_short
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_char) return vector_bool_short
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_pixel;
|
|
B : vector_unsigned_int) return vector_pixel
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_pixel;
|
|
B : vector_unsigned_short) return vector_pixel
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_pixel;
|
|
B : vector_unsigned_char) return vector_pixel
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_int) return vector_signed_char
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_short) return vector_signed_char
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_char) return vector_signed_char
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_int) return vector_unsigned_char
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_short) return vector_unsigned_char
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_int) return vector_bool_char
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_short) return vector_bool_char
|
|
renames vec_sll;
|
|
|
|
function vec_vsl
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_bool_char
|
|
renames vec_sll;
|
|
|
|
--------------
|
|
-- vec_vslo --
|
|
--------------
|
|
|
|
function vec_vslo
|
|
(A : vector_float;
|
|
B : vector_signed_char) return vector_float
|
|
renames vec_slo;
|
|
|
|
function vec_vslo
|
|
(A : vector_float;
|
|
B : vector_unsigned_char) return vector_float
|
|
renames vec_slo;
|
|
|
|
function vec_vslo
|
|
(A : vector_signed_int;
|
|
B : vector_signed_char) return vector_signed_int
|
|
renames vec_slo;
|
|
|
|
function vec_vslo
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_char) return vector_signed_int
|
|
renames vec_slo;
|
|
|
|
function vec_vslo
|
|
(A : vector_unsigned_int;
|
|
B : vector_signed_char) return vector_unsigned_int
|
|
renames vec_slo;
|
|
|
|
function vec_vslo
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_char) return vector_unsigned_int
|
|
renames vec_slo;
|
|
|
|
function vec_vslo
|
|
(A : vector_signed_short;
|
|
B : vector_signed_char) return vector_signed_short
|
|
renames vec_slo;
|
|
|
|
function vec_vslo
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_char) return vector_signed_short
|
|
renames vec_slo;
|
|
|
|
function vec_vslo
|
|
(A : vector_unsigned_short;
|
|
B : vector_signed_char) return vector_unsigned_short
|
|
renames vec_slo;
|
|
|
|
function vec_vslo
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_char) return vector_unsigned_short
|
|
renames vec_slo;
|
|
|
|
function vec_vslo
|
|
(A : vector_pixel;
|
|
B : vector_signed_char) return vector_pixel
|
|
renames vec_slo;
|
|
|
|
function vec_vslo
|
|
(A : vector_pixel;
|
|
B : vector_unsigned_char) return vector_pixel
|
|
renames vec_slo;
|
|
|
|
function vec_vslo
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char
|
|
renames vec_slo;
|
|
|
|
function vec_vslo
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_char) return vector_signed_char
|
|
renames vec_slo;
|
|
|
|
function vec_vslo
|
|
(A : vector_unsigned_char;
|
|
B : vector_signed_char) return vector_unsigned_char
|
|
renames vec_slo;
|
|
|
|
function vec_vslo
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char
|
|
renames vec_slo;
|
|
|
|
function vec_vsr
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_int) return vector_signed_int
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_short) return vector_signed_int
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_char) return vector_signed_int
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_short) return vector_unsigned_int
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_char) return vector_unsigned_int
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_bool_int
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_short) return vector_bool_int
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_char) return vector_bool_int
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_int) return vector_signed_short
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_short) return vector_signed_short
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_char) return vector_signed_short
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_int) return vector_unsigned_short
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_char) return vector_unsigned_short
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_int) return vector_bool_short
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_bool_short
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_char) return vector_bool_short
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_pixel;
|
|
B : vector_unsigned_int) return vector_pixel
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_pixel;
|
|
B : vector_unsigned_short) return vector_pixel
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_pixel;
|
|
B : vector_unsigned_char) return vector_pixel
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_int) return vector_signed_char
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_short) return vector_signed_char
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_char) return vector_signed_char
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_int) return vector_unsigned_char
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_short) return vector_unsigned_char
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_int) return vector_bool_char
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_short) return vector_bool_char
|
|
renames vec_srl;
|
|
|
|
function vec_vsr
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_bool_char
|
|
renames vec_srl;
|
|
|
|
function vec_vsro
|
|
(A : vector_float;
|
|
B : vector_signed_char) return vector_float
|
|
renames vec_sro;
|
|
|
|
function vec_vsro
|
|
(A : vector_float;
|
|
B : vector_unsigned_char) return vector_float
|
|
renames vec_sro;
|
|
|
|
function vec_vsro
|
|
(A : vector_signed_int;
|
|
B : vector_signed_char) return vector_signed_int
|
|
renames vec_sro;
|
|
|
|
function vec_vsro
|
|
(A : vector_signed_int;
|
|
B : vector_unsigned_char) return vector_signed_int
|
|
renames vec_sro;
|
|
|
|
function vec_vsro
|
|
(A : vector_unsigned_int;
|
|
B : vector_signed_char) return vector_unsigned_int
|
|
renames vec_sro;
|
|
|
|
function vec_vsro
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_char) return vector_unsigned_int
|
|
renames vec_sro;
|
|
|
|
function vec_vsro
|
|
(A : vector_signed_short;
|
|
B : vector_signed_char) return vector_signed_short
|
|
renames vec_sro;
|
|
|
|
function vec_vsro
|
|
(A : vector_signed_short;
|
|
B : vector_unsigned_char) return vector_signed_short
|
|
renames vec_sro;
|
|
|
|
function vec_vsro
|
|
(A : vector_unsigned_short;
|
|
B : vector_signed_char) return vector_unsigned_short
|
|
renames vec_sro;
|
|
|
|
function vec_vsro
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_char) return vector_unsigned_short
|
|
renames vec_sro;
|
|
|
|
function vec_vsro
|
|
(A : vector_pixel;
|
|
B : vector_signed_char) return vector_pixel
|
|
renames vec_sro;
|
|
|
|
function vec_vsro
|
|
(A : vector_pixel;
|
|
B : vector_unsigned_char) return vector_pixel
|
|
renames vec_sro;
|
|
|
|
function vec_vsro
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char
|
|
renames vec_sro;
|
|
|
|
function vec_vsro
|
|
(A : vector_signed_char;
|
|
B : vector_unsigned_char) return vector_signed_char
|
|
renames vec_sro;
|
|
|
|
function vec_vsro
|
|
(A : vector_unsigned_char;
|
|
B : vector_signed_char) return vector_unsigned_char
|
|
renames vec_sro;
|
|
|
|
function vec_vsro
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char
|
|
renames vec_sro;
|
|
|
|
--------------
|
|
-- vec_stvx --
|
|
--------------
|
|
|
|
procedure vec_stvx
|
|
(A : vector_float;
|
|
B : c_int;
|
|
C : vector_float_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_float;
|
|
B : c_int;
|
|
C : float_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_signed_int;
|
|
B : c_int;
|
|
C : vector_signed_int_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_signed_int;
|
|
B : c_int;
|
|
C : int_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_unsigned_int;
|
|
B : c_int;
|
|
C : vector_unsigned_int_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_unsigned_int;
|
|
B : c_int;
|
|
C : unsigned_int_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_bool_int;
|
|
B : c_int;
|
|
C : vector_bool_int_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_bool_int;
|
|
B : c_int;
|
|
C : unsigned_int_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_bool_int;
|
|
B : c_int;
|
|
C : int_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_signed_short;
|
|
B : c_int;
|
|
C : vector_signed_short_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_signed_short;
|
|
B : c_int;
|
|
C : short_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_unsigned_short;
|
|
B : c_int;
|
|
C : vector_unsigned_short_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_unsigned_short;
|
|
B : c_int;
|
|
C : unsigned_short_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_bool_short;
|
|
B : c_int;
|
|
C : vector_bool_short_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_bool_short;
|
|
B : c_int;
|
|
C : unsigned_short_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_pixel;
|
|
B : c_int;
|
|
C : vector_pixel_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_pixel;
|
|
B : c_int;
|
|
C : unsigned_short_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_pixel;
|
|
B : c_int;
|
|
C : short_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_bool_short;
|
|
B : c_int;
|
|
C : short_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_signed_char;
|
|
B : c_int;
|
|
C : vector_signed_char_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_signed_char;
|
|
B : c_int;
|
|
C : signed_char_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_unsigned_char;
|
|
B : c_int;
|
|
C : vector_unsigned_char_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_unsigned_char;
|
|
B : c_int;
|
|
C : unsigned_char_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_bool_char;
|
|
B : c_int;
|
|
C : vector_bool_char_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_bool_char;
|
|
B : c_int;
|
|
C : unsigned_char_ptr)
|
|
renames vec_st;
|
|
|
|
procedure vec_stvx
|
|
(A : vector_bool_char;
|
|
B : c_int;
|
|
C : signed_char_ptr)
|
|
renames vec_st;
|
|
|
|
---------------
|
|
-- vec_stvxl --
|
|
---------------
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_float;
|
|
B : c_int;
|
|
C : vector_float_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_float;
|
|
B : c_int;
|
|
C : float_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_signed_int;
|
|
B : c_int;
|
|
C : vector_signed_int_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_signed_int;
|
|
B : c_int;
|
|
C : int_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_unsigned_int;
|
|
B : c_int;
|
|
C : vector_unsigned_int_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_unsigned_int;
|
|
B : c_int;
|
|
C : unsigned_int_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_bool_int;
|
|
B : c_int;
|
|
C : vector_bool_int_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_bool_int;
|
|
B : c_int;
|
|
C : unsigned_int_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_bool_int;
|
|
B : c_int;
|
|
C : int_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_signed_short;
|
|
B : c_int;
|
|
C : vector_signed_short_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_signed_short;
|
|
B : c_int;
|
|
C : short_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_unsigned_short;
|
|
B : c_int;
|
|
C : vector_unsigned_short_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_unsigned_short;
|
|
B : c_int;
|
|
C : unsigned_short_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_bool_short;
|
|
B : c_int;
|
|
C : vector_bool_short_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_bool_short;
|
|
B : c_int;
|
|
C : unsigned_short_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_bool_short;
|
|
B : c_int;
|
|
C : short_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_pixel;
|
|
B : c_int;
|
|
C : vector_pixel_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_pixel;
|
|
B : c_int;
|
|
C : unsigned_short_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_pixel;
|
|
B : c_int;
|
|
C : short_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_signed_char;
|
|
B : c_int;
|
|
C : vector_signed_char_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_signed_char;
|
|
B : c_int;
|
|
C : signed_char_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_unsigned_char;
|
|
B : c_int;
|
|
C : vector_unsigned_char_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_unsigned_char;
|
|
B : c_int;
|
|
C : unsigned_char_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_bool_char;
|
|
B : c_int;
|
|
C : vector_bool_char_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_bool_char;
|
|
B : c_int;
|
|
C : unsigned_char_ptr)
|
|
renames vec_stl;
|
|
|
|
procedure vec_stvxl
|
|
(A : vector_bool_char;
|
|
B : c_int;
|
|
C : signed_char_ptr)
|
|
renames vec_stl;
|
|
|
|
function vec_vsubcuw
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int
|
|
renames vec_subc;
|
|
|
|
------------------
|
|
-- vec_vsum2sws --
|
|
------------------
|
|
|
|
function vec_vsum2sws
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int
|
|
renames vec_sum2s;
|
|
|
|
function vec_vsumsws
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int
|
|
renames vec_sums;
|
|
|
|
function vec_vrfiz
|
|
(A : vector_float) return vector_float
|
|
renames vec_trunc;
|
|
|
|
--------------
|
|
-- vec_vxor --
|
|
--------------
|
|
|
|
function vec_vxor
|
|
(A : vector_float;
|
|
B : vector_float) return vector_float
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_float;
|
|
B : vector_bool_int) return vector_float
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_bool_int;
|
|
B : vector_float) return vector_float
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_bool_int;
|
|
B : vector_bool_int) return vector_bool_int
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_bool_int;
|
|
B : vector_signed_int) return vector_signed_int
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_signed_int;
|
|
B : vector_bool_int) return vector_signed_int
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_signed_int;
|
|
B : vector_signed_int) return vector_signed_int
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_bool_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_unsigned_int;
|
|
B : vector_bool_int) return vector_unsigned_int
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_unsigned_int;
|
|
B : vector_unsigned_int) return vector_unsigned_int
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_bool_short;
|
|
B : vector_bool_short) return vector_bool_short
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_bool_short;
|
|
B : vector_signed_short) return vector_signed_short
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_signed_short;
|
|
B : vector_bool_short) return vector_signed_short
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_signed_short;
|
|
B : vector_signed_short) return vector_signed_short
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_bool_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_unsigned_short;
|
|
B : vector_bool_short) return vector_unsigned_short
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_unsigned_short;
|
|
B : vector_unsigned_short) return vector_unsigned_short
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_bool_char;
|
|
B : vector_signed_char) return vector_signed_char
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_bool_char;
|
|
B : vector_bool_char) return vector_bool_char
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_signed_char;
|
|
B : vector_bool_char) return vector_signed_char
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_signed_char;
|
|
B : vector_signed_char) return vector_signed_char
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_bool_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_unsigned_char;
|
|
B : vector_bool_char) return vector_unsigned_char
|
|
renames vec_xor;
|
|
|
|
function vec_vxor
|
|
(A : vector_unsigned_char;
|
|
B : vector_unsigned_char) return vector_unsigned_char
|
|
renames vec_xor;
|
|
|
|
--------------
|
|
-- vec_step --
|
|
--------------
|
|
|
|
function vec_step (V : vector_unsigned_char) return Integer;
|
|
function vec_step (V : vector_signed_char) return Integer;
|
|
function vec_step (V : vector_bool_char) return Integer;
|
|
|
|
function vec_step (V : vector_unsigned_short) return Integer;
|
|
function vec_step (V : vector_signed_short) return Integer;
|
|
function vec_step (V : vector_bool_short) return Integer;
|
|
|
|
function vec_step (V : vector_unsigned_int) return Integer;
|
|
function vec_step (V : vector_signed_int) return Integer;
|
|
function vec_step (V : vector_bool_int) return Integer;
|
|
|
|
function vec_step (V : vector_float) return Integer;
|
|
function vec_step (V : vector_pixel) return Integer;
|
|
|
|
private
|
|
|
|
pragma Inline_Always (vec_abs);
|
|
pragma Inline_Always (vec_abss);
|
|
pragma Inline_Always (vec_add);
|
|
pragma Inline_Always (vec_vaddfp);
|
|
pragma Inline_Always (vec_vadduwm);
|
|
pragma Inline_Always (vec_vadduhm);
|
|
pragma Inline_Always (vec_vaddubm);
|
|
pragma Inline_Always (vec_addc);
|
|
pragma Inline_Always (vec_adds);
|
|
pragma Inline_Always (vec_vaddsws);
|
|
pragma Inline_Always (vec_vadduws);
|
|
pragma Inline_Always (vec_vaddshs);
|
|
pragma Inline_Always (vec_vadduhs);
|
|
pragma Inline_Always (vec_vaddsbs);
|
|
pragma Inline_Always (vec_vaddubs);
|
|
pragma Inline_Always (vec_and);
|
|
pragma Inline_Always (vec_andc);
|
|
pragma Inline_Always (vec_avg);
|
|
pragma Inline_Always (vec_vavgsw);
|
|
pragma Inline_Always (vec_vavguw);
|
|
pragma Inline_Always (vec_vavgsh);
|
|
pragma Inline_Always (vec_vavguh);
|
|
pragma Inline_Always (vec_vavgsb);
|
|
pragma Inline_Always (vec_vavgub);
|
|
pragma Inline_Always (vec_ceil);
|
|
pragma Inline_Always (vec_cmpb);
|
|
pragma Inline_Always (vec_cmpeq);
|
|
pragma Inline_Always (vec_vcmpeqfp);
|
|
pragma Inline_Always (vec_vcmpequw);
|
|
pragma Inline_Always (vec_vcmpequh);
|
|
pragma Inline_Always (vec_vcmpequb);
|
|
pragma Inline_Always (vec_cmpge);
|
|
pragma Inline_Always (vec_cmpgt);
|
|
pragma Inline_Always (vec_vcmpgtfp);
|
|
pragma Inline_Always (vec_vcmpgtsw);
|
|
pragma Inline_Always (vec_vcmpgtuw);
|
|
pragma Inline_Always (vec_vcmpgtsh);
|
|
pragma Inline_Always (vec_vcmpgtuh);
|
|
pragma Inline_Always (vec_vcmpgtsb);
|
|
pragma Inline_Always (vec_vcmpgtub);
|
|
pragma Inline_Always (vec_cmple);
|
|
pragma Inline_Always (vec_cmplt);
|
|
pragma Inline_Always (vec_expte);
|
|
pragma Inline_Always (vec_floor);
|
|
pragma Inline_Always (vec_ld);
|
|
pragma Inline_Always (vec_lde);
|
|
pragma Inline_Always (vec_lvewx);
|
|
pragma Inline_Always (vec_lvehx);
|
|
pragma Inline_Always (vec_lvebx);
|
|
pragma Inline_Always (vec_ldl);
|
|
pragma Inline_Always (vec_loge);
|
|
pragma Inline_Always (vec_lvsl);
|
|
pragma Inline_Always (vec_lvsr);
|
|
pragma Inline_Always (vec_madd);
|
|
pragma Inline_Always (vec_madds);
|
|
pragma Inline_Always (vec_max);
|
|
pragma Inline_Always (vec_vmaxfp);
|
|
pragma Inline_Always (vec_vmaxsw);
|
|
pragma Inline_Always (vec_vmaxuw);
|
|
pragma Inline_Always (vec_vmaxsh);
|
|
pragma Inline_Always (vec_vmaxuh);
|
|
pragma Inline_Always (vec_vmaxsb);
|
|
pragma Inline_Always (vec_vmaxub);
|
|
pragma Inline_Always (vec_mergeh);
|
|
pragma Inline_Always (vec_vmrghw);
|
|
pragma Inline_Always (vec_vmrghh);
|
|
pragma Inline_Always (vec_vmrghb);
|
|
pragma Inline_Always (vec_mergel);
|
|
pragma Inline_Always (vec_vmrglw);
|
|
pragma Inline_Always (vec_vmrglh);
|
|
pragma Inline_Always (vec_vmrglb);
|
|
pragma Inline_Always (vec_mfvscr);
|
|
pragma Inline_Always (vec_min);
|
|
pragma Inline_Always (vec_vminfp);
|
|
pragma Inline_Always (vec_vminsw);
|
|
pragma Inline_Always (vec_vminuw);
|
|
pragma Inline_Always (vec_vminsh);
|
|
pragma Inline_Always (vec_vminuh);
|
|
pragma Inline_Always (vec_vminsb);
|
|
pragma Inline_Always (vec_vminub);
|
|
pragma Inline_Always (vec_mladd);
|
|
pragma Inline_Always (vec_mradds);
|
|
pragma Inline_Always (vec_msum);
|
|
pragma Inline_Always (vec_vmsumshm);
|
|
pragma Inline_Always (vec_vmsumuhm);
|
|
pragma Inline_Always (vec_vmsummbm);
|
|
pragma Inline_Always (vec_vmsumubm);
|
|
pragma Inline_Always (vec_msums);
|
|
pragma Inline_Always (vec_vmsumshs);
|
|
pragma Inline_Always (vec_vmsumuhs);
|
|
pragma Inline_Always (vec_mtvscr);
|
|
pragma Inline_Always (vec_mule);
|
|
pragma Inline_Always (vec_vmulesh);
|
|
pragma Inline_Always (vec_vmuleuh);
|
|
pragma Inline_Always (vec_vmulesb);
|
|
pragma Inline_Always (vec_vmuleub);
|
|
pragma Inline_Always (vec_mulo);
|
|
pragma Inline_Always (vec_vmulosh);
|
|
pragma Inline_Always (vec_vmulouh);
|
|
pragma Inline_Always (vec_vmulosb);
|
|
pragma Inline_Always (vec_vmuloub);
|
|
pragma Inline_Always (vec_nmsub);
|
|
pragma Inline_Always (vec_nor);
|
|
pragma Inline_Always (vec_or);
|
|
pragma Inline_Always (vec_pack);
|
|
pragma Inline_Always (vec_vpkuwum);
|
|
pragma Inline_Always (vec_vpkuhum);
|
|
pragma Inline_Always (vec_packpx);
|
|
pragma Inline_Always (vec_packs);
|
|
pragma Inline_Always (vec_vpkswss);
|
|
pragma Inline_Always (vec_vpkuwus);
|
|
pragma Inline_Always (vec_vpkshss);
|
|
pragma Inline_Always (vec_vpkuhus);
|
|
pragma Inline_Always (vec_packsu);
|
|
pragma Inline_Always (vec_vpkswus);
|
|
pragma Inline_Always (vec_vpkshus);
|
|
pragma Inline_Always (vec_perm);
|
|
pragma Inline_Always (vec_re);
|
|
pragma Inline_Always (vec_rl);
|
|
pragma Inline_Always (vec_vrlw);
|
|
pragma Inline_Always (vec_vrlh);
|
|
pragma Inline_Always (vec_vrlb);
|
|
pragma Inline_Always (vec_round);
|
|
pragma Inline_Always (vec_rsqrte);
|
|
pragma Inline_Always (vec_sel);
|
|
pragma Inline_Always (vec_sl);
|
|
pragma Inline_Always (vec_vslw);
|
|
pragma Inline_Always (vec_vslh);
|
|
pragma Inline_Always (vec_vslb);
|
|
pragma Inline_Always (vec_sll);
|
|
pragma Inline_Always (vec_slo);
|
|
pragma Inline_Always (vec_sr);
|
|
pragma Inline_Always (vec_vsrw);
|
|
pragma Inline_Always (vec_vsrh);
|
|
pragma Inline_Always (vec_vsrb);
|
|
pragma Inline_Always (vec_sra);
|
|
pragma Inline_Always (vec_vsraw);
|
|
pragma Inline_Always (vec_vsrah);
|
|
pragma Inline_Always (vec_vsrab);
|
|
pragma Inline_Always (vec_srl);
|
|
pragma Inline_Always (vec_sro);
|
|
pragma Inline_Always (vec_st);
|
|
pragma Inline_Always (vec_ste);
|
|
pragma Inline_Always (vec_stvewx);
|
|
pragma Inline_Always (vec_stvehx);
|
|
pragma Inline_Always (vec_stvebx);
|
|
pragma Inline_Always (vec_stl);
|
|
pragma Inline_Always (vec_sub);
|
|
pragma Inline_Always (vec_vsubfp);
|
|
pragma Inline_Always (vec_vsubuwm);
|
|
pragma Inline_Always (vec_vsubuhm);
|
|
pragma Inline_Always (vec_vsububm);
|
|
pragma Inline_Always (vec_subc);
|
|
pragma Inline_Always (vec_subs);
|
|
pragma Inline_Always (vec_vsubsws);
|
|
pragma Inline_Always (vec_vsubuws);
|
|
pragma Inline_Always (vec_vsubshs);
|
|
pragma Inline_Always (vec_vsubuhs);
|
|
pragma Inline_Always (vec_vsubsbs);
|
|
pragma Inline_Always (vec_vsububs);
|
|
pragma Inline_Always (vec_sum4s);
|
|
pragma Inline_Always (vec_vsum4shs);
|
|
pragma Inline_Always (vec_vsum4sbs);
|
|
pragma Inline_Always (vec_vsum4ubs);
|
|
pragma Inline_Always (vec_sum2s);
|
|
pragma Inline_Always (vec_sums);
|
|
pragma Inline_Always (vec_trunc);
|
|
pragma Inline_Always (vec_unpackh);
|
|
pragma Inline_Always (vec_vupkhsh);
|
|
pragma Inline_Always (vec_vupkhpx);
|
|
pragma Inline_Always (vec_vupkhsb);
|
|
pragma Inline_Always (vec_unpackl);
|
|
pragma Inline_Always (vec_vupklpx);
|
|
pragma Inline_Always (vec_vupklsh);
|
|
pragma Inline_Always (vec_vupklsb);
|
|
pragma Inline_Always (vec_xor);
|
|
|
|
pragma Inline_Always (vec_all_eq);
|
|
pragma Inline_Always (vec_all_ge);
|
|
pragma Inline_Always (vec_all_gt);
|
|
pragma Inline_Always (vec_all_in);
|
|
pragma Inline_Always (vec_all_le);
|
|
pragma Inline_Always (vec_all_lt);
|
|
pragma Inline_Always (vec_all_nan);
|
|
pragma Inline_Always (vec_all_ne);
|
|
pragma Inline_Always (vec_all_nge);
|
|
pragma Inline_Always (vec_all_ngt);
|
|
pragma Inline_Always (vec_all_nle);
|
|
pragma Inline_Always (vec_all_nlt);
|
|
pragma Inline_Always (vec_all_numeric);
|
|
pragma Inline_Always (vec_any_eq);
|
|
pragma Inline_Always (vec_any_ge);
|
|
pragma Inline_Always (vec_any_gt);
|
|
pragma Inline_Always (vec_any_le);
|
|
pragma Inline_Always (vec_any_lt);
|
|
pragma Inline_Always (vec_any_nan);
|
|
pragma Inline_Always (vec_any_ne);
|
|
pragma Inline_Always (vec_any_nge);
|
|
pragma Inline_Always (vec_any_ngt);
|
|
pragma Inline_Always (vec_any_nle);
|
|
pragma Inline_Always (vec_any_nlt);
|
|
pragma Inline_Always (vec_any_numeric);
|
|
pragma Inline_Always (vec_any_out);
|
|
pragma Inline_Always (vec_step);
|
|
|
|
end GNAT.Altivec.Vector_Operations;
|