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