| ------------------------------------------------------------------------------ |
| -- -- |
| -- 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; |
| |
|
