# Makefile.rtl for GNU Ada Compiler (GNAT).
-# Copyright (C) 2003, 2004 Free Software Foundation, Inc.
+# Copyright (C) 2003-2005, Free Software Foundation, Inc.
#This file is part of GCC.
a-sytaco$(objext) \
a-tasatt$(objext) \
a-taside$(objext) \
+ a-taster$(objext) \
g-boubuf$(objext) \
g-boumai$(objext) \
g-semaph$(objext) \
a-zzunio$(objext) \
ada$(objext) \
calendar$(objext) \
+ g-allein$(objext) \
+ g-alleve$(objext) \
+ g-altcon$(objext) \
+ g-altive$(objext) \
+ g-alveop$(objext) \
+ g-alvety$(objext) \
+ g-alvevi$(objext) \
g-arrspl$(objext) \
g-awk$(objext) \
g-bubsor$(objext) \
s-sopco4$(objext) \
s-sopco5$(objext) \
s-stache$(objext) \
+ s-stausa$(objext) \
s-stchop$(objext) \
s-stalib$(objext) \
s-stoele$(objext) \
-- Default version for most targets
with System.Standard_Library; use System.Standard_Library;
+-- Used for Adafinal
+
+with System.Soft_Links;
+-- Used for Task_Termination_Handler
+-- Task_Termination_NT
procedure Ada.Exceptions.Last_Chance_Handler
(Except : Exception_Occurrence)
-- Convenient shortcut
begin
+ -- Do not execute any task termination code when shutting down the system.
+ -- The Adafinal procedure would execute the task termination routine for
+ -- normal termination, but we have already executed the task termination
+ -- procedure because of an unhandled exception.
+
+ System.Soft_Links.Task_Termination_Handler :=
+ System.Soft_Links.Task_Termination_NT'Access;
+
-- Let's shutdown the runtime now. The rest of the procedure needs to be
-- careful not to use anything that would require runtime support. In
-- particular, functions returning strings are banned since the sec stack
-- Hook for GDB to support "break exception unhandled"
-- For "break exception", GDB uses __gnat_raise_nodefer_with_msg, which
- -- is not in this section because it fullfills other purposes than a mere
+ -- is not in this section because it functions as more than simply a
-- debugger interface.
--------------------------------
--------------------------------
procedure Notify_Unhandled_Exception is
+ Excep : constant EOA := Get_Current_Excep.all;
+
begin
- Notify_Exception (Get_Current_Excep.all, Is_Unhandled => True);
+ -- Check whether there is any termination handler to be executed for
+ -- the environment task, and execute it if needed. Here we handle both
+ -- the Abnormal and Unhandled_Exception task termination. Normal
+ -- task termination routine is executed elsewhere (either in the
+ -- Task_Wrapper or in the Adafinal routine for the environment task).
+
+ Task_Termination_Handler.all (Excep.all);
+
+ Notify_Exception (Excep, Is_Unhandled => True);
Unhandled_Exception;
end Notify_Unhandled_Exception;
-- package will be categorized as Preelaborate. See AI-362 for details.
-- It is safe in the context of the run-time to violate the rules!
-with System.Tasking.Stages;
+with System.Tasking.Utilities;
+-- Used for Abort_Tasks
pragma Warnings (On);
if T = Null_Task_Id then
raise Program_Error;
else
- System.Tasking.Stages.Abort_Tasks
+ System.Tasking.Utilities.Abort_Tasks
(System.Tasking.Task_List'(1 => Convert_Ids (T)));
end if;
end Abort_Task;
--- /dev/null
+------------------------------------------------------------------------------
+-- --
+-- GNAT RUN-TIME COMPONENTS --
+-- --
+-- A D A . T A S K _ T E R M I N A T I O N --
+-- --
+-- B o d y --
+-- --
+-- Copyright (C) 2005, Free Software Foundation, Inc. --
+-- --
+-- This specification is derived from the Ada Reference Manual for use with --
+-- GNAT. The copyright notice above, and the license provisions that follow --
+-- apply solely to the contents of the part following the private keyword. --
+-- --
+-- 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 2, 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. See the GNU General Public License --
+-- for more details. You should have received a copy of the GNU General --
+-- Public License distributed with GNAT; see file COPYING. If not, write --
+-- to the Free Software Foundation, 51 Franklin Street, Fifth Floor, --
+-- Boston, MA 02110-1301, USA. --
+-- --
+-- As a special exception, if other files instantiate generics from this --
+-- unit, or you link this unit with other files to produce an executable, --
+-- this unit does not by itself cause the resulting executable to be --
+-- covered by the GNU General Public License. This exception does not --
+-- however invalidate any other reasons why the executable file might be --
+-- covered by the GNU Public License. --
+-- --
+-- GNAT was originally developed by the GNAT team at New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc. --
+-- --
+------------------------------------------------------------------------------
+
+with System.Tasking;
+-- used for Task_Id
+
+with System.Task_Primitives.Operations;
+-- used for Self
+
+with Unchecked_Conversion;
+
+package body Ada.Task_Termination is
+
+ use type Ada.Task_Identification.Task_Id;
+
+ package STPO renames System.Task_Primitives.Operations;
+
+ -----------------------
+ -- Local subprograms --
+ -----------------------
+
+ function To_TT is new Unchecked_Conversion
+ (System.Tasking.Termination_Handler, Termination_Handler);
+
+ function To_ST is new Unchecked_Conversion
+ (Termination_Handler, System.Tasking.Termination_Handler);
+
+ function To_Task_Id is new Unchecked_Conversion
+ (Ada.Task_Identification.Task_Id, System.Tasking.Task_Id);
+
+ -----------------------------------
+ -- Current_Task_Fallback_Handler --
+ -----------------------------------
+
+ function Current_Task_Fallback_Handler return Termination_Handler is
+ begin
+ return To_TT (System.Tasking.Self.Common.Fall_Back_Handler);
+ end Current_Task_Fallback_Handler;
+
+ -------------------------------------
+ -- Set_Dependents_Fallback_Handler --
+ -------------------------------------
+
+ procedure Set_Dependents_Fallback_Handler
+ (Handler : Termination_Handler)
+ is
+ begin
+ STPO.Self.Common.Fall_Back_Handler := To_ST (Handler);
+ end Set_Dependents_Fallback_Handler;
+
+ --------------------------
+ -- Set_Specific_Handler --
+ --------------------------
+
+ procedure Set_Specific_Handler
+ (T : Ada.Task_Identification.Task_Id;
+ Handler : Termination_Handler)
+ is
+ begin
+ -- Tasking_Error is raised if the task identified by T has already
+ -- terminated. Program_Error is raised if the value of T is
+ -- Null_Task_Id.
+
+ if T = Ada.Task_Identification.Null_Task_Id then
+ raise Program_Error;
+ elsif Ada.Task_Identification.Is_Terminated (T) then
+ raise Tasking_Error;
+ else
+ To_Task_Id (T).Common.Specific_Handler := To_ST (Handler);
+ end if;
+ end Set_Specific_Handler;
+
+ ----------------------
+ -- Specific_Handler --
+ ----------------------
+
+ function Specific_Handler
+ (T : Ada.Task_Identification.Task_Id) return Termination_Handler
+ is
+ begin
+ -- Tasking_Error is raised if the task identified by T has already
+ -- terminated. Program_Error is raised if the value of T is
+ -- Null_Task_Id.
+
+ if T = Ada.Task_Identification.Null_Task_Id then
+ raise Program_Error;
+ elsif Ada.Task_Identification.Is_Terminated (T) then
+ raise Tasking_Error;
+ else
+ return To_TT (To_Task_Id (T).Common.Specific_Handler);
+ end if;
+ end Specific_Handler;
+
+end Ada.Task_Termination;
--- /dev/null
+------------------------------------------------------------------------------
+-- --
+-- GNAT RUN-TIME COMPONENTS --
+-- --
+-- A D A . T A S K _ T E R M I N A T I O N --
+-- --
+-- S p e c --
+-- --
+-- Copyright (C) 2005, Free Software Foundation, Inc. --
+-- --
+-- This specification is derived from the Ada Reference Manual for use with --
+-- GNAT. The copyright notice above, and the license provisions that follow --
+-- apply solely to the contents of the part following the private keyword. --
+-- --
+-- GNAT was originally developed by the GNAT team at New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc. --
+-- --
+------------------------------------------------------------------------------
+
+with Ada.Task_Identification;
+with Ada.Exceptions;
+
+package Ada.Task_Termination is
+ pragma Preelaborate (Task_Termination);
+
+ type Cause_Of_Termination is (Normal, Abnormal, Unhandled_Exception);
+
+ type Termination_Handler is access protected procedure
+ (Cause : Cause_Of_Termination;
+ T : Ada.Task_Identification.Task_Id;
+ X : Ada.Exceptions.Exception_Occurrence);
+
+ procedure Set_Dependents_Fallback_Handler
+ (Handler : Termination_Handler);
+ function Current_Task_Fallback_Handler return Termination_Handler;
+
+ procedure Set_Specific_Handler
+ (T : Ada.Task_Identification.Task_Id;
+ Handler : Termination_Handler);
+ function Specific_Handler
+ (T : Ada.Task_Identification.Task_Id) return Termination_Handler;
+
+end Ada.Task_Termination;
WBI (" pragma Import (C, finalize, ""__gnat_finalize"");");
end if;
+ -- If we want to analyze the stack, we have to import corresponding
+ -- symbols
+
+ if Dynamic_Stack_Measurement then
+ WBI ("");
+ WBI (" procedure Output_Results;");
+ WBI (" pragma Import (C, Output_Results, " &
+ """__gnat_stack_usage_output_results"");");
+
+ WBI ("");
+ WBI (" " &
+ "procedure Initialize_Stack_Analysis (Buffer_Size : Natural);");
+ WBI (" pragma Import (C, Initialize_Stack_Analysis, " &
+ """__gnat_stack_usage_initialize"");");
+ end if;
+
-- Deal with declarations for main program case
if not No_Main_Subprogram then
Write_Statement_Buffer;
end if;
+ if Dynamic_Stack_Measurement then
+ Set_String (" Initialize_Stack_Analysis (");
+ Set_Int (Dynamic_Stack_Measurement_Array_Size);
+ Set_String (");");
+ Write_Statement_Buffer;
+ end if;
+
if not Cumulative_Restrictions.Set (No_Finalization) then
if not No_Main_Subprogram
end if;
end if;
+ -- Prints the result of static stack analysis
+
+ if Dynamic_Stack_Measurement then
+ WBI (" Output_Results;");
+ end if;
+
-- Finalize is only called if we have a run time
if not Cumulative_Restrictions.Set (No_Finalization) then
Write_Statement_Buffer;
end if;
+ -- Initializes dynamic stack measurement if needed
+
+ if Dynamic_Stack_Measurement then
+ Set_String (" __gnat_stack_usage_initialize (");
+ Set_Int (Dynamic_Stack_Measurement_Array_Size);
+ Set_String (");");
+ Write_Statement_Buffer;
+ end if;
+
-- The __gnat_initialize routine is used only if we have a run-time
if not Suppress_Standard_Library_On_Target then
WBI (" system__standard_library__adafinal ();");
end if;
+ -- Outputs the dynamic stack measurement if needed
+
+ if Dynamic_Stack_Measurement then
+ WBI (" __gnat_stack_usage_output_results ();");
+ end if;
+
-- The finalize routine is used only if we have a run-time
if not Suppress_Standard_Library_On_Target then
-- filename object is seen. Multiply defined symbols will
-- result.
- if Hostparm.OpenVMS
+ if OpenVMS_On_Target
and then Is_Internal_File_Name
(ALIs.Table
(Units.Table (Elab_Order.Table (E)).My_ALI).Sfile)
WBI ("extern void __gnat_install_handler (void);");
end if;
+ if Dynamic_Stack_Measurement then
+ WBI ("");
+ WBI ("extern void __gnat_stack_usage_output_results (void);");
+ WBI ("extern void __gnat_stack_usage_initialize (int size);");
+ end if;
+
WBI ("");
Gen_Elab_Defs_C;
With_GNARL := True;
end if;
- if Hostparm.OpenVMS and then Name_Buffer (1 .. 5) = "dec%s" then
+ if OpenVMS_On_Target and then Name_Buffer (1 .. 5) = "dec%s" then
With_DECGNAT := True;
end if;
end loop;
Write_Str (" -Tn Set time slice value to n milliseconds (n >= 0)");
Write_Eol;
+ -- Line for -u switch
+
+ Write_Str (" -un Enable dynamic stack analysis, with n results ");
+ Write_Str ("stored");
+ Write_Eol;
+
-- Line for -v switch
Write_Str (" -v Verbose mode. Error messages, ");
--- /dev/null
+------------------------------------------------------------------------------
+-- --
+-- GNAT COMPILER COMPONENTS --
+-- --
+-- G N A T . A L T I V E C . L O W _ L E V E L _ I N T E R F A C E --
+-- --
+-- S p e c --
+-- --
+-- Copyright (C) 2004-2005, 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 2, 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. See the GNU General Public License --
+-- for more details. You should have received a copy of the GNU General --
+-- Public License distributed with GNAT; see file COPYING. If not, write --
+-- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
+-- MA 02111-1307, USA. --
+-- --
+-- As a special exception, if other files instantiate generics from this --
+-- unit, or you link this unit with other files to produce an executable, --
+-- this unit does not by itself cause the resulting executable to be --
+-- covered by the GNU General Public License. This exception does not --
+-- however invalidate any other reasons why the executable file might be --
+-- covered by the GNU Public License. --
+-- --
+-- GNAT was originally developed by the GNAT team at New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc. --
+-- --
+------------------------------------------------------------------------------
+
+-- This unit provides entities to be used internally by the units common to
+-- both bindings (Hard or Soft), and relevant to the interfacing with the
+-- underlying Low Level support.
+
+-- The set of "services" includes:
+--
+-- o Imports to the low level routines for which a direct binding is
+-- mandatory (or just possible when analyzed as such).
+--
+-- o Conversion routines (unchecked) between low level types, or between
+-- various pointer representations.
+
+with GNAT.Altivec.Vector_Types;
+with GNAT.Altivec.Low_Level_Vectors;
+
+with Ada.Unchecked_Conversion;
+
+package GNAT.Altivec.Low_Level_Interface is
+
+ ----------------------------------------------------------------------------
+ -- Imports for "argument must be literal" constraints in the Hard binding --
+ ----------------------------------------------------------------------------
+
+ use GNAT.Altivec.Vector_Types;
+
+ -- vec_ctf --
+
+ function vec_ctf_vui_cint_r_vf
+ (A : vector_unsigned_int;
+ B : c_int) return vector_float;
+
+ pragma Import
+ (LL_Altivec, vec_ctf_vui_cint_r_vf, "__builtin_altivec_vcfux");
+
+ function vec_ctf_vsi_cint_r_vf
+ (A : vector_signed_int;
+ B : c_int) return vector_float;
+
+ pragma Import
+ (LL_Altivec, vec_ctf_vsi_cint_r_vf, "__builtin_altivec_vcfsx");
+
+ -- vec_vcfsx --
+
+ function vec_vcfsx_vsi_cint_r_vf
+ (A : vector_signed_int;
+ B : c_int) return vector_float;
+
+ pragma Import
+ (LL_Altivec, vec_vcfsx_vsi_cint_r_vf, "__builtin_altivec_vcfsx");
+
+ -- vec_vcfux --
+
+ function vec_vcfux_vui_cint_r_vf
+ (A : vector_unsigned_int;
+ B : c_int) return vector_float;
+
+ pragma Import
+ (LL_Altivec, vec_vcfux_vui_cint_r_vf, "__builtin_altivec_vcfux");
+
+ -- vec_cts --
+
+ function vec_cts_vf_cint_r_vsi
+ (A : vector_float;
+ B : c_int) return vector_signed_int;
+
+ pragma Import
+ (LL_Altivec, vec_cts_vf_cint_r_vsi, "__builtin_altivec_vctsxs");
+
+ -- vec_ctu --
+
+ function vec_ctu_vf_cint_r_vui
+ (A : vector_float;
+ B : c_int) return vector_unsigned_int;
+
+ pragma Import
+ (LL_Altivec, vec_ctu_vf_cint_r_vui, "__builtin_altivec_vctuxs");
+
+ -- vec_dss --
+
+ procedure vec_dss_cint
+ (A : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dss_cint, "__builtin_altivec_dss");
+
+ -- vec_dst --
+
+ procedure vec_dst_kvucp_cint_cint
+ (A : const_vector_unsigned_char_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dst_kvucp_cint_cint, "__builtin_altivec_dst");
+
+ procedure vec_dst_kvscp_cint_cint
+ (A : const_vector_signed_char_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dst_kvscp_cint_cint, "__builtin_altivec_dst");
+
+ procedure vec_dst_kvbcp_cint_cint
+ (A : const_vector_bool_char_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dst_kvbcp_cint_cint, "__builtin_altivec_dst");
+
+ procedure vec_dst_kvusp_cint_cint
+ (A : const_vector_unsigned_short_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dst_kvusp_cint_cint, "__builtin_altivec_dst");
+
+ procedure vec_dst_kvssp_cint_cint
+ (A : const_vector_signed_short_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dst_kvssp_cint_cint, "__builtin_altivec_dst");
+
+ procedure vec_dst_kvbsp_cint_cint
+ (A : const_vector_bool_short_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dst_kvbsp_cint_cint, "__builtin_altivec_dst");
+
+ procedure vec_dst_kvxp_cint_cint
+ (A : const_vector_pixel_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dst_kvxp_cint_cint, "__builtin_altivec_dst");
+
+ procedure vec_dst_kvuip_cint_cint
+ (A : const_vector_unsigned_int_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dst_kvuip_cint_cint, "__builtin_altivec_dst");
+
+ procedure vec_dst_kvsip_cint_cint
+ (A : const_vector_signed_int_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dst_kvsip_cint_cint, "__builtin_altivec_dst");
+
+ procedure vec_dst_kvbip_cint_cint
+ (A : const_vector_bool_int_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dst_kvbip_cint_cint, "__builtin_altivec_dst");
+
+ procedure vec_dst_kvfp_cint_cint
+ (A : const_vector_float_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dst_kvfp_cint_cint, "__builtin_altivec_dst");
+
+ procedure vec_dst_kucp_cint_cint
+ (A : const_unsigned_char_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dst_kucp_cint_cint, "__builtin_altivec_dst");
+
+ procedure vec_dst_kscp_cint_cint
+ (A : const_signed_char_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dst_kscp_cint_cint, "__builtin_altivec_dst");
+
+ procedure vec_dst_kusp_cint_cint
+ (A : const_unsigned_short_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dst_kusp_cint_cint, "__builtin_altivec_dst");
+
+ procedure vec_dst_ksp_cint_cint
+ (A : const_short_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dst_ksp_cint_cint, "__builtin_altivec_dst");
+
+ procedure vec_dst_kuip_cint_cint
+ (A : const_unsigned_int_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dst_kuip_cint_cint, "__builtin_altivec_dst");
+
+ procedure vec_dst_kip_cint_cint
+ (A : const_int_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dst_kip_cint_cint, "__builtin_altivec_dst");
+
+ procedure vec_dst_kulongp_cint_cint
+ (A : const_unsigned_long_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dst_kulongp_cint_cint, "__builtin_altivec_dst");
+
+ procedure vec_dst_klongp_cint_cint
+ (A : const_long_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dst_klongp_cint_cint, "__builtin_altivec_dst");
+
+ procedure vec_dst_kfp_cint_cint
+ (A : const_float_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dst_kfp_cint_cint, "__builtin_altivec_dst");
+
+ -- vec_dstst --
+
+ procedure vec_dstst_kvucp_cint_cint
+ (A : const_vector_unsigned_char_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstst_kvucp_cint_cint, "__builtin_altivec_dstst");
+
+ procedure vec_dstst_kvscp_cint_cint
+ (A : const_vector_signed_char_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstst_kvscp_cint_cint, "__builtin_altivec_dstst");
+
+ procedure vec_dstst_kvbcp_cint_cint
+ (A : const_vector_bool_char_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstst_kvbcp_cint_cint, "__builtin_altivec_dstst");
+
+ procedure vec_dstst_kvusp_cint_cint
+ (A : const_vector_unsigned_short_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstst_kvusp_cint_cint, "__builtin_altivec_dstst");
+
+ procedure vec_dstst_kvssp_cint_cint
+ (A : const_vector_signed_short_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstst_kvssp_cint_cint, "__builtin_altivec_dstst");
+
+ procedure vec_dstst_kvbsp_cint_cint
+ (A : const_vector_bool_short_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstst_kvbsp_cint_cint, "__builtin_altivec_dstst");
+
+ procedure vec_dstst_kvxp_cint_cint
+ (A : const_vector_pixel_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstst_kvxp_cint_cint, "__builtin_altivec_dstst");
+
+ procedure vec_dstst_kvuip_cint_cint
+ (A : const_vector_unsigned_int_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstst_kvuip_cint_cint, "__builtin_altivec_dstst");
+
+ procedure vec_dstst_kvsip_cint_cint
+ (A : const_vector_signed_int_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstst_kvsip_cint_cint, "__builtin_altivec_dstst");
+
+ procedure vec_dstst_kvbip_cint_cint
+ (A : const_vector_bool_int_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstst_kvbip_cint_cint, "__builtin_altivec_dstst");
+
+ procedure vec_dstst_kvfp_cint_cint
+ (A : const_vector_float_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstst_kvfp_cint_cint, "__builtin_altivec_dstst");
+
+ procedure vec_dstst_kucp_cint_cint
+ (A : const_unsigned_char_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstst_kucp_cint_cint, "__builtin_altivec_dstst");
+
+ procedure vec_dstst_kscp_cint_cint
+ (A : const_signed_char_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstst_kscp_cint_cint, "__builtin_altivec_dstst");
+
+ procedure vec_dstst_kusp_cint_cint
+ (A : const_unsigned_short_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstst_kusp_cint_cint, "__builtin_altivec_dstst");
+
+ procedure vec_dstst_ksp_cint_cint
+ (A : const_short_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstst_ksp_cint_cint, "__builtin_altivec_dstst");
+
+ procedure vec_dstst_kuip_cint_cint
+ (A : const_unsigned_int_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstst_kuip_cint_cint, "__builtin_altivec_dstst");
+
+ procedure vec_dstst_kip_cint_cint
+ (A : const_int_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstst_kip_cint_cint, "__builtin_altivec_dstst");
+
+ procedure vec_dstst_kulongp_cint_cint
+ (A : const_unsigned_long_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstst_kulongp_cint_cint, "__builtin_altivec_dstst");
+
+ procedure vec_dstst_klongp_cint_cint
+ (A : const_long_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstst_klongp_cint_cint, "__builtin_altivec_dstst");
+
+ procedure vec_dstst_kfp_cint_cint
+ (A : const_float_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstst_kfp_cint_cint, "__builtin_altivec_dstst");
+
+ -- vec_dststt --
+
+ procedure vec_dststt_kvucp_cint_cint
+ (A : const_vector_unsigned_char_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dststt_kvucp_cint_cint, "__builtin_altivec_dststt");
+
+ procedure vec_dststt_kvscp_cint_cint
+ (A : const_vector_signed_char_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dststt_kvscp_cint_cint, "__builtin_altivec_dststt");
+
+ procedure vec_dststt_kvbcp_cint_cint
+ (A : const_vector_bool_char_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dststt_kvbcp_cint_cint, "__builtin_altivec_dststt");
+
+ procedure vec_dststt_kvusp_cint_cint
+ (A : const_vector_unsigned_short_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dststt_kvusp_cint_cint, "__builtin_altivec_dststt");
+
+ procedure vec_dststt_kvssp_cint_cint
+ (A : const_vector_signed_short_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dststt_kvssp_cint_cint, "__builtin_altivec_dststt");
+
+ procedure vec_dststt_kvbsp_cint_cint
+ (A : const_vector_bool_short_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dststt_kvbsp_cint_cint, "__builtin_altivec_dststt");
+
+ procedure vec_dststt_kvxp_cint_cint
+ (A : const_vector_pixel_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dststt_kvxp_cint_cint, "__builtin_altivec_dststt");
+
+ procedure vec_dststt_kvuip_cint_cint
+ (A : const_vector_unsigned_int_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dststt_kvuip_cint_cint, "__builtin_altivec_dststt");
+
+ procedure vec_dststt_kvsip_cint_cint
+ (A : const_vector_signed_int_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dststt_kvsip_cint_cint, "__builtin_altivec_dststt");
+
+ procedure vec_dststt_kvbip_cint_cint
+ (A : const_vector_bool_int_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dststt_kvbip_cint_cint, "__builtin_altivec_dststt");
+
+ procedure vec_dststt_kvfp_cint_cint
+ (A : const_vector_float_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dststt_kvfp_cint_cint, "__builtin_altivec_dststt");
+
+ procedure vec_dststt_kucp_cint_cint
+ (A : const_unsigned_char_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dststt_kucp_cint_cint, "__builtin_altivec_dststt");
+
+ procedure vec_dststt_kscp_cint_cint
+ (A : const_signed_char_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dststt_kscp_cint_cint, "__builtin_altivec_dststt");
+
+ procedure vec_dststt_kusp_cint_cint
+ (A : const_unsigned_short_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dststt_kusp_cint_cint, "__builtin_altivec_dststt");
+
+ procedure vec_dststt_ksp_cint_cint
+ (A : const_short_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dststt_ksp_cint_cint, "__builtin_altivec_dststt");
+
+ procedure vec_dststt_kuip_cint_cint
+ (A : const_unsigned_int_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dststt_kuip_cint_cint, "__builtin_altivec_dststt");
+
+ procedure vec_dststt_kip_cint_cint
+ (A : const_int_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dststt_kip_cint_cint, "__builtin_altivec_dststt");
+
+ procedure vec_dststt_kulongp_cint_cint
+ (A : const_unsigned_long_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dststt_kulongp_cint_cint, "__builtin_altivec_dststt");
+
+ procedure vec_dststt_klongp_cint_cint
+ (A : const_long_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dststt_klongp_cint_cint, "__builtin_altivec_dststt");
+
+ procedure vec_dststt_kfp_cint_cint
+ (A : const_float_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dststt_kfp_cint_cint, "__builtin_altivec_dststt");
+
+ -- vec_dstt --
+
+ procedure vec_dstt_kvucp_cint_cint
+ (A : const_vector_unsigned_char_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstt_kvucp_cint_cint, "__builtin_altivec_dstt");
+
+ procedure vec_dstt_kvscp_cint_cint
+ (A : const_vector_signed_char_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstt_kvscp_cint_cint, "__builtin_altivec_dstt");
+
+ procedure vec_dstt_kvbcp_cint_cint
+ (A : const_vector_bool_char_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstt_kvbcp_cint_cint, "__builtin_altivec_dstt");
+
+ procedure vec_dstt_kvusp_cint_cint
+ (A : const_vector_unsigned_short_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstt_kvusp_cint_cint, "__builtin_altivec_dstt");
+
+ procedure vec_dstt_kvssp_cint_cint
+ (A : const_vector_signed_short_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstt_kvssp_cint_cint, "__builtin_altivec_dstt");
+
+ procedure vec_dstt_kvbsp_cint_cint
+ (A : const_vector_bool_short_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstt_kvbsp_cint_cint, "__builtin_altivec_dstt");
+
+ procedure vec_dstt_kvxp_cint_cint
+ (A : const_vector_pixel_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstt_kvxp_cint_cint, "__builtin_altivec_dstt");
+
+ procedure vec_dstt_kvuip_cint_cint
+ (A : const_vector_unsigned_int_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstt_kvuip_cint_cint, "__builtin_altivec_dstt");
+
+ procedure vec_dstt_kvsip_cint_cint
+ (A : const_vector_signed_int_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstt_kvsip_cint_cint, "__builtin_altivec_dstt");
+
+ procedure vec_dstt_kvbip_cint_cint
+ (A : const_vector_bool_int_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstt_kvbip_cint_cint, "__builtin_altivec_dstt");
+
+ procedure vec_dstt_kvfp_cint_cint
+ (A : const_vector_float_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstt_kvfp_cint_cint, "__builtin_altivec_dstt");
+
+ procedure vec_dstt_kucp_cint_cint
+ (A : const_unsigned_char_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstt_kucp_cint_cint, "__builtin_altivec_dstt");
+
+ procedure vec_dstt_kscp_cint_cint
+ (A : const_signed_char_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstt_kscp_cint_cint, "__builtin_altivec_dstt");
+
+ procedure vec_dstt_kusp_cint_cint
+ (A : const_unsigned_short_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstt_kusp_cint_cint, "__builtin_altivec_dstt");
+
+ procedure vec_dstt_ksp_cint_cint
+ (A : const_short_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstt_ksp_cint_cint, "__builtin_altivec_dstt");
+
+ procedure vec_dstt_kuip_cint_cint
+ (A : const_unsigned_int_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstt_kuip_cint_cint, "__builtin_altivec_dstt");
+
+ procedure vec_dstt_kip_cint_cint
+ (A : const_int_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstt_kip_cint_cint, "__builtin_altivec_dstt");
+
+ procedure vec_dstt_kulongp_cint_cint
+ (A : const_unsigned_long_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstt_kulongp_cint_cint, "__builtin_altivec_dstt");
+
+ procedure vec_dstt_klongp_cint_cint
+ (A : const_long_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstt_klongp_cint_cint, "__builtin_altivec_dstt");
+
+ procedure vec_dstt_kfp_cint_cint
+ (A : const_float_ptr;
+ B : c_int;
+ C : c_int);
+
+ pragma Import
+ (LL_Altivec, vec_dstt_kfp_cint_cint, "__builtin_altivec_dstt");
+
+ -- vec_sld --
+
+ -- ??? The base GCC implementation maps everything to vsldoi_4si, while
+ -- it defines builtin variants for all the modes. Adjust here, to avoid
+ -- the infamous argument mode mismatch.
+
+ function vec_sld_vf_vf_cint_r_vf
+ (A : vector_float;
+ B : vector_float;
+ C : c_int) return vector_float;
+
+ pragma Import
+ (LL_Altivec, vec_sld_vf_vf_cint_r_vf, "__builtin_altivec_vsldoi_4sf");
+
+ function vec_sld_vsi_vsi_cint_r_vsi
+ (A : vector_signed_int;
+ B : vector_signed_int;
+ C : c_int) return vector_signed_int;
+
+ pragma Import
+ (LL_Altivec, vec_sld_vsi_vsi_cint_r_vsi, "__builtin_altivec_vsldoi_4si");
+
+ function vec_sld_vui_vui_cint_r_vui
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int;
+ C : c_int) return vector_unsigned_int;
+
+ pragma Import
+ (LL_Altivec, vec_sld_vui_vui_cint_r_vui, "__builtin_altivec_vsldoi_4si");
+
+ function vec_sld_vbi_vbi_cint_r_vbi
+ (A : vector_bool_int;
+ B : vector_bool_int;
+ C : c_int) return vector_bool_int;
+
+ pragma Import
+ (LL_Altivec, vec_sld_vbi_vbi_cint_r_vbi, "__builtin_altivec_vsldoi_4si");
+
+ function vec_sld_vss_vss_cint_r_vss
+ (A : vector_signed_short;
+ B : vector_signed_short;
+ C : c_int) return vector_signed_short;
+
+ pragma Import
+ (LL_Altivec, vec_sld_vss_vss_cint_r_vss, "__builtin_altivec_vsldoi_8hi");
+
+ function vec_sld_vus_vus_cint_r_vus
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short;
+ C : c_int) return vector_unsigned_short;
+
+ pragma Import
+ (LL_Altivec, vec_sld_vus_vus_cint_r_vus, "__builtin_altivec_vsldoi_8hi");
+
+ function vec_sld_vbs_vbs_cint_r_vbs
+ (A : vector_bool_short;
+ B : vector_bool_short;
+ C : c_int) return vector_bool_short;
+
+ pragma Import
+ (LL_Altivec, vec_sld_vbs_vbs_cint_r_vbs, "__builtin_altivec_vsldoi_8hi");
+
+ function vec_sld_vx_vx_cint_r_vx
+ (A : vector_pixel;
+ B : vector_pixel;
+ C : c_int) return vector_pixel;
+
+ pragma Import
+ (LL_Altivec, vec_sld_vx_vx_cint_r_vx, "__builtin_altivec_vsldoi_4si");
+
+ function vec_sld_vsc_vsc_cint_r_vsc
+ (A : vector_signed_char;
+ B : vector_signed_char;
+ C : c_int) return vector_signed_char;
+
+ pragma Import
+ (LL_Altivec, vec_sld_vsc_vsc_cint_r_vsc, "__builtin_altivec_vsldoi_16qi");
+
+ function vec_sld_vuc_vuc_cint_r_vuc
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char;
+ C : c_int) return vector_unsigned_char;
+
+ pragma Import
+ (LL_Altivec, vec_sld_vuc_vuc_cint_r_vuc, "__builtin_altivec_vsldoi_16qi");
+
+ function vec_sld_vbc_vbc_cint_r_vbc
+ (A : vector_bool_char;
+ B : vector_bool_char;
+ C : c_int) return vector_bool_char;
+
+ pragma Import
+ (LL_Altivec, vec_sld_vbc_vbc_cint_r_vbc, "__builtin_altivec_vsldoi_16qi");
+
+ -- vec_splat --
+
+ function vec_splat_vsc_cint_r_vsc
+ (A : vector_signed_char;
+ B : c_int) return vector_signed_char;
+
+ pragma Import
+ (LL_Altivec, vec_splat_vsc_cint_r_vsc, "__builtin_altivec_vspltb");
+
+ function vec_splat_vuc_cint_r_vuc
+ (A : vector_unsigned_char;
+ B : c_int) return vector_unsigned_char;
+
+ pragma Import
+ (LL_Altivec, vec_splat_vuc_cint_r_vuc, "__builtin_altivec_vspltb");
+
+ function vec_splat_vbc_cint_r_vbc
+ (A : vector_bool_char;
+ B : c_int) return vector_bool_char;
+
+ pragma Import
+ (LL_Altivec, vec_splat_vbc_cint_r_vbc, "__builtin_altivec_vspltb");
+
+ function vec_splat_vss_cint_r_vss
+ (A : vector_signed_short;
+ B : c_int) return vector_signed_short;
+
+ pragma Import
+ (LL_Altivec, vec_splat_vss_cint_r_vss, "__builtin_altivec_vsplth");
+
+ function vec_splat_vus_cint_r_vus
+ (A : vector_unsigned_short;
+ B : c_int) return vector_unsigned_short;
+
+ pragma Import
+ (LL_Altivec, vec_splat_vus_cint_r_vus, "__builtin_altivec_vsplth");
+
+ function vec_splat_vbs_cint_r_vbs
+ (A : vector_bool_short;
+ B : c_int) return vector_bool_short;
+
+ pragma Import
+ (LL_Altivec, vec_splat_vbs_cint_r_vbs, "__builtin_altivec_vsplth");
+
+ function vec_splat_vx_cint_r_vx
+ (A : vector_pixel;
+ B : c_int) return vector_pixel;
+
+ pragma Import
+ (LL_Altivec, vec_splat_vx_cint_r_vx, "__builtin_altivec_vsplth");
+
+ function vec_splat_vf_cint_r_vf
+ (A : vector_float;
+ B : c_int) return vector_float;
+
+ pragma Import
+ (LL_Altivec, vec_splat_vf_cint_r_vf, "__builtin_altivec_vspltw");
+
+ function vec_splat_vsi_cint_r_vsi
+ (A : vector_signed_int;
+ B : c_int) return vector_signed_int;
+
+ pragma Import
+ (LL_Altivec, vec_splat_vsi_cint_r_vsi, "__builtin_altivec_vspltw");
+
+ function vec_splat_vui_cint_r_vui
+ (A : vector_unsigned_int;
+ B : c_int) return vector_unsigned_int;
+
+ pragma Import
+ (LL_Altivec, vec_splat_vui_cint_r_vui, "__builtin_altivec_vspltw");
+
+ function vec_splat_vbi_cint_r_vbi
+ (A : vector_bool_int;
+ B : c_int) return vector_bool_int;
+
+ pragma Import
+ (LL_Altivec, vec_splat_vbi_cint_r_vbi, "__builtin_altivec_vspltw");
+
+ -- vec_vspltw --
+
+ function vec_vspltw_vf_cint_r_vf
+ (A : vector_float;
+ B : c_int) return vector_float;
+
+ pragma Import
+ (LL_Altivec, vec_vspltw_vf_cint_r_vf, "__builtin_altivec_vspltw");
+
+ function vec_vspltw_vsi_cint_r_vsi
+ (A : vector_signed_int;
+ B : c_int) return vector_signed_int;
+
+ pragma Import
+ (LL_Altivec, vec_vspltw_vsi_cint_r_vsi, "__builtin_altivec_vspltw");
+
+ function vec_vspltw_vui_cint_r_vui
+ (A : vector_unsigned_int;
+ B : c_int) return vector_unsigned_int;
+
+ pragma Import
+ (LL_Altivec, vec_vspltw_vui_cint_r_vui, "__builtin_altivec_vspltw");
+
+ function vec_vspltw_vbi_cint_r_vbi
+ (A : vector_bool_int;
+ B : c_int) return vector_bool_int;
+
+ pragma Import
+ (LL_Altivec, vec_vspltw_vbi_cint_r_vbi, "__builtin_altivec_vspltw");
+
+ -- vec_vsplth --
+
+ function vec_vsplth_vbs_cint_r_vbs
+ (A : vector_bool_short;
+ B : c_int) return vector_bool_short;
+
+ pragma Import
+ (LL_Altivec, vec_vsplth_vbs_cint_r_vbs, "__builtin_altivec_vsplth");
+
+ function vec_vsplth_vss_cint_r_vss
+ (A : vector_signed_short;
+ B : c_int) return vector_signed_short;
+
+ pragma Import
+ (LL_Altivec, vec_vsplth_vss_cint_r_vss, "__builtin_altivec_vsplth");
+
+ function vec_vsplth_vus_cint_r_vus
+ (A : vector_unsigned_short;
+ B : c_int) return vector_unsigned_short;
+
+ pragma Import
+ (LL_Altivec, vec_vsplth_vus_cint_r_vus, "__builtin_altivec_vsplth");
+
+ function vec_vsplth_vx_cint_r_vx
+ (A : vector_pixel;
+ B : c_int) return vector_pixel;
+
+ pragma Import
+ (LL_Altivec, vec_vsplth_vx_cint_r_vx, "__builtin_altivec_vsplth");
+
+ -- vec_vspltb --
+
+ function vec_vspltb_vsc_cint_r_vsc
+ (A : vector_signed_char;
+ B : c_int) return vector_signed_char;
+
+ pragma Import
+ (LL_Altivec, vec_vspltb_vsc_cint_r_vsc, "__builtin_altivec_vspltb");
+
+ function vec_vspltb_vuc_cint_r_vuc
+ (A : vector_unsigned_char;
+ B : c_int) return vector_unsigned_char;
+
+ pragma Import
+ (LL_Altivec, vec_vspltb_vuc_cint_r_vuc, "__builtin_altivec_vspltb");
+
+ function vec_vspltb_vbc_cint_r_vbc
+ (A : vector_bool_char;
+ B : c_int) return vector_bool_char;
+
+ pragma Import
+ (LL_Altivec, vec_vspltb_vbc_cint_r_vbc, "__builtin_altivec_vspltb");
+
+ -- vec_splat_s8 --
+
+ function vec_splat_s8_cint_r_vsc
+ (A : c_int) return vector_signed_char;
+
+ pragma Import
+ (LL_Altivec, vec_splat_s8_cint_r_vsc, "__builtin_altivec_vspltisb");
+
+ -- vec_splat_s16 --
+
+ function vec_splat_s16_cint_r_vss
+ (A : c_int) return vector_signed_short;
+
+ pragma Import
+ (LL_Altivec, vec_splat_s16_cint_r_vss, "__builtin_altivec_vspltish");
+
+ -- vec_splat_s32 --
+
+ function vec_splat_s32_cint_r_vsi
+ (A : c_int) return vector_signed_int;
+
+ pragma Import
+ (LL_Altivec, vec_splat_s32_cint_r_vsi, "__builtin_altivec_vspltisw");
+
+ -- vec_splat_u8 --
+
+ function vec_splat_u8_cint_r_vuc
+ (A : c_int) return vector_unsigned_char;
+
+ pragma Import
+ (LL_Altivec, vec_splat_u8_cint_r_vuc, "__builtin_altivec_vspltisb");
+
+ -- vec_splat_u16 --
+
+ function vec_splat_u16_cint_r_vus
+ (A : c_int) return vector_unsigned_short;
+
+ pragma Import
+ (LL_Altivec, vec_splat_u16_cint_r_vus, "__builtin_altivec_vspltish");
+
+ -- vec_splat_u32 --
+
+ function vec_splat_u32_cint_r_vui
+ (A : c_int) return vector_unsigned_int;
+
+ pragma Import
+ (LL_Altivec, vec_splat_u32_cint_r_vui, "__builtin_altivec_vspltisw");
+
+ ------------------------------------------------------------
+ -- Imports for low-level signature consistent subprograms --
+ ------------------------------------------------------------
+
+ -- vec_dssall --
+
+ procedure vec_dssall;
+
+ pragma Import
+ (LL_Altivec, vec_dssall, "__builtin_altivec_dssall");
+
+ -----------------------------------------
+ -- Conversions between low level types --
+ -----------------------------------------
+
+ use GNAT.Altivec.Low_Level_Vectors;
+
+ -- Something like...
+ --
+ -- TYPES="LL_VBC LL_VUC LL_VSC LL_VBS LL_VUS LL_VSS \
+ -- LL_VBI LL_VUI LL_VSI LL_VF LL_VP"
+ -- for TT in `echo $TYPES`; do
+ -- for ST in `echo $TYPES`; do
+ -- echo "function To_$TT is new Ada.Unchecked_Conversion ($ST, $TT);"
+ -- done
+ -- echo ""
+ -- done
+
+ function To_LL_VBC is new Ada.Unchecked_Conversion (LL_VBC, LL_VBC);
+ function To_LL_VBC is new Ada.Unchecked_Conversion (LL_VUC, LL_VBC);
+ function To_LL_VBC is new Ada.Unchecked_Conversion (LL_VSC, LL_VBC);
+ function To_LL_VBC is new Ada.Unchecked_Conversion (LL_VBS, LL_VBC);
+ function To_LL_VBC is new Ada.Unchecked_Conversion (LL_VUS, LL_VBC);
+ function To_LL_VBC is new Ada.Unchecked_Conversion (LL_VSS, LL_VBC);
+ function To_LL_VBC is new Ada.Unchecked_Conversion (LL_VBI, LL_VBC);
+ function To_LL_VBC is new Ada.Unchecked_Conversion (LL_VUI, LL_VBC);
+ function To_LL_VBC is new Ada.Unchecked_Conversion (LL_VSI, LL_VBC);
+ function To_LL_VBC is new Ada.Unchecked_Conversion (LL_VF, LL_VBC);
+ function To_LL_VBC is new Ada.Unchecked_Conversion (LL_VP, LL_VBC);
+
+ function To_LL_VUC is new Ada.Unchecked_Conversion (LL_VBC, LL_VUC);
+ function To_LL_VUC is new Ada.Unchecked_Conversion (LL_VUC, LL_VUC);
+ function To_LL_VUC is new Ada.Unchecked_Conversion (LL_VSC, LL_VUC);
+ function To_LL_VUC is new Ada.Unchecked_Conversion (LL_VBS, LL_VUC);
+ function To_LL_VUC is new Ada.Unchecked_Conversion (LL_VUS, LL_VUC);
+ function To_LL_VUC is new Ada.Unchecked_Conversion (LL_VSS, LL_VUC);
+ function To_LL_VUC is new Ada.Unchecked_Conversion (LL_VBI, LL_VUC);
+ function To_LL_VUC is new Ada.Unchecked_Conversion (LL_VUI, LL_VUC);
+ function To_LL_VUC is new Ada.Unchecked_Conversion (LL_VSI, LL_VUC);
+ function To_LL_VUC is new Ada.Unchecked_Conversion (LL_VF, LL_VUC);
+ function To_LL_VUC is new Ada.Unchecked_Conversion (LL_VP, LL_VUC);
+
+ function To_LL_VSC is new Ada.Unchecked_Conversion (LL_VBC, LL_VSC);
+ function To_LL_VSC is new Ada.Unchecked_Conversion (LL_VUC, LL_VSC);
+ function To_LL_VSC is new Ada.Unchecked_Conversion (LL_VSC, LL_VSC);
+ function To_LL_VSC is new Ada.Unchecked_Conversion (LL_VBS, LL_VSC);
+ function To_LL_VSC is new Ada.Unchecked_Conversion (LL_VUS, LL_VSC);
+ function To_LL_VSC is new Ada.Unchecked_Conversion (LL_VSS, LL_VSC);
+ function To_LL_VSC is new Ada.Unchecked_Conversion (LL_VBI, LL_VSC);
+ function To_LL_VSC is new Ada.Unchecked_Conversion (LL_VUI, LL_VSC);
+ function To_LL_VSC is new Ada.Unchecked_Conversion (LL_VSI, LL_VSC);
+ function To_LL_VSC is new Ada.Unchecked_Conversion (LL_VF, LL_VSC);
+ function To_LL_VSC is new Ada.Unchecked_Conversion (LL_VP, LL_VSC);
+
+ function To_LL_VBS is new Ada.Unchecked_Conversion (LL_VBC, LL_VBS);
+ function To_LL_VBS is new Ada.Unchecked_Conversion (LL_VUC, LL_VBS);
+ function To_LL_VBS is new Ada.Unchecked_Conversion (LL_VSC, LL_VBS);
+ function To_LL_VBS is new Ada.Unchecked_Conversion (LL_VBS, LL_VBS);
+ function To_LL_VBS is new Ada.Unchecked_Conversion (LL_VUS, LL_VBS);
+ function To_LL_VBS is new Ada.Unchecked_Conversion (LL_VSS, LL_VBS);
+ function To_LL_VBS is new Ada.Unchecked_Conversion (LL_VBI, LL_VBS);
+ function To_LL_VBS is new Ada.Unchecked_Conversion (LL_VUI, LL_VBS);
+ function To_LL_VBS is new Ada.Unchecked_Conversion (LL_VSI, LL_VBS);
+ function To_LL_VBS is new Ada.Unchecked_Conversion (LL_VF, LL_VBS);
+ function To_LL_VBS is new Ada.Unchecked_Conversion (LL_VP, LL_VBS);
+
+ function To_LL_VUS is new Ada.Unchecked_Conversion (LL_VBC, LL_VUS);
+ function To_LL_VUS is new Ada.Unchecked_Conversion (LL_VUC, LL_VUS);
+ function To_LL_VUS is new Ada.Unchecked_Conversion (LL_VSC, LL_VUS);
+ function To_LL_VUS is new Ada.Unchecked_Conversion (LL_VBS, LL_VUS);
+ function To_LL_VUS is new Ada.Unchecked_Conversion (LL_VUS, LL_VUS);
+ function To_LL_VUS is new Ada.Unchecked_Conversion (LL_VSS, LL_VUS);
+ function To_LL_VUS is new Ada.Unchecked_Conversion (LL_VBI, LL_VUS);
+ function To_LL_VUS is new Ada.Unchecked_Conversion (LL_VUI, LL_VUS);
+ function To_LL_VUS is new Ada.Unchecked_Conversion (LL_VSI, LL_VUS);
+ function To_LL_VUS is new Ada.Unchecked_Conversion (LL_VF, LL_VUS);
+ function To_LL_VUS is new Ada.Unchecked_Conversion (LL_VP, LL_VUS);
+
+ function To_LL_VSS is new Ada.Unchecked_Conversion (LL_VBC, LL_VSS);
+ function To_LL_VSS is new Ada.Unchecked_Conversion (LL_VUC, LL_VSS);
+ function To_LL_VSS is new Ada.Unchecked_Conversion (LL_VSC, LL_VSS);
+ function To_LL_VSS is new Ada.Unchecked_Conversion (LL_VBS, LL_VSS);
+ function To_LL_VSS is new Ada.Unchecked_Conversion (LL_VUS, LL_VSS);
+ function To_LL_VSS is new Ada.Unchecked_Conversion (LL_VSS, LL_VSS);
+ function To_LL_VSS is new Ada.Unchecked_Conversion (LL_VBI, LL_VSS);
+ function To_LL_VSS is new Ada.Unchecked_Conversion (LL_VUI, LL_VSS);
+ function To_LL_VSS is new Ada.Unchecked_Conversion (LL_VSI, LL_VSS);
+ function To_LL_VSS is new Ada.Unchecked_Conversion (LL_VF, LL_VSS);
+ function To_LL_VSS is new Ada.Unchecked_Conversion (LL_VP, LL_VSS);
+
+ function To_LL_VBI is new Ada.Unchecked_Conversion (LL_VBC, LL_VBI);
+ function To_LL_VBI is new Ada.Unchecked_Conversion (LL_VUC, LL_VBI);
+ function To_LL_VBI is new Ada.Unchecked_Conversion (LL_VSC, LL_VBI);
+ function To_LL_VBI is new Ada.Unchecked_Conversion (LL_VBS, LL_VBI);
+ function To_LL_VBI is new Ada.Unchecked_Conversion (LL_VUS, LL_VBI);
+ function To_LL_VBI is new Ada.Unchecked_Conversion (LL_VSS, LL_VBI);
+ function To_LL_VBI is new Ada.Unchecked_Conversion (LL_VBI, LL_VBI);
+ function To_LL_VBI is new Ada.Unchecked_Conversion (LL_VUI, LL_VBI);
+ function To_LL_VBI is new Ada.Unchecked_Conversion (LL_VSI, LL_VBI);
+ function To_LL_VBI is new Ada.Unchecked_Conversion (LL_VF, LL_VBI);
+ function To_LL_VBI is new Ada.Unchecked_Conversion (LL_VP, LL_VBI);
+
+ function To_LL_VUI is new Ada.Unchecked_Conversion (LL_VBC, LL_VUI);
+ function To_LL_VUI is new Ada.Unchecked_Conversion (LL_VUC, LL_VUI);
+ function To_LL_VUI is new Ada.Unchecked_Conversion (LL_VSC, LL_VUI);
+ function To_LL_VUI is new Ada.Unchecked_Conversion (LL_VBS, LL_VUI);
+ function To_LL_VUI is new Ada.Unchecked_Conversion (LL_VUS, LL_VUI);
+ function To_LL_VUI is new Ada.Unchecked_Conversion (LL_VSS, LL_VUI);
+ function To_LL_VUI is new Ada.Unchecked_Conversion (LL_VBI, LL_VUI);
+ function To_LL_VUI is new Ada.Unchecked_Conversion (LL_VUI, LL_VUI);
+ function To_LL_VUI is new Ada.Unchecked_Conversion (LL_VSI, LL_VUI);
+ function To_LL_VUI is new Ada.Unchecked_Conversion (LL_VF, LL_VUI);
+ function To_LL_VUI is new Ada.Unchecked_Conversion (LL_VP, LL_VUI);
+
+ function To_LL_VSI is new Ada.Unchecked_Conversion (LL_VBC, LL_VSI);
+ function To_LL_VSI is new Ada.Unchecked_Conversion (LL_VUC, LL_VSI);
+ function To_LL_VSI is new Ada.Unchecked_Conversion (LL_VSC, LL_VSI);
+ function To_LL_VSI is new Ada.Unchecked_Conversion (LL_VBS, LL_VSI);
+ function To_LL_VSI is new Ada.Unchecked_Conversion (LL_VUS, LL_VSI);
+ function To_LL_VSI is new Ada.Unchecked_Conversion (LL_VSS, LL_VSI);
+ function To_LL_VSI is new Ada.Unchecked_Conversion (LL_VBI, LL_VSI);
+ function To_LL_VSI is new Ada.Unchecked_Conversion (LL_VUI, LL_VSI);
+ function To_LL_VSI is new Ada.Unchecked_Conversion (LL_VSI, LL_VSI);
+ function To_LL_VSI is new Ada.Unchecked_Conversion (LL_VF, LL_VSI);
+ function To_LL_VSI is new Ada.Unchecked_Conversion (LL_VP, LL_VSI);
+
+ function To_LL_VF is new Ada.Unchecked_Conversion (LL_VBC, LL_VF);
+ function To_LL_VF is new Ada.Unchecked_Conversion (LL_VUC, LL_VF);
+ function To_LL_VF is new Ada.Unchecked_Conversion (LL_VSC, LL_VF);
+ function To_LL_VF is new Ada.Unchecked_Conversion (LL_VBS, LL_VF);
+ function To_LL_VF is new Ada.Unchecked_Conversion (LL_VUS, LL_VF);
+ function To_LL_VF is new Ada.Unchecked_Conversion (LL_VSS, LL_VF);
+ function To_LL_VF is new Ada.Unchecked_Conversion (LL_VBI, LL_VF);
+ function To_LL_VF is new Ada.Unchecked_Conversion (LL_VUI, LL_VF);
+ function To_LL_VF is new Ada.Unchecked_Conversion (LL_VSI, LL_VF);
+ function To_LL_VF is new Ada.Unchecked_Conversion (LL_VF, LL_VF);
+ function To_LL_VF is new Ada.Unchecked_Conversion (LL_VP, LL_VF);
+
+ function To_LL_VP is new Ada.Unchecked_Conversion (LL_VBC, LL_VP);
+ function To_LL_VP is new Ada.Unchecked_Conversion (LL_VUC, LL_VP);
+ function To_LL_VP is new Ada.Unchecked_Conversion (LL_VSC, LL_VP);
+ function To_LL_VP is new Ada.Unchecked_Conversion (LL_VBS, LL_VP);
+ function To_LL_VP is new Ada.Unchecked_Conversion (LL_VUS, LL_VP);
+ function To_LL_VP is new Ada.Unchecked_Conversion (LL_VSS, LL_VP);
+ function To_LL_VP is new Ada.Unchecked_Conversion (LL_VBI, LL_VP);
+ function To_LL_VP is new Ada.Unchecked_Conversion (LL_VUI, LL_VP);
+ function To_LL_VP is new Ada.Unchecked_Conversion (LL_VSI, LL_VP);
+ function To_LL_VP is new Ada.Unchecked_Conversion (LL_VF, LL_VP);
+ function To_LL_VP is new Ada.Unchecked_Conversion (LL_VP, LL_VP);
+
+ ----------------------------------------------
+ -- Conversions between pointer/access types --
+ ----------------------------------------------
+
+ function To_PTR is
+ new Ada.Unchecked_Conversion (vector_unsigned_char_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (vector_signed_char_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (vector_bool_char_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (vector_unsigned_short_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (vector_signed_short_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (vector_bool_short_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (vector_unsigned_int_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (vector_signed_int_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (vector_bool_int_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (vector_float_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (vector_pixel_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_vector_bool_char_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_vector_signed_char_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_vector_unsigned_char_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_vector_bool_short_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_vector_signed_short_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_vector_unsigned_short_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_vector_bool_int_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_vector_signed_int_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_vector_unsigned_int_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_vector_float_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_vector_pixel_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (c_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (signed_char_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (unsigned_char_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (short_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (signed_short_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (unsigned_short_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (int_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (signed_int_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (unsigned_int_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (long_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (signed_long_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (unsigned_long_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (float_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_signed_char_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_unsigned_char_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_short_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_signed_short_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_unsigned_short_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_int_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_signed_int_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_unsigned_int_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_long_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_signed_long_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_unsigned_long_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (const_float_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (constv_char_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (constv_signed_char_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (constv_unsigned_char_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (constv_short_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (constv_signed_short_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (constv_unsigned_short_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (constv_int_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (constv_signed_int_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (constv_unsigned_int_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (constv_long_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (constv_signed_long_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (constv_unsigned_long_ptr, c_ptr);
+ function To_PTR is
+ new Ada.Unchecked_Conversion (constv_float_ptr, c_ptr);
+
+end GNAT.Altivec.Low_Level_Interface;
--- /dev/null
+------------------------------------------------------------------------------
+-- --
+-- GNAT COMPILER COMPONENTS --
+-- --
+-- G N A T . A L T I V E C . L O W _ L E V E L _ V E C T O R S --
+-- --
+-- B o d y --
+-- (Soft Binding Version) --
+-- --
+-- Copyright (C) 2004-2005, 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 2, 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. See the GNU General Public License --
+-- for more details. You should have received a copy of the GNU General --
+-- Public License distributed with GNAT; see file COPYING. If not, write --
+-- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
+-- MA 02111-1307, USA. --
+-- --
+-- As a special exception, if other files instantiate generics from this --
+-- unit, or you link this unit with other files to produce an executable, --
+-- this unit does not by itself cause the resulting executable to be --
+-- covered by the GNU General Public License. This exception does not --
+-- however invalidate any other reasons why the executable file might be --
+-- covered by the GNU Public License. --
+-- --
+-- GNAT was originally developed by the GNAT team at New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc. --
+-- --
+------------------------------------------------------------------------------
+
+-- ??? What is exactly needed for the soft case is still a bit unclear on
+-- some accounts. The expected functional equivalence with the Hard binding
+-- might require tricky things to be done on some targets.
+
+-- Examples that come to mind are endianness variations or differences in the
+-- base FP model while we need the operation results to be the same as what
+-- the real AltiVec instructions would do on a PowerPC.
+
+with Ada.Numerics.Generic_Elementary_Functions;
+with Interfaces; use Interfaces;
+with System.Storage_Elements; use System.Storage_Elements;
+
+with GNAT.Altivec.Conversions; use GNAT.Altivec.Conversions;
+with GNAT.Altivec.Low_Level_Interface; use GNAT.Altivec.Low_Level_Interface;
+
+package body GNAT.Altivec.Low_Level_Vectors is
+
+ -- This package assumes C_float is an IEEE single-precision float type
+
+ pragma Assert (C_float'Machine_Radix = 2);
+ pragma Assert (C_float'Machine_Mantissa = 24);
+ pragma Assert (C_float'Machine_Emin = -125);
+ pragma Assert (C_float'Machine_Emax = 128);
+ pragma Assert (C_float'Machine_Rounds);
+ pragma Assert (not C_float'Machine_Overflows);
+ pragma Assert (C_float'Signed_Zeros);
+ pragma Assert (C_float'Denorm);
+
+ -- Pixel types. As defined in [PIM-2.1 Data types]:
+ -- A 16-bit pixel is 1/5/5/5;
+ -- A 32-bit pixel is 8/8/8/8.
+ -- We use the following records as an intermediate representation, to
+ -- ease computation.
+
+ type Unsigned_1 is mod 2 ** 1;
+ type Unsigned_5 is mod 2 ** 5;
+
+ type Pixel_16 is record
+ T : Unsigned_1;
+ R : Unsigned_5;
+ G : Unsigned_5;
+ B : Unsigned_5;
+ end record;
+
+ type Pixel_32 is record
+ T : unsigned_char;
+ R : unsigned_char;
+ G : unsigned_char;
+ B : unsigned_char;
+ end record;
+
+ -- Conversions to/from the pixel records to the integer types that are
+ -- actually stored into the pixel vectors:
+
+ function To_Pixel (Source : unsigned_short) return Pixel_16;
+ function To_unsigned_short (Source : Pixel_16) return unsigned_short;
+ function To_Pixel (Source : unsigned_int) return Pixel_32;
+ function To_unsigned_int (Source : Pixel_32) return unsigned_int;
+
+ package C_float_Operations is
+ new Ada.Numerics.Generic_Elementary_Functions (C_float);
+
+ -- Model of the Vector Status and Control Register (VSCR), as
+ -- defined in [PIM-4.1 Vector Status and Control Register]:
+
+ VSCR : unsigned_int;
+
+ -- Positions of the flags in VSCR(0 .. 31):
+
+ NJ_POS : constant := 15;
+ SAT_POS : constant := 31;
+
+ -- To control overflows, integer operations are done on 64-bit types:
+
+ SINT64_MIN : constant := -2 ** 63;
+ SINT64_MAX : constant := 2 ** 63 - 1;
+ UINT64_MAX : constant := 2 ** 64 - 1;
+
+ type SI64 is range SINT64_MIN .. SINT64_MAX;
+ type UI64 is mod UINT64_MAX + 1;
+
+ type F64 is digits 15
+ range -16#0.FFFF_FFFF_FFFF_F8#E+256 .. 16#0.FFFF_FFFF_FFFF_F8#E+256;
+
+ function Bits
+ (X : unsigned_int;
+ Low : Natural;
+ High : Natural) return unsigned_int;
+
+ function Bits
+ (X : unsigned_short;
+ Low : Natural;
+ High : Natural) return unsigned_short;
+
+ function Bits
+ (X : unsigned_char;
+ Low : Natural;
+ High : Natural) return unsigned_char;
+
+ function Write_Bit
+ (X : unsigned_int;
+ Where : Natural;
+ Value : Unsigned_1) return unsigned_int;
+
+ function Write_Bit
+ (X : unsigned_short;
+ Where : Natural;
+ Value : Unsigned_1) return unsigned_short;
+
+ function Write_Bit
+ (X : unsigned_char;
+ Where : Natural;
+ Value : Unsigned_1) return unsigned_char;
+
+ function NJ_Truncate (X : C_float) return C_float;
+ -- If NJ and A is a denormalized number, return zero
+
+ function Bound_Align
+ (X : Integer_Address;
+ Y : Integer_Address) return Integer_Address;
+ -- [PIM-4.3 Notations and Conventions]
+ -- Align X in a y-byte boundary and return the result
+
+ function Rnd_To_FP_Nearest (X : F64) return C_float;
+ -- [PIM-4.3 Notations and Conventions]
+
+ function Rnd_To_FPI_Near (X : F64) return F64;
+
+ function Rnd_To_FPI_Trunc (X : F64) return F64;
+
+ function FP_Recip_Est (X : C_float) return C_float;
+ -- [PIM-4.3 Notations and Conventions]
+ -- 12-bit accurate floating-point estimate of 1/x
+
+ function ROTL
+ (Value : unsigned_char;
+ Amount : Natural) return unsigned_char;
+ -- [PIM-4.3 Notations and Conventions]
+ -- Rotate left
+
+ function ROTL
+ (Value : unsigned_short;
+ Amount : Natural) return unsigned_short;
+
+ function ROTL
+ (Value : unsigned_int;
+ Amount : Natural) return unsigned_int;
+
+ function Recip_SQRT_Est (X : C_float) return C_float;
+
+ function Shift_Left
+ (Value : unsigned_char;
+ Amount : Natural) return unsigned_char;
+ -- [PIM-4.3 Notations and Conventions]
+ -- Shift left
+
+ function Shift_Left
+ (Value : unsigned_short;
+ Amount : Natural) return unsigned_short;
+
+ function Shift_Left
+ (Value : unsigned_int;
+ Amount : Natural) return unsigned_int;
+
+ function Shift_Right
+ (Value : unsigned_char;
+ Amount : Natural) return unsigned_char;
+ -- [PIM-4.3 Notations and Conventions]
+ -- Shift Right
+
+ function Shift_Right
+ (Value : unsigned_short;
+ Amount : Natural) return unsigned_short;
+
+ function Shift_Right
+ (Value : unsigned_int;
+ Amount : Natural) return unsigned_int;
+
+ Signed_Bool_False : constant := 0;
+ Signed_Bool_True : constant := -1;
+
+ ------------------------------
+ -- Signed_Operations (spec) --
+ ------------------------------
+
+ generic
+ type Component_Type is range <>;
+ type Index_Type is range <>;
+ type Varray_Type is array (Index_Type) of Component_Type;
+
+ package Signed_Operations is
+
+ function Modular_Result (X : SI64) return Component_Type;
+
+ function Saturate (X : SI64) return Component_Type;
+
+ function Saturate (X : F64) return Component_Type;
+
+ function Sign_Extend (X : c_int) return Component_Type;
+ -- [PIM-4.3 Notations and Conventions]
+ -- Sign-extend X
+
+ function abs_vxi (A : Varray_Type) return Varray_Type;
+ pragma Convention (LL_Altivec, abs_vxi);
+
+ function abss_vxi (A : Varray_Type) return Varray_Type;
+ pragma Convention (LL_Altivec, abss_vxi);
+
+ function vaddsxs (A : Varray_Type; B : Varray_Type) return Varray_Type;
+ pragma Convention (LL_Altivec, vaddsxs);
+
+ function vavgsx (A : Varray_Type; B : Varray_Type) return Varray_Type;
+ pragma Convention (LL_Altivec, vavgsx);
+
+ function vcmpgtsx (A : Varray_Type; B : Varray_Type) return Varray_Type;
+ pragma Convention (LL_Altivec, vcmpgtsx);
+
+ function lvexx (A : c_long; B : c_ptr) return Varray_Type;
+ pragma Convention (LL_Altivec, lvexx);
+
+ function vmaxsx (A : Varray_Type; B : Varray_Type) return Varray_Type;
+ pragma Convention (LL_Altivec, vmaxsx);
+
+ function vmrghx (A : Varray_Type; B : Varray_Type) return Varray_Type;
+ pragma Convention (LL_Altivec, vmrghx);
+
+ function vmrglx (A : Varray_Type; B : Varray_Type) return Varray_Type;
+ pragma Convention (LL_Altivec, vmrglx);
+
+ function vminsx (A : Varray_Type; B : Varray_Type) return Varray_Type;
+ pragma Convention (LL_Altivec, vminsx);
+
+ function vspltx (A : Varray_Type; B : c_int) return Varray_Type;
+ pragma Convention (LL_Altivec, vspltx);
+
+ function vspltisx (A : c_int) return Varray_Type;
+ pragma Convention (LL_Altivec, vspltisx);
+
+ type Bit_Operation is
+ access function
+ (Value : Component_Type;
+ Amount : Natural) return Component_Type;
+
+ function vsrax
+ (A : Varray_Type;
+ B : Varray_Type;
+ Shift_Func : Bit_Operation) return Varray_Type;
+
+ procedure stvexx (A : Varray_Type; B : c_int; C : c_ptr);
+ pragma Convention (LL_Altivec, stvexx);
+
+ function vsubsxs (A : Varray_Type; B : Varray_Type) return Varray_Type;
+ pragma Convention (LL_Altivec, vsubsxs);
+
+ function Check_CR6 (A : c_int; D : Varray_Type) return c_int;
+ -- If D is the result of a vcmp operation and A the flag for
+ -- the kind of operation (e.g CR6_LT), check the predicate
+ -- that corresponds to this flag.
+
+ end Signed_Operations;
+
+ ------------------------------
+ -- Signed_Operations (body) --
+ ------------------------------
+
+ package body Signed_Operations is
+
+ Bool_True : constant Component_Type := Signed_Bool_True;
+ Bool_False : constant Component_Type := Signed_Bool_False;
+
+ Number_Of_Elements : constant Integer :=
+ VECTOR_BIT / Component_Type'Size;
+
+ --------------------
+ -- Modular_Result --
+ --------------------
+
+ function Modular_Result (X : SI64) return Component_Type is
+ D : Component_Type;
+
+ begin
+ if X > 0 then
+ D := Component_Type (UI64 (X)
+ mod (UI64 (Component_Type'Last) + 1));
+ else
+ D := Component_Type ((-(UI64 (-X)
+ mod (UI64 (Component_Type'Last) + 1))));
+ end if;
+
+ return D;
+ end Modular_Result;
+
+ --------------
+ -- Saturate --
+ --------------
+
+ function Saturate (X : SI64) return Component_Type is
+ D : Component_Type;
+
+ begin
+ -- Saturation, as defined in
+ -- [PIM-4.1 Vector Status and Control Register]
+
+ D := Component_Type (SI64'Max
+ (SI64 (Component_Type'First),
+ SI64'Min
+ (SI64 (Component_Type'Last),
+ X)));
+
+ if SI64 (D) /= X then
+ VSCR := Write_Bit (VSCR, SAT_POS, 1);
+ end if;
+
+ return D;
+ end Saturate;
+
+ function Saturate (X : F64) return Component_Type is
+ D : Component_Type;
+
+ begin
+ -- Saturation, as defined in
+ -- [PIM-4.1 Vector Status and Control Register]
+
+ D := Component_Type (F64'Max
+ (F64 (Component_Type'First),
+ F64'Min
+ (F64 (Component_Type'Last),
+ X)));
+
+ if F64 (D) /= X then
+ VSCR := Write_Bit (VSCR, SAT_POS, 1);
+ end if;
+
+ return D;
+ end Saturate;
+
+ -----------------
+ -- Sign_Extend --
+ -----------------
+
+ function Sign_Extend (X : c_int) return Component_Type is
+ begin
+ -- X is usually a 5-bits literal. In the case of the simulator,
+ -- it is an integral parameter, so sign extension is straightforward.
+
+ return Component_Type (X);
+ end Sign_Extend;
+
+ -------------
+ -- abs_vxi --
+ -------------
+
+ function abs_vxi (A : Varray_Type) return Varray_Type is
+ D : Varray_Type;
+
+ begin
+ for K in Varray_Type'Range loop
+ if A (K) /= Component_Type'First then
+ D (K) := abs (A (K));
+ else
+ D (K) := Component_Type'First;
+ end if;
+ end loop;
+
+ return D;
+ end abs_vxi;
+
+ --------------
+ -- abss_vxi --
+ --------------
+
+ function abss_vxi (A : Varray_Type) return Varray_Type is
+ D : Varray_Type;
+
+ begin
+ for K in Varray_Type'Range loop
+ D (K) := Saturate (abs (SI64 (A (K))));
+ end loop;
+
+ return D;
+ end abss_vxi;
+
+ -------------
+ -- vaddsxs --
+ -------------
+
+ function vaddsxs (A : Varray_Type; B : Varray_Type) return Varray_Type is
+ D : Varray_Type;
+
+ begin
+ for J in Varray_Type'Range loop
+ D (J) := Saturate (SI64 (A (J)) + SI64 (B (J)));
+ end loop;
+
+ return D;
+ end vaddsxs;
+
+ ------------
+ -- vavgsx --
+ ------------
+
+ function vavgsx (A : Varray_Type; B : Varray_Type) return Varray_Type is
+ D : Varray_Type;
+
+ begin
+ for J in Varray_Type'Range loop
+ D (J) := Component_Type ((SI64 (A (J)) + SI64 (B (J)) + 1) / 2);
+ end loop;
+
+ return D;
+ end vavgsx;
+
+ --------------
+ -- vcmpgtsx --
+ --------------
+
+ function vcmpgtsx
+ (A : Varray_Type;
+ B : Varray_Type) return Varray_Type
+ is
+ D : Varray_Type;
+
+ begin
+ for J in Varray_Type'Range loop
+ if A (J) > B (J) then
+ D (J) := Bool_True;
+ else
+ D (J) := Bool_False;
+ end if;
+ end loop;
+
+ return D;
+ end vcmpgtsx;
+
+ -----------
+ -- lvexx --
+ -----------
+
+ function lvexx (A : c_long; B : c_ptr) return Varray_Type is
+ D : Varray_Type;
+ S : Integer;
+ EA : Integer_Address;
+ J : Index_Type;
+
+ begin
+ S := 16 / Number_Of_Elements;
+ EA := Bound_Align (Integer_Address (A) + To_Integer (B),
+ Integer_Address (S));
+ J := Index_Type (((EA mod 16) / Integer_Address (S))
+ + Integer_Address (Index_Type'First));
+
+ declare
+ Component : Component_Type;
+ for Component'Address use To_Address (EA);
+ begin
+ D (J) := Component;
+ end;
+
+ return D;
+ end lvexx;
+
+ ------------
+ -- vmaxsx --
+ ------------
+
+ function vmaxsx (A : Varray_Type; B : Varray_Type) return Varray_Type is
+ D : Varray_Type;
+
+ begin
+ for J in Varray_Type'Range loop
+ if A (J) > B (J) then
+ D (J) := A (J);
+ else
+ D (J) := B (J);
+ end if;
+ end loop;
+
+ return D;
+ end vmaxsx;
+
+ ------------
+ -- vmrghx --
+ ------------
+
+ function vmrghx (A : Varray_Type; B : Varray_Type) return Varray_Type is
+ D : Varray_Type;
+ Offset : constant Integer := Integer (Index_Type'First);
+ M : constant Integer := Number_Of_Elements / 2;
+
+ begin
+ for J in 0 .. M - 1 loop
+ D (Index_Type (2 * J + Offset)) := A (Index_Type (J + Offset));
+ D (Index_Type (2 * J + Offset + 1)) := B (Index_Type (J + Offset));
+ end loop;
+
+ return D;
+ end vmrghx;
+
+ ------------
+ -- vmrglx --
+ ------------
+
+ function vmrglx (A : Varray_Type; B : Varray_Type) return Varray_Type is
+ D : Varray_Type;
+ Offset : constant Integer := Integer (Index_Type'First);
+ M : constant Integer := Number_Of_Elements / 2;
+
+ begin
+ for J in 0 .. M - 1 loop
+ D (Index_Type (2 * J + Offset)) := A (Index_Type (J + Offset + M));
+ D (Index_Type (2 * J + Offset + 1)) :=
+ B (Index_Type (J + Offset + M));
+ end loop;
+
+ return D;
+ end vmrglx;
+
+ ------------
+ -- vminsx --
+ ------------
+
+ function vminsx (A : Varray_Type; B : Varray_Type) return Varray_Type is
+ D : Varray_Type;
+
+ begin
+ for J in Varray_Type'Range loop
+ if A (J) < B (J) then
+ D (J) := A (J);
+ else
+ D (J) := B (J);
+ end if;
+ end loop;
+
+ return D;
+ end vminsx;
+
+ ------------
+ -- vspltx --
+ ------------
+
+ function vspltx (A : Varray_Type; B : c_int) return Varray_Type is
+ J : constant Integer :=
+ Integer (B) mod Number_Of_Elements
+ + Integer (Varray_Type'First);
+ D : Varray_Type;
+
+ begin
+ for K in Varray_Type'Range loop
+ D (K) := A (Index_Type (J));
+ end loop;
+
+ return D;
+ end vspltx;
+
+ --------------
+ -- vspltisx --
+ --------------
+
+ function vspltisx (A : c_int) return Varray_Type is
+ D : Varray_Type;
+
+ begin
+ for J in Varray_Type'Range loop
+ D (J) := Sign_Extend (A);
+ end loop;
+
+ return D;
+ end vspltisx;
+
+ -----------
+ -- vsrax --
+ -----------
+
+ function vsrax
+ (A : Varray_Type;
+ B : Varray_Type;
+ Shift_Func : Bit_Operation) return Varray_Type
+ is
+ D : Varray_Type;
+ S : constant Component_Type :=
+ Component_Type (128 / Number_Of_Elements);
+
+ begin
+ for J in Varray_Type'Range loop
+ D (J) := Shift_Func (A (J), Natural (B (J) mod S));
+ end loop;
+
+ return D;
+ end vsrax;
+
+ ------------
+ -- stvexx --
+ ------------
+
+ procedure stvexx (A : Varray_Type; B : c_int; C : c_ptr) is
+ S : Integer;
+ EA : Integer_Address;
+ J : Index_Type;
+
+ begin
+ S := 16 / Number_Of_Elements;
+ EA := Bound_Align (Integer_Address (B) + To_Integer (C),
+ Integer_Address (S));
+ J := Index_Type ((EA mod 16) / Integer_Address (S)
+ + Integer_Address (Index_Type'First));
+
+ declare
+ Component : Component_Type;
+ for Component'Address use To_Address (EA);
+ begin
+ Component := A (J);
+ end;
+ end stvexx;
+
+ -------------
+ -- vsubsxs --
+ -------------
+
+ function vsubsxs (A : Varray_Type; B : Varray_Type) return Varray_Type is
+ D : Varray_Type;
+
+ begin
+ for J in Varray_Type'Range loop
+ D (J) := Saturate (SI64 (A (J)) - SI64 (B (J)));
+ end loop;
+
+ return D;
+ end vsubsxs;
+
+ ---------------
+ -- Check_CR6 --
+ ---------------
+
+ function Check_CR6 (A : c_int; D : Varray_Type) return c_int is
+ All_Element : Boolean := True;
+ Any_Element : Boolean := False;
+
+ begin
+ for J in Varray_Type'Range loop
+ All_Element := All_Element and (D (J) = Bool_True);
+ Any_Element := Any_Element or (D (J) = Bool_True);
+ end loop;
+
+ if A = CR6_LT then
+ if All_Element then
+ return 1;
+ else
+ return 0;
+ end if;
+
+ elsif A = CR6_EQ then
+ if not Any_Element then
+ return 1;
+ else
+ return 0;
+ end if;
+
+ elsif A = CR6_EQ_REV then
+ if Any_Element then
+ return 1;
+ else
+ return 0;
+ end if;
+
+ elsif A = CR6_LT_REV then
+ if not All_Element then
+ return 1;
+ else
+ return 0;
+ end if;
+ end if;
+
+ return 0;
+ end Check_CR6;
+
+ end Signed_Operations;
+
+ --------------------------------
+ -- Unsigned_Operations (spec) --
+ --------------------------------
+
+ generic
+ type Component_Type is mod <>;
+ type Index_Type is range <>;
+ type Varray_Type is array (Index_Type) of Component_Type;
+
+ package Unsigned_Operations is
+
+ function Bits
+ (X : Component_Type;
+ Low : Natural;
+ High : Natural) return Component_Type;
+ -- Return X [Low:High] as defined in [PIM-4.3 Notations and Conventions]
+ -- using big endian bit ordering.
+
+ function Write_Bit
+ (X : Component_Type;
+ Where : Natural;
+ Value : Unsigned_1) return Component_Type;
+ -- Write Value into X[Where:Where] (if it fits in) and return the result
+ -- (big endian bit ordering).
+
+ function Modular_Result (X : UI64) return Component_Type;
+
+ function Saturate (X : UI64) return Component_Type;
+
+ function Saturate (X : F64) return Component_Type;
+
+ function Saturate (X : SI64) return Component_Type;
+
+ function vadduxm (A : Varray_Type; B : Varray_Type) return Varray_Type;
+
+ function vadduxs (A : Varray_Type; B : Varray_Type) return Varray_Type;
+
+ function vavgux (A : Varray_Type; B : Varray_Type) return Varray_Type;
+
+ function vcmpequx (A : Varray_Type; B : Varray_Type) return Varray_Type;
+
+ function vcmpgtux (A : Varray_Type; B : Varray_Type) return Varray_Type;
+
+ function vmaxux (A : Varray_Type; B : Varray_Type) return Varray_Type;
+
+ function vminux (A : Varray_Type; B : Varray_Type) return Varray_Type;
+
+ type Bit_Operation is
+ access function
+ (Value : Component_Type;
+ Amount : Natural) return Component_Type;
+
+ function vrlx
+ (A : Varray_Type;
+ B : Varray_Type;
+ ROTL : Bit_Operation) return Varray_Type;
+
+ function vsxx
+ (A : Varray_Type;
+ B : Varray_Type;
+ Shift_Func : Bit_Operation) return Varray_Type;
+ -- Vector shift (left or right, depending on Shift_Func)
+
+ function vsubuxm (A : Varray_Type; B : Varray_Type) return Varray_Type;
+
+ function vsubuxs (A : Varray_Type; B : Varray_Type) return Varray_Type;
+
+ function Check_CR6 (A : c_int; D : Varray_Type) return c_int;
+ -- If D is the result of a vcmp operation and A the flag for
+ -- the kind of operation (e.g CR6_LT), check the predicate
+ -- that corresponds to this flag.
+
+ end Unsigned_Operations;
+
+ --------------------------------
+ -- Unsigned_Operations (body) --
+ --------------------------------
+
+ package body Unsigned_Operations is
+
+ Number_Of_Elements : constant Integer :=
+ VECTOR_BIT / Component_Type'Size;
+
+ Bool_True : constant Component_Type := Component_Type'Last;
+ Bool_False : constant Component_Type := 0;
+
+ --------------------
+ -- Modular_Result --
+ --------------------
+
+ function Modular_Result (X : UI64) return Component_Type is
+ D : Component_Type;
+ begin
+ D := Component_Type (X mod (UI64 (Component_Type'Last) + 1));
+ return D;
+ end Modular_Result;
+
+ --------------
+ -- Saturate --
+ --------------
+
+ function Saturate (X : UI64) return Component_Type is
+ D : Component_Type;
+
+ begin
+ -- Saturation, as defined in
+ -- [PIM-4.1 Vector Status and Control Register]
+
+ D := Component_Type (UI64'Max
+ (UI64 (Component_Type'First),
+ UI64'Min
+ (UI64 (Component_Type'Last),
+ X)));
+
+ if UI64 (D) /= X then
+ VSCR := Write_Bit (VSCR, SAT_POS, 1);
+ end if;
+
+ return D;
+ end Saturate;
+
+ function Saturate (X : SI64) return Component_Type is
+ D : Component_Type;
+
+ begin
+ -- Saturation, as defined in
+ -- [PIM-4.1 Vector Status and Control Register]
+
+ D := Component_Type (SI64'Max
+ (SI64 (Component_Type'First),
+ SI64'Min
+ (SI64 (Component_Type'Last),
+ X)));
+
+ if SI64 (D) /= X then
+ VSCR := Write_Bit (VSCR, SAT_POS, 1);
+ end if;
+
+ return D;
+ end Saturate;
+
+ function Saturate (X : F64) return Component_Type is
+ D : Component_Type;
+
+ begin
+ -- Saturation, as defined in
+ -- [PIM-4.1 Vector Status and Control Register]
+
+ D := Component_Type (F64'Max
+ (F64 (Component_Type'First),
+ F64'Min
+ (F64 (Component_Type'Last),
+ X)));
+
+ if F64 (D) /= X then
+ VSCR := Write_Bit (VSCR, SAT_POS, 1);
+ end if;
+
+ return D;
+ end Saturate;
+
+ ----------
+ -- Bits --
+ ----------
+
+ function Bits
+ (X : Component_Type;
+ Low : Natural;
+ High : Natural) return Component_Type
+ is
+ Mask : Component_Type := 0;
+
+ -- The Altivec ABI uses a big endian bit ordering, and we are
+ -- using little endian bit ordering for extracting bits:
+
+ Low_LE : constant Natural := Component_Type'Size - 1 - High;
+ High_LE : constant Natural := Component_Type'Size - 1 - Low;
+
+ begin
+ pragma Assert (Low <= Component_Type'Size);
+ pragma Assert (High <= Component_Type'Size);
+
+ for J in Low_LE .. High_LE loop
+ Mask := Mask or 2 ** J;
+ end loop;
+
+ return (X and Mask) / 2 ** Low_LE;
+ end Bits;
+
+ ---------------
+ -- Write_Bit --
+ ---------------
+
+ function Write_Bit
+ (X : Component_Type;
+ Where : Natural;
+ Value : Unsigned_1) return Component_Type
+ is
+ Result : Component_Type := 0;
+
+ -- The Altivec ABI uses a big endian bit ordering, and we are
+ -- using little endian bit ordering for extracting bits:
+
+ Where_LE : constant Natural := Component_Type'Size - 1 - Where;
+
+ begin
+ pragma Assert (Where < Component_Type'Size);
+
+ case Value is
+ when 1 =>
+ Result := X or 2 ** Where_LE;
+ when 0 =>
+ Result := X and not (2 ** Where_LE);
+ end case;
+
+ return Result;
+ end Write_Bit;
+
+ -------------
+ -- vadduxm --
+ -------------
+
+ function vadduxm (A : Varray_Type; B : Varray_Type) return Varray_Type is
+ D : Varray_Type;
+
+ begin
+ for J in Varray_Type'Range loop
+ D (J) := A (J) + B (J);
+ end loop;
+
+ return D;
+ end vadduxm;
+
+ -------------
+ -- vadduxs --
+ -------------
+
+ function vadduxs (A : Varray_Type; B : Varray_Type) return Varray_Type is
+ D : Varray_Type;
+
+ begin
+ for J in Varray_Type'Range loop
+ D (J) := Saturate (UI64 (A (J)) + UI64 (B (J)));
+ end loop;
+
+ return D;
+ end vadduxs;
+
+ ------------
+ -- vavgux --
+ ------------
+
+ function vavgux (A : Varray_Type; B : Varray_Type) return Varray_Type is
+ D : Varray_Type;
+
+ begin
+ for J in Varray_Type'Range loop
+ D (J) := Component_Type ((UI64 (A (J)) + UI64 (B (J)) + 1) / 2);
+ end loop;
+
+ return D;
+ end vavgux;
+
+ --------------
+ -- vcmpequx --
+ --------------
+
+ function vcmpequx
+ (A : Varray_Type;
+ B : Varray_Type) return Varray_Type
+ is
+ D : Varray_Type;
+
+ begin
+ for J in Varray_Type'Range loop
+ if A (J) = B (J) then
+ D (J) := Bool_True;
+ else
+ D (J) := Bool_False;
+ end if;
+ end loop;
+
+ return D;
+ end vcmpequx;
+
+ --------------
+ -- vcmpgtux --
+ --------------
+
+ function vcmpgtux
+ (A : Varray_Type;
+ B : Varray_Type) return Varray_Type
+ is
+ D : Varray_Type;
+ begin
+ for J in Varray_Type'Range loop
+ if A (J) > B (J) then
+ D (J) := Bool_True;
+ else
+ D (J) := Bool_False;
+ end if;
+ end loop;
+
+ return D;
+ end vcmpgtux;
+
+ ------------
+ -- vmaxux --
+ ------------
+
+ function vmaxux (A : Varray_Type; B : Varray_Type) return Varray_Type is
+ D : Varray_Type;
+
+ begin
+ for J in Varray_Type'Range loop
+ if A (J) > B (J) then
+ D (J) := A (J);
+ else
+ D (J) := B (J);
+ end if;
+ end loop;
+
+ return D;
+ end vmaxux;
+
+ ------------
+ -- vminux --
+ ------------
+
+ function vminux (A : Varray_Type; B : Varray_Type) return Varray_Type is
+ D : Varray_Type;
+
+ begin
+ for J in Varray_Type'Range loop
+ if A (J) < B (J) then
+ D (J) := A (J);
+ else
+ D (J) := B (J);
+ end if;
+ end loop;
+
+ return D;
+ end vminux;
+
+ ----------
+ -- vrlx --
+ ----------
+
+ function vrlx
+ (A : Varray_Type;
+ B : Varray_Type;
+ ROTL : Bit_Operation) return Varray_Type
+ is
+ D : Varray_Type;
+
+ begin
+ for J in Varray_Type'Range loop
+ D (J) := ROTL (A (J), Natural (B (J)));
+ end loop;
+
+ return D;
+ end vrlx;
+
+ ----------
+ -- vsxx --
+ ----------
+
+ function vsxx
+ (A : Varray_Type;
+ B : Varray_Type;
+ Shift_Func : Bit_Operation) return Varray_Type
+ is
+ D : Varray_Type;
+ S : constant Component_Type :=
+ Component_Type (128 / Number_Of_Elements);
+
+ begin
+ for J in Varray_Type'Range loop
+ D (J) := Shift_Func (A (J), Natural (B (J) mod S));
+ end loop;
+
+ return D;
+ end vsxx;
+
+ -------------
+ -- vsubuxm --
+ -------------
+
+ function vsubuxm (A : Varray_Type; B : Varray_Type) return Varray_Type is
+ D : Varray_Type;
+
+ begin
+ for J in Varray_Type'Range loop
+ D (J) := A (J) - B (J);
+ end loop;
+
+ return D;
+ end vsubuxm;
+
+ -------------
+ -- vsubuxs --
+ -------------
+
+ function vsubuxs (A : Varray_Type; B : Varray_Type) return Varray_Type is
+ D : Varray_Type;
+
+ begin
+ for J in Varray_Type'Range loop
+ D (J) := Saturate (SI64 (A (J)) - SI64 (B (J)));
+ end loop;
+
+ return D;
+ end vsubuxs;
+
+ ---------------
+ -- Check_CR6 --
+ ---------------
+
+ function Check_CR6 (A : c_int; D : Varray_Type) return c_int is
+ All_Element : Boolean := True;
+ Any_Element : Boolean := False;
+
+ begin
+ for J in Varray_Type'Range loop
+ All_Element := All_Element and (D (J) = Bool_True);
+ Any_Element := Any_Element or (D (J) = Bool_True);
+ end loop;
+
+ if A = CR6_LT then
+ if All_Element then
+ return 1;
+ else
+ return 0;
+ end if;
+
+ elsif A = CR6_EQ then
+ if not Any_Element then
+ return 1;
+ else
+ return 0;
+ end if;
+
+ elsif A = CR6_EQ_REV then
+ if Any_Element then
+ return 1;
+ else
+ return 0;
+ end if;
+
+ elsif A = CR6_LT_REV then
+ if not All_Element then
+ return 1;
+ else
+ return 0;
+ end if;
+ end if;
+
+ return 0;
+ end Check_CR6;
+
+ end Unsigned_Operations;
+
+ --------------------------------------
+ -- Signed_Merging_Operations (spec) --
+ --------------------------------------
+
+ generic
+ type Component_Type is range <>;
+ type Index_Type is range <>;
+ type Varray_Type is array (Index_Type) of Component_Type;
+ type Double_Component_Type is range <>;
+ type Double_Index_Type is range <>;
+ type Double_Varray_Type is array (Double_Index_Type)
+ of Double_Component_Type;
+
+ package Signed_Merging_Operations is
+
+ pragma Assert (Integer (Varray_Type'First)
+ = Integer (Double_Varray_Type'First));
+ pragma Assert (Varray_Type'Length = 2 * Double_Varray_Type'Length);
+ pragma Assert (2 * Component_Type'Size = Double_Component_Type'Size);
+
+ function Saturate
+ (X : Double_Component_Type) return Component_Type;
+
+ function vmulxsx
+ (Use_Even_Components : Boolean;
+ A : Varray_Type;
+ B : Varray_Type) return Double_Varray_Type;
+
+ function vpksxss
+ (A : Double_Varray_Type;
+ B : Double_Varray_Type) return Varray_Type;
+ pragma Convention (LL_Altivec, vpksxss);
+
+ function vupkxsx
+ (A : Varray_Type;
+ Offset : Natural) return Double_Varray_Type;
+
+ end Signed_Merging_Operations;
+
+ --------------------------------------
+ -- Signed_Merging_Operations (body) --
+ --------------------------------------
+
+ package body Signed_Merging_Operations is
+
+ --------------
+ -- Saturate --
+ --------------
+
+ function Saturate
+ (X : Double_Component_Type) return Component_Type
+ is
+ D : Component_Type;
+
+ begin
+ -- Saturation, as defined in
+ -- [PIM-4.1 Vector Status and Control Register]
+
+ D := Component_Type (Double_Component_Type'Max
+ (Double_Component_Type (Component_Type'First),
+ Double_Component_Type'Min
+ (Double_Component_Type (Component_Type'Last),
+ X)));
+
+ if Double_Component_Type (D) /= X then
+ VSCR := Write_Bit (VSCR, SAT_POS, 1);
+ end if;
+
+ return D;
+ end Saturate;
+
+ -------------
+ -- vmulsxs --
+ -------------
+
+ function vmulxsx
+ (Use_Even_Components : Boolean;
+ A : Varray_Type;
+ B : Varray_Type) return Double_Varray_Type
+ is
+ Double_Offset : Double_Index_Type;
+ Offset : Index_Type;
+ D : Double_Varray_Type;
+ N : constant Integer :=
+ Integer (Double_Index_Type'Last)
+ - Integer (Double_Index_Type'First) + 1;
+
+ begin
+
+ for J in 0 .. N - 1 loop
+ if Use_Even_Components then
+ Offset := Index_Type (2 * J + Integer (Index_Type'First));
+ else
+ Offset := Index_Type (2 * J + 1 + Integer (Index_Type'First));
+ end if;
+
+ Double_Offset :=
+ Double_Index_Type (J + Integer (Double_Index_Type'First));
+ D (Double_Offset) :=
+ Double_Component_Type (A (Offset))
+ * Double_Component_Type (B (Offset));
+ end loop;
+
+ return D;
+ end vmulxsx;
+
+ -------------
+ -- vpksxss --
+ -------------
+
+ function vpksxss
+ (A : Double_Varray_Type;
+ B : Double_Varray_Type) return Varray_Type
+ is
+ N : constant Index_Type :=
+ Index_Type (Double_Index_Type'Last);
+ D : Varray_Type;
+ Offset : Index_Type;
+ Double_Offset : Double_Index_Type;
+
+ begin
+ for J in 0 .. N - 1 loop
+ Offset := Index_Type (Integer (J) + Integer (Index_Type'First));
+ Double_Offset :=
+ Double_Index_Type (Integer (J)
+ + Integer (Double_Index_Type'First));
+ D (Offset) := Saturate (A (Double_Offset));
+ D (Offset + N) := Saturate (B (Double_Offset));
+ end loop;
+
+ return D;
+ end vpksxss;
+
+ -------------
+ -- vupkxsx --
+ -------------
+
+ function vupkxsx
+ (A : Varray_Type;
+ Offset : Natural) return Double_Varray_Type
+ is
+ K : Index_Type;
+ D : Double_Varray_Type;
+
+ begin
+ for J in Double_Varray_Type'Range loop
+ K := Index_Type (Integer (J)
+ - Integer (Double_Index_Type'First)
+ + Integer (Index_Type'First)
+ + Offset);
+ D (J) := Double_Component_Type (A (K));
+ end loop;
+
+ return D;
+ end vupkxsx;
+
+ end Signed_Merging_Operations;
+
+ ----------------------------------------
+ -- Unsigned_Merging_Operations (spec) --
+ ----------------------------------------
+
+ generic
+ type Component_Type is mod <>;
+ type Index_Type is range <>;
+ type Varray_Type is array (Index_Type) of Component_Type;
+ type Double_Component_Type is mod <>;
+ type Double_Index_Type is range <>;
+ type Double_Varray_Type is array (Double_Index_Type)
+ of Double_Component_Type;
+
+ package Unsigned_Merging_Operations is
+
+ pragma Assert (Integer (Varray_Type'First)
+ = Integer (Double_Varray_Type'First));
+ pragma Assert (Varray_Type'Length = 2 * Double_Varray_Type'Length);
+ pragma Assert (2 * Component_Type'Size = Double_Component_Type'Size);
+
+ function UI_To_UI_Mod
+ (X : Double_Component_Type;
+ Y : Natural) return Component_Type;
+
+ function Saturate (X : Double_Component_Type) return Component_Type;
+
+ function vmulxux
+ (Use_Even_Components : Boolean;
+ A : Varray_Type;
+ B : Varray_Type) return Double_Varray_Type;
+
+ function vpkuxum
+ (A : Double_Varray_Type;
+ B : Double_Varray_Type) return Varray_Type;
+
+ function vpkuxus
+ (A : Double_Varray_Type;
+ B : Double_Varray_Type) return Varray_Type;
+
+ end Unsigned_Merging_Operations;
+
+ ----------------------------------------
+ -- Unsigned_Merging_Operations (body) --
+ ----------------------------------------
+
+ package body Unsigned_Merging_Operations is
+
+ ------------------
+ -- UI_To_UI_Mod --
+ ------------------
+
+ function UI_To_UI_Mod
+ (X : Double_Component_Type;
+ Y : Natural) return Component_Type is
+ Z : Component_Type;
+ begin
+ Z := Component_Type (X mod 2 ** Y);
+ return Z;
+ end UI_To_UI_Mod;
+
+ --------------
+ -- Saturate --
+ --------------
+
+ function Saturate (X : Double_Component_Type) return Component_Type is
+ D : Component_Type;
+
+ begin
+ -- Saturation, as defined in
+ -- [PIM-4.1 Vector Status and Control Register]
+
+ D := Component_Type (Double_Component_Type'Max
+ (Double_Component_Type (Component_Type'First),
+ Double_Component_Type'Min
+ (Double_Component_Type (Component_Type'Last),
+ X)));
+
+ if Double_Component_Type (D) /= X then
+ VSCR := Write_Bit (VSCR, SAT_POS, 1);
+ end if;
+
+ return D;
+ end Saturate;
+
+ -------------
+ -- vmulxux --
+ -------------
+
+ function vmulxux
+ (Use_Even_Components : Boolean;
+ A : Varray_Type;
+ B : Varray_Type) return Double_Varray_Type
+ is
+ Double_Offset : Double_Index_Type;
+ Offset : Index_Type;
+ D : Double_Varray_Type;
+ N : constant Integer :=
+ Integer (Double_Index_Type'Last)
+ - Integer (Double_Index_Type'First) + 1;
+
+ begin
+ for J in 0 .. N - 1 loop
+ if Use_Even_Components then
+ Offset := Index_Type (2 * J + Integer (Index_Type'First));
+ else
+ Offset := Index_Type (2 * J + 1 + Integer (Index_Type'First));
+ end if;
+
+ Double_Offset :=
+ Double_Index_Type (J + Integer (Double_Index_Type'First));
+ D (Double_Offset) :=
+ Double_Component_Type (A (Offset))
+ * Double_Component_Type (B (Offset));
+ end loop;
+
+ return D;
+ end vmulxux;
+
+ -------------
+ -- vpkuxum --
+ -------------
+
+ function vpkuxum
+ (A : Double_Varray_Type;
+ B : Double_Varray_Type) return Varray_Type
+ is
+ S : constant Natural :=
+ Double_Component_Type'Size / 2;
+ N : constant Index_Type :=
+ Index_Type (Double_Index_Type'Last);
+ D : Varray_Type;
+ Offset : Index_Type;
+ Double_Offset : Double_Index_Type;
+
+ begin
+ for J in 0 .. N - 1 loop
+ Offset := Index_Type (Integer (J) + Integer (Index_Type'First));
+ Double_Offset :=
+ Double_Index_Type (Integer (J)
+ + Integer (Double_Index_Type'First));
+ D (Offset) := UI_To_UI_Mod (A (Double_Offset), S);
+ D (Offset + N) := UI_To_UI_Mod (B (Double_Offset), S);
+ end loop;
+
+ return D;
+ end vpkuxum;
+
+ -------------
+ -- vpkuxus --
+ -------------
+
+ function vpkuxus
+ (A : Double_Varray_Type;
+ B : Double_Varray_Type) return Varray_Type
+ is
+ N : constant Index_Type :=
+ Index_Type (Double_Index_Type'Last);
+ D : Varray_Type;
+ Offset : Index_Type;
+ Double_Offset : Double_Index_Type;
+
+ begin
+ for J in 0 .. N - 1 loop
+ Offset := Index_Type (Integer (J) + Integer (Index_Type'First));
+ Double_Offset :=
+ Double_Index_Type (Integer (J)
+ + Integer (Double_Index_Type'First));
+ D (Offset) := Saturate (A (Double_Offset));
+ D (Offset + N) := Saturate (B (Double_Offset));
+ end loop;
+
+ return D;
+ end vpkuxus;
+
+ end Unsigned_Merging_Operations;
+
+ package LL_VSC_Operations is
+ new Signed_Operations (signed_char,
+ Vchar_Range,
+ Varray_signed_char);
+
+ package LL_VSS_Operations is
+ new Signed_Operations (signed_short,
+ Vshort_Range,
+ Varray_signed_short);
+
+ package LL_VSI_Operations is
+ new Signed_Operations (signed_int,
+ Vint_Range,
+ Varray_signed_int);
+
+ package LL_VUC_Operations is
+ new Unsigned_Operations (unsigned_char,
+ Vchar_Range,
+ Varray_unsigned_char);
+
+ package LL_VUS_Operations is
+ new Unsigned_Operations (unsigned_short,
+ Vshort_Range,
+ Varray_unsigned_short);
+
+ package LL_VUI_Operations is
+ new Unsigned_Operations (unsigned_int,
+ Vint_Range,
+ Varray_unsigned_int);
+
+ package LL_VSC_LL_VSS_Operations is
+ new Signed_Merging_Operations (signed_char,
+ Vchar_Range,
+ Varray_signed_char,
+ signed_short,
+ Vshort_Range,
+ Varray_signed_short);
+
+ package LL_VSS_LL_VSI_Operations is
+ new Signed_Merging_Operations (signed_short,
+ Vshort_Range,
+ Varray_signed_short,
+ signed_int,
+ Vint_Range,
+ Varray_signed_int);
+
+ package LL_VUC_LL_VUS_Operations is
+ new Unsigned_Merging_Operations (unsigned_char,
+ Vchar_Range,
+ Varray_unsigned_char,
+ unsigned_short,
+ Vshort_Range,
+ Varray_unsigned_short);
+
+ package LL_VUS_LL_VUI_Operations is
+ new Unsigned_Merging_Operations (unsigned_short,
+ Vshort_Range,
+ Varray_unsigned_short,
+ unsigned_int,
+ Vint_Range,
+ Varray_unsigned_int);
+
+ ----------
+ -- Bits --
+ ----------
+
+ function Bits
+ (X : unsigned_int;
+ Low : Natural;
+ High : Natural) return unsigned_int renames LL_VUI_Operations.Bits;
+
+ function Bits
+ (X : unsigned_short;
+ Low : Natural;
+ High : Natural) return unsigned_short renames LL_VUS_Operations.Bits;
+
+ function Bits
+ (X : unsigned_char;
+ Low : Natural;
+ High : Natural) return unsigned_char renames LL_VUC_Operations.Bits;
+
+ ---------------
+ -- Write_Bit --
+ ---------------
+
+ function Write_Bit
+ (X : unsigned_int;
+ Where : Natural;
+ Value : Unsigned_1) return unsigned_int
+ renames LL_VUI_Operations.Write_Bit;
+
+ function Write_Bit
+ (X : unsigned_short;
+ Where : Natural;
+ Value : Unsigned_1) return unsigned_short
+ renames LL_VUS_Operations.Write_Bit;
+
+ function Write_Bit
+ (X : unsigned_char;
+ Where : Natural;
+ Value : Unsigned_1) return unsigned_char
+ renames LL_VUC_Operations.Write_Bit;
+
+ -----------------
+ -- Bound_Align --
+ -----------------
+
+ function Bound_Align
+ (X : Integer_Address;
+ Y : Integer_Address) return Integer_Address
+ is
+ D : Integer_Address;
+ begin
+ D := X - X mod Y;
+ return D;
+ end Bound_Align;
+
+ -----------------
+ -- NJ_Truncate --
+ -----------------
+
+ function NJ_Truncate (X : C_float) return C_float is
+ D : C_float;
+
+ begin
+ if (Bits (VSCR, NJ_POS, NJ_POS) = 1)
+ and then abs (X) < 2.0 ** (-126)
+ then
+ if X < 0.0 then
+ D := -0.0;
+ else
+ D := 0.0;
+ end if;
+ else
+ D := X;
+ end if;
+
+ return D;
+ end NJ_Truncate;
+
+ -----------------------
+ -- Rnd_To_FP_Nearest --
+ -----------------------
+
+ function Rnd_To_FP_Nearest (X : F64) return C_float is
+ begin
+ return C_float (X);
+ end Rnd_To_FP_Nearest;
+
+ ---------------------
+ -- Rnd_To_FPI_Near --
+ ---------------------
+
+ function Rnd_To_FPI_Near (X : F64) return F64 is
+ Result : F64;
+ Ceiling : F64;
+ begin
+ Result := F64 (SI64 (X));
+
+ if (F64'Ceiling (X) - X) = (X + 1.0 - F64'Ceiling (X)) then
+ -- Round to even
+ Ceiling := F64'Ceiling (X);
+ if Rnd_To_FPI_Trunc (Ceiling / 2.0) * 2.0 = Ceiling then
+ Result := Ceiling;
+ else
+ Result := Ceiling - 1.0;
+ end if;
+ end if;
+
+ return Result;
+ end Rnd_To_FPI_Near;
+
+ ----------------------
+ -- Rnd_To_FPI_Trunc --
+ ----------------------
+
+ function Rnd_To_FPI_Trunc (X : F64) return F64 is
+ Result : F64;
+
+ begin
+ Result := F64'Ceiling (X);
+
+ -- Rnd_To_FPI_Trunc rounds toward 0, 'Ceiling rounds toward
+ -- +Infinity
+
+ if X > 0.0
+ and then Result /= X
+ then
+ Result := Result - 1.0;
+ end if;
+
+ return Result;
+ end Rnd_To_FPI_Trunc;
+
+ ------------------
+ -- FP_Recip_Est --
+ ------------------
+
+ function FP_Recip_Est (X : C_float) return C_float is
+ begin
+ -- ??? [PIM-4.4 vec_re] "For result that are not +0, -0, +Inf,
+ -- -Inf, or QNaN, the estimate has a relative error no greater
+ -- than one part in 4096, that is:
+ -- Abs ((estimate - 1 / x) / (1 / x)) < = 1/4096"
+
+ return NJ_Truncate (1.0 / NJ_Truncate (X));
+ end FP_Recip_Est;
+
+ ----------
+ -- ROTL --
+ ----------
+
+ function ROTL
+ (Value : unsigned_char;
+ Amount : Natural) return unsigned_char
+ is
+ Result : Unsigned_8;
+ begin
+ Result := Rotate_Left (Unsigned_8 (Value), Amount);
+ return unsigned_char (Result);
+ end ROTL;
+
+ function ROTL
+ (Value : unsigned_short;
+ Amount : Natural) return unsigned_short
+ is
+ Result : Unsigned_16;
+ begin
+ Result := Rotate_Left (Unsigned_16 (Value), Amount);
+ return unsigned_short (Result);
+ end ROTL;
+
+ function ROTL
+ (Value : unsigned_int;
+ Amount : Natural) return unsigned_int
+ is
+ Result : Unsigned_32;
+ begin
+ Result := Rotate_Left (Unsigned_32 (Value), Amount);
+ return unsigned_int (Result);
+ end ROTL;
+
+ --------------------
+ -- Recip_SQRT_Est --
+ --------------------
+
+ function Recip_SQRT_Est (X : C_float) return C_float is
+ Result : C_float;
+
+ begin
+ -- ???
+ -- [PIM-4.4 vec_rsqrte] the estimate has a relative error in precision
+ -- no greater than one part in 4096, that is:
+ -- abs ((estimate - 1 / sqrt (x)) / (1 / sqrt (x)) <= 1 / 4096"
+
+ Result := 1.0 / NJ_Truncate (C_float_Operations.Sqrt (NJ_Truncate (X)));
+ return NJ_Truncate (Result);
+ end Recip_SQRT_Est;
+
+ ----------------
+ -- Shift_Left --
+ ----------------
+
+ function Shift_Left
+ (Value : unsigned_char;
+ Amount : Natural) return unsigned_char
+ is
+ Result : Unsigned_8;
+ begin
+ Result := Shift_Left (Unsigned_8 (Value), Amount);
+ return unsigned_char (Result);
+ end Shift_Left;
+
+ function Shift_Left
+ (Value : unsigned_short;
+ Amount : Natural) return unsigned_short
+ is
+ Result : Unsigned_16;
+ begin
+ Result := Shift_Left (Unsigned_16 (Value), Amount);
+ return unsigned_short (Result);
+ end Shift_Left;
+
+ function Shift_Left
+ (Value : unsigned_int;
+ Amount : Natural) return unsigned_int
+ is
+ Result : Unsigned_32;
+ begin
+ Result := Shift_Left (Unsigned_32 (Value), Amount);
+ return unsigned_int (Result);
+ end Shift_Left;
+
+ -----------------
+ -- Shift_Right --
+ -----------------
+
+ function Shift_Right
+ (Value : unsigned_char;
+ Amount : Natural) return unsigned_char
+ is
+ Result : Unsigned_8;
+ begin
+ Result := Shift_Right (Unsigned_8 (Value), Amount);
+ return unsigned_char (Result);
+ end Shift_Right;
+
+ function Shift_Right
+ (Value : unsigned_short;
+ Amount : Natural) return unsigned_short
+ is
+ Result : Unsigned_16;
+ begin
+ Result := Shift_Right (Unsigned_16 (Value), Amount);
+ return unsigned_short (Result);
+ end Shift_Right;
+
+ function Shift_Right
+ (Value : unsigned_int;
+ Amount : Natural) return unsigned_int
+ is
+ Result : Unsigned_32;
+ begin
+ Result := Shift_Right (Unsigned_32 (Value), Amount);
+ return unsigned_int (Result);
+ end Shift_Right;
+
+ -------------------
+ -- Shift_Right_A --
+ -------------------
+
+ generic
+ type Signed_Type is range <>;
+ type Unsigned_Type is mod <>;
+ with function Shift_Right (Value : Unsigned_Type; Amount : Natural)
+ return Unsigned_Type;
+ function Shift_Right_Arithmetic
+ (Value : Signed_Type;
+ Amount : Natural) return Signed_Type;
+
+ function Shift_Right_Arithmetic
+ (Value : Signed_Type;
+ Amount : Natural) return Signed_Type
+ is
+ begin
+ if Value > 0 then
+ return Signed_Type (Shift_Right (Unsigned_Type (Value), Amount));
+ else
+ return -Signed_Type (Shift_Right (Unsigned_Type (-Value - 1), Amount)
+ + 1);
+ end if;
+ end Shift_Right_Arithmetic;
+
+ function Shift_Right_A is new Shift_Right_Arithmetic (signed_int,
+ Unsigned_32,
+ Shift_Right);
+
+ function Shift_Right_A is new Shift_Right_Arithmetic (signed_short,
+ Unsigned_16,
+ Shift_Right);
+
+ function Shift_Right_A is new Shift_Right_Arithmetic (signed_char,
+ Unsigned_8,
+ Shift_Right);
+ --------------
+ -- To_Pixel --
+ --------------
+
+ function To_Pixel (Source : unsigned_short) return Pixel_16 is
+
+ -- This conversion should not depend on the host endianess;
+ -- therefore, we cannot use an unchecked conversion.
+
+ Target : Pixel_16;
+
+ begin
+ Target.T := Unsigned_1 (Bits (Source, 0, 0) mod 2 ** 1);
+ Target.R := Unsigned_5 (Bits (Source, 1, 5) mod 2 ** 5);
+ Target.G := Unsigned_5 (Bits (Source, 6, 10) mod 2 ** 5);
+ Target.B := Unsigned_5 (Bits (Source, 11, 15) mod 2 ** 5);
+ return Target;
+ end To_Pixel;
+
+ function To_Pixel (Source : unsigned_int) return Pixel_32 is
+
+ -- This conversion should not depend on the host endianess;
+ -- therefore, we cannot use an unchecked conversion.
+
+ Target : Pixel_32;
+
+ begin
+ Target.T := unsigned_char (Bits (Source, 0, 7));
+ Target.R := unsigned_char (Bits (Source, 8, 15));
+ Target.G := unsigned_char (Bits (Source, 16, 23));
+ Target.B := unsigned_char (Bits (Source, 24, 31));
+ return Target;
+ end To_Pixel;
+
+ ---------------------
+ -- To_unsigned_int --
+ ---------------------
+
+ function To_unsigned_int (Source : Pixel_32) return unsigned_int is
+
+ -- This conversion should not depend on the host endianess;
+ -- therefore, we cannot use an unchecked conversion.
+ -- It should also be the same result, value-wise, on two hosts
+ -- with the same endianess.
+
+ Target : unsigned_int := 0;
+
+ begin
+ -- In big endian bit ordering, Pixel_32 looks like:
+ -- -------------------------------------
+ -- | T | R | G | B |
+ -- -------------------------------------
+ -- 0 (MSB) 7 15 23 32
+ --
+ -- Sizes of the components: (8/8/8/8)
+ --
+ Target := Target or unsigned_int (Source.T);
+ Target := Shift_Left (Target, 8);
+ Target := Target or unsigned_int (Source.R);
+ Target := Shift_Left (Target, 8);
+ Target := Target or unsigned_int (Source.G);
+ Target := Shift_Left (Target, 8);
+ Target := Target or unsigned_int (Source.B);
+ return Target;
+ end To_unsigned_int;
+
+ -----------------------
+ -- To_unsigned_short --
+ -----------------------
+
+ function To_unsigned_short (Source : Pixel_16) return unsigned_short is
+
+ -- This conversion should not depend on the host endianess;
+ -- therefore, we cannot use an unchecked conversion.
+ -- It should also be the same result, value-wise, on two hosts
+ -- with the same endianess.
+
+ Target : unsigned_short := 0;
+
+ begin
+ -- In big endian bit ordering, Pixel_16 looks like:
+ -- -------------------------------------
+ -- | T | R | G | B |
+ -- -------------------------------------
+ -- 0 (MSB) 1 5 11 15
+ --
+ -- Sizes of the components: (1/5/5/5)
+ --
+ Target := Target or unsigned_short (Source.T);
+ Target := Shift_Left (Target, 5);
+ Target := Target or unsigned_short (Source.R);
+ Target := Shift_Left (Target, 5);
+ Target := Target or unsigned_short (Source.G);
+ Target := Shift_Left (Target, 5);
+ Target := Target or unsigned_short (Source.B);
+ return Target;
+ end To_unsigned_short;
+
+ ---------------
+ -- abs_v16qi --
+ ---------------
+
+ function abs_v16qi (A : LL_VSC) return LL_VSC is
+ VA : constant VSC_View := To_View (A);
+ begin
+ return To_Vector ((Values =>
+ LL_VSC_Operations.abs_vxi (VA.Values)));
+ end abs_v16qi;
+
+ --------------
+ -- abs_v8hi --
+ --------------
+
+ function abs_v8hi (A : LL_VSS) return LL_VSS is
+ VA : constant VSS_View := To_View (A);
+ begin
+ return To_Vector ((Values =>
+ LL_VSS_Operations.abs_vxi (VA.Values)));
+ end abs_v8hi;
+
+ --------------
+ -- abs_v4si --
+ --------------
+
+ function abs_v4si (A : LL_VSI) return LL_VSI is
+ VA : constant VSI_View := To_View (A);
+ begin
+ return To_Vector ((Values =>
+ LL_VSI_Operations.abs_vxi (VA.Values)));
+ end abs_v4si;
+
+ --------------
+ -- abs_v4sf --
+ --------------
+
+ function abs_v4sf (A : LL_VF) return LL_VF is
+ D : Varray_float;
+ VA : constant VF_View := To_View (A);
+
+ begin
+ for J in Varray_float'Range loop
+ D (J) := abs (VA.Values (J));
+ end loop;
+
+ return To_Vector ((Values => D));
+ end abs_v4sf;
+
+ ----------------
+ -- abss_v16qi --
+ ----------------
+
+ function abss_v16qi (A : LL_VSC) return LL_VSC is
+ VA : constant VSC_View := To_View (A);
+ begin
+ return To_Vector ((Values =>
+ LL_VSC_Operations.abss_vxi (VA.Values)));
+ end abss_v16qi;
+
+ ---------------
+ -- abss_v8hi --
+ ---------------
+
+ function abss_v8hi (A : LL_VSS) return LL_VSS is
+ VA : constant VSS_View := To_View (A);
+ begin
+ return To_Vector ((Values =>
+ LL_VSS_Operations.abss_vxi (VA.Values)));
+ end abss_v8hi;
+
+ ---------------
+ -- abss_v4si --
+ ---------------
+
+ function abss_v4si (A : LL_VSI) return LL_VSI is
+ VA : constant VSI_View := To_View (A);
+ begin
+ return To_Vector ((Values =>
+ LL_VSI_Operations.abss_vxi (VA.Values)));
+ end abss_v4si;
+
+ -------------
+ -- vaddubm --
+ -------------
+
+ function vaddubm (A : LL_VSC; B : LL_VSC) return LL_VSC is
+ UC : constant GNAT.Altivec.Low_Level_Vectors.LL_VUC :=
+ To_LL_VUC (A);
+ VA : constant VUC_View :=
+ To_View (UC);
+ VB : constant VUC_View := To_View (To_LL_VUC (B));
+ D : Varray_unsigned_char;
+
+ begin
+ D := LL_VUC_Operations.vadduxm (VA.Values, VB.Values);
+ return To_LL_VSC (To_Vector (VUC_View'(Values => D)));
+ end vaddubm;
+
+ -------------
+ -- vadduhm --
+ -------------
+
+ function vadduhm (A : LL_VSS; B : LL_VSS) return LL_VSS is
+ VA : constant VUS_View := To_View (To_LL_VUS (A));
+ VB : constant VUS_View := To_View (To_LL_VUS (B));
+ D : Varray_unsigned_short;
+
+ begin
+ D := LL_VUS_Operations.vadduxm (VA.Values, VB.Values);
+ return To_LL_VSS (To_Vector (VUS_View'(Values => D)));
+ end vadduhm;
+
+ -------------
+ -- vadduwm --
+ -------------
+
+ function vadduwm (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : Varray_unsigned_int;
+
+ begin
+ D := LL_VUI_Operations.vadduxm (VA.Values, VB.Values);
+ return To_LL_VSI (To_Vector (VUI_View'(Values => D)));
+ end vadduwm;
+
+ ------------
+ -- vaddfp --
+ ------------
+
+ function vaddfp (A : LL_VF; B : LL_VF) return LL_VF is
+ VA : constant VF_View := To_View (A);
+ VB : constant VF_View := To_View (B);
+ D : Varray_float;
+
+ begin
+ for J in Varray_float'Range loop
+ D (J) := NJ_Truncate (NJ_Truncate (VA.Values (J))
+ + NJ_Truncate (VB.Values (J)));
+ end loop;
+
+ return To_Vector (VF_View'(Values => D));
+ end vaddfp;
+
+ -------------
+ -- vaddcuw --
+ -------------
+
+ function vaddcuw (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ Addition_Result : UI64;
+ D : VUI_View;
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+
+ begin
+ for J in Varray_unsigned_int'Range loop
+ Addition_Result :=
+ UI64 (VA.Values (J)) + UI64 (VB.Values (J));
+
+ if Addition_Result > UI64 (unsigned_int'Last) then
+ D.Values (J) := 1;
+ else
+ D.Values (J) := 0;
+ end if;
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vaddcuw;
+
+ -------------
+ -- vaddubs --
+ -------------
+
+ function vaddubs (A : LL_VSC; B : LL_VSC) return LL_VSC is
+ VA : constant VUC_View := To_View (To_LL_VUC (A));
+ VB : constant VUC_View := To_View (To_LL_VUC (B));
+
+ begin
+ return To_LL_VSC (To_Vector
+ (VUC_View'(Values =>
+ (LL_VUC_Operations.vadduxs
+ (VA.Values,
+ VB.Values)))));
+ end vaddubs;
+
+ -------------
+ -- vaddsbs --
+ -------------
+
+ function vaddsbs (A : LL_VSC; B : LL_VSC) return LL_VSC is
+ VA : constant VSC_View := To_View (A);
+ VB : constant VSC_View := To_View (B);
+ D : VSC_View;
+
+ begin
+ D.Values := LL_VSC_Operations.vaddsxs (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vaddsbs;
+
+ -------------
+ -- vadduhs --
+ -------------
+
+ function vadduhs (A : LL_VSS; B : LL_VSS) return LL_VSS is
+ VA : constant VUS_View := To_View (To_LL_VUS (A));
+ VB : constant VUS_View := To_View (To_LL_VUS (B));
+ D : VUS_View;
+
+ begin
+ D.Values := LL_VUS_Operations.vadduxs (VA.Values, VB.Values);
+ return To_LL_VSS (To_Vector (D));
+ end vadduhs;
+
+ -------------
+ -- vaddshs --
+ -------------
+
+ function vaddshs (A : LL_VSS; B : LL_VSS) return LL_VSS is
+ VA : constant VSS_View := To_View (A);
+ VB : constant VSS_View := To_View (B);
+ D : VSS_View;
+
+ begin
+ D.Values := LL_VSS_Operations.vaddsxs (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vaddshs;
+
+ -------------
+ -- vadduws --
+ -------------
+
+ function vadduws (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : VUI_View;
+
+ begin
+ D.Values := LL_VUI_Operations.vadduxs (VA.Values, VB.Values);
+ return To_LL_VSI (To_Vector (D));
+ end vadduws;
+
+ -------------
+ -- vaddsws --
+ -------------
+
+ function vaddsws (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VSI_View := To_View (A);
+ VB : constant VSI_View := To_View (B);
+ D : VSI_View;
+
+ begin
+ D.Values := LL_VSI_Operations.vaddsxs (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vaddsws;
+
+ ----------
+ -- vand --
+ ----------
+
+ function vand (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : VUI_View;
+
+ begin
+ for J in Varray_unsigned_int'Range loop
+ D.Values (J) := VA.Values (J) and VB.Values (J);
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vand;
+
+ -----------
+ -- vandc --
+ -----------
+
+ function vandc (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : VUI_View;
+
+ begin
+ for J in Varray_unsigned_int'Range loop
+ D.Values (J) := VA.Values (J) and not VB.Values (J);
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vandc;
+
+ ------------
+ -- vavgub --
+ ------------
+
+ function vavgub (A : LL_VSC; B : LL_VSC) return LL_VSC is
+ VA : constant VUC_View := To_View (To_LL_VUC (A));
+ VB : constant VUC_View := To_View (To_LL_VUC (B));
+ D : VUC_View;
+
+ begin
+ D.Values := LL_VUC_Operations.vavgux (VA.Values, VB.Values);
+ return To_LL_VSC (To_Vector (D));
+ end vavgub;
+
+ ------------
+ -- vavgsb --
+ ------------
+
+ function vavgsb (A : LL_VSC; B : LL_VSC) return LL_VSC is
+ VA : constant VSC_View := To_View (A);
+ VB : constant VSC_View := To_View (B);
+ D : VSC_View;
+
+ begin
+ D.Values := LL_VSC_Operations.vavgsx (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vavgsb;
+
+ ------------
+ -- vavguh --
+ ------------
+
+ function vavguh (A : LL_VSS; B : LL_VSS) return LL_VSS is
+ VA : constant VUS_View := To_View (To_LL_VUS (A));
+ VB : constant VUS_View := To_View (To_LL_VUS (B));
+ D : VUS_View;
+
+ begin
+ D.Values := LL_VUS_Operations.vavgux (VA.Values, VB.Values);
+ return To_LL_VSS (To_Vector (D));
+ end vavguh;
+
+ ------------
+ -- vavgsh --
+ ------------
+
+ function vavgsh (A : LL_VSS; B : LL_VSS) return LL_VSS is
+ VA : constant VSS_View := To_View (A);
+ VB : constant VSS_View := To_View (B);
+ D : VSS_View;
+
+ begin
+ D.Values := LL_VSS_Operations.vavgsx (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vavgsh;
+
+ ------------
+ -- vavguw --
+ ------------
+
+ function vavguw (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : VUI_View;
+
+ begin
+ D.Values := LL_VUI_Operations.vavgux (VA.Values, VB.Values);
+ return To_LL_VSI (To_Vector (D));
+ end vavguw;
+
+ ------------
+ -- vavgsw --
+ ------------
+
+ function vavgsw (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VSI_View := To_View (A);
+ VB : constant VSI_View := To_View (B);
+ D : VSI_View;
+
+ begin
+ D.Values := LL_VSI_Operations.vavgsx (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vavgsw;
+
+ -----------
+ -- vrfip --
+ -----------
+
+ function vrfip (A : LL_VF) return LL_VF is
+ VA : constant VF_View := To_View (A);
+ D : VF_View;
+
+ begin
+ for J in Varray_float'Range loop
+
+ -- If A (J) is infinite, D (J) should be infinite; With
+ -- IEEE floating points, we can use 'Ceiling for that purpose.
+
+ D.Values (J) := C_float'Ceiling (NJ_Truncate (VA.Values (J)));
+
+ end loop;
+
+ return To_Vector (D);
+ end vrfip;
+
+ -------------
+ -- vcmpbfp --
+ -------------
+
+ function vcmpbfp (A : LL_VF; B : LL_VF) return LL_VSI is
+ VA : constant VF_View := To_View (A);
+ VB : constant VF_View := To_View (B);
+ D : VUI_View;
+ K : Vint_Range;
+
+ begin
+ for J in Varray_float'Range loop
+ K := Vint_Range (J);
+ D.Values (K) := 0;
+
+ if NJ_Truncate (VB.Values (J)) < 0.0 then
+
+ -- [PIM-4.4 vec_cmpb] "If any single-precision floating-point
+ -- word element in B is negative; the corresponding element in A
+ -- is out of bounds.
+
+ D.Values (K) := Write_Bit (D.Values (K), 0, 1);
+ D.Values (K) := Write_Bit (D.Values (K), 1, 1);
+
+ else
+ if NJ_Truncate (VA.Values (J))
+ <= NJ_Truncate (VB.Values (J)) then
+ D.Values (K) := Write_Bit (D.Values (K), 0, 0);
+ else
+ D.Values (K) := Write_Bit (D.Values (K), 0, 1);
+ end if;
+
+ if NJ_Truncate (VA.Values (J))
+ >= -NJ_Truncate (VB.Values (J)) then
+ D.Values (K) := Write_Bit (D.Values (K), 1, 0);
+ else
+ D.Values (K) := Write_Bit (D.Values (K), 1, 1);
+ end if;
+ end if;
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vcmpbfp;
+
+ --------------
+ -- vcmpequb --
+ --------------
+
+ function vcmpequb (A : LL_VSC; B : LL_VSC) return LL_VSC is
+ VA : constant VUC_View := To_View (To_LL_VUC (A));
+ VB : constant VUC_View := To_View (To_LL_VUC (B));
+ D : VUC_View;
+
+ begin
+ D.Values := LL_VUC_Operations.vcmpequx (VA.Values, VB.Values);
+ return To_LL_VSC (To_Vector (D));
+ end vcmpequb;
+
+ --------------
+ -- vcmpequh --
+ --------------
+
+ function vcmpequh (A : LL_VSS; B : LL_VSS) return LL_VSS is
+ VA : constant VUS_View := To_View (To_LL_VUS (A));
+ VB : constant VUS_View := To_View (To_LL_VUS (B));
+ D : VUS_View;
+ begin
+ D.Values := LL_VUS_Operations.vcmpequx (VA.Values, VB.Values);
+ return To_LL_VSS (To_Vector (D));
+ end vcmpequh;
+
+ --------------
+ -- vcmpequw --
+ --------------
+
+ function vcmpequw (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : VUI_View;
+ begin
+ D.Values := LL_VUI_Operations.vcmpequx (VA.Values, VB.Values);
+ return To_LL_VSI (To_Vector (D));
+ end vcmpequw;
+
+ --------------
+ -- vcmpeqfp --
+ --------------
+
+ function vcmpeqfp (A : LL_VF; B : LL_VF) return LL_VSI is
+ VA : constant VF_View := To_View (A);
+ VB : constant VF_View := To_View (B);
+ D : VUI_View;
+ K : Vint_Range;
+
+ begin
+ for J in Varray_float'Range loop
+ K := Vint_Range (J);
+
+ if VA.Values (J) = VB.Values (J) then
+ D.Values (K) := unsigned_int'Last;
+ else
+ D.Values (K) := 0;
+ end if;
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vcmpeqfp;
+
+ --------------
+ -- vcmpgefp --
+ --------------
+
+ function vcmpgefp (A : LL_VF; B : LL_VF) return LL_VSI is
+ VA : constant VF_View := To_View (A);
+ VB : constant VF_View := To_View (B);
+ D : VSI_View;
+ K : Vint_Range;
+
+ begin
+ for J in Varray_float'Range loop
+ K := Vint_Range (J);
+
+ if VA.Values (J) >= VB.Values (J) then
+ D.Values (K) := Signed_Bool_True;
+ else
+ D.Values (K) := Signed_Bool_False;
+ end if;
+ end loop;
+
+ return To_Vector (D);
+ end vcmpgefp;
+
+ --------------
+ -- vcmpgtub --
+ --------------
+
+ function vcmpgtub (A : LL_VSC; B : LL_VSC) return LL_VSC is
+ VA : constant VUC_View := To_View (To_LL_VUC (A));
+ VB : constant VUC_View := To_View (To_LL_VUC (B));
+ D : VUC_View;
+ begin
+ D.Values := LL_VUC_Operations.vcmpgtux (VA.Values, VB.Values);
+ return To_LL_VSC (To_Vector (D));
+ end vcmpgtub;
+
+ --------------
+ -- vcmpgtsb --
+ --------------
+
+ function vcmpgtsb (A : LL_VSC; B : LL_VSC) return LL_VSC is
+ VA : constant VSC_View := To_View (A);
+ VB : constant VSC_View := To_View (B);
+ D : VSC_View;
+ begin
+ D.Values := LL_VSC_Operations.vcmpgtsx (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vcmpgtsb;
+
+ --------------
+ -- vcmpgtuh --
+ --------------
+
+ function vcmpgtuh (A : LL_VSS; B : LL_VSS) return LL_VSS is
+ VA : constant VUS_View := To_View (To_LL_VUS (A));
+ VB : constant VUS_View := To_View (To_LL_VUS (B));
+ D : VUS_View;
+ begin
+ D.Values := LL_VUS_Operations.vcmpgtux (VA.Values, VB.Values);
+ return To_LL_VSS (To_Vector (D));
+ end vcmpgtuh;
+
+ --------------
+ -- vcmpgtsh --
+ --------------
+
+ function vcmpgtsh (A : LL_VSS; B : LL_VSS) return LL_VSS is
+ VA : constant VSS_View := To_View (A);
+ VB : constant VSS_View := To_View (B);
+ D : VSS_View;
+ begin
+ D.Values := LL_VSS_Operations.vcmpgtsx (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vcmpgtsh;
+
+ --------------
+ -- vcmpgtuw --
+ --------------
+
+ function vcmpgtuw (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : VUI_View;
+ begin
+ D.Values := LL_VUI_Operations.vcmpgtux (VA.Values, VB.Values);
+ return To_LL_VSI (To_Vector (D));
+ end vcmpgtuw;
+
+ --------------
+ -- vcmpgtsw --
+ --------------
+
+ function vcmpgtsw (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VSI_View := To_View (A);
+ VB : constant VSI_View := To_View (B);
+ D : VSI_View;
+ begin
+ D.Values := LL_VSI_Operations.vcmpgtsx (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vcmpgtsw;
+
+ --------------
+ -- vcmpgtfp --
+ --------------
+
+ function vcmpgtfp (A : LL_VF; B : LL_VF) return LL_VSI is
+ VA : constant VF_View := To_View (A);
+ VB : constant VF_View := To_View (B);
+ D : VSI_View;
+ K : Vint_Range;
+
+ begin
+ for J in Varray_float'Range loop
+ K := Vint_Range (J);
+
+ if NJ_Truncate (VA.Values (J))
+ > NJ_Truncate (VB.Values (J)) then
+ D.Values (K) := Signed_Bool_True;
+ else
+ D.Values (K) := Signed_Bool_False;
+ end if;
+ end loop;
+
+ return To_Vector (D);
+ end vcmpgtfp;
+
+ -----------
+ -- vcfux --
+ -----------
+
+ function vcfux (A : LL_VSI; B : c_int) return LL_VF is
+ D : VF_View;
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ K : Vfloat_Range;
+
+ begin
+ for J in Varray_signed_int'Range loop
+ K := Vfloat_Range (J);
+
+ -- Note: The conversion to Integer is safe, as Integers are required
+ -- to include the range -2 ** 15 + 1 .. 2 ** 15 + 1 and therefore
+ -- include the range of B (should be 0 .. 255).
+
+ D.Values (K) :=
+ C_float (VA.Values (J)) / (2.0 ** Integer (B));
+ end loop;
+
+ return To_Vector (D);
+ end vcfux;
+
+ -----------
+ -- vcfsx --
+ -----------
+
+ function vcfsx (A : LL_VSI; B : c_int) return LL_VF is
+ VA : constant VSI_View := To_View (A);
+ D : VF_View;
+ K : Vfloat_Range;
+
+ begin
+ for J in Varray_signed_int'Range loop
+ K := Vfloat_Range (J);
+ D.Values (K) := C_float (VA.Values (J))
+ / (2.0 ** Integer (B));
+ end loop;
+
+ return To_Vector (D);
+ end vcfsx;
+
+ ------------
+ -- vctsxs --
+ ------------
+
+ function vctsxs (A : LL_VF; B : c_int) return LL_VSI is
+ VA : constant VF_View := To_View (A);
+ D : VSI_View;
+ K : Vfloat_Range;
+
+ begin
+ for J in Varray_signed_int'Range loop
+ K := Vfloat_Range (J);
+ D.Values (J) :=
+ LL_VSI_Operations.Saturate
+ (F64 (NJ_Truncate (VA.Values (K)))
+ * F64 (2.0 ** Integer (B)));
+ end loop;
+
+ return To_Vector (D);
+ end vctsxs;
+
+ ------------
+ -- vctuxs --
+ ------------
+
+ function vctuxs (A : LL_VF; B : c_int) return LL_VSI is
+ VA : constant VF_View := To_View (A);
+ D : VUI_View;
+ K : Vfloat_Range;
+
+ begin
+ for J in Varray_unsigned_int'Range loop
+ K := Vfloat_Range (J);
+ D.Values (J) :=
+ LL_VUI_Operations.Saturate
+ (F64 (NJ_Truncate (VA.Values (K)))
+ * F64 (2.0 ** Integer (B)));
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vctuxs;
+
+ ---------
+ -- dss --
+ ---------
+
+ -- No-ops, as allowed by [PEM-5.2.1.1 Data Stream Touch (dst)]:
+
+ procedure dss (A : c_int) is
+ pragma Unreferenced (A);
+ begin
+ null;
+ end dss;
+
+ ------------
+ -- dssall --
+ ------------
+
+ -- No-ops, as allowed by [PEM-5.2.1.1 Data Stream Touch (dst)]:
+
+ procedure dssall is
+ begin
+ null;
+ end dssall;
+
+ ---------
+ -- dst --
+ ---------
+
+ -- No-ops, as allowed by [PEM-5.2.1.1 Data Stream Touch (dst)]:
+
+ procedure dst (A : c_ptr; B : c_int; C : c_int) is
+ pragma Unreferenced (A);
+ pragma Unreferenced (B);
+ pragma Unreferenced (C);
+ begin
+ null;
+ end dst;
+
+ -----------
+ -- dstst --
+ -----------
+
+ -- No-ops, as allowed by [PEM-5.2.1.1 Data Stream Touch (dst)]:
+
+ procedure dstst (A : c_ptr; B : c_int; C : c_int) is
+ pragma Unreferenced (A);
+ pragma Unreferenced (B);
+ pragma Unreferenced (C);
+ begin
+ null;
+ end dstst;
+
+ ------------
+ -- dststt --
+ ------------
+
+ -- No-ops, as allowed by [PEM-5.2.1.1 Data Stream Touch (dst)]:
+
+ procedure dststt (A : c_ptr; B : c_int; C : c_int) is
+ pragma Unreferenced (A);
+ pragma Unreferenced (B);
+ pragma Unreferenced (C);
+ begin
+ null;
+ end dststt;
+
+ ----------
+ -- dstt --
+ ----------
+
+ -- No-ops, as allowed by [PEM-5.2.1.1 Data Stream Touch (dst)]:
+
+ procedure dstt (A : c_ptr; B : c_int; C : c_int) is
+ pragma Unreferenced (A);
+ pragma Unreferenced (B);
+ pragma Unreferenced (C);
+ begin
+ null;
+ end dstt;
+
+ --------------
+ -- vexptefp --
+ --------------
+
+ function vexptefp (A : LL_VF) return LL_VF is
+ use C_float_Operations;
+
+ VA : constant VF_View := To_View (A);
+ D : VF_View;
+
+ begin
+ for J in Varray_float'Range loop
+
+ -- ??? Check the precision of the operation.
+ -- As described in [PEM-6 vexptefp]:
+ -- If theorical_result is equal to 2 at the power of A (J) with
+ -- infinite precision, we should have:
+ -- abs ((D (J) - theorical_result) / theorical_result) <= 1/16
+
+ D.Values (J) := 2.0 ** NJ_Truncate (VA.Values (J));
+ end loop;
+
+ return To_Vector (D);
+ end vexptefp;
+
+ -----------
+ -- vrfim --
+ -----------
+
+ function vrfim (A : LL_VF) return LL_VF is
+ VA : constant VF_View := To_View (A);
+ D : VF_View;
+
+ begin
+ for J in Varray_float'Range loop
+
+ -- If A (J) is infinite, D (J) should be infinite; With
+ -- IEEE floating point, we can use 'Ceiling for that purpose.
+
+ D.Values (J) := C_float'Ceiling (NJ_Truncate (VA.Values (J)));
+
+ -- Vrfim rounds toward -Infinity, whereas 'Ceiling rounds toward
+ -- +Infinity:
+
+ if D.Values (J) /= VA.Values (J) then
+ D.Values (J) := D.Values (J) - 1.0;
+ end if;
+ end loop;
+
+ return To_Vector (D);
+ end vrfim;
+
+ ---------
+ -- lvx --
+ ---------
+
+ function lvx (A : c_long; B : c_ptr) return LL_VSI is
+ EA : Integer_Address;
+
+ begin
+ EA := Bound_Align (Integer_Address (A) + To_Integer (B), 16);
+
+ declare
+ D : LL_VSI;
+ for D'Address use To_Address (EA);
+ begin
+ return D;
+ end;
+ end lvx;
+
+ -----------
+ -- lvebx --
+ -----------
+
+ function lvebx (A : c_long; B : c_ptr) return LL_VSC is
+ D : VSC_View;
+ begin
+ D.Values := LL_VSC_Operations.lvexx (A, B);
+ return To_Vector (D);
+ end lvebx;
+
+ -----------
+ -- lvehx --
+ -----------
+
+ function lvehx (A : c_long; B : c_ptr) return LL_VSS is
+ D : VSS_View;
+ begin
+ D.Values := LL_VSS_Operations.lvexx (A, B);
+ return To_Vector (D);
+ end lvehx;
+
+ -----------
+ -- lvewx --
+ -----------
+
+ function lvewx (A : c_long; B : c_ptr) return LL_VSI is
+ D : VSI_View;
+ begin
+ D.Values := LL_VSI_Operations.lvexx (A, B);
+ return To_Vector (D);
+ end lvewx;
+
+ ----------
+ -- lvxl --
+ ----------
+
+ function lvxl (A : c_long; B : c_ptr) return LL_VSI renames
+ lvx;
+
+ -------------
+ -- vlogefp --
+ -------------
+
+ function vlogefp (A : LL_VF) return LL_VF is
+ VA : constant VF_View := To_View (A);
+ D : VF_View;
+
+ begin
+ for J in Varray_float'Range loop
+
+ -- ??? Check the precision of the operation.
+ -- As described in [PEM-6 vlogefp]:
+ -- If theorical_result is equal to the log2 of A (J) with
+ -- infinite precision, we should have:
+ -- abs (D (J) - theorical_result) <= 1/32,
+ -- unless abs(D(J) - 1) <= 1/8.
+
+ D.Values (J) :=
+ C_float_Operations.Log (NJ_Truncate (VA.Values (J)), 2.0);
+ end loop;
+
+ return To_Vector (D);
+ end vlogefp;
+
+ ----------
+ -- lvsl --
+ ----------
+
+ function lvsl (A : c_long; B : c_ptr) return LL_VSC is
+ type bit4_type is mod 16#F# + 1;
+ for bit4_type'Alignment use 1;
+ EA : Integer_Address;
+ D : VUC_View;
+ SH : bit4_type;
+
+ begin
+ EA := Integer_Address (A) + To_Integer (B);
+ SH := bit4_type (EA mod 2 ** 4);
+
+ for J in D.Values'Range loop
+ D.Values (J) := unsigned_char (SH) + unsigned_char (J)
+ - unsigned_char (D.Values'First);
+ end loop;
+
+ return To_LL_VSC (To_Vector (D));
+ end lvsl;
+
+ ----------
+ -- lvsr --
+ ----------
+
+ function lvsr (A : c_long; B : c_ptr) return LL_VSC is
+ type bit4_type is mod 16#F# + 1;
+ for bit4_type'Alignment use 1;
+ EA : Integer_Address;
+ D : VUC_View;
+ SH : bit4_type;
+
+ begin
+ EA := Integer_Address (A) + To_Integer (B);
+ SH := bit4_type (EA mod 2 ** 4);
+
+ for J in D.Values'Range loop
+ D.Values (J) := (16#F# - unsigned_char (SH)) + unsigned_char (J);
+ end loop;
+
+ return To_LL_VSC (To_Vector (D));
+ end lvsr;
+
+ -------------
+ -- vmaddfp --
+ -------------
+
+ function vmaddfp (A : LL_VF; B : LL_VF; C : LL_VF) return LL_VF is
+ VA : constant VF_View := To_View (A);
+ VB : constant VF_View := To_View (B);
+ VC : constant VF_View := To_View (C);
+ D : VF_View;
+
+ begin
+ for J in Varray_float'Range loop
+ D.Values (J) :=
+ Rnd_To_FP_Nearest (F64 (VA.Values (J))
+ * F64 (VB.Values (J))
+ + F64 (VC.Values (J)));
+ end loop;
+
+ return To_Vector (D);
+ end vmaddfp;
+
+ ---------------
+ -- vmhaddshs --
+ ---------------
+
+ function vmhaddshs (A : LL_VSS; B : LL_VSS; C : LL_VSS) return LL_VSS is
+ VA : constant VSS_View := To_View (A);
+ VB : constant VSS_View := To_View (B);
+ VC : constant VSS_View := To_View (C);
+ D : VSS_View;
+
+ begin
+ for J in Varray_signed_short'Range loop
+ D.Values (J) := LL_VSS_Operations.Saturate
+ ((SI64 (VA.Values (J)) * SI64 (VB.Values (J)))
+ / SI64 (2 ** 15) + SI64 (VC.Values (J)));
+ end loop;
+
+ return To_Vector (D);
+ end vmhaddshs;
+
+ ------------
+ -- vmaxub --
+ ------------
+
+ function vmaxub (A : LL_VSC; B : LL_VSC) return LL_VSC is
+ VA : constant VUC_View := To_View (To_LL_VUC (A));
+ VB : constant VUC_View := To_View (To_LL_VUC (B));
+ D : VUC_View;
+ begin
+ D.Values := LL_VUC_Operations.vmaxux (VA.Values, VB.Values);
+ return To_LL_VSC (To_Vector (D));
+ end vmaxub;
+
+ ------------
+ -- vmaxsb --
+ ------------
+
+ function vmaxsb (A : LL_VSC; B : LL_VSC) return LL_VSC is
+ VA : constant VSC_View := To_View (A);
+ VB : constant VSC_View := To_View (B);
+ D : VSC_View;
+ begin
+ D.Values := LL_VSC_Operations.vmaxsx (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vmaxsb;
+
+ ------------
+ -- vmaxuh --
+ ------------
+
+ function vmaxuh (A : LL_VSS; B : LL_VSS) return LL_VSS is
+ VA : constant VUS_View := To_View (To_LL_VUS (A));
+ VB : constant VUS_View := To_View (To_LL_VUS (B));
+ D : VUS_View;
+ begin
+ D.Values := LL_VUS_Operations.vmaxux (VA.Values, VB.Values);
+ return To_LL_VSS (To_Vector (D));
+ end vmaxuh;
+
+ ------------
+ -- vmaxsh --
+ ------------
+
+ function vmaxsh (A : LL_VSS; B : LL_VSS) return LL_VSS is
+ VA : constant VSS_View := To_View (A);
+ VB : constant VSS_View := To_View (B);
+ D : VSS_View;
+ begin
+ D.Values := LL_VSS_Operations.vmaxsx (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vmaxsh;
+
+ ------------
+ -- vmaxuw --
+ ------------
+
+ function vmaxuw (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : VUI_View;
+ begin
+ D.Values := LL_VUI_Operations.vmaxux (VA.Values, VB.Values);
+ return To_LL_VSI (To_Vector (D));
+ end vmaxuw;
+
+ ------------
+ -- vmaxsw --
+ ------------
+
+ function vmaxsw (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VSI_View := To_View (A);
+ VB : constant VSI_View := To_View (B);
+ D : VSI_View;
+ begin
+ D.Values := LL_VSI_Operations.vmaxsx (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vmaxsw;
+
+ --------------
+ -- vmaxsxfp --
+ --------------
+
+ function vmaxfp (A : LL_VF; B : LL_VF) return LL_VF is
+ VA : constant VF_View := To_View (A);
+ VB : constant VF_View := To_View (B);
+ D : VF_View;
+
+ begin
+ for J in Varray_float'Range loop
+ if VA.Values (J) > VB.Values (J) then
+ D.Values (J) := VA.Values (J);
+ else
+ D.Values (J) := VB.Values (J);
+ end if;
+ end loop;
+
+ return To_Vector (D);
+ end vmaxfp;
+
+ ------------
+ -- vmrghb --
+ ------------
+
+ function vmrghb (A : LL_VSC; B : LL_VSC) return LL_VSC is
+ VA : constant VSC_View := To_View (A);
+ VB : constant VSC_View := To_View (B);
+ D : VSC_View;
+ begin
+ D.Values := LL_VSC_Operations.vmrghx (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vmrghb;
+
+ ------------
+ -- vmrghh --
+ ------------
+
+ function vmrghh (A : LL_VSS; B : LL_VSS) return LL_VSS is
+ VA : constant VSS_View := To_View (A);
+ VB : constant VSS_View := To_View (B);
+ D : VSS_View;
+ begin
+ D.Values := LL_VSS_Operations.vmrghx (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vmrghh;
+
+ ------------
+ -- vmrghw --
+ ------------
+
+ function vmrghw (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VSI_View := To_View (A);
+ VB : constant VSI_View := To_View (B);
+ D : VSI_View;
+ begin
+ D.Values := LL_VSI_Operations.vmrghx (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vmrghw;
+
+ ------------
+ -- vmrglb --
+ ------------
+
+ function vmrglb (A : LL_VSC; B : LL_VSC) return LL_VSC is
+ VA : constant VSC_View := To_View (A);
+ VB : constant VSC_View := To_View (B);
+ D : VSC_View;
+ begin
+ D.Values := LL_VSC_Operations.vmrglx (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vmrglb;
+
+ ------------
+ -- vmrglh --
+ ------------
+
+ function vmrglh (A : LL_VSS; B : LL_VSS) return LL_VSS is
+ VA : constant VSS_View := To_View (A);
+ VB : constant VSS_View := To_View (B);
+ D : VSS_View;
+ begin
+ D.Values := LL_VSS_Operations.vmrglx (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vmrglh;
+
+ ------------
+ -- vmrglw --
+ ------------
+
+ function vmrglw (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VSI_View := To_View (A);
+ VB : constant VSI_View := To_View (B);
+ D : VSI_View;
+ begin
+ D.Values := LL_VSI_Operations.vmrglx (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vmrglw;
+
+ ------------
+ -- mfvscr --
+ ------------
+
+ function mfvscr return LL_VSS is
+ D : VUS_View;
+ begin
+ for J in Varray_unsigned_short'Range loop
+ D.Values (J) := 0;
+ end loop;
+
+ D.Values (Varray_unsigned_short'Last) :=
+ unsigned_short (VSCR mod 2 ** unsigned_short'Size);
+ D.Values (Varray_unsigned_short'Last - 1) :=
+ unsigned_short (VSCR / 2 ** unsigned_short'Size);
+ return To_LL_VSS (To_Vector (D));
+ end mfvscr;
+
+ ------------
+ -- vminfp --
+ ------------
+
+ function vminfp (A : LL_VF; B : LL_VF) return LL_VF is
+ VA : constant VF_View := To_View (A);
+ VB : constant VF_View := To_View (B);
+ D : VF_View;
+
+ begin
+ for J in Varray_float'Range loop
+ if VA.Values (J) < VB.Values (J) then
+ D.Values (J) := VA.Values (J);
+ else
+ D.Values (J) := VB.Values (J);
+ end if;
+ end loop;
+
+ return To_Vector (D);
+ end vminfp;
+
+ ------------
+ -- vminsb --
+ ------------
+
+ function vminsb (A : LL_VSC; B : LL_VSC) return LL_VSC is
+ VA : constant VSC_View := To_View (A);
+ VB : constant VSC_View := To_View (B);
+ D : VSC_View;
+ begin
+ D.Values := LL_VSC_Operations.vminsx (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vminsb;
+
+ ------------
+ -- vminub --
+ ------------
+
+ function vminub (A : LL_VSC; B : LL_VSC) return LL_VSC is
+ VA : constant VUC_View := To_View (To_LL_VUC (A));
+ VB : constant VUC_View := To_View (To_LL_VUC (B));
+ D : VUC_View;
+ begin
+ D.Values := LL_VUC_Operations.vminux (VA.Values, VB.Values);
+ return To_LL_VSC (To_Vector (D));
+ end vminub;
+
+ ------------
+ -- vminsh --
+ ------------
+
+ function vminsh (A : LL_VSS; B : LL_VSS) return LL_VSS is
+ VA : constant VSS_View := To_View (A);
+ VB : constant VSS_View := To_View (B);
+ D : VSS_View;
+ begin
+ D.Values := LL_VSS_Operations.vminsx (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vminsh;
+
+ ------------
+ -- vminuh --
+ ------------
+
+ function vminuh (A : LL_VSS; B : LL_VSS) return LL_VSS is
+ VA : constant VUS_View := To_View (To_LL_VUS (A));
+ VB : constant VUS_View := To_View (To_LL_VUS (B));
+ D : VUS_View;
+ begin
+ D.Values := LL_VUS_Operations.vminux (VA.Values, VB.Values);
+ return To_LL_VSS (To_Vector (D));
+ end vminuh;
+
+ ------------
+ -- vminsw --
+ ------------
+
+ function vminsw (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VSI_View := To_View (A);
+ VB : constant VSI_View := To_View (B);
+ D : VSI_View;
+ begin
+ D.Values := LL_VSI_Operations.vminsx (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vminsw;
+
+ ------------
+ -- vminuw --
+ ------------
+
+ function vminuw (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : VUI_View;
+ begin
+ D.Values := LL_VUI_Operations.vminux (VA.Values,
+ VB.Values);
+ return To_LL_VSI (To_Vector (D));
+ end vminuw;
+
+ ---------------
+ -- vmladduhm --
+ ---------------
+
+ function vmladduhm (A : LL_VSS; B : LL_VSS; C : LL_VSS) return LL_VSS is
+ VA : constant VUS_View := To_View (To_LL_VUS (A));
+ VB : constant VUS_View := To_View (To_LL_VUS (B));
+ VC : constant VUS_View := To_View (To_LL_VUS (C));
+ D : VUS_View;
+
+ begin
+ for J in Varray_unsigned_short'Range loop
+ D.Values (J) := VA.Values (J) * VB.Values (J)
+ + VC.Values (J);
+ end loop;
+
+ return To_LL_VSS (To_Vector (D));
+ end vmladduhm;
+
+ ----------------
+ -- vmhraddshs --
+ ----------------
+
+ function vmhraddshs (A : LL_VSS; B : LL_VSS; C : LL_VSS) return LL_VSS is
+ VA : constant VSS_View := To_View (A);
+ VB : constant VSS_View := To_View (B);
+ VC : constant VSS_View := To_View (C);
+ D : VSS_View;
+
+ begin
+ for J in Varray_signed_short'Range loop
+ D.Values (J) :=
+ LL_VSS_Operations.Saturate (((SI64 (VA.Values (J))
+ * SI64 (VB.Values (J))
+ + 2 ** 14)
+ / 2 ** 15
+ + SI64 (VC.Values (J))));
+ end loop;
+
+ return To_Vector (D);
+ end vmhraddshs;
+
+ --------------
+ -- vmsumubm --
+ --------------
+
+ function vmsumubm (A : LL_VSC; B : LL_VSC; C : LL_VSI) return LL_VSI is
+ Offset : Vchar_Range;
+ VA : constant VUC_View := To_View (To_LL_VUC (A));
+ VB : constant VUC_View := To_View (To_LL_VUC (B));
+ VC : constant VUI_View := To_View (To_LL_VUI (C));
+ D : VUI_View;
+
+ begin
+ for J in 0 .. 3 loop
+ Offset := Vchar_Range (4 * J + Integer (Vchar_Range'First));
+ D.Values (Vint_Range
+ (J + Integer (Vint_Range'First))) :=
+ (unsigned_int (VA.Values (Offset))
+ * unsigned_int (VB.Values (Offset)))
+ + (unsigned_int (VA.Values (Offset + 1))
+ * unsigned_int (VB.Values (1 + Offset)))
+ + (unsigned_int (VA.Values (2 + Offset))
+ * unsigned_int (VB.Values (2 + Offset)))
+ + (unsigned_int (VA.Values (3 + Offset))
+ * unsigned_int (VB.Values (3 + Offset)))
+ + VC.Values (Vint_Range
+ (J + Integer (Varray_unsigned_int'First)));
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vmsumubm;
+
+ --------------
+ -- vmsumumbm --
+ --------------
+
+ function vmsummbm (A : LL_VSC; B : LL_VSC; C : LL_VSI) return LL_VSI is
+ Offset : Vchar_Range;
+ VA : constant VSC_View := To_View (A);
+ VB : constant VUC_View := To_View (To_LL_VUC (B));
+ VC : constant VSI_View := To_View (C);
+ D : VSI_View;
+
+ begin
+ for J in 0 .. 3 loop
+ Offset := Vchar_Range (4 * J + Integer (Vchar_Range'First));
+ D.Values (Vint_Range
+ (J + Integer (Varray_unsigned_int'First))) := 0
+ + LL_VSI_Operations.Modular_Result (SI64 (VA.Values (Offset))
+ * SI64 (VB.Values (Offset)))
+ + LL_VSI_Operations.Modular_Result (SI64 (VA.Values (Offset + 1))
+ * SI64 (VB.Values
+ (1 + Offset)))
+ + LL_VSI_Operations.Modular_Result (SI64 (VA.Values (2 + Offset))
+ * SI64 (VB.Values
+ (2 + Offset)))
+ + LL_VSI_Operations.Modular_Result (SI64 (VA.Values (3 + Offset))
+ * SI64 (VB.Values
+ (3 + Offset)))
+ + VC.Values (Vint_Range
+ (J + Integer (Varray_unsigned_int'First)));
+ end loop;
+
+ return To_Vector (D);
+ end vmsummbm;
+
+ --------------
+ -- vmsumuhm --
+ --------------
+
+ function vmsumuhm (A : LL_VSS; B : LL_VSS; C : LL_VSI) return LL_VSI is
+ Offset : Vshort_Range;
+ VA : constant VUS_View := To_View (To_LL_VUS (A));
+ VB : constant VUS_View := To_View (To_LL_VUS (B));
+ VC : constant VUI_View := To_View (To_LL_VUI (C));
+ D : VUI_View;
+
+ begin
+ for J in 0 .. 3 loop
+ Offset :=
+ Vshort_Range (2 * J + Integer (Vshort_Range'First));
+ D.Values (Vint_Range
+ (J + Integer (Varray_unsigned_int'First))) :=
+ (unsigned_int (VA.Values (Offset))
+ * unsigned_int (VB.Values (Offset)))
+ + (unsigned_int (VA.Values (Offset + 1))
+ * unsigned_int (VB.Values (1 + Offset)))
+ + VC.Values (Vint_Range
+ (J + Integer (Vint_Range'First)));
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vmsumuhm;
+
+ --------------
+ -- vmsumshm --
+ --------------
+
+ function vmsumshm (A : LL_VSS; B : LL_VSS; C : LL_VSI) return LL_VSI is
+ VA : constant VSS_View := To_View (A);
+ VB : constant VSS_View := To_View (B);
+ VC : constant VSI_View := To_View (C);
+ Offset : Vshort_Range;
+ D : VSI_View;
+
+ begin
+ for J in 0 .. 3 loop
+ Offset :=
+ Vshort_Range (2 * J + Integer (Varray_signed_char'First));
+ D.Values (Vint_Range
+ (J + Integer (Varray_unsigned_int'First))) := 0
+ + LL_VSI_Operations.Modular_Result (SI64 (VA.Values (Offset))
+ * SI64 (VB.Values (Offset)))
+ + LL_VSI_Operations.Modular_Result (SI64 (VA.Values (Offset + 1))
+ * SI64 (VB.Values
+ (1 + Offset)))
+ + VC.Values (Vint_Range
+ (J + Integer (Varray_unsigned_int'First)));
+ end loop;
+
+ return To_Vector (D);
+ end vmsumshm;
+
+ --------------
+ -- vmsumuhs --
+ --------------
+
+ function vmsumuhs (A : LL_VSS; B : LL_VSS; C : LL_VSI) return LL_VSI is
+ Offset : Vshort_Range;
+ VA : constant VUS_View := To_View (To_LL_VUS (A));
+ VB : constant VUS_View := To_View (To_LL_VUS (B));
+ VC : constant VUI_View := To_View (To_LL_VUI (C));
+ D : VUI_View;
+
+ begin
+ for J in 0 .. 3 loop
+ Offset :=
+ Vshort_Range (2 * J + Integer (Varray_signed_short'First));
+ D.Values (Vint_Range
+ (J + Integer (Varray_unsigned_int'First))) :=
+ LL_VUI_Operations.Saturate
+ (UI64 (VA.Values (Offset))
+ * UI64 (VB.Values (Offset))
+ + UI64 (VA.Values (Offset + 1))
+ * UI64 (VB.Values (1 + Offset))
+ + UI64 (VC.Values
+ (Vint_Range
+ (J + Integer (Varray_unsigned_int'First)))));
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vmsumuhs;
+
+ --------------
+ -- vmsumshs --
+ --------------
+
+ function vmsumshs (A : LL_VSS; B : LL_VSS; C : LL_VSI) return LL_VSI is
+ VA : constant VSS_View := To_View (A);
+ VB : constant VSS_View := To_View (B);
+ VC : constant VSI_View := To_View (C);
+ Offset : Vshort_Range;
+ D : VSI_View;
+
+ begin
+ for J in 0 .. 3 loop
+ Offset :=
+ Vshort_Range (2 * J + Integer (Varray_signed_short'First));
+ D.Values (Vint_Range
+ (J + Integer (Varray_signed_int'First))) :=
+ LL_VSI_Operations.Saturate
+ (SI64 (VA.Values (Offset))
+ * SI64 (VB.Values (Offset))
+ + SI64 (VA.Values (Offset + 1))
+ * SI64 (VB.Values (1 + Offset))
+ + SI64 (VC.Values
+ (Vint_Range
+ (J + Integer (Varray_signed_int'First)))));
+ end loop;
+
+ return To_Vector (D);
+ end vmsumshs;
+
+ ------------
+ -- mtvscr --
+ ------------
+
+ procedure mtvscr (A : LL_VSI) is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ begin
+ VSCR := VA.Values (Varray_unsigned_int'Last);
+ end mtvscr;
+
+ -------------
+ -- vmuleub --
+ -------------
+
+ function vmuleub (A : LL_VSC; B : LL_VSC) return LL_VSS is
+ VA : constant VUC_View := To_View (To_LL_VUC (A));
+ VB : constant VUC_View := To_View (To_LL_VUC (B));
+ D : VUS_View;
+ begin
+ D.Values := LL_VUC_LL_VUS_Operations.vmulxux (True,
+ VA.Values,
+ VB.Values);
+ return To_LL_VSS (To_Vector (D));
+ end vmuleub;
+
+ -------------
+ -- vmuleuh --
+ -------------
+
+ function vmuleuh (A : LL_VSS; B : LL_VSS) return LL_VSI is
+ VA : constant VUS_View := To_View (To_LL_VUS (A));
+ VB : constant VUS_View := To_View (To_LL_VUS (B));
+ D : VUI_View;
+ begin
+ D.Values := LL_VUS_LL_VUI_Operations.vmulxux (True,
+ VA.Values,
+ VB.Values);
+ return To_LL_VSI (To_Vector (D));
+ end vmuleuh;
+
+ -------------
+ -- vmulesb --
+ -------------
+
+ function vmulesb (A : LL_VSC; B : LL_VSC) return LL_VSS is
+ VA : constant VSC_View := To_View (A);
+ VB : constant VSC_View := To_View (B);
+ D : VSS_View;
+ begin
+ D.Values := LL_VSC_LL_VSS_Operations.vmulxsx (True,
+ VA.Values,
+ VB.Values);
+ return To_Vector (D);
+ end vmulesb;
+
+ -------------
+ -- vmulesh --
+ -------------
+
+ function vmulesh (A : LL_VSS; B : LL_VSS) return LL_VSI is
+ VA : constant VSS_View := To_View (A);
+ VB : constant VSS_View := To_View (B);
+ D : VSI_View;
+ begin
+ D.Values := LL_VSS_LL_VSI_Operations.vmulxsx (True,
+ VA.Values,
+ VB.Values);
+ return To_Vector (D);
+ end vmulesh;
+
+ -------------
+ -- vmuloub --
+ -------------
+
+ function vmuloub (A : LL_VSC; B : LL_VSC) return LL_VSS is
+ VA : constant VUC_View := To_View (To_LL_VUC (A));
+ VB : constant VUC_View := To_View (To_LL_VUC (B));
+ D : VUS_View;
+ begin
+ D.Values := LL_VUC_LL_VUS_Operations.vmulxux (False,
+ VA.Values,
+ VB.Values);
+ return To_LL_VSS (To_Vector (D));
+ end vmuloub;
+
+ -------------
+ -- vmulouh --
+ -------------
+
+ function vmulouh (A : LL_VSS; B : LL_VSS) return LL_VSI is
+ VA : constant VUS_View := To_View (To_LL_VUS (A));
+ VB : constant VUS_View := To_View (To_LL_VUS (B));
+ D : VUI_View;
+ begin
+ D.Values :=
+ LL_VUS_LL_VUI_Operations.vmulxux (False, VA.Values, VB.Values);
+ return To_LL_VSI (To_Vector (D));
+ end vmulouh;
+
+ -------------
+ -- vmulosb --
+ -------------
+
+ function vmulosb (A : LL_VSC; B : LL_VSC) return LL_VSS is
+ VA : constant VSC_View := To_View (A);
+ VB : constant VSC_View := To_View (B);
+ D : VSS_View;
+ begin
+ D.Values := LL_VSC_LL_VSS_Operations.vmulxsx (False,
+ VA.Values,
+ VB.Values);
+ return To_Vector (D);
+ end vmulosb;
+
+ -------------
+ -- vmulosh --
+ -------------
+
+ function vmulosh (A : LL_VSS; B : LL_VSS) return LL_VSI is
+ VA : constant VSS_View := To_View (A);
+ VB : constant VSS_View := To_View (B);
+ D : VSI_View;
+ begin
+ D.Values := LL_VSS_LL_VSI_Operations.vmulxsx (False,
+ VA.Values,
+ VB.Values);
+ return To_Vector (D);
+ end vmulosh;
+
+ --------------
+ -- vnmsubfp --
+ --------------
+
+ function vnmsubfp (A : LL_VF; B : LL_VF; C : LL_VF) return LL_VF is
+ VA : constant VF_View := To_View (A);
+ VB : constant VF_View := To_View (B);
+ VC : constant VF_View := To_View (C);
+ D : VF_View;
+
+ begin
+ for J in Vfloat_Range'Range loop
+ D.Values (J) :=
+ -Rnd_To_FP_Nearest (F64 (VA.Values (J))
+ * F64 (VB.Values (J))
+ - F64 (VC.Values (J)));
+ end loop;
+
+ return To_Vector (D);
+ end vnmsubfp;
+
+ ----------
+ -- vnor --
+ ----------
+
+ function vnor (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : VUI_View;
+
+ begin
+ for J in Vint_Range'Range loop
+ D.Values (J) := not (VA.Values (J) or VB.Values (J));
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vnor;
+
+ ----------
+ -- vor --
+ ----------
+
+ function vor (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : VUI_View;
+
+ begin
+ for J in Vint_Range'Range loop
+ D.Values (J) := VA.Values (J) or VB.Values (J);
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vor;
+
+ -------------
+ -- vpkuhum --
+ -------------
+
+ function vpkuhum (A : LL_VSS; B : LL_VSS) return LL_VSC is
+ VA : constant VUS_View := To_View (To_LL_VUS (A));
+ VB : constant VUS_View := To_View (To_LL_VUS (B));
+ D : VUC_View;
+ begin
+ D.Values := LL_VUC_LL_VUS_Operations.vpkuxum (VA.Values, VB.Values);
+ return To_LL_VSC (To_Vector (D));
+ end vpkuhum;
+
+ -------------
+ -- vpkuwum --
+ -------------
+
+ function vpkuwum (A : LL_VSI; B : LL_VSI) return LL_VSS is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : VUS_View;
+ begin
+ D.Values := LL_VUS_LL_VUI_Operations.vpkuxum (VA.Values, VB.Values);
+ return To_LL_VSS (To_Vector (D));
+ end vpkuwum;
+
+ -----------
+ -- vpkpx --
+ -----------
+
+ function vpkpx (A : LL_VSI; B : LL_VSI) return LL_VSS is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : VUS_View;
+ Offset : Vint_Range;
+ P16 : Pixel_16;
+ P32 : Pixel_32;
+
+ begin
+ for J in 0 .. 3 loop
+ Offset := Vint_Range (J + Integer (Vshort_Range'First));
+ P32 := To_Pixel (VA.Values (Offset));
+ P16.T := Unsigned_1 (P32.T mod 2 ** 1);
+ P16.R := Unsigned_5 (Shift_Right (P32.R, 3) mod 2 ** 5);
+ P16.G := Unsigned_5 (Shift_Right (P32.G, 3) mod 2 ** 5);
+ P16.B := Unsigned_5 (Shift_Right (P32.B, 3) mod 2 ** 5);
+ D.Values (Vshort_Range (Offset)) := To_unsigned_short (P16);
+ P32 := To_Pixel (VB.Values (Offset));
+ P16.T := Unsigned_1 (P32.T mod 2 ** 1);
+ P16.R := Unsigned_5 (Shift_Right (P32.R, 3) mod 2 ** 5);
+ P16.G := Unsigned_5 (Shift_Right (P32.G, 3) mod 2 ** 5);
+ P16.B := Unsigned_5 (Shift_Right (P32.B, 3) mod 2 ** 5);
+ D.Values (Vshort_Range (Offset) + 4) := To_unsigned_short (P16);
+ end loop;
+
+ return To_LL_VSS (To_Vector (D));
+ end vpkpx;
+
+ -------------
+ -- vpkuhus --
+ -------------
+
+ function vpkuhus (A : LL_VSS; B : LL_VSS) return LL_VSC is
+ VA : constant VUS_View := To_View (To_LL_VUS (A));
+ VB : constant VUS_View := To_View (To_LL_VUS (B));
+ D : VUC_View;
+ begin
+ D.Values := LL_VUC_LL_VUS_Operations.vpkuxus (VA.Values, VB.Values);
+ return To_LL_VSC (To_Vector (D));
+ end vpkuhus;
+
+ -------------
+ -- vpkuwus --
+ -------------
+
+ function vpkuwus (A : LL_VSI; B : LL_VSI) return LL_VSS is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : VUS_View;
+ begin
+ D.Values := LL_VUS_LL_VUI_Operations.vpkuxus (VA.Values, VB.Values);
+ return To_LL_VSS (To_Vector (D));
+ end vpkuwus;
+
+ -------------
+ -- vpkshss --
+ -------------
+
+ function vpkshss (A : LL_VSS; B : LL_VSS) return LL_VSC is
+ VA : constant VSS_View := To_View (A);
+ VB : constant VSS_View := To_View (B);
+ D : VSC_View;
+ begin
+ D.Values := LL_VSC_LL_VSS_Operations.vpksxss (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vpkshss;
+
+ -------------
+ -- vpkswss --
+ -------------
+
+ function vpkswss (A : LL_VSI; B : LL_VSI) return LL_VSS is
+ VA : constant VSI_View := To_View (A);
+ VB : constant VSI_View := To_View (B);
+ D : VSS_View;
+ begin
+ D.Values := LL_VSS_LL_VSI_Operations.vpksxss (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vpkswss;
+
+ -------------
+ -- vpksxus --
+ -------------
+
+ generic
+ type Signed_Component_Type is range <>;
+ type Signed_Index_Type is range <>;
+ type Signed_Varray_Type is
+ array (Signed_Index_Type) of Signed_Component_Type;
+ type Unsigned_Component_Type is mod <>;
+ type Unsigned_Index_Type is range <>;
+ type Unsigned_Varray_Type is
+ array (Unsigned_Index_Type) of Unsigned_Component_Type;
+
+ function vpksxus
+ (A : Signed_Varray_Type;
+ B : Signed_Varray_Type) return Unsigned_Varray_Type;
+
+ function vpksxus
+ (A : Signed_Varray_Type;
+ B : Signed_Varray_Type) return Unsigned_Varray_Type
+ is
+ N : constant Unsigned_Index_Type :=
+ Unsigned_Index_Type (Signed_Index_Type'Last);
+ Offset : Unsigned_Index_Type;
+ Signed_Offset : Signed_Index_Type;
+ D : Unsigned_Varray_Type;
+
+ function Saturate
+ (X : Signed_Component_Type) return Unsigned_Component_Type;
+ -- Saturation, as defined in
+ -- [PIM-4.1 Vector Status and Control Register]
+
+ --------------
+ -- Saturate --
+ --------------
+
+ function Saturate
+ (X : Signed_Component_Type) return Unsigned_Component_Type
+ is
+ D : Unsigned_Component_Type;
+
+ begin
+ D := Unsigned_Component_Type
+ (Signed_Component_Type'Max
+ (Signed_Component_Type (Unsigned_Component_Type'First),
+ Signed_Component_Type'Min
+ (Signed_Component_Type (Unsigned_Component_Type'Last),
+ X)));
+ if Signed_Component_Type (D) /= X then
+ VSCR := Write_Bit (VSCR, SAT_POS, 1);
+ end if;
+
+ return D;
+ end Saturate;
+
+ -- Start of processing for vpksxus
+
+ begin
+ for J in 0 .. N - 1 loop
+ Offset :=
+ Unsigned_Index_Type (Integer (J)
+ + Integer (Unsigned_Index_Type'First));
+ Signed_Offset :=
+ Signed_Index_Type (Integer (J)
+ + Integer (Signed_Index_Type'First));
+ D (Offset) := Saturate (A (Signed_Offset));
+ D (Offset + N) := Saturate (B (Signed_Offset));
+ end loop;
+
+ return D;
+ end vpksxus;
+
+ -------------
+ -- vpkshus --
+ -------------
+
+ function vpkshus (A : LL_VSS; B : LL_VSS) return LL_VSC is
+ function vpkshus_Instance is
+ new vpksxus (signed_short,
+ Vshort_Range,
+ Varray_signed_short,
+ unsigned_char,
+ Vchar_Range,
+ Varray_unsigned_char);
+
+ VA : constant VSS_View := To_View (A);
+ VB : constant VSS_View := To_View (B);
+ D : VUC_View;
+
+ begin
+ D.Values := vpkshus_Instance (VA.Values, VB.Values);
+ return To_LL_VSC (To_Vector (D));
+ end vpkshus;
+
+ -------------
+ -- vpkswus --
+ -------------
+
+ function vpkswus (A : LL_VSI; B : LL_VSI) return LL_VSS is
+ function vpkswus_Instance is
+ new vpksxus (signed_int,
+ Vint_Range,
+ Varray_signed_int,
+ unsigned_short,
+ Vshort_Range,
+ Varray_unsigned_short);
+
+ VA : constant VSI_View := To_View (A);
+ VB : constant VSI_View := To_View (B);
+ D : VUS_View;
+ begin
+ D.Values := vpkswus_Instance (VA.Values, VB.Values);
+ return To_LL_VSS (To_Vector (D));
+ end vpkswus;
+
+ ---------------
+ -- vperm_4si --
+ ---------------
+
+ function vperm_4si (A : LL_VSI; B : LL_VSI; C : LL_VSC) return LL_VSI is
+ VA : constant VUC_View := To_View (To_LL_VUC (A));
+ VB : constant VUC_View := To_View (To_LL_VUC (B));
+ VC : constant VUC_View := To_View (To_LL_VUC (C));
+ J : Vchar_Range;
+ D : VUC_View;
+
+ begin
+ for N in Vchar_Range'Range loop
+ J := Vchar_Range (Integer (Bits (VC.Values (N), 4, 7))
+ + Integer (Vchar_Range'First));
+
+ if Bits (VC.Values (N), 3, 3) = 0 then
+ D.Values (N) := VA.Values (J);
+ else
+ D.Values (N) := VB.Values (J);
+ end if;
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vperm_4si;
+
+ -----------
+ -- vrefp --
+ -----------
+
+ function vrefp (A : LL_VF) return LL_VF is
+ VA : constant VF_View := To_View (A);
+ D : VF_View;
+
+ begin
+ for J in Vfloat_Range'Range loop
+ D.Values (J) := FP_Recip_Est (VA.Values (J));
+ end loop;
+
+ return To_Vector (D);
+ end vrefp;
+
+ ----------
+ -- vrlb --
+ ----------
+
+ function vrlb (A : LL_VSC; B : LL_VSC) return LL_VSC is
+ VA : constant VUC_View := To_View (To_LL_VUC (A));
+ VB : constant VUC_View := To_View (To_LL_VUC (B));
+ D : VUC_View;
+ begin
+ D.Values := LL_VUC_Operations.vrlx (VA.Values, VB.Values, ROTL'Access);
+ return To_LL_VSC (To_Vector (D));
+ end vrlb;
+
+ ----------
+ -- vrlh --
+ ----------
+
+ function vrlh (A : LL_VSS; B : LL_VSS) return LL_VSS is
+ VA : constant VUS_View := To_View (To_LL_VUS (A));
+ VB : constant VUS_View := To_View (To_LL_VUS (B));
+ D : VUS_View;
+ begin
+ D.Values := LL_VUS_Operations.vrlx (VA.Values, VB.Values, ROTL'Access);
+ return To_LL_VSS (To_Vector (D));
+ end vrlh;
+
+ ----------
+ -- vrlw --
+ ----------
+
+ function vrlw (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : VUI_View;
+ begin
+ D.Values := LL_VUI_Operations.vrlx (VA.Values, VB.Values, ROTL'Access);
+ return To_LL_VSI (To_Vector (D));
+ end vrlw;
+
+ -----------
+ -- vrfin --
+ -----------
+
+ function vrfin (A : LL_VF) return LL_VF is
+ VA : constant VF_View := To_View (A);
+ D : VF_View;
+
+ begin
+ for J in Vfloat_Range'Range loop
+ D.Values (J) := C_float (Rnd_To_FPI_Near (F64 (VA.Values (J))));
+ end loop;
+
+ return To_Vector (D);
+ end vrfin;
+
+ ---------------
+ -- vrsqrtefp --
+ ---------------
+
+ function vrsqrtefp (A : LL_VF) return LL_VF is
+ VA : constant VF_View := To_View (A);
+ D : VF_View;
+
+ begin
+ for J in Vfloat_Range'Range loop
+ D.Values (J) := Recip_SQRT_Est (VA.Values (J));
+ end loop;
+
+ return To_Vector (D);
+ end vrsqrtefp;
+
+ --------------
+ -- vsel_4si --
+ --------------
+
+ function vsel_4si (A : LL_VSI; B : LL_VSI; C : LL_VSI) return LL_VSI is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ VC : constant VUI_View := To_View (To_LL_VUI (C));
+ D : VUI_View;
+
+ begin
+ for J in Vint_Range'Range loop
+ D.Values (J) := ((not VC.Values (J)) and VA.Values (J))
+ or (VC.Values (J) and VB.Values (J));
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vsel_4si;
+
+ ----------
+ -- vslb --
+ ----------
+
+ function vslb (A : LL_VSC; B : LL_VSC) return LL_VSC is
+ VA : constant VUC_View := To_View (To_LL_VUC (A));
+ VB : constant VUC_View := To_View (To_LL_VUC (B));
+ D : VUC_View;
+ begin
+ D.Values :=
+ LL_VUC_Operations.vsxx (VA.Values, VB.Values, Shift_Left'Access);
+ return To_LL_VSC (To_Vector (D));
+ end vslb;
+
+ ----------
+ -- vslh --
+ ----------
+
+ function vslh (A : LL_VSS; B : LL_VSS) return LL_VSS is
+ VA : constant VUS_View := To_View (To_LL_VUS (A));
+ VB : constant VUS_View := To_View (To_LL_VUS (B));
+ D : VUS_View;
+ begin
+ D.Values :=
+ LL_VUS_Operations.vsxx (VA.Values, VB.Values, Shift_Left'Access);
+ return To_LL_VSS (To_Vector (D));
+ end vslh;
+
+ ----------
+ -- vslw --
+ ----------
+
+ function vslw (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : VUI_View;
+ begin
+ D.Values :=
+ LL_VUI_Operations.vsxx (VA.Values, VB.Values, Shift_Left'Access);
+ return To_LL_VSI (To_Vector (D));
+ end vslw;
+
+ ----------------
+ -- vsldoi_4si --
+ ----------------
+
+ function vsldoi_4si (A : LL_VSI; B : LL_VSI; C : c_int) return LL_VSI is
+ VA : constant VUC_View := To_View (To_LL_VUC (A));
+ VB : constant VUC_View := To_View (To_LL_VUC (B));
+ Offset : c_int;
+ Bound : c_int;
+ D : VUC_View;
+
+ begin
+ for J in Vchar_Range'Range loop
+ Offset := c_int (J) + C;
+ Bound := c_int (Vchar_Range'First)
+ + c_int (Varray_unsigned_char'Length);
+
+ if Offset < Bound then
+ D.Values (J) := VA.Values (Vchar_Range (Offset));
+ else
+ D.Values (J) :=
+ VB.Values (Vchar_Range (Offset - Bound
+ + c_int (Vchar_Range'First)));
+ end if;
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vsldoi_4si;
+
+ ----------------
+ -- vsldoi_8hi --
+ ----------------
+
+ function vsldoi_8hi (A : LL_VSS; B : LL_VSS; C : c_int) return LL_VSS is
+ begin
+ return To_LL_VSS (vsldoi_4si (To_LL_VSI (A), To_LL_VSI (B), C));
+ end vsldoi_8hi;
+
+ -----------------
+ -- vsldoi_16qi --
+ -----------------
+
+ function vsldoi_16qi (A : LL_VSC; B : LL_VSC; C : c_int) return LL_VSC is
+ begin
+ return To_LL_VSC (vsldoi_4si (To_LL_VSI (A), To_LL_VSI (B), C));
+ end vsldoi_16qi;
+
+ ----------------
+ -- vsldoi_4sf --
+ ----------------
+
+ function vsldoi_4sf (A : LL_VF; B : LL_VF; C : c_int) return LL_VF is
+ begin
+ return To_LL_VF (vsldoi_4si (To_LL_VSI (A), To_LL_VSI (B), C));
+ end vsldoi_4sf;
+
+ ---------
+ -- vsl --
+ ---------
+
+ function vsl (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : VUI_View;
+ M : constant Natural :=
+ Natural (Bits (VB.Values (Vint_Range'Last), 29, 31));
+
+ -- [PIM-4.4 vec_sll] "Note that the three low-order byte elements in B
+ -- must be the same. Otherwise the value placed into D is undefined."
+ -- ??? Shall we add a optional check for B?
+
+ begin
+ for J in Vint_Range'Range loop
+ D.Values (J) := 0;
+ D.Values (J) := D.Values (J) + Shift_Left (VA.Values (J), M);
+
+ if J /= Vint_Range'Last then
+ D.Values (J) :=
+ D.Values (J) + Shift_Right (VA.Values (J + 1),
+ signed_int'Size - M);
+ end if;
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vsl;
+
+ ----------
+ -- vslo --
+ ----------
+
+ function vslo (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VUC_View := To_View (To_LL_VUC (A));
+ VB : constant VUC_View := To_View (To_LL_VUC (B));
+ D : VUC_View;
+ M : constant Natural :=
+ Natural (Bits (VB.Values (Vchar_Range'Last), 1, 4));
+ J : Natural;
+
+ begin
+ for N in Vchar_Range'Range loop
+ J := Natural (N) + M;
+
+ if J <= Natural (Vchar_Range'Last) then
+ D.Values (N) := VA.Values (Vchar_Range (J));
+ else
+ D.Values (N) := 0;
+ end if;
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vslo;
+
+ ------------
+ -- vspltb --
+ ------------
+
+ function vspltb (A : LL_VSC; B : c_int) return LL_VSC is
+ VA : constant VSC_View := To_View (A);
+ D : VSC_View;
+ begin
+ D.Values := LL_VSC_Operations.vspltx (VA.Values, B);
+ return To_Vector (D);
+ end vspltb;
+
+ ------------
+ -- vsplth --
+ ------------
+
+ function vsplth (A : LL_VSS; B : c_int) return LL_VSS is
+ VA : constant VSS_View := To_View (A);
+ D : VSS_View;
+ begin
+ D.Values := LL_VSS_Operations.vspltx (VA.Values, B);
+ return To_Vector (D);
+ end vsplth;
+
+ ------------
+ -- vspltw --
+ ------------
+
+ function vspltw (A : LL_VSI; B : c_int) return LL_VSI is
+ VA : constant VSI_View := To_View (A);
+ D : VSI_View;
+ begin
+ D.Values := LL_VSI_Operations.vspltx (VA.Values, B);
+ return To_Vector (D);
+ end vspltw;
+
+ --------------
+ -- vspltisb --
+ --------------
+
+ function vspltisb (A : c_int) return LL_VSC is
+ D : VSC_View;
+ begin
+ D.Values := LL_VSC_Operations.vspltisx (A);
+ return To_Vector (D);
+ end vspltisb;
+
+ --------------
+ -- vspltish --
+ --------------
+
+ function vspltish (A : c_int) return LL_VSS is
+ D : VSS_View;
+ begin
+ D.Values := LL_VSS_Operations.vspltisx (A);
+ return To_Vector (D);
+ end vspltish;
+
+ --------------
+ -- vspltisw --
+ --------------
+
+ function vspltisw (A : c_int) return LL_VSI is
+ D : VSI_View;
+ begin
+ D.Values := LL_VSI_Operations.vspltisx (A);
+ return To_Vector (D);
+ end vspltisw;
+
+ ----------
+ -- vsrb --
+ ----------
+
+ function vsrb (A : LL_VSC; B : LL_VSC) return LL_VSC is
+ VA : constant VUC_View := To_View (To_LL_VUC (A));
+ VB : constant VUC_View := To_View (To_LL_VUC (B));
+ D : VUC_View;
+ begin
+ D.Values :=
+ LL_VUC_Operations.vsxx (VA.Values, VB.Values, Shift_Right'Access);
+ return To_LL_VSC (To_Vector (D));
+ end vsrb;
+
+ ----------
+ -- vsrh --
+ ----------
+
+ function vsrh (A : LL_VSS; B : LL_VSS) return LL_VSS is
+ VA : constant VUS_View := To_View (To_LL_VUS (A));
+ VB : constant VUS_View := To_View (To_LL_VUS (B));
+ D : VUS_View;
+ begin
+ D.Values :=
+ LL_VUS_Operations.vsxx (VA.Values, VB.Values, Shift_Right'Access);
+ return To_LL_VSS (To_Vector (D));
+ end vsrh;
+
+ ----------
+ -- vsrw --
+ ----------
+
+ function vsrw (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : VUI_View;
+ begin
+ D.Values :=
+ LL_VUI_Operations.vsxx (VA.Values, VB.Values, Shift_Right'Access);
+ return To_LL_VSI (To_Vector (D));
+ end vsrw;
+
+ -----------
+ -- vsrab --
+ -----------
+
+ function vsrab (A : LL_VSC; B : LL_VSC) return LL_VSC is
+ VA : constant VSC_View := To_View (A);
+ VB : constant VSC_View := To_View (B);
+ D : VSC_View;
+ begin
+ D.Values :=
+ LL_VSC_Operations.vsrax (VA.Values, VB.Values, Shift_Right_A'Access);
+ return To_Vector (D);
+ end vsrab;
+
+ -----------
+ -- vsrah --
+ -----------
+
+ function vsrah (A : LL_VSS; B : LL_VSS) return LL_VSS is
+ VA : constant VSS_View := To_View (A);
+ VB : constant VSS_View := To_View (B);
+ D : VSS_View;
+ begin
+ D.Values :=
+ LL_VSS_Operations.vsrax (VA.Values, VB.Values, Shift_Right_A'Access);
+ return To_Vector (D);
+ end vsrah;
+
+ -----------
+ -- vsraw --
+ -----------
+
+ function vsraw (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VSI_View := To_View (A);
+ VB : constant VSI_View := To_View (B);
+ D : VSI_View;
+ begin
+ D.Values :=
+ LL_VSI_Operations.vsrax (VA.Values, VB.Values, Shift_Right_A'Access);
+ return To_Vector (D);
+ end vsraw;
+
+ ---------
+ -- vsr --
+ ---------
+
+ function vsr (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ M : constant Natural :=
+ Natural (Bits (VB.Values (Vint_Range'Last), 29, 31));
+ D : VUI_View;
+
+ begin
+ for J in Vint_Range'Range loop
+ D.Values (J) := 0;
+ D.Values (J) := D.Values (J) + Shift_Right (VA.Values (J), M);
+
+ if J /= Vint_Range'First then
+ D.Values (J) :=
+ D.Values (J)
+ + Shift_Left (VA.Values (J - 1), signed_int'Size - M);
+ end if;
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vsr;
+
+ ----------
+ -- vsro --
+ ----------
+
+ function vsro (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VUC_View := To_View (To_LL_VUC (A));
+ VB : constant VUC_View := To_View (To_LL_VUC (B));
+ M : constant Natural :=
+ Natural (Bits (VB.Values (Vchar_Range'Last), 1, 4));
+ J : Natural;
+ D : VUC_View;
+
+ begin
+ for N in Vchar_Range'Range loop
+ J := Natural (N) - M;
+
+ if J >= Natural (Vchar_Range'First) then
+ D.Values (N) := VA.Values (Vchar_Range (J));
+ else
+ D.Values (N) := 0;
+ end if;
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vsro;
+
+ ----------
+ -- stvx --
+ ----------
+
+ procedure stvx (A : LL_VSI; B : c_int; C : c_ptr) is
+ EA : Integer_Address;
+
+ begin
+ EA := Bound_Align (Integer_Address (B) + To_Integer (C), 16);
+
+ declare
+ D : LL_VSI;
+ for D'Address use To_Address (EA);
+ begin
+ D := A;
+ end;
+ end stvx;
+
+ ------------
+ -- stvewx --
+ ------------
+
+ procedure stvebx (A : LL_VSC; B : c_int; C : c_ptr) is
+ VA : constant VSC_View := To_View (A);
+ begin
+ LL_VSC_Operations.stvexx (VA.Values, B, C);
+ end stvebx;
+
+ ------------
+ -- stvehx --
+ ------------
+
+ procedure stvehx (A : LL_VSS; B : c_int; C : c_ptr) is
+ VA : constant VSS_View := To_View (A);
+ begin
+ LL_VSS_Operations.stvexx (VA.Values, B, C);
+ end stvehx;
+
+ ------------
+ -- stvewx --
+ ------------
+
+ procedure stvewx (A : LL_VSI; B : c_int; C : c_ptr) is
+ VA : constant VSI_View := To_View (A);
+ begin
+ LL_VSI_Operations.stvexx (VA.Values, B, C);
+ end stvewx;
+
+ -----------
+ -- stvxl --
+ -----------
+
+ procedure stvxl (A : LL_VSI; B : c_int; C : c_ptr) renames stvx;
+
+ -------------
+ -- vsububm --
+ -------------
+
+ function vsububm (A : LL_VSC; B : LL_VSC) return LL_VSC is
+ VA : constant VUC_View := To_View (To_LL_VUC (A));
+ VB : constant VUC_View := To_View (To_LL_VUC (B));
+ D : VUC_View;
+ begin
+ D.Values := LL_VUC_Operations.vsubuxm (VA.Values, VB.Values);
+ return To_LL_VSC (To_Vector (D));
+ end vsububm;
+
+ -------------
+ -- vsubuhm --
+ -------------
+
+ function vsubuhm (A : LL_VSS; B : LL_VSS) return LL_VSS is
+ VA : constant VUS_View := To_View (To_LL_VUS (A));
+ VB : constant VUS_View := To_View (To_LL_VUS (B));
+ D : VUS_View;
+ begin
+ D.Values := LL_VUS_Operations.vsubuxm (VA.Values, VB.Values);
+ return To_LL_VSS (To_Vector (D));
+ end vsubuhm;
+
+ -------------
+ -- vsubuwm --
+ -------------
+
+ function vsubuwm (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : VUI_View;
+ begin
+ D.Values := LL_VUI_Operations.vsubuxm (VA.Values, VB.Values);
+ return To_LL_VSI (To_Vector (D));
+ end vsubuwm;
+
+ ------------
+ -- vsubfp --
+ ------------
+
+ function vsubfp (A : LL_VF; B : LL_VF) return LL_VF is
+ VA : constant VF_View := To_View (A);
+ VB : constant VF_View := To_View (B);
+ D : VF_View;
+
+ begin
+ for J in Vfloat_Range'Range loop
+ D.Values (J) :=
+ NJ_Truncate (NJ_Truncate (VA.Values (J))
+ - NJ_Truncate (VB.Values (J)));
+ end loop;
+
+ return To_Vector (D);
+ end vsubfp;
+
+ -------------
+ -- vsubcuw --
+ -------------
+
+ function vsubcuw (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ Subst_Result : SI64;
+
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : VUI_View;
+
+ begin
+ for J in Vint_Range'Range loop
+ Subst_Result := SI64 (VA.Values (J)) - SI64 (VB.Values (J));
+
+ if Subst_Result < SI64 (unsigned_int'First) then
+ D.Values (J) := 0;
+ else
+ D.Values (J) := 1;
+ end if;
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vsubcuw;
+
+ -------------
+ -- vsububs --
+ -------------
+
+ function vsububs (A : LL_VSC; B : LL_VSC) return LL_VSC is
+ VA : constant VUC_View := To_View (To_LL_VUC (A));
+ VB : constant VUC_View := To_View (To_LL_VUC (B));
+ D : VUC_View;
+ begin
+ D.Values := LL_VUC_Operations.vsubuxs (VA.Values, VB.Values);
+ return To_LL_VSC (To_Vector (D));
+ end vsububs;
+
+ -------------
+ -- vsubsbs --
+ -------------
+
+ function vsubsbs (A : LL_VSC; B : LL_VSC) return LL_VSC is
+ VA : constant VSC_View := To_View (A);
+ VB : constant VSC_View := To_View (B);
+ D : VSC_View;
+ begin
+ D.Values := LL_VSC_Operations.vsubsxs (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vsubsbs;
+
+ -------------
+ -- vsubuhs --
+ -------------
+
+ function vsubuhs (A : LL_VSS; B : LL_VSS) return LL_VSS is
+ VA : constant VUS_View := To_View (To_LL_VUS (A));
+ VB : constant VUS_View := To_View (To_LL_VUS (B));
+ D : VUS_View;
+ begin
+ D.Values := LL_VUS_Operations.vsubuxs (VA.Values, VB.Values);
+ return To_LL_VSS (To_Vector (D));
+ end vsubuhs;
+
+ -------------
+ -- vsubshs --
+ -------------
+
+ function vsubshs (A : LL_VSS; B : LL_VSS) return LL_VSS is
+ VA : constant VSS_View := To_View (A);
+ VB : constant VSS_View := To_View (B);
+ D : VSS_View;
+ begin
+ D.Values := LL_VSS_Operations.vsubsxs (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vsubshs;
+
+ -------------
+ -- vsubuws --
+ -------------
+
+ function vsubuws (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : VUI_View;
+ begin
+ D.Values := LL_VUI_Operations.vsubuxs (VA.Values, VB.Values);
+ return To_LL_VSI (To_Vector (D));
+ end vsubuws;
+
+ -------------
+ -- vsubsws --
+ -------------
+
+ function vsubsws (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VSI_View := To_View (A);
+ VB : constant VSI_View := To_View (B);
+ D : VSI_View;
+ begin
+ D.Values := LL_VSI_Operations.vsubsxs (VA.Values, VB.Values);
+ return To_Vector (D);
+ end vsubsws;
+
+ --------------
+ -- vsum4ubs --
+ --------------
+
+ function vsum4ubs (A : LL_VSC; B : LL_VSI) return LL_VSI is
+ VA : constant VUC_View := To_View (To_LL_VUC (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ Offset : Vchar_Range;
+ D : VUI_View;
+
+ begin
+ for J in 0 .. 3 loop
+ Offset := Vchar_Range (4 * J + Integer (Vchar_Range'First));
+ D.Values (Vint_Range (J + Integer (Vint_Range'First))) :=
+ LL_VUI_Operations.Saturate
+ (UI64 (VA.Values (Offset))
+ + UI64 (VA.Values (Offset + 1))
+ + UI64 (VA.Values (Offset + 2))
+ + UI64 (VA.Values (Offset + 3))
+ + UI64 (VB.Values (Vint_Range (J + Integer (Vint_Range'First)))));
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vsum4ubs;
+
+ --------------
+ -- vsum4sbs --
+ --------------
+
+ function vsum4sbs (A : LL_VSC; B : LL_VSI) return LL_VSI is
+ VA : constant VSC_View := To_View (A);
+ VB : constant VSI_View := To_View (B);
+ Offset : Vchar_Range;
+ D : VSI_View;
+
+ begin
+ for J in 0 .. 3 loop
+ Offset := Vchar_Range (4 * J + Integer (Vchar_Range'First));
+ D.Values (Vint_Range (J + Integer (Vint_Range'First))) :=
+ LL_VSI_Operations.Saturate
+ (SI64 (VA.Values (Offset))
+ + SI64 (VA.Values (Offset + 1))
+ + SI64 (VA.Values (Offset + 2))
+ + SI64 (VA.Values (Offset + 3))
+ + SI64 (VB.Values (Vint_Range (J + Integer (Vint_Range'First)))));
+ end loop;
+
+ return To_Vector (D);
+ end vsum4sbs;
+
+ --------------
+ -- vsum4shs --
+ --------------
+
+ function vsum4shs (A : LL_VSS; B : LL_VSI) return LL_VSI is
+ VA : constant VSS_View := To_View (A);
+ VB : constant VSI_View := To_View (B);
+ Offset : Vshort_Range;
+ D : VSI_View;
+
+ begin
+ for J in 0 .. 3 loop
+ Offset := Vshort_Range (2 * J + Integer (Vchar_Range'First));
+ D.Values (Vint_Range (J + Integer (Vint_Range'First))) :=
+ LL_VSI_Operations.Saturate
+ (SI64 (VA.Values (Offset))
+ + SI64 (VA.Values (Offset + 1))
+ + SI64 (VB.Values (Vint_Range (J + Integer (Vint_Range'First)))));
+ end loop;
+
+ return To_Vector (D);
+ end vsum4shs;
+
+ --------------
+ -- vsum2sws --
+ --------------
+
+ function vsum2sws (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VSI_View := To_View (A);
+ VB : constant VSI_View := To_View (B);
+ Offset : Vint_Range;
+ D : VSI_View;
+
+ begin
+ for J in 0 .. 1 loop
+ Offset := Vint_Range (2 * J + Integer (Vchar_Range'First));
+ D.Values (Offset) := 0;
+ D.Values (Offset + 1) :=
+ LL_VSI_Operations.Saturate
+ (SI64 (VA.Values (Offset))
+ + SI64 (VA.Values (Offset + 1))
+ + SI64 (VB.Values (Vint_Range (Offset + 1))));
+ end loop;
+
+ return To_Vector (D);
+ end vsum2sws;
+
+ -------------
+ -- vsumsws --
+ -------------
+
+ function vsumsws (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VSI_View := To_View (A);
+ VB : constant VSI_View := To_View (B);
+ D : VSI_View;
+ Sum_Buffer : SI64 := 0;
+
+ begin
+ for J in Vint_Range'Range loop
+ D.Values (J) := 0;
+ Sum_Buffer := Sum_Buffer + SI64 (VA.Values (J));
+ end loop;
+
+ Sum_Buffer := Sum_Buffer + SI64 (VB.Values (Vint_Range'Last));
+ D.Values (Vint_Range'Last) := LL_VSI_Operations.Saturate (Sum_Buffer);
+ return To_Vector (D);
+ end vsumsws;
+
+ -----------
+ -- vrfiz --
+ -----------
+
+ function vrfiz (A : LL_VF) return LL_VF is
+ VA : constant VF_View := To_View (A);
+ D : VF_View;
+ begin
+ for J in Vfloat_Range'Range loop
+ D.Values (J) := C_float (Rnd_To_FPI_Trunc (F64 (VA.Values (J))));
+ end loop;
+
+ return To_Vector (D);
+ end vrfiz;
+
+ -------------
+ -- vupkhsb --
+ -------------
+
+ function vupkhsb (A : LL_VSC) return LL_VSS is
+ VA : constant VSC_View := To_View (A);
+ D : VSS_View;
+ begin
+ D.Values := LL_VSC_LL_VSS_Operations.vupkxsx (VA.Values, 0);
+ return To_Vector (D);
+ end vupkhsb;
+
+ -------------
+ -- vupkhsh --
+ -------------
+
+ function vupkhsh (A : LL_VSS) return LL_VSI is
+ VA : constant VSS_View := To_View (A);
+ D : VSI_View;
+ begin
+ D.Values := LL_VSS_LL_VSI_Operations.vupkxsx (VA.Values, 0);
+ return To_Vector (D);
+ end vupkhsh;
+
+ -------------
+ -- vupkxpx --
+ -------------
+
+ function vupkxpx (A : LL_VSS; Offset : Natural) return LL_VSI;
+ -- For vupkhpx and vupklpx (depending on Offset)
+
+ function vupkxpx (A : LL_VSS; Offset : Natural) return LL_VSI is
+ VA : constant VUS_View := To_View (To_LL_VUS (A));
+ K : Vshort_Range;
+ D : VUI_View;
+ P16 : Pixel_16;
+ P32 : Pixel_32;
+
+ function Sign_Extend (X : Unsigned_1) return unsigned_char;
+
+ function Sign_Extend (X : Unsigned_1) return unsigned_char is
+ begin
+ if X = 1 then
+ return 16#FF#;
+ else
+ return 16#00#;
+ end if;
+ end Sign_Extend;
+
+ begin
+ for J in Vint_Range'Range loop
+ K := Vshort_Range (Integer (J)
+ - Integer (Vint_Range'First)
+ + Integer (Vshort_Range'First)
+ + Offset);
+ P16 := To_Pixel (VA.Values (K));
+ P32.T := Sign_Extend (P16.T);
+ P32.R := unsigned_char (P16.R);
+ P32.G := unsigned_char (P16.G);
+ P32.B := unsigned_char (P16.B);
+ D.Values (J) := To_unsigned_int (P32);
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vupkxpx;
+
+ -------------
+ -- vupkhpx --
+ -------------
+
+ function vupkhpx (A : LL_VSS) return LL_VSI is
+ begin
+ return vupkxpx (A, 0);
+ end vupkhpx;
+
+ -------------
+ -- vupklsb --
+ -------------
+
+ function vupklsb (A : LL_VSC) return LL_VSS is
+ VA : constant VSC_View := To_View (A);
+ D : VSS_View;
+ begin
+ D.Values :=
+ LL_VSC_LL_VSS_Operations.vupkxsx (VA.Values,
+ Varray_signed_short'Length);
+ return To_Vector (D);
+ end vupklsb;
+
+ -------------
+ -- vupklsh --
+ -------------
+
+ function vupklsh (A : LL_VSS) return LL_VSI is
+ VA : constant VSS_View := To_View (A);
+ D : VSI_View;
+ begin
+ D.Values :=
+ LL_VSS_LL_VSI_Operations.vupkxsx (VA.Values,
+ Varray_signed_int'Length);
+ return To_Vector (D);
+ end vupklsh;
+
+ -------------
+ -- vupklpx --
+ -------------
+
+ function vupklpx (A : LL_VSS) return LL_VSI is
+ begin
+ return vupkxpx (A, Varray_signed_int'Length);
+ end vupklpx;
+
+ ----------
+ -- vxor --
+ ----------
+
+ function vxor (A : LL_VSI; B : LL_VSI) return LL_VSI is
+ VA : constant VUI_View := To_View (To_LL_VUI (A));
+ VB : constant VUI_View := To_View (To_LL_VUI (B));
+ D : VUI_View;
+
+ begin
+ for J in Vint_Range'Range loop
+ D.Values (J) := VA.Values (J) xor VB.Values (J);
+ end loop;
+
+ return To_LL_VSI (To_Vector (D));
+ end vxor;
+
+ ----------------
+ -- vcmpequb_p --
+ ----------------
+
+ function vcmpequb_p (A : c_int; B : LL_VSC; C : LL_VSC) return c_int is
+ D : LL_VSC;
+ begin
+ D := vcmpequb (B, C);
+ return LL_VSC_Operations.Check_CR6 (A, To_View (D).Values);
+ end vcmpequb_p;
+
+ ----------------
+ -- vcmpequh_p --
+ ----------------
+
+ function vcmpequh_p (A : c_int; B : LL_VSS; C : LL_VSS) return c_int is
+ D : LL_VSS;
+ begin
+ D := vcmpequh (B, C);
+ return LL_VSS_Operations.Check_CR6 (A, To_View (D).Values);
+ end vcmpequh_p;
+
+ ----------------
+ -- vcmpequw_p --
+ ----------------
+
+ function vcmpequw_p (A : c_int; B : LL_VSI; C : LL_VSI) return c_int is
+ D : LL_VSI;
+ begin
+ D := vcmpequw (B, C);
+ return LL_VSI_Operations.Check_CR6 (A, To_View (D).Values);
+ end vcmpequw_p;
+
+ ----------------
+ -- vcmpeqfp_p --
+ ----------------
+
+ function vcmpeqfp_p (A : c_int; B : LL_VF; C : LL_VF) return c_int is
+ D : LL_VSI;
+ begin
+ D := vcmpeqfp (B, C);
+ return LL_VSI_Operations.Check_CR6 (A, To_View (D).Values);
+ end vcmpeqfp_p;
+
+ ----------------
+ -- vcmpgtub_p --
+ ----------------
+
+ function vcmpgtub_p (A : c_int; B : LL_VSC; C : LL_VSC) return c_int is
+ D : LL_VSC;
+ begin
+ D := vcmpgtub (B, C);
+ return LL_VSC_Operations.Check_CR6 (A, To_View (D).Values);
+ end vcmpgtub_p;
+
+ ----------------
+ -- vcmpgtuh_p --
+ ----------------
+
+ function vcmpgtuh_p (A : c_int; B : LL_VSS; C : LL_VSS) return c_int is
+ D : LL_VSS;
+ begin
+ D := vcmpgtuh (B, C);
+ return LL_VSS_Operations.Check_CR6 (A, To_View (D).Values);
+ end vcmpgtuh_p;
+
+ ----------------
+ -- vcmpgtuw_p --
+ ----------------
+
+ function vcmpgtuw_p (A : c_int; B : LL_VSI; C : LL_VSI) return c_int is
+ D : LL_VSI;
+ begin
+ D := vcmpgtuw (B, C);
+ return LL_VSI_Operations.Check_CR6 (A, To_View (D).Values);
+ end vcmpgtuw_p;
+
+ ----------------
+ -- vcmpgtsb_p --
+ ----------------
+
+ function vcmpgtsb_p (A : c_int; B : LL_VSC; C : LL_VSC) return c_int is
+ D : LL_VSC;
+ begin
+ D := vcmpgtsb (B, C);
+ return LL_VSC_Operations.Check_CR6 (A, To_View (D).Values);
+ end vcmpgtsb_p;
+
+ ----------------
+ -- vcmpgtsh_p --
+ ----------------
+
+ function vcmpgtsh_p (A : c_int; B : LL_VSS; C : LL_VSS) return c_int is
+ D : LL_VSS;
+ begin
+ D := vcmpgtsh (B, C);
+ return LL_VSS_Operations.Check_CR6 (A, To_View (D).Values);
+ end vcmpgtsh_p;
+
+ ----------------
+ -- vcmpgtsw_p --
+ ----------------
+
+ function vcmpgtsw_p (A : c_int; B : LL_VSI; C : LL_VSI) return c_int is
+ D : LL_VSI;
+ begin
+ D := vcmpgtsw (B, C);
+ return LL_VSI_Operations.Check_CR6 (A, To_View (D).Values);
+ end vcmpgtsw_p;
+
+ ----------------
+ -- vcmpgefp_p --
+ ----------------
+
+ function vcmpgefp_p (A : c_int; B : LL_VF; C : LL_VF) return c_int is
+ D : LL_VSI;
+ begin
+ D := vcmpgefp (B, C);
+ return LL_VSI_Operations.Check_CR6 (A, To_View (D).Values);
+ end vcmpgefp_p;
+
+ ----------------
+ -- vcmpgtfp_p --
+ ----------------
+
+ function vcmpgtfp_p (A : c_int; B : LL_VF; C : LL_VF) return c_int is
+ D : LL_VSI;
+ begin
+ D := vcmpgtfp (B, C);
+ return LL_VSI_Operations.Check_CR6 (A, To_View (D).Values);
+ end vcmpgtfp_p;
+
+ ----------------
+ -- vcmpbfp_p --
+ ----------------
+
+ function vcmpbfp_p (A : c_int; B : LL_VF; C : LL_VF) return c_int is
+ D : VSI_View;
+ begin
+ D := To_View (vcmpbfp (B, C));
+
+ for J in Vint_Range'Range loop
+ -- vcmpbfp is not returning the usual bool vector; do the conversion
+ if D.Values (J) = 0 then
+ D.Values (J) := Signed_Bool_False;
+ else
+ D.Values (J) := Signed_Bool_True;
+ end if;
+ end loop;
+
+ return LL_VSI_Operations.Check_CR6 (A, D.Values);
+ end vcmpbfp_p;
+
+end GNAT.Altivec.Low_Level_Vectors;
--- /dev/null
+------------------------------------------------------------------------------
+-- --
+-- GNAT COMPILER COMPONENTS --
+-- --
+-- G N A T . A L T I V E C . L O W _ L E V E L _ V E C T O R S --
+-- --
+-- S p e c --
+-- (Soft Binding Version) --
+-- --
+-- Copyright (C) 2004-2005, 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 2, 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. See the GNU General Public License --
+-- for more details. You should have received a copy of the GNU General --
+-- Public License distributed with GNAT; see file COPYING. If not, write --
+-- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
+-- MA 02111-1307, USA. --
+-- --
+-- As a special exception, if other files instantiate generics from this --
+-- unit, or you link this unit with other files to produce an executable, --
+-- this unit does not by itself cause the resulting executable to be --
+-- covered by the GNU General Public License. This exception does not --
+-- however invalidate any other reasons why the executable file might be --
+-- covered by the GNU Public License. --
+-- --
+-- GNAT was originally developed by the GNAT team at New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc. --
+-- --
+------------------------------------------------------------------------------
+
+-- This unit exposes the low level vector support for the Soft binding,
+-- intended for non AltiVec capable targets. See Altivec.Design for a
+-- description of what is expected to be exposed.
+
+with GNAT.Altivec.Vector_Views; use GNAT.Altivec.Vector_Views;
+
+package GNAT.Altivec.Low_Level_Vectors is
+
+ ----------------------------------------
+ -- Low level vector type declarations --
+ ----------------------------------------
+
+ type LL_VUC is private;
+ type LL_VSC is private;
+ type LL_VBC is private;
+
+ type LL_VUS is private;
+ type LL_VSS is private;
+ type LL_VBS is private;
+
+ type LL_VUI is private;
+ type LL_VSI is private;
+ type LL_VBI is private;
+
+ type LL_VF is private;
+ type LL_VP is private;
+
+ ------------------------------------
+ -- Low level functional interface --
+ ------------------------------------
+
+ function abs_v16qi (A : LL_VSC) return LL_VSC;
+ function abs_v8hi (A : LL_VSS) return LL_VSS;
+ function abs_v4si (A : LL_VSI) return LL_VSI;
+ function abs_v4sf (A : LL_VF) return LL_VF;
+
+ function abss_v16qi (A : LL_VSC) return LL_VSC;
+ function abss_v8hi (A : LL_VSS) return LL_VSS;
+ function abss_v4si (A : LL_VSI) return LL_VSI;
+
+ function vaddubm (A : LL_VSC; B : LL_VSC) return LL_VSC;
+ function vadduhm (A : LL_VSS; B : LL_VSS) return LL_VSS;
+ function vadduwm (A : LL_VSI; B : LL_VSI) return LL_VSI;
+ function vaddfp (A : LL_VF; B : LL_VF) return LL_VF;
+
+ function vaddcuw (A : LL_VSI; B : LL_VSI) return LL_VSI;
+
+ function vaddubs (A : LL_VSC; B : LL_VSC) return LL_VSC;
+ function vaddsbs (A : LL_VSC; B : LL_VSC) return LL_VSC;
+ function vadduhs (A : LL_VSS; B : LL_VSS) return LL_VSS;
+ function vaddshs (A : LL_VSS; B : LL_VSS) return LL_VSS;
+ function vadduws (A : LL_VSI; B : LL_VSI) return LL_VSI;
+ function vaddsws (A : LL_VSI; B : LL_VSI) return LL_VSI;
+
+ function vand (A : LL_VSI; B : LL_VSI) return LL_VSI;
+ function vandc (A : LL_VSI; B : LL_VSI) return LL_VSI;
+
+ function vavgub (A : LL_VSC; B : LL_VSC) return LL_VSC;
+ function vavgsb (A : LL_VSC; B : LL_VSC) return LL_VSC;
+ function vavguh (A : LL_VSS; B : LL_VSS) return LL_VSS;
+ function vavgsh (A : LL_VSS; B : LL_VSS) return LL_VSS;
+ function vavguw (A : LL_VSI; B : LL_VSI) return LL_VSI;
+ function vavgsw (A : LL_VSI; B : LL_VSI) return LL_VSI;
+
+ function vcmpbfp (A : LL_VF; B : LL_VF) return LL_VSI;
+
+ function vcmpequb (A : LL_VSC; B : LL_VSC) return LL_VSC;
+ function vcmpequh (A : LL_VSS; B : LL_VSS) return LL_VSS;
+ function vcmpequw (A : LL_VSI; B : LL_VSI) return LL_VSI;
+ function vcmpeqfp (A : LL_VF; B : LL_VF) return LL_VSI;
+
+ function vcmpgefp (A : LL_VF; B : LL_VF) return LL_VSI;
+
+ function vcmpgtub (A : LL_VSC; B : LL_VSC) return LL_VSC;
+ function vcmpgtsb (A : LL_VSC; B : LL_VSC) return LL_VSC;
+ function vcmpgtuh (A : LL_VSS; B : LL_VSS) return LL_VSS;
+ function vcmpgtsh (A : LL_VSS; B : LL_VSS) return LL_VSS;
+ function vcmpgtuw (A : LL_VSI; B : LL_VSI) return LL_VSI;
+ function vcmpgtsw (A : LL_VSI; B : LL_VSI) return LL_VSI;
+ function vcmpgtfp (A : LL_VF; B : LL_VF) return LL_VSI;
+
+ function vcfux (A : LL_VSI; B : c_int) return LL_VF;
+ function vcfsx (A : LL_VSI; B : c_int) return LL_VF;
+
+ function vctsxs (A : LL_VF; B : c_int) return LL_VSI;
+ function vctuxs (A : LL_VF; B : c_int) return LL_VSI;
+
+ procedure dss (A : c_int);
+ procedure dssall;
+
+ procedure dst (A : c_ptr; B : c_int; C : c_int);
+ procedure dstst (A : c_ptr; B : c_int; C : c_int);
+ procedure dststt (A : c_ptr; B : c_int; C : c_int);
+ procedure dstt (A : c_ptr; B : c_int; C : c_int);
+
+ function vexptefp (A : LL_VF) return LL_VF;
+
+ function vrfim (A : LL_VF) return LL_VF;
+
+ function lvx (A : c_long; B : c_ptr) return LL_VSI;
+ function lvebx (A : c_long; B : c_ptr) return LL_VSC;
+ function lvehx (A : c_long; B : c_ptr) return LL_VSS;
+ function lvewx (A : c_long; B : c_ptr) return LL_VSI;
+ function lvxl (A : c_long; B : c_ptr) return LL_VSI;
+
+ function vlogefp (A : LL_VF) return LL_VF;
+
+ function lvsl (A : c_long; B : c_ptr) return LL_VSC;
+ function lvsr (A : c_long; B : c_ptr) return LL_VSC;
+
+ function vmaddfp (A : LL_VF; B : LL_VF; C : LL_VF) return LL_VF;
+
+ function vmhaddshs (A : LL_VSS; B : LL_VSS; C : LL_VSS) return LL_VSS;
+
+ function vmaxub (A : LL_VSC; B : LL_VSC) return LL_VSC;
+ function vmaxsb (A : LL_VSC; B : LL_VSC) return LL_VSC;
+ function vmaxuh (A : LL_VSS; B : LL_VSS) return LL_VSS;
+ function vmaxsh (A : LL_VSS; B : LL_VSS) return LL_VSS;
+ function vmaxuw (A : LL_VSI; B : LL_VSI) return LL_VSI;
+ function vmaxsw (A : LL_VSI; B : LL_VSI) return LL_VSI;
+ function vmaxfp (A : LL_VF; B : LL_VF) return LL_VF;
+
+ function vmrghb (A : LL_VSC; B : LL_VSC) return LL_VSC;
+ function vmrghh (A : LL_VSS; B : LL_VSS) return LL_VSS;
+ function vmrghw (A : LL_VSI; B : LL_VSI) return LL_VSI;
+ function vmrglb (A : LL_VSC; B : LL_VSC) return LL_VSC;
+ function vmrglh (A : LL_VSS; B : LL_VSS) return LL_VSS;
+ function vmrglw (A : LL_VSI; B : LL_VSI) return LL_VSI;
+
+ function mfvscr return LL_VSS;
+
+ function vminfp (A : LL_VF; B : LL_VF) return LL_VF;
+ function vminsb (A : LL_VSC; B : LL_VSC) return LL_VSC;
+ function vminsh (A : LL_VSS; B : LL_VSS) return LL_VSS;
+ function vminsw (A : LL_VSI; B : LL_VSI) return LL_VSI;
+ function vminub (A : LL_VSC; B : LL_VSC) return LL_VSC;
+ function vminuh (A : LL_VSS; B : LL_VSS) return LL_VSS;
+ function vminuw (A : LL_VSI; B : LL_VSI) return LL_VSI;
+
+ function vmladduhm (A : LL_VSS; B : LL_VSS; C : LL_VSS) return LL_VSS;
+
+ function vmhraddshs (A : LL_VSS; B : LL_VSS; C : LL_VSS) return LL_VSS;
+
+ function vmsumubm (A : LL_VSC; B : LL_VSC; C : LL_VSI) return LL_VSI;
+ function vmsummbm (A : LL_VSC; B : LL_VSC; C : LL_VSI) return LL_VSI;
+ function vmsumuhm (A : LL_VSS; B : LL_VSS; C : LL_VSI) return LL_VSI;
+ function vmsumshm (A : LL_VSS; B : LL_VSS; C : LL_VSI) return LL_VSI;
+ function vmsumuhs (A : LL_VSS; B : LL_VSS; C : LL_VSI) return LL_VSI;
+ function vmsumshs (A : LL_VSS; B : LL_VSS; C : LL_VSI) return LL_VSI;
+
+ procedure mtvscr (A : LL_VSI);
+
+ function vmuleub (A : LL_VSC; B : LL_VSC) return LL_VSS;
+ function vmuleuh (A : LL_VSS; B : LL_VSS) return LL_VSI;
+ function vmulesb (A : LL_VSC; B : LL_VSC) return LL_VSS;
+ function vmulesh (A : LL_VSS; B : LL_VSS) return LL_VSI;
+
+ function vmulosb (A : LL_VSC; B : LL_VSC) return LL_VSS;
+ function vmulosh (A : LL_VSS; B : LL_VSS) return LL_VSI;
+ function vmuloub (A : LL_VSC; B : LL_VSC) return LL_VSS;
+ function vmulouh (A : LL_VSS; B : LL_VSS) return LL_VSI;
+
+ function vnmsubfp (A : LL_VF; B : LL_VF; C : LL_VF) return LL_VF;
+
+ function vxor (A : LL_VSI; B : LL_VSI) return LL_VSI;
+ function vnor (A : LL_VSI; B : LL_VSI) return LL_VSI;
+ function vor (A : LL_VSI; B : LL_VSI) return LL_VSI;
+
+ function vpkuhum (A : LL_VSS; B : LL_VSS) return LL_VSC;
+ function vpkuwum (A : LL_VSI; B : LL_VSI) return LL_VSS;
+ function vpkpx (A : LL_VSI; B : LL_VSI) return LL_VSS;
+ function vpkuhus (A : LL_VSS; B : LL_VSS) return LL_VSC;
+ function vpkuwus (A : LL_VSI; B : LL_VSI) return LL_VSS;
+ function vpkshss (A : LL_VSS; B : LL_VSS) return LL_VSC;
+ function vpkswss (A : LL_VSI; B : LL_VSI) return LL_VSS;
+ function vpkshus (A : LL_VSS; B : LL_VSS) return LL_VSC;
+ function vpkswus (A : LL_VSI; B : LL_VSI) return LL_VSS;
+
+ function vperm_4si (A : LL_VSI; B : LL_VSI; C : LL_VSC) return LL_VSI;
+
+ function vrefp (A : LL_VF) return LL_VF;
+
+ function vrlb (A : LL_VSC; B : LL_VSC) return LL_VSC;
+ function vrlh (A : LL_VSS; B : LL_VSS) return LL_VSS;
+ function vrlw (A : LL_VSI; B : LL_VSI) return LL_VSI;
+
+ function vrfin (A : LL_VF) return LL_VF;
+ function vrfip (A : LL_VF) return LL_VF;
+ function vrfiz (A : LL_VF) return LL_VF;
+
+ function vrsqrtefp (A : LL_VF) return LL_VF;
+
+ function vsel_4si (A : LL_VSI; B : LL_VSI; C : LL_VSI) return LL_VSI;
+
+ function vslb (A : LL_VSC; B : LL_VSC) return LL_VSC;
+ function vslh (A : LL_VSS; B : LL_VSS) return LL_VSS;
+ function vslw (A : LL_VSI; B : LL_VSI) return LL_VSI;
+
+ function vsldoi_4si (A : LL_VSI; B : LL_VSI; C : c_int) return LL_VSI;
+ function vsldoi_8hi (A : LL_VSS; B : LL_VSS; C : c_int) return LL_VSS;
+ function vsldoi_16qi (A : LL_VSC; B : LL_VSC; C : c_int) return LL_VSC;
+ function vsldoi_4sf (A : LL_VF; B : LL_VF; C : c_int) return LL_VF;
+
+ function vsl (A : LL_VSI; B : LL_VSI) return LL_VSI;
+ function vslo (A : LL_VSI; B : LL_VSI) return LL_VSI;
+
+ function vspltb (A : LL_VSC; B : c_int) return LL_VSC;
+ function vsplth (A : LL_VSS; B : c_int) return LL_VSS;
+ function vspltw (A : LL_VSI; B : c_int) return LL_VSI;
+
+ function vspltisb (A : c_int) return LL_VSC;
+ function vspltish (A : c_int) return LL_VSS;
+ function vspltisw (A : c_int) return LL_VSI;
+
+ function vsrb (A : LL_VSC; B : LL_VSC) return LL_VSC;
+ function vsrh (A : LL_VSS; B : LL_VSS) return LL_VSS;
+ function vsrw (A : LL_VSI; B : LL_VSI) return LL_VSI;
+
+ function vsrab (A : LL_VSC; B : LL_VSC) return LL_VSC;
+ function vsrah (A : LL_VSS; B : LL_VSS) return LL_VSS;
+ function vsraw (A : LL_VSI; B : LL_VSI) return LL_VSI;
+
+ function vsr (A : LL_VSI; B : LL_VSI) return LL_VSI;
+ function vsro (A : LL_VSI; B : LL_VSI) return LL_VSI;
+
+ procedure stvx (A : LL_VSI; B : c_int; C : c_ptr);
+ procedure stvebx (A : LL_VSC; B : c_int; C : c_ptr);
+ procedure stvehx (A : LL_VSS; B : c_int; C : c_ptr);
+ procedure stvewx (A : LL_VSI; B : c_int; C : c_ptr);
+ procedure stvxl (A : LL_VSI; B : c_int; C : c_ptr);
+
+ function vsububm (A : LL_VSC; B : LL_VSC) return LL_VSC;
+ function vsubuhm (A : LL_VSS; B : LL_VSS) return LL_VSS;
+ function vsubuwm (A : LL_VSI; B : LL_VSI) return LL_VSI;
+ function vsubfp (A : LL_VF; B : LL_VF) return LL_VF;
+
+ function vsubcuw (A : LL_VSI; B : LL_VSI) return LL_VSI;
+
+ function vsububs (A : LL_VSC; B : LL_VSC) return LL_VSC;
+ function vsubsbs (A : LL_VSC; B : LL_VSC) return LL_VSC;
+ function vsubuhs (A : LL_VSS; B : LL_VSS) return LL_VSS;
+ function vsubshs (A : LL_VSS; B : LL_VSS) return LL_VSS;
+ function vsubuws (A : LL_VSI; B : LL_VSI) return LL_VSI;
+ function vsubsws (A : LL_VSI; B : LL_VSI) return LL_VSI;
+
+ function vsum4ubs (A : LL_VSC; B : LL_VSI) return LL_VSI;
+ function vsum4sbs (A : LL_VSC; B : LL_VSI) return LL_VSI;
+ function vsum4shs (A : LL_VSS; B : LL_VSI) return LL_VSI;
+
+ function vsum2sws (A : LL_VSI; B : LL_VSI) return LL_VSI;
+ function vsumsws (A : LL_VSI; B : LL_VSI) return LL_VSI;
+
+ function vupkhsb (A : LL_VSC) return LL_VSS;
+ function vupkhsh (A : LL_VSS) return LL_VSI;
+ function vupkhpx (A : LL_VSS) return LL_VSI;
+
+ function vupklsb (A : LL_VSC) return LL_VSS;
+ function vupklsh (A : LL_VSS) return LL_VSI;
+ function vupklpx (A : LL_VSS) return LL_VSI;
+
+ function vcmpequb_p (A : c_int; B : LL_VSC; C : LL_VSC) return c_int;
+ function vcmpequh_p (A : c_int; B : LL_VSS; C : LL_VSS) return c_int;
+ function vcmpequw_p (A : c_int; B : LL_VSI; C : LL_VSI) return c_int;
+ function vcmpeqfp_p (A : c_int; B : LL_VF; C : LL_VF) return c_int;
+
+ function vcmpgtub_p (A : c_int; B : LL_VSC; C : LL_VSC) return c_int;
+ function vcmpgtuh_p (A : c_int; B : LL_VSS; C : LL_VSS) return c_int;
+ function vcmpgtuw_p (A : c_int; B : LL_VSI; C : LL_VSI) return c_int;
+ function vcmpgtsb_p (A : c_int; B : LL_VSC; C : LL_VSC) return c_int;
+ function vcmpgtsh_p (A : c_int; B : LL_VSS; C : LL_VSS) return c_int;
+ function vcmpgtsw_p (A : c_int; B : LL_VSI; C : LL_VSI) return c_int;
+ function vcmpgtfp_p (A : c_int; B : LL_VF; C : LL_VF) return c_int;
+
+ function vcmpgefp_p (A : c_int; B : LL_VF; C : LL_VF) return c_int;
+ function vcmpbfp_p (A : c_int; B : LL_VF; C : LL_VF) return c_int;
+
+private
+
+ ---------------------------------------
+ -- Low level vector type definitions --
+ ---------------------------------------
+
+ -- We simply use the natural array definitions corresponding to each
+ -- user-level vector type.
+
+ type LL_VUI is new VUC_View;
+ type LL_VSI is new VUC_View;
+
+ type LL_VUS is new VUC_View;
+ type LL_VSS is new VUC_View;
+
+ type LL_VUC is new VUC_View;
+ type LL_VSC is new VUC_View;
+
+ type LL_VF is new VUC_View;
+
+ type LL_VBC is new VUC_View;
+ type LL_VBS is new VUC_View;
+ type LL_VBI is new VUC_View;
+ type LL_VP is new VUC_View;
+
+ ------------------------------------
+ -- Low level functional interface --
+ ------------------------------------
+
+ pragma Convention_Identifier (LL_Altivec, C);
+
+ pragma Export (LL_Altivec, dss, "__builtin_altivec_dss");
+ pragma Export (LL_Altivec, dssall, "__builtin_altivec_dssall");
+ pragma Export (LL_Altivec, dst, "__builtin_altivec_dst");
+ pragma Export (LL_Altivec, dstst, "__builtin_altivec_dstst");
+ pragma Export (LL_Altivec, dststt, "__builtin_altivec_dststt");
+ pragma Export (LL_Altivec, dstt, "__builtin_altivec_dstt");
+ pragma Export (LL_Altivec, mtvscr, "__builtin_altivec_mtvscr");
+ pragma Export (LL_Altivec, mfvscr, "__builtin_altivec_mfvscr");
+ pragma Export (LL_Altivec, stvebx, "__builtin_altivec_stvebx");
+ pragma Export (LL_Altivec, stvehx, "__builtin_altivec_stvehx");
+ pragma Export (LL_Altivec, stvewx, "__builtin_altivec_stvewx");
+ pragma Export (LL_Altivec, stvx, "__builtin_altivec_stvx");
+ pragma Export (LL_Altivec, stvxl, "__builtin_altivec_stvxl");
+ pragma Export (LL_Altivec, lvebx, "__builtin_altivec_lvebx");
+ pragma Export (LL_Altivec, lvehx, "__builtin_altivec_lvehx");
+ pragma Export (LL_Altivec, lvewx, "__builtin_altivec_lvewx");
+ pragma Export (LL_Altivec, lvx, "__builtin_altivec_lvx");
+ pragma Export (LL_Altivec, lvxl, "__builtin_altivec_lvxl");
+ pragma Export (LL_Altivec, lvsl, "__builtin_altivec_lvsl");
+ pragma Export (LL_Altivec, lvsr, "__builtin_altivec_lvsr");
+ pragma Export (LL_Altivec, abs_v16qi, "__builtin_altivec_abs_v16qi");
+ pragma Export (LL_Altivec, abs_v8hi, "__builtin_altivec_abs_v8hi");
+ pragma Export (LL_Altivec, abs_v4si, "__builtin_altivec_abs_v4si");
+ pragma Export (LL_Altivec, abs_v4sf, "__builtin_altivec_abs_v4sf");
+ pragma Export (LL_Altivec, abss_v16qi, "__builtin_altivec_abss_v16qi");
+ pragma Export (LL_Altivec, abss_v8hi, "__builtin_altivec_abss_v8hi");
+ pragma Export (LL_Altivec, abss_v4si, "__builtin_altivec_abss_v4si");
+ pragma Export (LL_Altivec, vaddcuw, "__builtin_altivec_vaddcuw");
+ pragma Export (LL_Altivec, vaddfp, "__builtin_altivec_vaddfp");
+ pragma Export (LL_Altivec, vaddsbs, "__builtin_altivec_vaddsbs");
+ pragma Export (LL_Altivec, vaddshs, "__builtin_altivec_vaddshs");
+ pragma Export (LL_Altivec, vaddsws, "__builtin_altivec_vaddsws");
+ pragma Export (LL_Altivec, vaddubm, "__builtin_altivec_vaddubm");
+ pragma Export (LL_Altivec, vaddubs, "__builtin_altivec_vaddubs");
+ pragma Export (LL_Altivec, vadduhm, "__builtin_altivec_vadduhm");
+ pragma Export (LL_Altivec, vadduhs, "__builtin_altivec_vadduhs");
+ pragma Export (LL_Altivec, vadduwm, "__builtin_altivec_vadduwm");
+ pragma Export (LL_Altivec, vadduws, "__builtin_altivec_vadduws");
+ pragma Export (LL_Altivec, vand, "__builtin_altivec_vand");
+ pragma Export (LL_Altivec, vandc, "__builtin_altivec_vandc");
+ pragma Export (LL_Altivec, vavgsb, "__builtin_altivec_vavgsb");
+ pragma Export (LL_Altivec, vavgsh, "__builtin_altivec_vavgsh");
+ pragma Export (LL_Altivec, vavgsw, "__builtin_altivec_vavgsw");
+ pragma Export (LL_Altivec, vavgub, "__builtin_altivec_vavgub");
+ pragma Export (LL_Altivec, vavguh, "__builtin_altivec_vavguh");
+ pragma Export (LL_Altivec, vavguw, "__builtin_altivec_vavguw");
+ pragma Export (LL_Altivec, vcfsx, "__builtin_altivec_vcfsx");
+ pragma Export (LL_Altivec, vcfux, "__builtin_altivec_vcfux");
+ pragma Export (LL_Altivec, vcmpbfp, "__builtin_altivec_vcmpbfp");
+ pragma Export (LL_Altivec, vcmpeqfp, "__builtin_altivec_vcmpeqfp");
+ pragma Export (LL_Altivec, vcmpequb, "__builtin_altivec_vcmpequb");
+ pragma Export (LL_Altivec, vcmpequh, "__builtin_altivec_vcmpequh");
+ pragma Export (LL_Altivec, vcmpequw, "__builtin_altivec_vcmpequw");
+ pragma Export (LL_Altivec, vcmpgefp, "__builtin_altivec_vcmpgefp");
+ pragma Export (LL_Altivec, vcmpgtfp, "__builtin_altivec_vcmpgtfp");
+ pragma Export (LL_Altivec, vcmpgtsb, "__builtin_altivec_vcmpgtsb");
+ pragma Export (LL_Altivec, vcmpgtsh, "__builtin_altivec_vcmpgtsh");
+ pragma Export (LL_Altivec, vcmpgtsw, "__builtin_altivec_vcmpgtsw");
+ pragma Export (LL_Altivec, vcmpgtub, "__builtin_altivec_vcmpgtub");
+ pragma Export (LL_Altivec, vcmpgtuh, "__builtin_altivec_vcmpgtuh");
+ pragma Export (LL_Altivec, vcmpgtuw, "__builtin_altivec_vcmpgtuw");
+ pragma Export (LL_Altivec, vctsxs, "__builtin_altivec_vctsxs");
+ pragma Export (LL_Altivec, vctuxs, "__builtin_altivec_vctuxs");
+ pragma Export (LL_Altivec, vexptefp, "__builtin_altivec_vexptefp");
+ pragma Export (LL_Altivec, vlogefp, "__builtin_altivec_vlogefp");
+ pragma Export (LL_Altivec, vmaddfp, "__builtin_altivec_vmaddfp");
+ pragma Export (LL_Altivec, vmaxfp, "__builtin_altivec_vmaxfp");
+ pragma Export (LL_Altivec, vmaxsb, "__builtin_altivec_vmaxsb");
+ pragma Export (LL_Altivec, vmaxsh, "__builtin_altivec_vmaxsh");
+ pragma Export (LL_Altivec, vmaxsw, "__builtin_altivec_vmaxsw");
+ pragma Export (LL_Altivec, vmaxub, "__builtin_altivec_vmaxub");
+ pragma Export (LL_Altivec, vmaxuh, "__builtin_altivec_vmaxuh");
+ pragma Export (LL_Altivec, vmaxuw, "__builtin_altivec_vmaxuw");
+ pragma Export (LL_Altivec, vmhaddshs, "__builtin_altivec_vmhaddshs");
+ pragma Export (LL_Altivec, vmhraddshs, "__builtin_altivec_vmhraddshs");
+ pragma Export (LL_Altivec, vminfp, "__builtin_altivec_vminfp");
+ pragma Export (LL_Altivec, vminsb, "__builtin_altivec_vminsb");
+ pragma Export (LL_Altivec, vminsh, "__builtin_altivec_vminsh");
+ pragma Export (LL_Altivec, vminsw, "__builtin_altivec_vminsw");
+ pragma Export (LL_Altivec, vminub, "__builtin_altivec_vminub");
+ pragma Export (LL_Altivec, vminuh, "__builtin_altivec_vminuh");
+ pragma Export (LL_Altivec, vminuw, "__builtin_altivec_vminuw");
+ pragma Export (LL_Altivec, vmladduhm, "__builtin_altivec_vmladduhm");
+ pragma Export (LL_Altivec, vmrghb, "__builtin_altivec_vmrghb");
+ pragma Export (LL_Altivec, vmrghh, "__builtin_altivec_vmrghh");
+ pragma Export (LL_Altivec, vmrghw, "__builtin_altivec_vmrghw");
+ pragma Export (LL_Altivec, vmrglb, "__builtin_altivec_vmrglb");
+ pragma Export (LL_Altivec, vmrglh, "__builtin_altivec_vmrglh");
+ pragma Export (LL_Altivec, vmrglw, "__builtin_altivec_vmrglw");
+ pragma Export (LL_Altivec, vmsummbm, "__builtin_altivec_vmsummbm");
+ pragma Export (LL_Altivec, vmsumshm, "__builtin_altivec_vmsumshm");
+ pragma Export (LL_Altivec, vmsumshs, "__builtin_altivec_vmsumshs");
+ pragma Export (LL_Altivec, vmsumubm, "__builtin_altivec_vmsumubm");
+ pragma Export (LL_Altivec, vmsumuhm, "__builtin_altivec_vmsumuhm");
+ pragma Export (LL_Altivec, vmsumuhs, "__builtin_altivec_vmsumuhs");
+ pragma Export (LL_Altivec, vmulesb, "__builtin_altivec_vmulesb");
+ pragma Export (LL_Altivec, vmulesh, "__builtin_altivec_vmulesh");
+ pragma Export (LL_Altivec, vmuleub, "__builtin_altivec_vmuleub");
+ pragma Export (LL_Altivec, vmuleuh, "__builtin_altivec_vmuleuh");
+ pragma Export (LL_Altivec, vmulosb, "__builtin_altivec_vmulosb");
+ pragma Export (LL_Altivec, vmulosh, "__builtin_altivec_vmulosh");
+ pragma Export (LL_Altivec, vmuloub, "__builtin_altivec_vmuloub");
+ pragma Export (LL_Altivec, vmulouh, "__builtin_altivec_vmulouh");
+ pragma Export (LL_Altivec, vnmsubfp, "__builtin_altivec_vnmsubfp");
+ pragma Export (LL_Altivec, vnor, "__builtin_altivec_vnor");
+ pragma Export (LL_Altivec, vxor, "__builtin_altivec_vxor");
+ pragma Export (LL_Altivec, vor, "__builtin_altivec_vor");
+ pragma Export (LL_Altivec, vperm_4si, "__builtin_altivec_vperm_4si");
+ pragma Export (LL_Altivec, vpkpx, "__builtin_altivec_vpkpx");
+ pragma Export (LL_Altivec, vpkshss, "__builtin_altivec_vpkshss");
+ pragma Export (LL_Altivec, vpkshus, "__builtin_altivec_vpkshus");
+ pragma Export (LL_Altivec, vpkswss, "__builtin_altivec_vpkswss");
+ pragma Export (LL_Altivec, vpkswus, "__builtin_altivec_vpkswus");
+ pragma Export (LL_Altivec, vpkuhum, "__builtin_altivec_vpkuhum");
+ pragma Export (LL_Altivec, vpkuhus, "__builtin_altivec_vpkuhus");
+ pragma Export (LL_Altivec, vpkuwum, "__builtin_altivec_vpkuwum");
+ pragma Export (LL_Altivec, vpkuwus, "__builtin_altivec_vpkuwus");
+ pragma Export (LL_Altivec, vrefp, "__builtin_altivec_vrefp");
+ pragma Export (LL_Altivec, vrfim, "__builtin_altivec_vrfim");
+ pragma Export (LL_Altivec, vrfin, "__builtin_altivec_vrfin");
+ pragma Export (LL_Altivec, vrfip, "__builtin_altivec_vrfip");
+ pragma Export (LL_Altivec, vrfiz, "__builtin_altivec_vrfiz");
+ pragma Export (LL_Altivec, vrlb, "__builtin_altivec_vrlb");
+ pragma Export (LL_Altivec, vrlh, "__builtin_altivec_vrlh");
+ pragma Export (LL_Altivec, vrlw, "__builtin_altivec_vrlw");
+ pragma Export (LL_Altivec, vrsqrtefp, "__builtin_altivec_vrsqrtefp");
+ pragma Export (LL_Altivec, vsel_4si, "__builtin_altivec_vsel_4si");
+ pragma Export (LL_Altivec, vsldoi_4si, "__builtin_altivec_vsldoi_4si");
+ pragma Export (LL_Altivec, vsldoi_8hi, "__builtin_altivec_vsldoi_8hi");
+ pragma Export (LL_Altivec, vsldoi_16qi, "__builtin_altivec_vsldoi_16qi");
+ pragma Export (LL_Altivec, vsldoi_4sf, "__builtin_altivec_vsldoi_4sf");
+ pragma Export (LL_Altivec, vsl, "__builtin_altivec_vsl");
+ pragma Export (LL_Altivec, vslb, "__builtin_altivec_vslb");
+ pragma Export (LL_Altivec, vslh, "__builtin_altivec_vslh");
+ pragma Export (LL_Altivec, vslo, "__builtin_altivec_vslo");
+ pragma Export (LL_Altivec, vslw, "__builtin_altivec_vslw");
+ pragma Export (LL_Altivec, vspltb, "__builtin_altivec_vspltb");
+ pragma Export (LL_Altivec, vsplth, "__builtin_altivec_vsplth");
+ pragma Export (LL_Altivec, vspltisb, "__builtin_altivec_vspltisb");
+ pragma Export (LL_Altivec, vspltish, "__builtin_altivec_vspltish");
+ pragma Export (LL_Altivec, vspltisw, "__builtin_altivec_vspltisw");
+ pragma Export (LL_Altivec, vspltw, "__builtin_altivec_vspltw");
+ pragma Export (LL_Altivec, vsr, "__builtin_altivec_vsr");
+ pragma Export (LL_Altivec, vsrab, "__builtin_altivec_vsrab");
+ pragma Export (LL_Altivec, vsrah, "__builtin_altivec_vsrah");
+ pragma Export (LL_Altivec, vsraw, "__builtin_altivec_vsraw");
+ pragma Export (LL_Altivec, vsrb, "__builtin_altivec_vsrb");
+ pragma Export (LL_Altivec, vsrh, "__builtin_altivec_vsrh");
+ pragma Export (LL_Altivec, vsro, "__builtin_altivec_vsro");
+ pragma Export (LL_Altivec, vsrw, "__builtin_altivec_vsrw");
+ pragma Export (LL_Altivec, vsubcuw, "__builtin_altivec_vsubcuw");
+ pragma Export (LL_Altivec, vsubfp, "__builtin_altivec_vsubfp");
+ pragma Export (LL_Altivec, vsubsbs, "__builtin_altivec_vsubsbs");
+ pragma Export (LL_Altivec, vsubshs, "__builtin_altivec_vsubshs");
+ pragma Export (LL_Altivec, vsubsws, "__builtin_altivec_vsubsws");
+ pragma Export (LL_Altivec, vsububm, "__builtin_altivec_vsububm");
+ pragma Export (LL_Altivec, vsububs, "__builtin_altivec_vsububs");
+ pragma Export (LL_Altivec, vsubuhm, "__builtin_altivec_vsubuhm");
+ pragma Export (LL_Altivec, vsubuhs, "__builtin_altivec_vsubuhs");
+ pragma Export (LL_Altivec, vsubuwm, "__builtin_altivec_vsubuwm");
+ pragma Export (LL_Altivec, vsubuws, "__builtin_altivec_vsubuws");
+ pragma Export (LL_Altivec, vsum2sws, "__builtin_altivec_vsum2sws");
+ pragma Export (LL_Altivec, vsum4sbs, "__builtin_altivec_vsum4sbs");
+ pragma Export (LL_Altivec, vsum4shs, "__builtin_altivec_vsum4shs");
+ pragma Export (LL_Altivec, vsum4ubs, "__builtin_altivec_vsum4ubs");
+ pragma Export (LL_Altivec, vsumsws, "__builtin_altivec_vsumsws");
+ pragma Export (LL_Altivec, vupkhpx, "__builtin_altivec_vupkhpx");
+ pragma Export (LL_Altivec, vupkhsb, "__builtin_altivec_vupkhsb");
+ pragma Export (LL_Altivec, vupkhsh, "__builtin_altivec_vupkhsh");
+ pragma Export (LL_Altivec, vupklpx, "__builtin_altivec_vupklpx");
+ pragma Export (LL_Altivec, vupklsb, "__builtin_altivec_vupklsb");
+ pragma Export (LL_Altivec, vupklsh, "__builtin_altivec_vupklsh");
+ pragma Export (LL_Altivec, vcmpbfp_p, "__builtin_altivec_vcmpbfp_p");
+ pragma Export (LL_Altivec, vcmpeqfp_p, "__builtin_altivec_vcmpeqfp_p");
+ pragma Export (LL_Altivec, vcmpgefp_p, "__builtin_altivec_vcmpgefp_p");
+ pragma Export (LL_Altivec, vcmpgtfp_p, "__builtin_altivec_vcmpgtfp_p");
+ pragma Export (LL_Altivec, vcmpequw_p, "__builtin_altivec_vcmpequw_p");
+ pragma Export (LL_Altivec, vcmpgtsw_p, "__builtin_altivec_vcmpgtsw_p");
+ pragma Export (LL_Altivec, vcmpgtuw_p, "__builtin_altivec_vcmpgtuw_p");
+ pragma Export (LL_Altivec, vcmpgtuh_p, "__builtin_altivec_vcmpgtuh_p");
+ pragma Export (LL_Altivec, vcmpgtsh_p, "__builtin_altivec_vcmpgtsh_p");
+ pragma Export (LL_Altivec, vcmpequh_p, "__builtin_altivec_vcmpequh_p");
+ pragma Export (LL_Altivec, vcmpequb_p, "__builtin_altivec_vcmpequb_p");
+ pragma Export (LL_Altivec, vcmpgtsb_p, "__builtin_altivec_vcmpgtsb_p");
+ pragma Export (LL_Altivec, vcmpgtub_p, "__builtin_altivec_vcmpgtub_p");
+
+end GNAT.Altivec.Low_Level_Vectors;
--- /dev/null
+------------------------------------------------------------------------------
+-- --
+-- GNAT COMPILER COMPONENTS --
+-- --
+-- G N A T . A L T I V E C . C O N V E R S I O N S --
+-- --
+-- B o d y --
+-- --
+-- Copyright (C) 2005, 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 2, 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. See the GNU General Public License --
+-- for more details. You should have received a copy of the GNU General --
+-- Public License distributed with GNAT; see file COPYING. If not, write --
+-- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
+-- MA 02111-1307, USA. --
+-- --
+-- As a special exception, if other files instantiate generics from this --
+-- unit, or you link this unit with other files to produce an executable, --
+-- this unit does not by itself cause the resulting executable to be --
+-- covered by the GNU General Public License. This exception does not --
+-- however invalidate any other reasons why the executable file might be --
+-- covered by the GNU Public License. --
+-- --
+-- GNAT was originally developed by the GNAT team at New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc. --
+-- --
+------------------------------------------------------------------------------
+
+with Ada.Unchecked_Conversion;
+
+with System; use System;
+
+with GNAT.Altivec.Low_Level_Interface; use GNAT.Altivec.Low_Level_Interface;
+with GNAT.Altivec.Low_Level_Vectors; use GNAT.Altivec.Low_Level_Vectors;
+
+package body GNAT.Altivec.Conversions is
+
+ function To_Varray_unsigned_char is
+ new Ada.Unchecked_Conversion (Varray_signed_char,
+ Varray_unsigned_char);
+
+ function To_Varray_unsigned_char is
+ new Ada.Unchecked_Conversion (Varray_bool_char,
+ Varray_unsigned_char);
+
+ function To_Varray_unsigned_short is
+ new Ada.Unchecked_Conversion (Varray_signed_short,
+ Varray_unsigned_short);
+
+ function To_Varray_unsigned_short is
+ new Ada.Unchecked_Conversion (Varray_bool_short,
+ Varray_unsigned_short);
+
+ function To_Varray_unsigned_short is
+ new Ada.Unchecked_Conversion (Varray_pixel,
+ Varray_unsigned_short);
+
+ function To_Varray_unsigned_int is
+ new Ada.Unchecked_Conversion (Varray_signed_int,
+ Varray_unsigned_int);
+
+ function To_Varray_unsigned_int is
+ new Ada.Unchecked_Conversion (Varray_bool_int,
+ Varray_unsigned_int);
+
+ function To_Varray_unsigned_int is
+ new Ada.Unchecked_Conversion (Varray_float,
+ Varray_unsigned_int);
+
+ function To_Varray_signed_char is
+ new Ada.Unchecked_Conversion (Varray_unsigned_char,
+ Varray_signed_char);
+
+ function To_Varray_bool_char is
+ new Ada.Unchecked_Conversion (Varray_unsigned_char,
+ Varray_bool_char);
+
+ function To_Varray_signed_short is
+ new Ada.Unchecked_Conversion (Varray_unsigned_short,
+ Varray_signed_short);
+
+ function To_Varray_bool_short is
+ new Ada.Unchecked_Conversion (Varray_unsigned_short,
+ Varray_bool_short);
+
+ function To_Varray_pixel is
+ new Ada.Unchecked_Conversion (Varray_unsigned_short,
+ Varray_pixel);
+
+ function To_Varray_signed_int is
+ new Ada.Unchecked_Conversion (Varray_unsigned_int,
+ Varray_signed_int);
+
+ function To_Varray_bool_int is
+ new Ada.Unchecked_Conversion (Varray_unsigned_int,
+ Varray_bool_int);
+
+ function To_Varray_float is
+ new Ada.Unchecked_Conversion (Varray_unsigned_int,
+ Varray_float);
+
+ function To_VUC is new Ada.Unchecked_Conversion (VUC_View, VUC);
+ function To_VSC is new Ada.Unchecked_Conversion (VSC_View, VSC);
+ function To_VBC is new Ada.Unchecked_Conversion (VBC_View, VBC);
+ function To_VUS is new Ada.Unchecked_Conversion (VUS_View, VUS);
+ function To_VSS is new Ada.Unchecked_Conversion (VSS_View, VSS);
+ function To_VBS is new Ada.Unchecked_Conversion (VBS_View, VBS);
+ function To_VUI is new Ada.Unchecked_Conversion (VUI_View, VUI);
+ function To_VSI is new Ada.Unchecked_Conversion (VSI_View, VSI);
+ function To_VBI is new Ada.Unchecked_Conversion (VBI_View, VBI);
+ function To_VF is new Ada.Unchecked_Conversion (VF_View, VF);
+ function To_VP is new Ada.Unchecked_Conversion (VP_View, VP);
+
+ function To_VUC_View is new Ada.Unchecked_Conversion (VUC, VUC_View);
+ function To_VSC_View is new Ada.Unchecked_Conversion (VSC, VSC_View);
+ function To_VBC_View is new Ada.Unchecked_Conversion (VBC, VBC_View);
+ function To_VUS_View is new Ada.Unchecked_Conversion (VUS, VUS_View);
+ function To_VSS_View is new Ada.Unchecked_Conversion (VSS, VSS_View);
+ function To_VBS_View is new Ada.Unchecked_Conversion (VBS, VBS_View);
+ function To_VUI_View is new Ada.Unchecked_Conversion (VUI, VUI_View);
+ function To_VSI_View is new Ada.Unchecked_Conversion (VSI, VSI_View);
+ function To_VBI_View is new Ada.Unchecked_Conversion (VBI, VBI_View);
+ function To_VF_View is new Ada.Unchecked_Conversion (VF, VF_View);
+ function To_VP_View is new Ada.Unchecked_Conversion (VP, VP_View);
+
+ pragma Warnings (Off, Default_Bit_Order);
+
+ ---------------
+ -- To_Vector --
+ ---------------
+
+ function To_Vector (S : VSC_View) return VSC is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VSC (S);
+ else
+ declare
+ Result : LL_VUC;
+ VS : constant VUC_View :=
+ (Values => To_Varray_unsigned_char (S.Values));
+ begin
+ Result := To_Vector (VS);
+ return To_LL_VSC (Result);
+ end;
+ end if;
+ end To_Vector;
+
+ function To_Vector (S : VBC_View) return VBC is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VBC (S);
+ else
+ declare
+ Result : LL_VUC;
+ VS : constant VUC_View :=
+ (Values => To_Varray_unsigned_char (S.Values));
+ begin
+ Result := To_Vector (VS);
+ return To_LL_VBC (Result);
+ end;
+ end if;
+ end To_Vector;
+
+ function To_Vector (S : VSS_View) return VSS is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VSS (S);
+ else
+ declare
+ Result : LL_VUS;
+ VS : constant VUS_View :=
+ (Values => To_Varray_unsigned_short (S.Values));
+ begin
+ Result := To_Vector (VS);
+ return VSS (To_LL_VSS (Result));
+ end;
+ end if;
+ end To_Vector;
+
+ function To_Vector (S : VBS_View) return VBS is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VBS (S);
+ else
+ declare
+ Result : LL_VUS;
+ VS : constant VUS_View :=
+ (Values => To_Varray_unsigned_short (S.Values));
+ begin
+ Result := To_Vector (VS);
+ return To_LL_VBS (Result);
+ end;
+ end if;
+ end To_Vector;
+
+ function To_Vector (S : VP_View) return VP is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VP (S);
+ else
+ declare
+ Result : LL_VUS;
+ VS : constant VUS_View :=
+ (Values => To_Varray_unsigned_short (S.Values));
+ begin
+ Result := To_Vector (VS);
+ return To_LL_VP (Result);
+ end;
+ end if;
+ end To_Vector;
+
+ function To_Vector (S : VSI_View) return VSI is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VSI (S);
+ else
+ declare
+ Result : LL_VUI;
+ VS : constant VUI_View :=
+ (Values => To_Varray_unsigned_int (S.Values));
+ begin
+ Result := To_Vector (VS);
+ return To_LL_VSI (Result);
+ end;
+ end if;
+ end To_Vector;
+
+ function To_Vector (S : VBI_View) return VBI is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VBI (S);
+ else
+ declare
+ Result : LL_VUI;
+ VS : constant VUI_View :=
+ (Values => To_Varray_unsigned_int (S.Values));
+ begin
+ Result := To_Vector (VS);
+ return To_LL_VBI (Result);
+ end;
+ end if;
+ end To_Vector;
+
+ function To_Vector (S : VF_View) return VF is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VF (S);
+ else
+ declare
+ Result : LL_VUI;
+ VS : constant VUI_View :=
+ (Values => To_Varray_unsigned_int (S.Values));
+ begin
+ Result := To_Vector (VS);
+ return To_LL_VF (Result);
+ end;
+ end if;
+ end To_Vector;
+
+ function To_Vector (S : VUC_View) return VUC is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VUC (S);
+ else
+ declare
+ Result : VUC_View;
+ begin
+ for J in Vchar_Range'Range loop
+ Result.Values (J) :=
+ S.Values (Vchar_Range'Last - J + Vchar_Range'First);
+ end loop;
+ return To_VUC (Result);
+ end;
+ end if;
+ end To_Vector;
+
+ function To_Vector (S : VUS_View) return VUS is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VUS (S);
+ else
+ declare
+ Result : VUS_View;
+ begin
+ for J in Vshort_Range'Range loop
+ Result.Values (J) :=
+ S.Values (Vshort_Range'Last - J + Vshort_Range'First);
+ end loop;
+ return To_VUS (Result);
+ end;
+ end if;
+ end To_Vector;
+
+ function To_Vector (S : VUI_View) return VUI is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VUI (S);
+ else
+ declare
+ Result : VUI_View;
+ begin
+ for J in Vint_Range'Range loop
+ Result.Values (J) :=
+ S.Values (Vint_Range'Last - J + Vint_Range'First);
+ end loop;
+ return To_VUI (Result);
+ end;
+ end if;
+ end To_Vector;
+
+ --------------
+ -- To_View --
+ --------------
+
+ function To_View (S : VSC) return VSC_View is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VSC_View (S);
+ else
+ declare
+ Result : VUC_View;
+ begin
+ Result := To_View (To_LL_VUC (S));
+ return (Values => To_Varray_signed_char (Result.Values));
+ end;
+ end if;
+ end To_View;
+
+ function To_View (S : VBC) return VBC_View is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VBC_View (S);
+ else
+ declare
+ Result : VUC_View;
+ begin
+ Result := To_View (To_LL_VUC (S));
+ return (Values => To_Varray_bool_char (Result.Values));
+ end;
+ end if;
+ end To_View;
+
+ function To_View (S : VSS) return VSS_View is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VSS_View (S);
+ else
+ declare
+ Result : VUS_View;
+ begin
+ Result := To_View (To_LL_VUS (S));
+ return (Values => To_Varray_signed_short (Result.Values));
+ end;
+ end if;
+ end To_View;
+
+ function To_View (S : VBS) return VBS_View is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VBS_View (S);
+ else
+ declare
+ Result : VUS_View;
+ begin
+ Result := To_View (To_LL_VUS (S));
+ return (Values => To_Varray_bool_short (Result.Values));
+ end;
+ end if;
+ end To_View;
+
+ function To_View (S : VP) return VP_View is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VP_View (S);
+ else
+ declare
+ Result : VUS_View;
+ begin
+ Result := To_View (To_LL_VUS (S));
+ return (Values => To_Varray_pixel (Result.Values));
+ end;
+ end if;
+ end To_View;
+
+ function To_View (S : VSI) return VSI_View is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VSI_View (S);
+ else
+ declare
+ Result : VUI_View;
+ begin
+ Result := To_View (To_LL_VUI (S));
+ return (Values => To_Varray_signed_int (Result.Values));
+ end;
+ end if;
+ end To_View;
+
+ function To_View (S : VBI) return VBI_View is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VBI_View (S);
+ else
+ declare
+ Result : VUI_View;
+ begin
+ Result := To_View (To_LL_VUI (S));
+ return (Values => To_Varray_bool_int (Result.Values));
+ end;
+ end if;
+ end To_View;
+
+ function To_View (S : VF) return VF_View is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VF_View (S);
+ else
+ declare
+ Result : VUI_View;
+ begin
+ Result := To_View (To_LL_VUI (S));
+ return (Values => To_Varray_float (Result.Values));
+ end;
+ end if;
+ end To_View;
+
+ function To_View (S : VUC) return VUC_View is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VUC_View (S);
+ else
+ declare
+ VS : constant VUC_View := To_VUC_View (S);
+ Result : VUC_View;
+ begin
+ for J in Vchar_Range'Range loop
+ Result.Values (J) :=
+ VS.Values (Vchar_Range'Last - J + Vchar_Range'First);
+ end loop;
+ return Result;
+ end;
+ end if;
+ end To_View;
+
+ function To_View (S : VUS) return VUS_View is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VUS_View (S);
+ else
+ declare
+ VS : constant VUS_View := To_VUS_View (S);
+ Result : VUS_View;
+ begin
+ for J in Vshort_Range'Range loop
+ Result.Values (J) :=
+ VS.Values (Vshort_Range'Last - J + Vshort_Range'First);
+ end loop;
+ return Result;
+ end;
+ end if;
+ end To_View;
+
+ function To_View (S : VUI) return VUI_View is
+ begin
+ if Default_Bit_Order = High_Order_First then
+ return To_VUI_View (S);
+ else
+ declare
+ VS : constant VUI_View := To_VUI_View (S);
+ Result : VUI_View;
+ begin
+ for J in Vint_Range'Range loop
+ Result.Values (J) :=
+ VS.Values (Vint_Range'Last - J + Vint_Range'First);
+ end loop;
+ return Result;
+ end;
+ end if;
+ end To_View;
+
+end GNAT.Altivec.Conversions;
--- /dev/null
+------------------------------------------------------------------------------
+-- --
+-- GNAT COMPILER COMPONENTS --
+-- --
+-- G N A T . A L T I V E C . C O N V E R S I O N S --
+-- --
+-- S p e c --
+-- --
+-- Copyright (C) 2005, 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 2, 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. See the GNU General Public License --
+-- for more details. You should have received a copy of the GNU General --
+-- Public License distributed with GNAT; see file COPYING. If not, write --
+-- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
+-- MA 02111-1307, USA. --
+-- --
+-- As a special exception, if other files instantiate generics from this --
+-- unit, or you link this unit with other files to produce an executable, --
+-- this unit does not by itself cause the resulting executable to be --
+-- covered by the GNU General Public License. This exception does not --
+-- however invalidate any other reasons why the executable file might be --
+-- covered by the GNU Public License. --
+-- --
+-- GNAT was originally developed by the GNAT team at New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc. --
+-- --
+------------------------------------------------------------------------------
+
+-- This unit provides the Vector/Views conversions
+
+with GNAT.Altivec.Vector_Types; use GNAT.Altivec.Vector_Types;
+with GNAT.Altivec.Vector_Views; use GNAT.Altivec.Vector_Views;
+
+package GNAT.Altivec.Conversions is
+
+ ---------------------
+ -- char components --
+ ---------------------
+
+ function To_Vector (S : VUC_View) return VUC;
+ function To_Vector (S : VSC_View) return VSC;
+ function To_Vector (S : VBC_View) return VBC;
+
+ function To_View (S : VUC) return VUC_View;
+ function To_View (S : VSC) return VSC_View;
+ function To_View (S : VBC) return VBC_View;
+
+ ----------------------
+ -- short components --
+ ----------------------
+
+ function To_Vector (S : VUS_View) return VUS;
+ function To_Vector (S : VSS_View) return VSS;
+ function To_Vector (S : VBS_View) return VBS;
+
+ function To_View (S : VUS) return VUS_View;
+ function To_View (S : VSS) return VSS_View;
+ function To_View (S : VBS) return VBS_View;
+
+ --------------------
+ -- int components --
+ --------------------
+
+ function To_Vector (S : VUI_View) return VUI;
+ function To_Vector (S : VSI_View) return VSI;
+ function To_Vector (S : VBI_View) return VBI;
+
+ function To_View (S : VUI) return VUI_View;
+ function To_View (S : VSI) return VSI_View;
+ function To_View (S : VBI) return VBI_View;
+
+ ----------------------
+ -- float components --
+ ----------------------
+
+ function To_Vector (S : VF_View) return VF;
+
+ function To_View (S : VF) return VF_View;
+
+ ----------------------
+ -- pixel components --
+ ----------------------
+
+ function To_Vector (S : VP_View) return VP;
+
+ function To_View (S : VP) return VP_View;
+
+private
+
+ -- We want the above subprograms to always be inlined in the case of the
+ -- hard PowerPC AltiVec support in order to avoid the unnecessary function
+ -- call. On the other hand there is no problem with inlining these
+ -- subprograms on little-endian targets.
+
+ pragma Inline_Always (To_Vector);
+ pragma Inline_Always (To_View);
+
+end GNAT.Altivec.Conversions;
--- /dev/null
+------------------------------------------------------------------------------
+-- --
+-- GNAT COMPILER COMPONENTS --
+-- --
+-- G N A T . A L T I V E C --
+-- --
+-- S p e c --
+-- --
+-- Copyright (C) 2004-2005, 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 2, 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. See the GNU General Public License --
+-- for more details. You should have received a copy of the GNU General --
+-- Public License distributed with GNAT; see file COPYING. If not, write --
+-- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
+-- MA 02111-1307, USA. --
+-- --
+-- As a special exception, if other files instantiate generics from this --
+-- unit, or you link this unit with other files to produce an executable, --
+-- this unit does not by itself cause the resulting executable to be --
+-- covered by the GNU General Public License. This exception does not --
+-- however invalidate any other reasons why the executable file might be --
+-- covered by the GNU Public License. --
+-- --
+-- GNAT was originally developed by the GNAT team at New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc. --
+-- --
+------------------------------------------------------------------------------
+
+-------------------------
+-- General description --
+-------------------------
+
+-- This is the root of a package hierarchy offering an Ada binding to the
+-- PowerPC AltiVec extensions. These extensions basically consist in a set of
+-- 128bit vector types together with a set of subprograms operating on such
+-- vectors. On a real Altivec capable target, vector objects map to hardware
+-- vector registers and the subprograms map to a set of specific hardware
+-- instructions.
+
+-- Relevant documents are:
+
+-- o AltiVec Technology, Programming Interface Manual (1999-06)
+-- to which we will refer as [PIM], describes the data types, the
+-- functional interface and the ABI conventions.
+
+-- o AltiVec Technology, Programming Environments Manual (2002-02)
+-- to which we will refer as [PEM], describes the hardware architecture
+-- and instruction set.
+
+-- These documents, as well as a number of others of general interest on the
+-- AltiVec technology, are available from the Motorola/AltiVec Web site at
+
+-- http://www.motorola.com/altivec
+
+-- We offer two versions of this binding: one for real AltiVec capable
+-- targets, and one for other targets. In the latter case, everything is
+-- emulated in software. We will refer to the two bindings as:
+
+-- o The Hard binding for AltiVec capable targets (with the appropriate
+-- hardware support and corresponding instruction set)
+
+-- o The Soft binding for other targets (with the low level primitives
+-- emulated in software).
+
+-- The two versions of the binding are expected to be equivalent from the
+-- functional standpoint. The same client application code should observe no
+-- difference in operation results, even if the Soft version is used on a
+-- non-powerpc target. The Hard binding is naturally expected to run faster
+-- than the Soft version on the same target.
+
+-- We also offer interfaces not strictly part of the base AltiVec API, such
+-- as vector conversions to/from array representations, which are of interest
+-- for client applications (e.g. for vector initialization purposes) and may
+-- also be used as implementation facilities.
+
+-----------------------------------------
+-- General package architecture survey --
+-----------------------------------------
+
+-- The various vector representations are all "containers" of elementary
+-- values, the possible types of which are declared in this root package to
+-- be generally accessible.
+
+-- From the user standpoint, the two versions of the binding are available
+-- through a consistent hierarchy of units providing identical services:
+
+-- GNAT.Altivec
+-- (component types)
+-- |
+-- o----------------o----------------o-------------o
+-- | | | |
+-- Vector_Types Vector_Operations Vector_Views Conversions
+
+-- The user can manipulate vectors through two families of types: Vector
+-- types and View types.
+
+-- Vector types are defined in the GNAT.Altivec.Vector_Types package
+
+-- On these types, the user can apply the Altivec operations defined in
+-- GNAT.Altivec.Vector_Operations. Their layout is opaque and may vary across
+-- configurations, for it is typically target-endianness dependant.
+
+-- Vector_Types and Vector_Operations implement the core binding to the
+-- AltiVec API, as described in [PIM-2.1 data types] and [PIM-4 AltiVec
+-- operations and predicates].
+
+-- View types are defined in the GNAT.Altivec.Vector_Views package
+
+-- These types do not represent Altivec vectors per se, in the sense that the
+-- Altivec_Operations are not available for them. They are intended to allow
+-- Vector initializations as well as access to the Vector component values.
+
+-- The GNAT.Altivec.Conversions package is provided to convert a View to the
+-- corresponding Vector and vice-versa.
+
+-- The two versions of the binding rely on a low level internal interface,
+-- and switching from one version to the other amounts to select one low
+-- level implementation instead of the other.
+
+-- The bindings are provided as a set of sources together with a project file
+-- (altivec.gpr). The hard/soft binding selection is controlled by a project
+-- variable on targets where switching makes sense. See the example usage
+-- section below.
+
+---------------------------
+-- Underlying principles --
+---------------------------
+
+-- The general organization sketched above has been devised from a number
+-- of driving ideas:
+
+-- o From the clients standpoint, the two versions of the binding should be
+-- as easily exchangable as possible,
+
+-- o From the maintenance standpoint, we want to avoid as much code
+-- duplication as possible.
+
+-- o From both standpoints above, we want to maintain a clear interface
+-- separation between the base bindings to the Motorola API and the
+-- additional facilities.
+
+-- The identification of the low level interface is directly inspired by the
+-- the base API organization, basically consisting of a rich set of functions
+-- around a core of low level primitives mapping to AltiVec instructions.
+
+-- See for instance "vec_add" in [PIM-4.4 Generic and Specific AltiVec
+-- operations]: no less than six result/arguments combinations of byte vector
+-- types map to "vaddubm".
+
+-- The "hard" version of the low level primitives map to real AltiVec
+-- instructions via the corresponding GCC builtins. The "soft" version is
+-- a software emulation of those.
+
+-------------------
+-- Example usage --
+-------------------
+
+-- Here is a sample program declaring and initializing two vectors, 'add'ing
+-- them and displaying the result components:
+
+-- with GNAT.Altivec.Vector_Types; use GNAT.Altivec.Vector_Types;
+-- with GNAT.Altivec.Vector_Operations; use GNAT.Altivec.Vector_Operations;
+-- with GNAT.Altivec.Vector_Views; use GNAT.Altivec.Vector_Views;
+-- with GNAT.Altivec.Conversions; use GNAT.Altivec.Conversions;
+
+-- use GNAT.Altivec;
+
+-- procedure Sample is
+-- Va : Vector_Unsigned_Int := To_Vector ((Values => (1, 2, 3, 4)));
+-- Vb : Vector_Unsigned_Int := To_Vector ((Values => (1, 2, 3, 4)));
+
+-- Vs : Vector_Unsigned_Int;
+-- Vs_View : VUI_View;
+-- begin
+-- Vs := Vec_Add (Va, Vb);
+-- Vs_View := To_View (Vs);
+
+-- for I in Vs_View.Values'Range loop
+-- Put_Line (Unsigned_Int'Image (Vs_View.Values (I)));
+-- end loop;
+-- end;
+
+-- This currently requires the GNAT project management facilities to compile,
+-- to automatically retrieve the set of necessary sources and switches
+-- depending on your configuration. For the example above, customizing the
+-- switches to include -g also, this would be something like:
+
+-- sample.gpr
+--
+-- with "altivec.gpr";
+--
+-- project Sample is
+
+-- for Source_Dirs use (".");
+-- for Main use ("sample");
+
+-- package Compiler is
+-- for Default_Switches ("Ada") use
+-- Altivec.Compiler'Default_Switches ("Ada") & "-g";
+-- end Compiler;
+
+-- end Sample;
+
+-- $ gnatmake -Psample
+-- [...]
+-- $ ./sample
+-- 2
+-- 4
+-- 6
+-- 8
+
+------------------------------------------------------------------------------
+
+with System;
+
+package GNAT.Altivec is
+
+ -- Definitions of constants and vector/array component types common to all
+ -- the versions of the binding.
+
+ -- All the vector types are 128bits
+
+ VECTOR_BIT : constant := 128;
+
+ -------------------------------------------
+ -- [PIM-2.3.1 Alignment of vector types] --
+ -------------------------------------------
+
+ -- "A defined data item of any vector data type in memory is always
+ -- aligned on a 16-byte boundary. A pointer to any vector data type always
+ -- points to a 16-byte boundary. The compiler is responsible for aligning
+ -- vector data types on 16-byte boundaries."
+
+ VECTOR_ALIGNMENT : constant := 16;
+
+ -------------------------------------------------------
+ -- [PIM-2.1] Data Types - Interpretation of contents --
+ -------------------------------------------------------
+
+ ---------------------
+ -- char components --
+ ---------------------
+
+ CHAR_BIT : constant := 8;
+ SCHAR_MIN : constant := -2 ** (CHAR_BIT - 1);
+ SCHAR_MAX : constant := 2 ** (CHAR_BIT - 1) - 1;
+ UCHAR_MAX : constant := 2 ** CHAR_BIT - 1;
+
+ type unsigned_char is mod UCHAR_MAX + 1;
+ for unsigned_char'Size use CHAR_BIT;
+
+ type signed_char is range SCHAR_MIN .. SCHAR_MAX;
+ for signed_char'Size use CHAR_BIT;
+
+ subtype bool_char is unsigned_char;
+ -- ??? There is a difference here between what the Altivec Technology
+ -- Programming Interface Manual says and what GCC says. In the manual,
+ -- vector_bool_char is a vector_unsigned_char, while in altivec.h it
+ -- is a vector_signed_char.
+
+ bool_char_True : constant bool_char := bool_char'Last;
+ bool_char_False : constant bool_char := 0;
+
+ ----------------------
+ -- short components --
+ ----------------------
+
+ SHORT_BIT : constant := 16;
+ SSHORT_MIN : constant := -2 ** (SHORT_BIT - 1);
+ SSHORT_MAX : constant := 2 ** (SHORT_BIT - 1) - 1;
+ USHORT_MAX : constant := 2 ** SHORT_BIT - 1;
+
+ type unsigned_short is mod USHORT_MAX + 1;
+ for unsigned_short'Size use SHORT_BIT;
+
+ subtype unsigned_short_int is unsigned_short;
+
+ type signed_short is range SSHORT_MIN .. SSHORT_MAX;
+ for signed_short'Size use SHORT_BIT;
+
+ subtype signed_short_int is signed_short;
+
+ subtype bool_short is unsigned_short;
+ -- ??? See bool_char
+
+ bool_short_True : constant bool_short := bool_short'Last;
+ bool_short_False : constant bool_short := 0;
+
+ subtype bool_short_int is bool_short;
+
+ --------------------
+ -- int components --
+ --------------------
+
+ INT_BIT : constant := 32;
+ SINT_MIN : constant := -2 ** (INT_BIT - 1);
+ SINT_MAX : constant := 2 ** (INT_BIT - 1) - 1;
+ UINT_MAX : constant := 2 ** INT_BIT - 1;
+
+ type unsigned_int is mod UINT_MAX + 1;
+ for unsigned_int'Size use INT_BIT;
+
+ type signed_int is range SINT_MIN .. SINT_MAX;
+ for signed_int'Size use INT_BIT;
+
+ subtype bool_int is unsigned_int;
+ -- ??? See bool_char
+
+ bool_int_True : constant bool_int := bool_int'Last;
+ bool_int_False : constant bool_int := 0;
+
+ ----------------------
+ -- float components --
+ ----------------------
+
+ FLOAT_BIT : constant := 32;
+ FLOAT_DIGIT : constant := 6;
+ FLOAT_MIN : constant := -16#0.FFFF_FF#E+32;
+ FLOAT_MAX : constant := 16#0.FFFF_FF#E+32;
+
+ type C_float is digits FLOAT_DIGIT range FLOAT_MIN .. FLOAT_MAX;
+ for C_float'Size use FLOAT_BIT;
+
+ ----------------------
+ -- pixel components --
+ ----------------------
+
+ subtype pixel is unsigned_short;
+
+ -----------------------------------------------------------
+ -- Subtypes for variants found in the GCC implementation --
+ -----------------------------------------------------------
+
+ subtype c_int is signed_int;
+ subtype c_short is c_int;
+
+ LONG_BIT : constant := 32;
+ -- Some of the GCC builtins are built with "long" arguments and
+ -- expect SImode to come in.
+
+ SLONG_MIN : constant := -2 ** (LONG_BIT - 1);
+ SLONG_MAX : constant := 2 ** (LONG_BIT - 1) - 1;
+ ULONG_MAX : constant := 2 ** LONG_BIT - 1;
+
+ type signed_long is range SLONG_MIN .. SLONG_MAX;
+ type unsigned_long is mod ULONG_MAX + 1;
+
+ subtype c_long is signed_long;
+
+ subtype c_ptr is System.Address;
+
+ ---------------------------------------------------------
+ -- Access types, for the sake of some argument passing --
+ ---------------------------------------------------------
+
+ type signed_char_ptr is access all signed_char;
+ type unsigned_char_ptr is access all unsigned_char;
+
+ type short_ptr is access all c_short;
+ type signed_short_ptr is access all signed_short;
+ type unsigned_short_ptr is access all unsigned_short;
+
+ type int_ptr is access all c_int;
+ type signed_int_ptr is access all signed_int;
+ type unsigned_int_ptr is access all unsigned_int;
+
+ type long_ptr is access all c_long;
+ type signed_long_ptr is access all signed_long;
+ type unsigned_long_ptr is access all unsigned_long;
+
+ type float_ptr is access all Float;
+
+ --
+
+ type const_signed_char_ptr is access constant signed_char;
+ type const_unsigned_char_ptr is access constant unsigned_char;
+
+ type const_short_ptr is access constant c_short;
+ type const_signed_short_ptr is access constant signed_short;
+ type const_unsigned_short_ptr is access constant unsigned_short;
+
+ type const_int_ptr is access constant c_int;
+ type const_signed_int_ptr is access constant signed_int;
+ type const_unsigned_int_ptr is access constant unsigned_int;
+
+ type const_long_ptr is access constant c_long;
+ type const_signed_long_ptr is access constant signed_long;
+ type const_unsigned_long_ptr is access constant unsigned_long;
+
+ type const_float_ptr is access constant Float;
+
+ -- Access to const volatile arguments need specialized types
+
+ type volatile_float is new Float;
+ pragma Volatile (volatile_float);
+
+ type volatile_signed_char is new signed_char;
+ pragma Volatile (volatile_signed_char);
+
+ type volatile_unsigned_char is new unsigned_char;
+ pragma Volatile (volatile_unsigned_char);
+
+ type volatile_signed_short is new signed_short;
+ pragma Volatile (volatile_signed_short);
+
+ type volatile_unsigned_short is new unsigned_short;
+ pragma Volatile (volatile_unsigned_short);
+
+ type volatile_signed_int is new signed_int;
+ pragma Volatile (volatile_signed_int);
+
+ type volatile_unsigned_int is new unsigned_int;
+ pragma Volatile (volatile_unsigned_int);
+
+ type volatile_signed_long is new signed_long;
+ pragma Volatile (volatile_signed_long);
+
+ type volatile_unsigned_long is new unsigned_long;
+ pragma Volatile (volatile_unsigned_long);
+
+ type constv_char_ptr is access constant volatile_signed_char;
+ type constv_signed_char_ptr is access constant volatile_signed_char;
+ type constv_unsigned_char_ptr is access constant volatile_unsigned_char;
+
+ type constv_short_ptr is access constant volatile_signed_short;
+ type constv_signed_short_ptr is access constant volatile_signed_short;
+ type constv_unsigned_short_ptr is access constant volatile_unsigned_short;
+
+ type constv_int_ptr is access constant volatile_signed_int;
+ type constv_signed_int_ptr is access constant volatile_signed_int;
+ type constv_unsigned_int_ptr is access constant volatile_unsigned_int;
+
+ type constv_long_ptr is access constant volatile_signed_long;
+ type constv_signed_long_ptr is access constant volatile_signed_long;
+ type constv_unsigned_long_ptr is access constant volatile_unsigned_long;
+
+ type constv_float_ptr is access constant volatile_float;
+
+private
+
+ -----------------------
+ -- Various constants --
+ -----------------------
+
+ CR6_EQ : constant := 0;
+ CR6_EQ_REV : constant := 1;
+ CR6_LT : constant := 2;
+ CR6_LT_REV : constant := 3;
+
+end GNAT.Altivec;
--- /dev/null
+------------------------------------------------------------------------------
+-- --
+-- 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 --
+-- --
+-- B o d y --
+-- --
+-- Copyright (C) 2004-2005, 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 2, 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. See the GNU General Public License --
+-- for more details. You should have received a copy of the GNU General --
+-- Public License distributed with GNAT; see file COPYING. If not, write --
+-- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
+-- MA 02111-1307, USA. --
+-- --
+-- As a special exception, if other files instantiate generics from this --
+-- unit, or you link this unit with other files to produce an executable, --
+-- this unit does not by itself cause the resulting executable to be --
+-- covered by the GNU General Public License. This exception does not --
+-- however invalidate any other reasons why the executable file might be --
+-- covered by the GNU Public License. --
+-- --
+-- GNAT was originally developed by the GNAT team at New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc. --
+-- --
+------------------------------------------------------------------------------
+
+with GNAT.Altivec.Low_Level_Vectors; use GNAT.Altivec.Low_Level_Vectors;
+
+package body GNAT.Altivec.Vector_Operations is
+
+ --------------------------------------------------------
+ -- Bodies for generic and specific Altivec operations --
+ --------------------------------------------------------
+
+ -- vec_abs --
+
+ function vec_abs
+ (A : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (abs_v16qi (A));
+ end vec_abs;
+
+ function vec_abs
+ (A : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (abs_v8hi (A));
+ end vec_abs;
+
+ function vec_abs
+ (A : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (abs_v4si (A));
+ end vec_abs;
+
+ function vec_abs
+ (A : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (abs_v4sf (A));
+ end vec_abs;
+
+ -- vec_abss --
+
+ function vec_abss
+ (A : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (abss_v16qi (A));
+ end vec_abss;
+
+ function vec_abss
+ (A : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (abss_v8hi (A));
+ end vec_abss;
+
+ function vec_abss
+ (A : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (abss_v4si (A));
+ end vec_abss;
+
+ -- vec_add --
+
+ function vec_add
+ (A : vector_bool_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vaddubm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_add;
+
+ function vec_add
+ (A : vector_signed_char;
+ B : vector_bool_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vaddubm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_add;
+
+ function vec_add
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vaddubm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_add;
+
+ function vec_add
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vaddubm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_add;
+
+ function vec_add
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vaddubm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_add;
+
+ function vec_add
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vaddubm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_add;
+
+ function vec_add
+ (A : vector_bool_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vadduhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_add;
+
+ function vec_add
+ (A : vector_signed_short;
+ B : vector_bool_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vadduhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_add;
+
+ function vec_add
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vadduhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_add;
+
+ function vec_add
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vadduhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_add;
+
+ function vec_add
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vadduhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_add;
+
+ function vec_add
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vadduhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_add;
+
+ function vec_add
+ (A : vector_bool_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vadduwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_add;
+
+ function vec_add
+ (A : vector_signed_int;
+ B : vector_bool_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vadduwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_add;
+
+ function vec_add
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vadduwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_add;
+
+ function vec_add
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vadduwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_add;
+
+ function vec_add
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vadduwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_add;
+
+ function vec_add
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vadduwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_add;
+
+ function vec_add
+ (A : vector_float;
+ B : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vaddfp (To_LL_VF (A), To_LL_VF (B)));
+ end vec_add;
+
+ -- vec_vaddfp --
+
+ function vec_vaddfp
+ (A : vector_float;
+ B : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vaddfp (To_LL_VF (A), To_LL_VF (B)));
+ end vec_vaddfp;
+
+ -- vec_vadduwm --
+
+ function vec_vadduwm
+ (A : vector_bool_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vadduwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vadduwm;
+
+ function vec_vadduwm
+ (A : vector_signed_int;
+ B : vector_bool_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vadduwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vadduwm;
+
+ function vec_vadduwm
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vadduwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vadduwm;
+
+ function vec_vadduwm
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vadduwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vadduwm;
+
+ function vec_vadduwm
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vadduwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vadduwm;
+
+ function vec_vadduwm
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vadduwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vadduwm;
+
+ -- vec_vadduhm --
+
+ function vec_vadduhm
+ (A : vector_bool_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vadduhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vadduhm;
+
+ function vec_vadduhm
+ (A : vector_signed_short;
+ B : vector_bool_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vadduhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vadduhm;
+
+ function vec_vadduhm
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vadduhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vadduhm;
+
+ function vec_vadduhm
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vadduhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vadduhm;
+
+ function vec_vadduhm
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vadduhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vadduhm;
+
+ function vec_vadduhm
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vadduhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vadduhm;
+
+ -- vec_vaddubm --
+
+ function vec_vaddubm
+ (A : vector_bool_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vaddubm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vaddubm;
+
+ function vec_vaddubm
+ (A : vector_signed_char;
+ B : vector_bool_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vaddubm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vaddubm;
+
+ function vec_vaddubm
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vaddubm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vaddubm;
+
+ function vec_vaddubm
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vaddubm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vaddubm;
+
+ function vec_vaddubm
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vaddubm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vaddubm;
+
+ function vec_vaddubm
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vaddubm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vaddubm;
+
+ -- vec_addc --
+
+ function vec_addc
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vaddcuw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_addc;
+
+ -- vec_adds --
+
+ function vec_adds
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vaddubs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_adds;
+
+ function vec_adds
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vaddubs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_adds;
+
+ function vec_adds
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vaddubs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_adds;
+
+ function vec_adds
+ (A : vector_bool_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vaddsbs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_adds;
+
+ function vec_adds
+ (A : vector_signed_char;
+ B : vector_bool_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vaddsbs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_adds;
+
+ function vec_adds
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vaddsbs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_adds;
+
+ function vec_adds
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vadduhs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_adds;
+
+ function vec_adds
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vadduhs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_adds;
+
+ function vec_adds
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vadduhs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_adds;
+
+ function vec_adds
+ (A : vector_bool_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vaddshs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_adds;
+
+ function vec_adds
+ (A : vector_signed_short;
+ B : vector_bool_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vaddshs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_adds;
+
+ function vec_adds
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vaddshs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_adds;
+
+ function vec_adds
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vadduws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_adds;
+
+ function vec_adds
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vadduws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_adds;
+
+ function vec_adds
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vadduws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_adds;
+
+ function vec_adds
+ (A : vector_bool_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vaddsws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_adds;
+
+ function vec_adds
+ (A : vector_signed_int;
+ B : vector_bool_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vaddsws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_adds;
+
+ function vec_adds
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vaddsws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_adds;
+
+ -- vec_vaddsws --
+
+ function vec_vaddsws
+ (A : vector_bool_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vaddsws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vaddsws;
+
+ function vec_vaddsws
+ (A : vector_signed_int;
+ B : vector_bool_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vaddsws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vaddsws;
+
+ function vec_vaddsws
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vaddsws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vaddsws;
+
+ -- vec_vadduws --
+
+ function vec_vadduws
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vadduws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vadduws;
+
+ function vec_vadduws
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vadduws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vadduws;
+
+ function vec_vadduws
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vadduws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vadduws;
+
+ -- vec_vaddshs --
+
+ function vec_vaddshs
+ (A : vector_bool_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vaddshs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vaddshs;
+
+ function vec_vaddshs
+ (A : vector_signed_short;
+ B : vector_bool_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vaddshs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vaddshs;
+
+ function vec_vaddshs
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vaddshs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vaddshs;
+
+ -- vec_vadduhs --
+
+ function vec_vadduhs
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vadduhs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vadduhs;
+
+ function vec_vadduhs
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vadduhs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vadduhs;
+
+ function vec_vadduhs
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vadduhs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vadduhs;
+
+ -- vec_vaddsbs --
+
+ function vec_vaddsbs
+ (A : vector_bool_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vaddsbs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vaddsbs;
+
+ function vec_vaddsbs
+ (A : vector_signed_char;
+ B : vector_bool_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vaddsbs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vaddsbs;
+
+ function vec_vaddsbs
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vaddsbs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vaddsbs;
+
+ -- vec_vaddubs --
+
+ function vec_vaddubs
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vaddubs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vaddubs;
+
+ function vec_vaddubs
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vaddubs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vaddubs;
+
+ function vec_vaddubs
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vaddubs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vaddubs;
+
+ -- vec_and --
+
+ function vec_and
+ (A : vector_float;
+ B : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_float;
+ B : vector_bool_int) return vector_float
+ is
+ begin
+ return To_LL_VF (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_bool_int;
+ B : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_bool_int;
+ B : vector_bool_int) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_bool_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_signed_int;
+ B : vector_bool_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_bool_short;
+ B : vector_bool_short) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_bool_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_signed_short;
+ B : vector_bool_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_bool_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_bool_char;
+ B : vector_bool_char) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_signed_char;
+ B : vector_bool_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ function vec_and
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vand (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_and;
+
+ -- vec_andc --
+
+ function vec_andc
+ (A : vector_float;
+ B : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_float;
+ B : vector_bool_int) return vector_float
+ is
+ begin
+ return To_LL_VF (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_bool_int;
+ B : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_bool_int;
+ B : vector_bool_int) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_bool_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_signed_int;
+ B : vector_bool_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_bool_short;
+ B : vector_bool_short) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_bool_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_signed_short;
+ B : vector_bool_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_bool_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_bool_char;
+ B : vector_bool_char) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_signed_char;
+ B : vector_bool_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ function vec_andc
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vandc (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_andc;
+
+ -- vec_avg --
+
+ function vec_avg
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vavgub (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_avg;
+
+ function vec_avg
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vavgsb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_avg;
+
+ function vec_avg
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vavguh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_avg;
+
+ function vec_avg
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vavgsh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_avg;
+
+ function vec_avg
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vavguw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_avg;
+
+ function vec_avg
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vavgsw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_avg;
+
+ -- vec_vavgsw --
+
+ function vec_vavgsw
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vavgsw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vavgsw;
+
+ -- vec_vavguw --
+
+ function vec_vavguw
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vavguw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vavguw;
+
+ -- vec_vavgsh --
+
+ function vec_vavgsh
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vavgsh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vavgsh;
+
+ -- vec_vavguh --
+
+ function vec_vavguh
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vavguh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vavguh;
+
+ -- vec_vavgsb --
+
+ function vec_vavgsb
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vavgsb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vavgsb;
+
+ -- vec_vavgub --
+
+ function vec_vavgub
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vavgub (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vavgub;
+
+ -- vec_ceil --
+
+ function vec_ceil
+ (A : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vrfip (To_LL_VF (A)));
+ end vec_ceil;
+
+ -- vec_cmpb --
+
+ function vec_cmpb
+ (A : vector_float;
+ B : vector_float) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vcmpbfp (To_LL_VF (A), To_LL_VF (B)));
+ end vec_cmpb;
+
+ -- vec_cmpeq --
+
+ function vec_cmpeq
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vcmpequb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_cmpeq;
+
+ function vec_cmpeq
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vcmpequb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_cmpeq;
+
+ function vec_cmpeq
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vcmpequh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_cmpeq;
+
+ function vec_cmpeq
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vcmpequh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_cmpeq;
+
+ function vec_cmpeq
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vcmpequw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_cmpeq;
+
+ function vec_cmpeq
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vcmpequw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_cmpeq;
+
+ function vec_cmpeq
+ (A : vector_float;
+ B : vector_float) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vcmpeqfp (To_LL_VF (A), To_LL_VF (B)));
+ end vec_cmpeq;
+
+ -- vec_vcmpeqfp --
+
+ function vec_vcmpeqfp
+ (A : vector_float;
+ B : vector_float) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vcmpeqfp (To_LL_VF (A), To_LL_VF (B)));
+ end vec_vcmpeqfp;
+
+ -- vec_vcmpequw --
+
+ function vec_vcmpequw
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vcmpequw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vcmpequw;
+
+ function vec_vcmpequw
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vcmpequw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vcmpequw;
+
+ -- vec_vcmpequh --
+
+ function vec_vcmpequh
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vcmpequh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vcmpequh;
+
+ function vec_vcmpequh
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vcmpequh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vcmpequh;
+
+ -- vec_vcmpequb --
+
+ function vec_vcmpequb
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vcmpequb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vcmpequb;
+
+ function vec_vcmpequb
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vcmpequb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vcmpequb;
+
+ -- vec_cmpge --
+
+ function vec_cmpge
+ (A : vector_float;
+ B : vector_float) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vcmpgefp (To_LL_VF (A), To_LL_VF (B)));
+ end vec_cmpge;
+
+ -- vec_cmpgt --
+
+ function vec_cmpgt
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vcmpgtub (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_cmpgt;
+
+ function vec_cmpgt
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vcmpgtsb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_cmpgt;
+
+ function vec_cmpgt
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vcmpgtuh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_cmpgt;
+
+ function vec_cmpgt
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vcmpgtsh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_cmpgt;
+
+ function vec_cmpgt
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vcmpgtuw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_cmpgt;
+
+ function vec_cmpgt
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vcmpgtsw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_cmpgt;
+
+ function vec_cmpgt
+ (A : vector_float;
+ B : vector_float) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vcmpgtfp (To_LL_VF (A), To_LL_VF (B)));
+ end vec_cmpgt;
+
+ -- vec_vcmpgtfp --
+
+ function vec_vcmpgtfp
+ (A : vector_float;
+ B : vector_float) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vcmpgtfp (To_LL_VF (A), To_LL_VF (B)));
+ end vec_vcmpgtfp;
+
+ -- vec_vcmpgtsw --
+
+ function vec_vcmpgtsw
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vcmpgtsw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vcmpgtsw;
+
+ -- vec_vcmpgtuw --
+
+ function vec_vcmpgtuw
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vcmpgtuw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vcmpgtuw;
+
+ -- vec_vcmpgtsh --
+
+ function vec_vcmpgtsh
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vcmpgtsh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vcmpgtsh;
+
+ -- vec_vcmpgtuh --
+
+ function vec_vcmpgtuh
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vcmpgtuh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vcmpgtuh;
+
+ -- vec_vcmpgtsb --
+
+ function vec_vcmpgtsb
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vcmpgtsb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vcmpgtsb;
+
+ -- vec_vcmpgtub --
+
+ function vec_vcmpgtub
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vcmpgtub (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vcmpgtub;
+
+ -- vec_cmple --
+
+ function vec_cmple
+ (A : vector_float;
+ B : vector_float) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vcmpgefp (To_LL_VF (B), To_LL_VF (A)));
+ end vec_cmple;
+
+ -- vec_cmplt --
+
+ function vec_cmplt
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vcmpgtub (To_LL_VSC (B), To_LL_VSC (A)));
+ end vec_cmplt;
+
+ function vec_cmplt
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vcmpgtsb (To_LL_VSC (B), To_LL_VSC (A)));
+ end vec_cmplt;
+
+ function vec_cmplt
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vcmpgtuh (To_LL_VSS (B), To_LL_VSS (A)));
+ end vec_cmplt;
+
+ function vec_cmplt
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vcmpgtsh (To_LL_VSS (B), To_LL_VSS (A)));
+ end vec_cmplt;
+
+ function vec_cmplt
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vcmpgtuw (To_LL_VSI (B), To_LL_VSI (A)));
+ end vec_cmplt;
+
+ function vec_cmplt
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vcmpgtsw (To_LL_VSI (B), To_LL_VSI (A)));
+ end vec_cmplt;
+
+ function vec_cmplt
+ (A : vector_float;
+ B : vector_float) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vcmpgtfp (To_LL_VF (B), To_LL_VF (A)));
+ end vec_cmplt;
+
+ -- vec_expte --
+
+ function vec_expte
+ (A : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vexptefp (To_LL_VF (A)));
+ end vec_expte;
+
+ -- vec_floor --
+
+ function vec_floor
+ (A : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vrfim (To_LL_VF (A)));
+ end vec_floor;
+
+ -- vec_ld --
+
+ function vec_ld
+ (A : c_long;
+ B : const_vector_float_ptr) return vector_float
+ is
+ begin
+ return To_LL_VF (lvx (A, To_PTR (B)));
+ end vec_ld;
+
+ function vec_ld
+ (A : c_long;
+ B : const_float_ptr) return vector_float
+ is
+ begin
+ return To_LL_VF (lvx (A, To_PTR (B)));
+ end vec_ld;
+
+ function vec_ld
+ (A : c_long;
+ B : const_vector_bool_int_ptr) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (lvx (A, To_PTR (B)));
+ end vec_ld;
+
+ function vec_ld
+ (A : c_long;
+ B : const_vector_signed_int_ptr) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (lvx (A, To_PTR (B)));
+ end vec_ld;
+
+ function vec_ld
+ (A : c_long;
+ B : const_int_ptr) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (lvx (A, To_PTR (B)));
+ end vec_ld;
+
+ function vec_ld
+ (A : c_long;
+ B : const_long_ptr) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (lvx (A, To_PTR (B)));
+ end vec_ld;
+
+ function vec_ld
+ (A : c_long;
+ B : const_vector_unsigned_int_ptr) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (lvx (A, To_PTR (B)));
+ end vec_ld;
+
+ function vec_ld
+ (A : c_long;
+ B : const_unsigned_int_ptr) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (lvx (A, To_PTR (B)));
+ end vec_ld;
+
+ function vec_ld
+ (A : c_long;
+ B : const_unsigned_long_ptr) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (lvx (A, To_PTR (B)));
+ end vec_ld;
+
+ function vec_ld
+ (A : c_long;
+ B : const_vector_bool_short_ptr) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (lvx (A, To_PTR (B)));
+ end vec_ld;
+
+ function vec_ld
+ (A : c_long;
+ B : const_vector_pixel_ptr) return vector_pixel
+ is
+ begin
+ return To_LL_VP (lvx (A, To_PTR (B)));
+ end vec_ld;
+
+ function vec_ld
+ (A : c_long;
+ B : const_vector_signed_short_ptr) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (lvx (A, To_PTR (B)));
+ end vec_ld;
+
+ function vec_ld
+ (A : c_long;
+ B : const_short_ptr) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (lvx (A, To_PTR (B)));
+ end vec_ld;
+
+ function vec_ld
+ (A : c_long;
+ B : const_vector_unsigned_short_ptr) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (lvx (A, To_PTR (B)));
+ end vec_ld;
+
+ function vec_ld
+ (A : c_long;
+ B : const_unsigned_short_ptr) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (lvx (A, To_PTR (B)));
+ end vec_ld;
+
+ function vec_ld
+ (A : c_long;
+ B : const_vector_bool_char_ptr) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (lvx (A, To_PTR (B)));
+ end vec_ld;
+
+ function vec_ld
+ (A : c_long;
+ B : const_vector_signed_char_ptr) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (lvx (A, To_PTR (B)));
+ end vec_ld;
+
+ function vec_ld
+ (A : c_long;
+ B : const_signed_char_ptr) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (lvx (A, To_PTR (B)));
+ end vec_ld;
+
+ function vec_ld
+ (A : c_long;
+ B : const_vector_unsigned_char_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvx (A, To_PTR (B)));
+ end vec_ld;
+
+ function vec_ld
+ (A : c_long;
+ B : const_unsigned_char_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvx (A, To_PTR (B)));
+ end vec_ld;
+
+ -- vec_lde --
+
+ function vec_lde
+ (A : c_long;
+ B : const_signed_char_ptr) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (lvebx (A, To_PTR (B)));
+ end vec_lde;
+
+ function vec_lde
+ (A : c_long;
+ B : const_unsigned_char_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvebx (A, To_PTR (B)));
+ end vec_lde;
+
+ function vec_lde
+ (A : c_long;
+ B : const_short_ptr) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (lvehx (A, To_PTR (B)));
+ end vec_lde;
+
+ function vec_lde
+ (A : c_long;
+ B : const_unsigned_short_ptr) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (lvehx (A, To_PTR (B)));
+ end vec_lde;
+
+ function vec_lde
+ (A : c_long;
+ B : const_float_ptr) return vector_float
+ is
+ begin
+ return To_LL_VF (lvewx (A, To_PTR (B)));
+ end vec_lde;
+
+ function vec_lde
+ (A : c_long;
+ B : const_int_ptr) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (lvewx (A, To_PTR (B)));
+ end vec_lde;
+
+ function vec_lde
+ (A : c_long;
+ B : const_unsigned_int_ptr) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (lvewx (A, To_PTR (B)));
+ end vec_lde;
+
+ function vec_lde
+ (A : c_long;
+ B : const_long_ptr) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (lvewx (A, To_PTR (B)));
+ end vec_lde;
+
+ function vec_lde
+ (A : c_long;
+ B : const_unsigned_long_ptr) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (lvewx (A, To_PTR (B)));
+ end vec_lde;
+
+ -- vec_lvewx --
+
+ function vec_lvewx
+ (A : c_long;
+ B : float_ptr) return vector_float
+ is
+ begin
+ return To_LL_VF (lvewx (A, To_PTR (B)));
+ end vec_lvewx;
+
+ function vec_lvewx
+ (A : c_long;
+ B : int_ptr) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (lvewx (A, To_PTR (B)));
+ end vec_lvewx;
+
+ function vec_lvewx
+ (A : c_long;
+ B : unsigned_int_ptr) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (lvewx (A, To_PTR (B)));
+ end vec_lvewx;
+
+ function vec_lvewx
+ (A : c_long;
+ B : long_ptr) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (lvewx (A, To_PTR (B)));
+ end vec_lvewx;
+
+ function vec_lvewx
+ (A : c_long;
+ B : unsigned_long_ptr) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (lvewx (A, To_PTR (B)));
+ end vec_lvewx;
+
+ -- vec_lvehx --
+
+ function vec_lvehx
+ (A : c_long;
+ B : short_ptr) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (lvehx (A, To_PTR (B)));
+ end vec_lvehx;
+
+ function vec_lvehx
+ (A : c_long;
+ B : unsigned_short_ptr) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (lvehx (A, To_PTR (B)));
+ end vec_lvehx;
+
+ -- vec_lvebx --
+
+ function vec_lvebx
+ (A : c_long;
+ B : signed_char_ptr) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (lvebx (A, To_PTR (B)));
+ end vec_lvebx;
+
+ function vec_lvebx
+ (A : c_long;
+ B : unsigned_char_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvebx (A, To_PTR (B)));
+ end vec_lvebx;
+
+ -- vec_ldl --
+
+ function vec_ldl
+ (A : c_long;
+ B : const_vector_float_ptr) return vector_float
+ is
+ begin
+ return To_LL_VF (lvxl (A, To_PTR (B)));
+ end vec_ldl;
+
+ function vec_ldl
+ (A : c_long;
+ B : const_float_ptr) return vector_float
+ is
+ begin
+ return To_LL_VF (lvxl (A, To_PTR (B)));
+ end vec_ldl;
+
+ function vec_ldl
+ (A : c_long;
+ B : const_vector_bool_int_ptr) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (lvxl (A, To_PTR (B)));
+ end vec_ldl;
+
+ function vec_ldl
+ (A : c_long;
+ B : const_vector_signed_int_ptr) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (lvxl (A, To_PTR (B)));
+ end vec_ldl;
+
+ function vec_ldl
+ (A : c_long;
+ B : const_int_ptr) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (lvxl (A, To_PTR (B)));
+ end vec_ldl;
+
+ function vec_ldl
+ (A : c_long;
+ B : const_long_ptr) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (lvxl (A, To_PTR (B)));
+ end vec_ldl;
+
+ function vec_ldl
+ (A : c_long;
+ B : const_vector_unsigned_int_ptr) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (lvxl (A, To_PTR (B)));
+ end vec_ldl;
+
+ function vec_ldl
+ (A : c_long;
+ B : const_unsigned_int_ptr) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (lvxl (A, To_PTR (B)));
+ end vec_ldl;
+
+ function vec_ldl
+ (A : c_long;
+ B : const_unsigned_long_ptr) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (lvxl (A, To_PTR (B)));
+ end vec_ldl;
+
+ function vec_ldl
+ (A : c_long;
+ B : const_vector_bool_short_ptr) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (lvxl (A, To_PTR (B)));
+ end vec_ldl;
+
+ function vec_ldl
+ (A : c_long;
+ B : const_vector_pixel_ptr) return vector_pixel
+ is
+ begin
+ return To_LL_VP (lvxl (A, To_PTR (B)));
+ end vec_ldl;
+
+ function vec_ldl
+ (A : c_long;
+ B : const_vector_signed_short_ptr) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (lvxl (A, To_PTR (B)));
+ end vec_ldl;
+
+ function vec_ldl
+ (A : c_long;
+ B : const_short_ptr) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (lvxl (A, To_PTR (B)));
+ end vec_ldl;
+
+ function vec_ldl
+ (A : c_long;
+ B : const_vector_unsigned_short_ptr) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (lvxl (A, To_PTR (B)));
+ end vec_ldl;
+
+ function vec_ldl
+ (A : c_long;
+ B : const_unsigned_short_ptr) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (lvxl (A, To_PTR (B)));
+ end vec_ldl;
+
+ function vec_ldl
+ (A : c_long;
+ B : const_vector_bool_char_ptr) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (lvxl (A, To_PTR (B)));
+ end vec_ldl;
+
+ function vec_ldl
+ (A : c_long;
+ B : const_vector_signed_char_ptr) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (lvxl (A, To_PTR (B)));
+ end vec_ldl;
+
+ function vec_ldl
+ (A : c_long;
+ B : const_signed_char_ptr) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (lvxl (A, To_PTR (B)));
+ end vec_ldl;
+
+ function vec_ldl
+ (A : c_long;
+ B : const_vector_unsigned_char_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvxl (A, To_PTR (B)));
+ end vec_ldl;
+
+ function vec_ldl
+ (A : c_long;
+ B : const_unsigned_char_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvxl (A, To_PTR (B)));
+ end vec_ldl;
+
+ -- vec_loge --
+
+ function vec_loge
+ (A : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vlogefp (To_LL_VF (A)));
+ end vec_loge;
+
+ -- vec_lvsl --
+
+ function vec_lvsl
+ (A : c_long;
+ B : constv_unsigned_char_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvsl (A, To_PTR (B)));
+ end vec_lvsl;
+
+ function vec_lvsl
+ (A : c_long;
+ B : constv_signed_char_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvsl (A, To_PTR (B)));
+ end vec_lvsl;
+
+ function vec_lvsl
+ (A : c_long;
+ B : constv_unsigned_short_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvsl (A, To_PTR (B)));
+ end vec_lvsl;
+
+ function vec_lvsl
+ (A : c_long;
+ B : constv_short_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvsl (A, To_PTR (B)));
+ end vec_lvsl;
+
+ function vec_lvsl
+ (A : c_long;
+ B : constv_unsigned_int_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvsl (A, To_PTR (B)));
+ end vec_lvsl;
+
+ function vec_lvsl
+ (A : c_long;
+ B : constv_int_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvsl (A, To_PTR (B)));
+ end vec_lvsl;
+
+ function vec_lvsl
+ (A : c_long;
+ B : constv_unsigned_long_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvsl (A, To_PTR (B)));
+ end vec_lvsl;
+
+ function vec_lvsl
+ (A : c_long;
+ B : constv_long_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvsl (A, To_PTR (B)));
+ end vec_lvsl;
+
+ function vec_lvsl
+ (A : c_long;
+ B : constv_float_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvsl (A, To_PTR (B)));
+ end vec_lvsl;
+
+ -- vec_lvsr --
+
+ function vec_lvsr
+ (A : c_long;
+ B : constv_unsigned_char_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvsr (A, To_PTR (B)));
+ end vec_lvsr;
+
+ function vec_lvsr
+ (A : c_long;
+ B : constv_signed_char_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvsr (A, To_PTR (B)));
+ end vec_lvsr;
+
+ function vec_lvsr
+ (A : c_long;
+ B : constv_unsigned_short_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvsr (A, To_PTR (B)));
+ end vec_lvsr;
+
+ function vec_lvsr
+ (A : c_long;
+ B : constv_short_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvsr (A, To_PTR (B)));
+ end vec_lvsr;
+
+ function vec_lvsr
+ (A : c_long;
+ B : constv_unsigned_int_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvsr (A, To_PTR (B)));
+ end vec_lvsr;
+
+ function vec_lvsr
+ (A : c_long;
+ B : constv_int_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvsr (A, To_PTR (B)));
+ end vec_lvsr;
+
+ function vec_lvsr
+ (A : c_long;
+ B : constv_unsigned_long_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvsr (A, To_PTR (B)));
+ end vec_lvsr;
+
+ function vec_lvsr
+ (A : c_long;
+ B : constv_long_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvsr (A, To_PTR (B)));
+ end vec_lvsr;
+
+ function vec_lvsr
+ (A : c_long;
+ B : constv_float_ptr) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (lvsr (A, To_PTR (B)));
+ end vec_lvsr;
+
+ -- vec_madd --
+
+ function vec_madd
+ (A : vector_float;
+ B : vector_float;
+ C : vector_float) return vector_float
+ is
+ begin
+ return vmaddfp (A, B, C);
+ end vec_madd;
+
+ -- vec_madds --
+
+ function vec_madds
+ (A : vector_signed_short;
+ B : vector_signed_short;
+ C : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return vmhaddshs (A, B, C);
+ end vec_madds;
+
+ -- vec_max --
+
+ function vec_max
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vmaxub (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_max;
+
+ function vec_max
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vmaxub (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_max;
+
+ function vec_max
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vmaxub (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_max;
+
+ function vec_max
+ (A : vector_bool_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vmaxsb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_max;
+
+ function vec_max
+ (A : vector_signed_char;
+ B : vector_bool_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vmaxsb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_max;
+
+ function vec_max
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vmaxsb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_max;
+
+ function vec_max
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vmaxuh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_max;
+
+ function vec_max
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vmaxuh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_max;
+
+ function vec_max
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vmaxuh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_max;
+
+ function vec_max
+ (A : vector_bool_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vmaxsh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_max;
+
+ function vec_max
+ (A : vector_signed_short;
+ B : vector_bool_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vmaxsh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_max;
+
+ function vec_max
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vmaxsh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_max;
+
+ function vec_max
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vmaxuw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_max;
+
+ function vec_max
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vmaxuw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_max;
+
+ function vec_max
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vmaxuw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_max;
+
+ function vec_max
+ (A : vector_bool_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vmaxsw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_max;
+
+ function vec_max
+ (A : vector_signed_int;
+ B : vector_bool_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vmaxsw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_max;
+
+ function vec_max
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vmaxsw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_max;
+
+ function vec_max
+ (A : vector_float;
+ B : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vmaxfp (To_LL_VF (A), To_LL_VF (B)));
+ end vec_max;
+
+ -- vec_vmaxfp --
+
+ function vec_vmaxfp
+ (A : vector_float;
+ B : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vmaxfp (To_LL_VF (A), To_LL_VF (B)));
+ end vec_vmaxfp;
+
+ -- vec_vmaxsw --
+
+ function vec_vmaxsw
+ (A : vector_bool_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vmaxsw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vmaxsw;
+
+ function vec_vmaxsw
+ (A : vector_signed_int;
+ B : vector_bool_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vmaxsw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vmaxsw;
+
+ function vec_vmaxsw
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vmaxsw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vmaxsw;
+
+ -- vec_vmaxuw --
+
+ function vec_vmaxuw
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vmaxuw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vmaxuw;
+
+ function vec_vmaxuw
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vmaxuw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vmaxuw;
+
+ function vec_vmaxuw
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vmaxuw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vmaxuw;
+
+ -- vec_vmaxsh --
+
+ function vec_vmaxsh
+ (A : vector_bool_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vmaxsh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vmaxsh;
+
+ function vec_vmaxsh
+ (A : vector_signed_short;
+ B : vector_bool_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vmaxsh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vmaxsh;
+
+ function vec_vmaxsh
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vmaxsh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vmaxsh;
+
+ -- vec_vmaxuh --
+
+ function vec_vmaxuh
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vmaxuh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vmaxuh;
+
+ function vec_vmaxuh
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vmaxuh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vmaxuh;
+
+ function vec_vmaxuh
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vmaxuh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vmaxuh;
+
+ -- vec_vmaxsb --
+
+ function vec_vmaxsb
+ (A : vector_bool_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vmaxsb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vmaxsb;
+
+ function vec_vmaxsb
+ (A : vector_signed_char;
+ B : vector_bool_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vmaxsb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vmaxsb;
+
+ function vec_vmaxsb
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vmaxsb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vmaxsb;
+
+ -- vec_vmaxub --
+
+ function vec_vmaxub
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vmaxub (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vmaxub;
+
+ function vec_vmaxub
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vmaxub (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vmaxub;
+
+ function vec_vmaxub
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vmaxub (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vmaxub;
+
+ -- vec_mergeh --
+
+ function vec_mergeh
+ (A : vector_bool_char;
+ B : vector_bool_char) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vmrghb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_mergeh;
+
+ function vec_mergeh
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vmrghb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_mergeh;
+
+ function vec_mergeh
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vmrghb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_mergeh;
+
+ function vec_mergeh
+ (A : vector_bool_short;
+ B : vector_bool_short) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vmrghh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_mergeh;
+
+ function vec_mergeh
+ (A : vector_pixel;
+ B : vector_pixel) return vector_pixel
+ is
+ begin
+ return To_LL_VP (vmrghh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_mergeh;
+
+ function vec_mergeh
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vmrghh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_mergeh;
+
+ function vec_mergeh
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vmrghh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_mergeh;
+
+ function vec_mergeh
+ (A : vector_float;
+ B : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vmrghw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_mergeh;
+
+ function vec_mergeh
+ (A : vector_bool_int;
+ B : vector_bool_int) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vmrghw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_mergeh;
+
+ function vec_mergeh
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vmrghw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_mergeh;
+
+ function vec_mergeh
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vmrghw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_mergeh;
+
+ -- vec_vmrghw --
+
+ function vec_vmrghw
+ (A : vector_float;
+ B : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vmrghw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vmrghw;
+
+ function vec_vmrghw
+ (A : vector_bool_int;
+ B : vector_bool_int) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vmrghw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vmrghw;
+
+ function vec_vmrghw
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vmrghw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vmrghw;
+
+ function vec_vmrghw
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vmrghw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vmrghw;
+
+ -- vec_vmrghh --
+
+ function vec_vmrghh
+ (A : vector_bool_short;
+ B : vector_bool_short) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vmrghh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vmrghh;
+
+ function vec_vmrghh
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vmrghh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vmrghh;
+
+ function vec_vmrghh
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vmrghh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vmrghh;
+
+ function vec_vmrghh
+ (A : vector_pixel;
+ B : vector_pixel) return vector_pixel
+ is
+ begin
+ return To_LL_VP (vmrghh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vmrghh;
+
+ -- vec_vmrghb --
+
+ function vec_vmrghb
+ (A : vector_bool_char;
+ B : vector_bool_char) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vmrghb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vmrghb;
+
+ function vec_vmrghb
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vmrghb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vmrghb;
+
+ function vec_vmrghb
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vmrghb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vmrghb;
+
+ -- vec_mergel --
+
+ function vec_mergel
+ (A : vector_bool_char;
+ B : vector_bool_char) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vmrglb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_mergel;
+
+ function vec_mergel
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vmrglb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_mergel;
+
+ function vec_mergel
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vmrglb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_mergel;
+
+ function vec_mergel
+ (A : vector_bool_short;
+ B : vector_bool_short) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vmrglh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_mergel;
+
+ function vec_mergel
+ (A : vector_pixel;
+ B : vector_pixel) return vector_pixel
+ is
+ begin
+ return To_LL_VP (vmrglh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_mergel;
+
+ function vec_mergel
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vmrglh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_mergel;
+
+ function vec_mergel
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vmrglh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_mergel;
+
+ function vec_mergel
+ (A : vector_float;
+ B : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vmrglw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_mergel;
+
+ function vec_mergel
+ (A : vector_bool_int;
+ B : vector_bool_int) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vmrglw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_mergel;
+
+ function vec_mergel
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vmrglw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_mergel;
+
+ function vec_mergel
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vmrglw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_mergel;
+
+ -- vec_vmrglw --
+
+ function vec_vmrglw
+ (A : vector_float;
+ B : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vmrglw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vmrglw;
+
+ function vec_vmrglw
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vmrglw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vmrglw;
+
+ function vec_vmrglw
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vmrglw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vmrglw;
+
+ function vec_vmrglw
+ (A : vector_bool_int;
+ B : vector_bool_int) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vmrglw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vmrglw;
+
+ -- vec_vmrglh --
+
+ function vec_vmrglh
+ (A : vector_bool_short;
+ B : vector_bool_short) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vmrglh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vmrglh;
+
+ function vec_vmrglh
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vmrglh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vmrglh;
+
+ function vec_vmrglh
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vmrglh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vmrglh;
+
+ function vec_vmrglh
+ (A : vector_pixel;
+ B : vector_pixel) return vector_pixel
+ is
+ begin
+ return To_LL_VP (vmrglh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vmrglh;
+
+ -- vec_vmrglb --
+
+ function vec_vmrglb
+ (A : vector_bool_char;
+ B : vector_bool_char) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vmrglb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vmrglb;
+
+ function vec_vmrglb
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vmrglb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vmrglb;
+
+ function vec_vmrglb
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vmrglb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vmrglb;
+
+ -- vec_mfvscr --
+
+ function vec_mfvscr return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (mfvscr);
+ end vec_mfvscr;
+
+ -- vec_min --
+
+ function vec_min
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vminub (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_min;
+
+ function vec_min
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vminub (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_min;
+
+ function vec_min
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vminub (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_min;
+
+ function vec_min
+ (A : vector_bool_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vminsb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_min;
+
+ function vec_min
+ (A : vector_signed_char;
+ B : vector_bool_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vminsb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_min;
+
+ function vec_min
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vminsb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_min;
+
+ function vec_min
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vminuh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_min;
+
+ function vec_min
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vminuh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_min;
+
+ function vec_min
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vminuh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_min;
+
+ function vec_min
+ (A : vector_bool_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vminsh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_min;
+
+ function vec_min
+ (A : vector_signed_short;
+ B : vector_bool_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vminsh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_min;
+
+ function vec_min
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vminsh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_min;
+
+ function vec_min
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vminuw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_min;
+
+ function vec_min
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vminuw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_min;
+
+ function vec_min
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vminuw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_min;
+
+ function vec_min
+ (A : vector_bool_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vminsw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_min;
+
+ function vec_min
+ (A : vector_signed_int;
+ B : vector_bool_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vminsw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_min;
+
+ function vec_min
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vminsw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_min;
+
+ function vec_min
+ (A : vector_float;
+ B : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vminfp (To_LL_VF (A), To_LL_VF (B)));
+ end vec_min;
+
+ -- vec_vminfp --
+
+ function vec_vminfp
+ (A : vector_float;
+ B : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vminfp (To_LL_VF (A), To_LL_VF (B)));
+ end vec_vminfp;
+
+ -- vec_vminsw --
+
+ function vec_vminsw
+ (A : vector_bool_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vminsw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vminsw;
+
+ function vec_vminsw
+ (A : vector_signed_int;
+ B : vector_bool_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vminsw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vminsw;
+
+ function vec_vminsw
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vminsw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vminsw;
+
+ -- vec_vminuw --
+
+ function vec_vminuw
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vminuw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vminuw;
+
+ function vec_vminuw
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vminuw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vminuw;
+
+ function vec_vminuw
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vminuw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vminuw;
+
+ -- vec_vminsh --
+
+ function vec_vminsh
+ (A : vector_bool_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vminsh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vminsh;
+
+ function vec_vminsh
+ (A : vector_signed_short;
+ B : vector_bool_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vminsh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vminsh;
+
+ function vec_vminsh
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vminsh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vminsh;
+
+ -- vec_vminuh --
+
+ function vec_vminuh
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vminuh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vminuh;
+
+ function vec_vminuh
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vminuh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vminuh;
+
+ function vec_vminuh
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vminuh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vminuh;
+
+ -- vec_vminsb --
+
+ function vec_vminsb
+ (A : vector_bool_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vminsb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vminsb;
+
+ function vec_vminsb
+ (A : vector_signed_char;
+ B : vector_bool_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vminsb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vminsb;
+
+ function vec_vminsb
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vminsb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vminsb;
+
+ -- vec_vminub --
+
+ function vec_vminub
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vminub (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vminub;
+
+ function vec_vminub
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vminub (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vminub;
+
+ function vec_vminub
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vminub (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vminub;
+
+ -- vec_mladd --
+
+ function vec_mladd
+ (A : vector_signed_short;
+ B : vector_signed_short;
+ C : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return vmladduhm (A, B, C);
+ end vec_mladd;
+
+ function vec_mladd
+ (A : vector_signed_short;
+ B : vector_unsigned_short;
+ C : vector_unsigned_short) return vector_signed_short
+ is
+ begin
+ return vmladduhm (A, To_LL_VSS (B), To_LL_VSS (C));
+ end vec_mladd;
+
+ function vec_mladd
+ (A : vector_unsigned_short;
+ B : vector_signed_short;
+ C : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return vmladduhm (To_LL_VSS (A), B, C);
+ end vec_mladd;
+
+ function vec_mladd
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short;
+ C : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return
+ To_LL_VUS (vmladduhm (To_LL_VSS (A), To_LL_VSS (B), To_LL_VSS (C)));
+ end vec_mladd;
+
+ -- vec_mradds --
+
+ function vec_mradds
+ (A : vector_signed_short;
+ B : vector_signed_short;
+ C : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return vmhraddshs (A, B, C);
+ end vec_mradds;
+
+ -- vec_msum --
+
+ function vec_msum
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char;
+ C : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return
+ To_LL_VUI (vmsumubm (To_LL_VSC (A), To_LL_VSC (B), To_LL_VSI (C)));
+ end vec_msum;
+
+ function vec_msum
+ (A : vector_signed_char;
+ B : vector_unsigned_char;
+ C : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return
+ To_LL_VSI (vmsummbm (To_LL_VSC (A), To_LL_VSC (B), To_LL_VSI (C)));
+ end vec_msum;
+
+ function vec_msum
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short;
+ C : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return
+ To_LL_VUI (vmsumuhm (To_LL_VSS (A), To_LL_VSS (B), To_LL_VSI (C)));
+ end vec_msum;
+
+ function vec_msum
+ (A : vector_signed_short;
+ B : vector_signed_short;
+ C : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return
+ To_LL_VSI (vmsumshm (To_LL_VSS (A), To_LL_VSS (B), To_LL_VSI (C)));
+ end vec_msum;
+
+ -- vec_vmsumshm --
+
+ function vec_vmsumshm
+ (A : vector_signed_short;
+ B : vector_signed_short;
+ C : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return
+ To_LL_VSI (vmsumshm (To_LL_VSS (A), To_LL_VSS (B), To_LL_VSI (C)));
+ end vec_vmsumshm;
+
+ -- vec_vmsumuhm --
+
+ function vec_vmsumuhm
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short;
+ C : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return
+ To_LL_VUI (vmsumuhm (To_LL_VSS (A), To_LL_VSS (B), To_LL_VSI (C)));
+ end vec_vmsumuhm;
+
+ -- vec_vmsummbm --
+
+ function vec_vmsummbm
+ (A : vector_signed_char;
+ B : vector_unsigned_char;
+ C : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return
+ To_LL_VSI (vmsummbm (To_LL_VSC (A), To_LL_VSC (B), To_LL_VSI (C)));
+ end vec_vmsummbm;
+
+ -- vec_vmsumubm --
+
+ function vec_vmsumubm
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char;
+ C : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return
+ To_LL_VUI (vmsumubm (To_LL_VSC (A), To_LL_VSC (B), To_LL_VSI (C)));
+ end vec_vmsumubm;
+
+ -- vec_msums --
+
+ function vec_msums
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short;
+ C : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return
+ To_LL_VUI (vmsumuhs (To_LL_VSS (A), To_LL_VSS (B), To_LL_VSI (C)));
+ end vec_msums;
+
+ function vec_msums
+ (A : vector_signed_short;
+ B : vector_signed_short;
+ C : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return
+ To_LL_VSI (vmsumshs (To_LL_VSS (A), To_LL_VSS (B), To_LL_VSI (C)));
+ end vec_msums;
+
+ -- vec_vmsumshs --
+
+ function vec_vmsumshs
+ (A : vector_signed_short;
+ B : vector_signed_short;
+ C : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return
+ To_LL_VSI (vmsumshs (To_LL_VSS (A), To_LL_VSS (B), To_LL_VSI (C)));
+ end vec_vmsumshs;
+
+ -- vec_vmsumuhs --
+
+ function vec_vmsumuhs
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short;
+ C : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return
+ To_LL_VUI (vmsumuhs (To_LL_VSS (A), To_LL_VSS (B), To_LL_VSI (C)));
+ end vec_vmsumuhs;
+
+ -- vec_mtvscr --
+
+ procedure vec_mtvscr
+ (A : vector_signed_int)
+ is
+ begin
+ mtvscr (To_LL_VSI (A));
+ end vec_mtvscr;
+
+ procedure vec_mtvscr
+ (A : vector_unsigned_int)
+ is
+ begin
+ mtvscr (To_LL_VSI (A));
+ end vec_mtvscr;
+
+ procedure vec_mtvscr
+ (A : vector_bool_int)
+ is
+ begin
+ mtvscr (To_LL_VSI (A));
+ end vec_mtvscr;
+
+ procedure vec_mtvscr
+ (A : vector_signed_short)
+ is
+ begin
+ mtvscr (To_LL_VSI (A));
+ end vec_mtvscr;
+
+ procedure vec_mtvscr
+ (A : vector_unsigned_short)
+ is
+ begin
+ mtvscr (To_LL_VSI (A));
+ end vec_mtvscr;
+
+ procedure vec_mtvscr
+ (A : vector_bool_short)
+ is
+ begin
+ mtvscr (To_LL_VSI (A));
+ end vec_mtvscr;
+
+ procedure vec_mtvscr
+ (A : vector_pixel)
+ is
+ begin
+ mtvscr (To_LL_VSI (A));
+ end vec_mtvscr;
+
+ procedure vec_mtvscr
+ (A : vector_signed_char)
+ is
+ begin
+ mtvscr (To_LL_VSI (A));
+ end vec_mtvscr;
+
+ procedure vec_mtvscr
+ (A : vector_unsigned_char)
+ is
+ begin
+ mtvscr (To_LL_VSI (A));
+ end vec_mtvscr;
+
+ procedure vec_mtvscr
+ (A : vector_bool_char)
+ is
+ begin
+ mtvscr (To_LL_VSI (A));
+ end vec_mtvscr;
+
+ -- vec_mule --
+
+ function vec_mule
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vmuleub (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_mule;
+
+ function vec_mule
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vmulesb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_mule;
+
+ function vec_mule
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vmuleuh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_mule;
+
+ function vec_mule
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vmulesh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_mule;
+
+ -- vec_vmulesh --
+
+ function vec_vmulesh
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vmulesh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vmulesh;
+
+ -- vec_vmuleuh --
+
+ function vec_vmuleuh
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vmuleuh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vmuleuh;
+
+ -- vec_vmulesb --
+
+ function vec_vmulesb
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vmuleub (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vmulesb;
+
+ -- vec_vmuleub --
+
+ function vec_vmuleub
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vmuleub (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vmuleub;
+
+ -- vec_mulo --
+
+ function vec_mulo
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vmuloub (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_mulo;
+
+ function vec_mulo
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vmulosb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_mulo;
+
+ function vec_mulo
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vmulouh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_mulo;
+
+ function vec_mulo
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vmulosh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_mulo;
+
+ -- vec_vmulosh --
+
+ function vec_vmulosh
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vmulosh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vmulosh;
+
+ -- vec_vmulouh --
+
+ function vec_vmulouh
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vmulouh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vmulouh;
+
+ -- vec_vmulosb --
+
+ function vec_vmulosb
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vmulosb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vmulosb;
+
+ -- vec_vmuloub --
+
+ function vec_vmuloub
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vmuloub (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vmuloub;
+
+ -- vec_nmsub --
+
+ function vec_nmsub
+ (A : vector_float;
+ B : vector_float;
+ C : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vnmsubfp (To_LL_VF (A), To_LL_VF (B), To_LL_VF (C)));
+ end vec_nmsub;
+
+ -- vec_nor --
+
+ function vec_nor
+ (A : vector_float;
+ B : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vnor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_nor;
+
+ function vec_nor
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vnor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_nor;
+
+ function vec_nor
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vnor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_nor;
+
+ function vec_nor
+ (A : vector_bool_int;
+ B : vector_bool_int) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vnor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_nor;
+
+ function vec_nor
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vnor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_nor;
+
+ function vec_nor
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vnor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_nor;
+
+ function vec_nor
+ (A : vector_bool_short;
+ B : vector_bool_short) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vnor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_nor;
+
+ function vec_nor
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vnor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_nor;
+
+ function vec_nor
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vnor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_nor;
+
+ function vec_nor
+ (A : vector_bool_char;
+ B : vector_bool_char) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vnor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_nor;
+
+ -- vec_or --
+
+ function vec_or
+ (A : vector_float;
+ B : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_float;
+ B : vector_bool_int) return vector_float
+ is
+ begin
+ return To_LL_VF (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_bool_int;
+ B : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_bool_int;
+ B : vector_bool_int) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_bool_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_signed_int;
+ B : vector_bool_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_bool_short;
+ B : vector_bool_short) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_bool_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_signed_short;
+ B : vector_bool_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_bool_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_bool_char;
+ B : vector_bool_char) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_signed_char;
+ B : vector_bool_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ function vec_or
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_or;
+
+ -- vec_pack --
+
+ function vec_pack
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vpkuhum (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_pack;
+
+ function vec_pack
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vpkuhum (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_pack;
+
+ function vec_pack
+ (A : vector_bool_short;
+ B : vector_bool_short) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vpkuhum (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_pack;
+
+ function vec_pack
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vpkuwum (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_pack;
+
+ function vec_pack
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vpkuwum (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_pack;
+
+ function vec_pack
+ (A : vector_bool_int;
+ B : vector_bool_int) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vpkuwum (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_pack;
+
+ -- vec_vpkuwum --
+
+ function vec_vpkuwum
+ (A : vector_bool_int;
+ B : vector_bool_int) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vpkuwum (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vpkuwum;
+
+ function vec_vpkuwum
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vpkuwum (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vpkuwum;
+
+ function vec_vpkuwum
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vpkuwum (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vpkuwum;
+
+ -- vec_vpkuhum --
+
+ function vec_vpkuhum
+ (A : vector_bool_short;
+ B : vector_bool_short) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vpkuhum (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vpkuhum;
+
+ function vec_vpkuhum
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vpkuhum (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vpkuhum;
+
+ function vec_vpkuhum
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vpkuhum (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vpkuhum;
+
+ -- vec_packpx --
+
+ function vec_packpx
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_pixel
+ is
+ begin
+ return To_LL_VP (vpkpx (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_packpx;
+
+ -- vec_packs --
+
+ function vec_packs
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vpkuhus (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_packs;
+
+ function vec_packs
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vpkshss (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_packs;
+
+ function vec_packs
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vpkuwus (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_packs;
+
+ function vec_packs
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vpkswss (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_packs;
+
+ -- vec_vpkswss --
+
+ function vec_vpkswss
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vpkswss (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vpkswss;
+
+ -- vec_vpkuwus --
+
+ function vec_vpkuwus
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vpkuwus (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vpkuwus;
+
+ -- vec_vpkshss --
+
+ function vec_vpkshss
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vpkshss (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vpkshss;
+
+ -- vec_vpkuhus --
+
+ function vec_vpkuhus
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vpkuhus (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vpkuhus;
+
+ -- vec_packsu --
+
+ function vec_packsu
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vpkuhus (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_packsu;
+
+ function vec_packsu
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vpkshus (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_packsu;
+
+ function vec_packsu
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vpkuwus (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_packsu;
+
+ function vec_packsu
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vpkswus (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_packsu;
+
+ -- vec_vpkswus --
+
+ function vec_vpkswus
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vpkswus (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vpkswus;
+
+ -- vec_vpkshus --
+
+ function vec_vpkshus
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vpkshus (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vpkshus;
+
+ -- vec_perm --
+
+ function vec_perm
+ (A : vector_float;
+ B : vector_float;
+ C : vector_unsigned_char) return vector_float
+ is
+ begin
+ return
+ To_LL_VF (vperm_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSC (C)));
+ end vec_perm;
+
+ function vec_perm
+ (A : vector_signed_int;
+ B : vector_signed_int;
+ C : vector_unsigned_char) return vector_signed_int
+ is
+ begin
+ return
+ To_LL_VSI (vperm_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSC (C)));
+ end vec_perm;
+
+ function vec_perm
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int;
+ C : vector_unsigned_char) return vector_unsigned_int
+ is
+ begin
+ return
+ To_LL_VUI (vperm_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSC (C)));
+ end vec_perm;
+
+ function vec_perm
+ (A : vector_bool_int;
+ B : vector_bool_int;
+ C : vector_unsigned_char) return vector_bool_int
+ is
+ begin
+ return
+ To_LL_VBI (vperm_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSC (C)));
+ end vec_perm;
+
+ function vec_perm
+ (A : vector_signed_short;
+ B : vector_signed_short;
+ C : vector_unsigned_char) return vector_signed_short
+ is
+ begin
+ return
+ To_LL_VSS (vperm_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSC (C)));
+ end vec_perm;
+
+ function vec_perm
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short;
+ C : vector_unsigned_char) return vector_unsigned_short
+ is
+ begin
+ return
+ To_LL_VUS (vperm_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSC (C)));
+ end vec_perm;
+
+ function vec_perm
+ (A : vector_bool_short;
+ B : vector_bool_short;
+ C : vector_unsigned_char) return vector_bool_short
+ is
+ begin
+ return
+ To_LL_VBS (vperm_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSC (C)));
+ end vec_perm;
+
+ function vec_perm
+ (A : vector_pixel;
+ B : vector_pixel;
+ C : vector_unsigned_char) return vector_pixel
+ is
+ begin
+ return To_LL_VP
+ (vperm_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSC (C)));
+ end vec_perm;
+
+ function vec_perm
+ (A : vector_signed_char;
+ B : vector_signed_char;
+ C : vector_unsigned_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC
+ (vperm_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSC (C)));
+ end vec_perm;
+
+ function vec_perm
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char;
+ C : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return
+ To_LL_VUC (vperm_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSC (C)));
+ end vec_perm;
+
+ function vec_perm
+ (A : vector_bool_char;
+ B : vector_bool_char;
+ C : vector_unsigned_char) return vector_bool_char
+ is
+ begin
+ return
+ To_LL_VBC (vperm_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSC (C)));
+ end vec_perm;
+
+ -- vec_re --
+
+ function vec_re
+ (A : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vrefp (To_LL_VF (A)));
+ end vec_re;
+
+ -- vec_rl --
+
+ function vec_rl
+ (A : vector_signed_char;
+ B : vector_unsigned_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vrlb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_rl;
+
+ function vec_rl
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vrlb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_rl;
+
+ function vec_rl
+ (A : vector_signed_short;
+ B : vector_unsigned_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vrlh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_rl;
+
+ function vec_rl
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vrlh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_rl;
+
+ function vec_rl
+ (A : vector_signed_int;
+ B : vector_unsigned_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vrlw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_rl;
+
+ function vec_rl
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vrlw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_rl;
+
+ -- vec_vrlw --
+
+ function vec_vrlw
+ (A : vector_signed_int;
+ B : vector_unsigned_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vrlw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vrlw;
+
+ function vec_vrlw
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vrlw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vrlw;
+
+ -- vec_vrlh --
+
+ function vec_vrlh
+ (A : vector_signed_short;
+ B : vector_unsigned_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vrlh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vrlh;
+
+ function vec_vrlh
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vrlh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vrlh;
+
+ -- vec_vrlb --
+
+ function vec_vrlb
+ (A : vector_signed_char;
+ B : vector_unsigned_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vrlb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vrlb;
+
+ function vec_vrlb
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vrlb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vrlb;
+
+ -- vec_round --
+
+ function vec_round
+ (A : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vrfin (To_LL_VF (A)));
+ end vec_round;
+
+ -- vec_rsqrte --
+
+ function vec_rsqrte
+ (A : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vrsqrtefp (To_LL_VF (A)));
+ end vec_rsqrte;
+
+ -- vec_sel --
+
+ function vec_sel
+ (A : vector_float;
+ B : vector_float;
+ C : vector_bool_int) return vector_float
+ is
+ begin
+ return To_LL_VF (vsel_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSI (C)));
+ end vec_sel;
+
+ function vec_sel
+ (A : vector_float;
+ B : vector_float;
+ C : vector_unsigned_int) return vector_float
+ is
+ begin
+ return To_LL_VF (vsel_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSI (C)));
+ end vec_sel;
+
+ function vec_sel
+ (A : vector_signed_int;
+ B : vector_signed_int;
+ C : vector_bool_int) return vector_signed_int
+ is
+ begin
+ return
+ To_LL_VSI (vsel_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSI (C)));
+ end vec_sel;
+
+ function vec_sel
+ (A : vector_signed_int;
+ B : vector_signed_int;
+ C : vector_unsigned_int) return vector_signed_int
+ is
+ begin
+ return
+ To_LL_VSI (vsel_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSI (C)));
+ end vec_sel;
+
+ function vec_sel
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int;
+ C : vector_bool_int) return vector_unsigned_int
+ is
+ begin
+ return
+ To_LL_VUI (vsel_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSI (C)));
+ end vec_sel;
+
+ function vec_sel
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int;
+ C : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return
+ To_LL_VUI (vsel_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSI (C)));
+ end vec_sel;
+
+ function vec_sel
+ (A : vector_bool_int;
+ B : vector_bool_int;
+ C : vector_bool_int) return vector_bool_int
+ is
+ begin
+ return
+ To_LL_VBI (vsel_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSI (C)));
+ end vec_sel;
+
+ function vec_sel
+ (A : vector_bool_int;
+ B : vector_bool_int;
+ C : vector_unsigned_int) return vector_bool_int
+ is
+ begin
+ return
+ To_LL_VBI (vsel_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSI (C)));
+ end vec_sel;
+
+ function vec_sel
+ (A : vector_signed_short;
+ B : vector_signed_short;
+ C : vector_bool_short) return vector_signed_short
+ is
+ begin
+ return
+ To_LL_VSS (vsel_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSI (C)));
+ end vec_sel;
+
+ function vec_sel
+ (A : vector_signed_short;
+ B : vector_signed_short;
+ C : vector_unsigned_short) return vector_signed_short
+ is
+ begin
+ return
+ To_LL_VSS (vsel_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSI (C)));
+ end vec_sel;
+
+ function vec_sel
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short;
+ C : vector_bool_short) return vector_unsigned_short
+ is
+ begin
+ return
+ To_LL_VUS (vsel_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSI (C)));
+ end vec_sel;
+
+ function vec_sel
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short;
+ C : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return
+ To_LL_VUS (vsel_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSI (C)));
+ end vec_sel;
+
+ function vec_sel
+ (A : vector_bool_short;
+ B : vector_bool_short;
+ C : vector_bool_short) return vector_bool_short
+ is
+ begin
+ return
+ To_LL_VBS (vsel_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSI (C)));
+ end vec_sel;
+
+ function vec_sel
+ (A : vector_bool_short;
+ B : vector_bool_short;
+ C : vector_unsigned_short) return vector_bool_short
+ is
+ begin
+ return
+ To_LL_VBS (vsel_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSI (C)));
+ end vec_sel;
+
+ function vec_sel
+ (A : vector_signed_char;
+ B : vector_signed_char;
+ C : vector_bool_char) return vector_signed_char
+ is
+ begin
+ return
+ To_LL_VSC (vsel_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSI (C)));
+ end vec_sel;
+
+ function vec_sel
+ (A : vector_signed_char;
+ B : vector_signed_char;
+ C : vector_unsigned_char) return vector_signed_char
+ is
+ begin
+ return
+ To_LL_VSC (vsel_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSI (C)));
+ end vec_sel;
+
+ function vec_sel
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char;
+ C : vector_bool_char) return vector_unsigned_char
+ is
+ begin
+ return
+ To_LL_VUC (vsel_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSI (C)));
+ end vec_sel;
+
+ function vec_sel
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char;
+ C : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return
+ To_LL_VUC (vsel_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSI (C)));
+ end vec_sel;
+
+ function vec_sel
+ (A : vector_bool_char;
+ B : vector_bool_char;
+ C : vector_bool_char) return vector_bool_char
+ is
+ begin
+ return
+ To_LL_VBC (vsel_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSI (C)));
+ end vec_sel;
+
+ function vec_sel
+ (A : vector_bool_char;
+ B : vector_bool_char;
+ C : vector_unsigned_char) return vector_bool_char
+ is
+ begin
+ return
+ To_LL_VBC (vsel_4si (To_LL_VSI (A), To_LL_VSI (B), To_LL_VSI (C)));
+ end vec_sel;
+
+ -- vec_sl --
+
+ function vec_sl
+ (A : vector_signed_char;
+ B : vector_unsigned_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vslb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_sl;
+
+ function vec_sl
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vslb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_sl;
+
+ function vec_sl
+ (A : vector_signed_short;
+ B : vector_unsigned_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vslh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_sl;
+
+ function vec_sl
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vslh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_sl;
+
+ function vec_sl
+ (A : vector_signed_int;
+ B : vector_unsigned_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vslw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sl;
+
+ function vec_sl
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vslw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sl;
+
+ -- vec_vslw --
+
+ function vec_vslw
+ (A : vector_signed_int;
+ B : vector_unsigned_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vslw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vslw;
+
+ function vec_vslw
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vslw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vslw;
+
+ -- vec_vslh --
+
+ function vec_vslh
+ (A : vector_signed_short;
+ B : vector_unsigned_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vslh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vslh;
+
+ function vec_vslh
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vslh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vslh;
+
+ -- vec_vslb --
+
+ function vec_vslb
+ (A : vector_signed_char;
+ B : vector_unsigned_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vslb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vslb;
+
+ function vec_vslb
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vslb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vslb;
+
+ -- vec_sll --
+
+ function vec_sll
+ (A : vector_signed_int;
+ B : vector_unsigned_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_signed_int;
+ B : vector_unsigned_short) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_signed_int;
+ B : vector_unsigned_char) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_unsigned_int;
+ B : vector_unsigned_short) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_unsigned_int;
+ B : vector_unsigned_char) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_bool_int;
+ B : vector_unsigned_short) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_bool_int;
+ B : vector_unsigned_char) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_signed_short;
+ B : vector_unsigned_int) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_signed_short;
+ B : vector_unsigned_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_signed_short;
+ B : vector_unsigned_char) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_unsigned_short;
+ B : vector_unsigned_int) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_unsigned_short;
+ B : vector_unsigned_char) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_bool_short;
+ B : vector_unsigned_int) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_bool_short;
+ B : vector_unsigned_char) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_pixel;
+ B : vector_unsigned_int) return vector_pixel
+ is
+ begin
+ return To_LL_VP (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_pixel;
+ B : vector_unsigned_short) return vector_pixel
+ is
+ begin
+ return To_LL_VP (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_pixel;
+ B : vector_unsigned_char) return vector_pixel
+ is
+ begin
+ return To_LL_VP (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_signed_char;
+ B : vector_unsigned_int) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_signed_char;
+ B : vector_unsigned_short) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_signed_char;
+ B : vector_unsigned_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_unsigned_char;
+ B : vector_unsigned_int) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_unsigned_char;
+ B : vector_unsigned_short) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_bool_char;
+ B : vector_unsigned_int) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_bool_char;
+ B : vector_unsigned_short) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ function vec_sll
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vsl (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sll;
+
+ -- vec_slo --
+
+ function vec_slo
+ (A : vector_float;
+ B : vector_signed_char) return vector_float
+ is
+ begin
+ return To_LL_VF (vslo (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_slo;
+
+ function vec_slo
+ (A : vector_float;
+ B : vector_unsigned_char) return vector_float
+ is
+ begin
+ return To_LL_VF (vslo (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_slo;
+
+ function vec_slo
+ (A : vector_signed_int;
+ B : vector_signed_char) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vslo (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_slo;
+
+ function vec_slo
+ (A : vector_signed_int;
+ B : vector_unsigned_char) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vslo (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_slo;
+
+ function vec_slo
+ (A : vector_unsigned_int;
+ B : vector_signed_char) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vslo (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_slo;
+
+ function vec_slo
+ (A : vector_unsigned_int;
+ B : vector_unsigned_char) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vslo (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_slo;
+
+ function vec_slo
+ (A : vector_signed_short;
+ B : vector_signed_char) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vslo (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_slo;
+
+ function vec_slo
+ (A : vector_signed_short;
+ B : vector_unsigned_char) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vslo (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_slo;
+
+ function vec_slo
+ (A : vector_unsigned_short;
+ B : vector_signed_char) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vslo (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_slo;
+
+ function vec_slo
+ (A : vector_unsigned_short;
+ B : vector_unsigned_char) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vslo (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_slo;
+
+ function vec_slo
+ (A : vector_pixel;
+ B : vector_signed_char) return vector_pixel
+ is
+ begin
+ return To_LL_VP (vslo (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_slo;
+
+ function vec_slo
+ (A : vector_pixel;
+ B : vector_unsigned_char) return vector_pixel
+ is
+ begin
+ return To_LL_VP (vslo (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_slo;
+
+ function vec_slo
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vslo (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_slo;
+
+ function vec_slo
+ (A : vector_signed_char;
+ B : vector_unsigned_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vslo (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_slo;
+
+ function vec_slo
+ (A : vector_unsigned_char;
+ B : vector_signed_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vslo (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_slo;
+
+ function vec_slo
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vslo (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_slo;
+
+ -- vec_sr --
+
+ function vec_sr
+ (A : vector_signed_char;
+ B : vector_unsigned_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsrb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_sr;
+
+ function vec_sr
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsrb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_sr;
+
+ function vec_sr
+ (A : vector_signed_short;
+ B : vector_unsigned_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsrh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_sr;
+
+ function vec_sr
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsrh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_sr;
+
+ function vec_sr
+ (A : vector_signed_int;
+ B : vector_unsigned_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsrw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sr;
+
+ function vec_sr
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsrw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sr;
+
+ -- vec_vsrw --
+
+ function vec_vsrw
+ (A : vector_signed_int;
+ B : vector_unsigned_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsrw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vsrw;
+
+ function vec_vsrw
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsrw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vsrw;
+
+ -- vec_vsrh --
+
+ function vec_vsrh
+ (A : vector_signed_short;
+ B : vector_unsigned_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsrh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vsrh;
+
+ function vec_vsrh
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsrh (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vsrh;
+
+ -- vec_vsrb --
+
+ function vec_vsrb
+ (A : vector_signed_char;
+ B : vector_unsigned_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsrb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vsrb;
+
+ function vec_vsrb
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsrb (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vsrb;
+
+ -- vec_sra --
+
+ function vec_sra
+ (A : vector_signed_char;
+ B : vector_unsigned_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsrab (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_sra;
+
+ function vec_sra
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsrab (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_sra;
+
+ function vec_sra
+ (A : vector_signed_short;
+ B : vector_unsigned_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsrah (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_sra;
+
+ function vec_sra
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsrah (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_sra;
+
+ function vec_sra
+ (A : vector_signed_int;
+ B : vector_unsigned_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsraw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sra;
+
+ function vec_sra
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsraw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sra;
+
+ -- vec_vsraw --
+
+ function vec_vsraw
+ (A : vector_signed_int;
+ B : vector_unsigned_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsraw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vsraw;
+
+ function vec_vsraw
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsraw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vsraw;
+
+ -- vec_vsrah --
+
+ function vec_vsrah
+ (A : vector_signed_short;
+ B : vector_unsigned_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsrah (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vsrah;
+
+ function vec_vsrah
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsrah (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vsrah;
+
+ -- vec_vsrab --
+
+ function vec_vsrab
+ (A : vector_signed_char;
+ B : vector_unsigned_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsrab (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vsrab;
+
+ function vec_vsrab
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsrab (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vsrab;
+
+ -- vec_srl --
+
+ function vec_srl
+ (A : vector_signed_int;
+ B : vector_unsigned_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_signed_int;
+ B : vector_unsigned_short) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_signed_int;
+ B : vector_unsigned_char) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_unsigned_int;
+ B : vector_unsigned_short) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_unsigned_int;
+ B : vector_unsigned_char) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_bool_int;
+ B : vector_unsigned_short) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_bool_int;
+ B : vector_unsigned_char) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_signed_short;
+ B : vector_unsigned_int) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_signed_short;
+ B : vector_unsigned_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_signed_short;
+ B : vector_unsigned_char) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_unsigned_short;
+ B : vector_unsigned_int) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_unsigned_short;
+ B : vector_unsigned_char) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_bool_short;
+ B : vector_unsigned_int) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_bool_short;
+ B : vector_unsigned_char) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_pixel;
+ B : vector_unsigned_int) return vector_pixel
+ is
+ begin
+ return To_LL_VP (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_pixel;
+ B : vector_unsigned_short) return vector_pixel
+ is
+ begin
+ return To_LL_VP (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_pixel;
+ B : vector_unsigned_char) return vector_pixel
+ is
+ begin
+ return To_LL_VP (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_signed_char;
+ B : vector_unsigned_int) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_signed_char;
+ B : vector_unsigned_short) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_signed_char;
+ B : vector_unsigned_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_unsigned_char;
+ B : vector_unsigned_int) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_unsigned_char;
+ B : vector_unsigned_short) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_bool_char;
+ B : vector_unsigned_int) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_bool_char;
+ B : vector_unsigned_short) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ function vec_srl
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vsr (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_srl;
+
+ -- vec_sro --
+
+ function vec_sro
+ (A : vector_float;
+ B : vector_signed_char) return vector_float
+ is
+ begin
+ return To_LL_VF (vsro (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sro;
+
+ function vec_sro
+ (A : vector_float;
+ B : vector_unsigned_char) return vector_float
+ is
+ begin
+ return To_LL_VF (vsro (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sro;
+
+ function vec_sro
+ (A : vector_signed_int;
+ B : vector_signed_char) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsro (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sro;
+
+ function vec_sro
+ (A : vector_signed_int;
+ B : vector_unsigned_char) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsro (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sro;
+
+ function vec_sro
+ (A : vector_unsigned_int;
+ B : vector_signed_char) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsro (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sro;
+
+ function vec_sro
+ (A : vector_unsigned_int;
+ B : vector_unsigned_char) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsro (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sro;
+
+ function vec_sro
+ (A : vector_signed_short;
+ B : vector_signed_char) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsro (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sro;
+
+ function vec_sro
+ (A : vector_signed_short;
+ B : vector_unsigned_char) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsro (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sro;
+
+ function vec_sro
+ (A : vector_unsigned_short;
+ B : vector_signed_char) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsro (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sro;
+
+ function vec_sro
+ (A : vector_unsigned_short;
+ B : vector_unsigned_char) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsro (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sro;
+
+ function vec_sro
+ (A : vector_pixel;
+ B : vector_signed_char) return vector_pixel
+ is
+ begin
+ return To_LL_VP (vsro (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sro;
+
+ function vec_sro
+ (A : vector_pixel;
+ B : vector_unsigned_char) return vector_pixel
+ is
+ begin
+ return To_LL_VP (vsro (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sro;
+
+ function vec_sro
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsro (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sro;
+
+ function vec_sro
+ (A : vector_signed_char;
+ B : vector_unsigned_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsro (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sro;
+
+ function vec_sro
+ (A : vector_unsigned_char;
+ B : vector_signed_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsro (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sro;
+
+ function vec_sro
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsro (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sro;
+
+ -- vec_st --
+
+ procedure vec_st
+ (A : vector_float;
+ B : c_int;
+ C : vector_float_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_float;
+ B : c_int;
+ C : float_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_signed_int;
+ B : c_int;
+ C : vector_signed_int_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_signed_int;
+ B : c_int;
+ C : int_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_unsigned_int;
+ B : c_int;
+ C : vector_unsigned_int_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_unsigned_int;
+ B : c_int;
+ C : unsigned_int_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_bool_int;
+ B : c_int;
+ C : vector_bool_int_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_bool_int;
+ B : c_int;
+ C : unsigned_int_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_bool_int;
+ B : c_int;
+ C : int_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_signed_short;
+ B : c_int;
+ C : vector_signed_short_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_signed_short;
+ B : c_int;
+ C : short_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_unsigned_short;
+ B : c_int;
+ C : vector_unsigned_short_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_unsigned_short;
+ B : c_int;
+ C : unsigned_short_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_bool_short;
+ B : c_int;
+ C : vector_bool_short_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_bool_short;
+ B : c_int;
+ C : unsigned_short_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_pixel;
+ B : c_int;
+ C : vector_pixel_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_pixel;
+ B : c_int;
+ C : unsigned_short_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_pixel;
+ B : c_int;
+ C : short_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_bool_short;
+ B : c_int;
+ C : short_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_signed_char;
+ B : c_int;
+ C : vector_signed_char_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_signed_char;
+ B : c_int;
+ C : signed_char_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_unsigned_char;
+ B : c_int;
+ C : vector_unsigned_char_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_unsigned_char;
+ B : c_int;
+ C : unsigned_char_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_bool_char;
+ B : c_int;
+ C : vector_bool_char_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_bool_char;
+ B : c_int;
+ C : unsigned_char_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ procedure vec_st
+ (A : vector_bool_char;
+ B : c_int;
+ C : signed_char_ptr)
+ is
+ begin
+ stvx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_st;
+
+ -- vec_ste --
+
+ procedure vec_ste
+ (A : vector_signed_char;
+ B : c_int;
+ C : signed_char_ptr)
+ is
+ begin
+ stvebx (To_LL_VSC (A), B, To_PTR (C));
+ end vec_ste;
+
+ procedure vec_ste
+ (A : vector_unsigned_char;
+ B : c_int;
+ C : unsigned_char_ptr)
+ is
+ begin
+ stvebx (To_LL_VSC (A), B, To_PTR (C));
+ end vec_ste;
+
+ procedure vec_ste
+ (A : vector_bool_char;
+ B : c_int;
+ C : signed_char_ptr)
+ is
+ begin
+ stvebx (To_LL_VSC (A), B, To_PTR (C));
+ end vec_ste;
+
+ procedure vec_ste
+ (A : vector_bool_char;
+ B : c_int;
+ C : unsigned_char_ptr)
+ is
+ begin
+ stvebx (To_LL_VSC (A), B, To_PTR (C));
+ end vec_ste;
+
+ procedure vec_ste
+ (A : vector_signed_short;
+ B : c_int;
+ C : short_ptr)
+ is
+ begin
+ stvehx (To_LL_VSS (A), B, To_PTR (C));
+ end vec_ste;
+
+ procedure vec_ste
+ (A : vector_unsigned_short;
+ B : c_int;
+ C : unsigned_short_ptr)
+ is
+ begin
+ stvehx (To_LL_VSS (A), B, To_PTR (C));
+ end vec_ste;
+
+ procedure vec_ste
+ (A : vector_bool_short;
+ B : c_int;
+ C : short_ptr)
+ is
+ begin
+ stvehx (To_LL_VSS (A), B, To_PTR (C));
+ end vec_ste;
+
+ procedure vec_ste
+ (A : vector_bool_short;
+ B : c_int;
+ C : unsigned_short_ptr)
+ is
+ begin
+ stvehx (To_LL_VSS (A), B, To_PTR (C));
+ end vec_ste;
+
+ procedure vec_ste
+ (A : vector_pixel;
+ B : c_int;
+ C : short_ptr)
+ is
+ begin
+ stvehx (To_LL_VSS (A), B, To_PTR (C));
+ end vec_ste;
+
+ procedure vec_ste
+ (A : vector_pixel;
+ B : c_int;
+ C : unsigned_short_ptr)
+ is
+ begin
+ stvehx (To_LL_VSS (A), B, To_PTR (C));
+ end vec_ste;
+
+ procedure vec_ste
+ (A : vector_float;
+ B : c_int;
+ C : float_ptr)
+ is
+ begin
+ stvewx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_ste;
+
+ procedure vec_ste
+ (A : vector_signed_int;
+ B : c_int;
+ C : int_ptr)
+ is
+ begin
+ stvewx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_ste;
+
+ procedure vec_ste
+ (A : vector_unsigned_int;
+ B : c_int;
+ C : unsigned_int_ptr)
+ is
+ begin
+ stvewx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_ste;
+
+ procedure vec_ste
+ (A : vector_bool_int;
+ B : c_int;
+ C : int_ptr)
+ is
+ begin
+ stvewx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_ste;
+
+ procedure vec_ste
+ (A : vector_bool_int;
+ B : c_int;
+ C : unsigned_int_ptr)
+ is
+ begin
+ stvewx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_ste;
+
+ -- vec_stvewx --
+
+ procedure vec_stvewx
+ (A : vector_float;
+ B : c_int;
+ C : float_ptr)
+ is
+ begin
+ stvewx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stvewx;
+
+ procedure vec_stvewx
+ (A : vector_signed_int;
+ B : c_int;
+ C : int_ptr)
+ is
+ begin
+ stvewx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stvewx;
+
+ procedure vec_stvewx
+ (A : vector_unsigned_int;
+ B : c_int;
+ C : unsigned_int_ptr)
+ is
+ begin
+ stvewx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stvewx;
+
+ procedure vec_stvewx
+ (A : vector_bool_int;
+ B : c_int;
+ C : int_ptr)
+ is
+ begin
+ stvewx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stvewx;
+
+ procedure vec_stvewx
+ (A : vector_bool_int;
+ B : c_int;
+ C : unsigned_int_ptr)
+ is
+ begin
+ stvewx (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stvewx;
+
+ -- vec_stvehx --
+
+ procedure vec_stvehx
+ (A : vector_signed_short;
+ B : c_int;
+ C : short_ptr)
+ is
+ begin
+ stvehx (To_LL_VSS (A), B, To_PTR (C));
+ end vec_stvehx;
+
+ procedure vec_stvehx
+ (A : vector_unsigned_short;
+ B : c_int;
+ C : unsigned_short_ptr)
+ is
+ begin
+ stvehx (To_LL_VSS (A), B, To_PTR (C));
+ end vec_stvehx;
+
+ procedure vec_stvehx
+ (A : vector_bool_short;
+ B : c_int;
+ C : short_ptr)
+ is
+ begin
+ stvehx (To_LL_VSS (A), B, To_PTR (C));
+ end vec_stvehx;
+
+ procedure vec_stvehx
+ (A : vector_bool_short;
+ B : c_int;
+ C : unsigned_short_ptr)
+ is
+ begin
+ stvehx (To_LL_VSS (A), B, To_PTR (C));
+ end vec_stvehx;
+
+ procedure vec_stvehx
+ (A : vector_pixel;
+ B : c_int;
+ C : short_ptr)
+ is
+ begin
+ stvehx (To_LL_VSS (A), B, To_PTR (C));
+ end vec_stvehx;
+
+ procedure vec_stvehx
+ (A : vector_pixel;
+ B : c_int;
+ C : unsigned_short_ptr)
+ is
+ begin
+ stvehx (To_LL_VSS (A), B, To_PTR (C));
+ end vec_stvehx;
+
+ -- vec_stvebx --
+
+ procedure vec_stvebx
+ (A : vector_signed_char;
+ B : c_int;
+ C : signed_char_ptr)
+ is
+ begin
+ stvebx (To_LL_VSC (A), B, To_PTR (C));
+ end vec_stvebx;
+
+ procedure vec_stvebx
+ (A : vector_unsigned_char;
+ B : c_int;
+ C : unsigned_char_ptr)
+ is
+ begin
+ stvebx (To_LL_VSC (A), B, To_PTR (C));
+ end vec_stvebx;
+
+ procedure vec_stvebx
+ (A : vector_bool_char;
+ B : c_int;
+ C : signed_char_ptr)
+ is
+ begin
+ stvebx (To_LL_VSC (A), B, To_PTR (C));
+ end vec_stvebx;
+
+ procedure vec_stvebx
+ (A : vector_bool_char;
+ B : c_int;
+ C : unsigned_char_ptr)
+ is
+ begin
+ stvebx (To_LL_VSC (A), B, To_PTR (C));
+ end vec_stvebx;
+
+ -- vec_stl --
+
+ procedure vec_stl
+ (A : vector_float;
+ B : c_int;
+ C : vector_float_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_float;
+ B : c_int;
+ C : float_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_signed_int;
+ B : c_int;
+ C : vector_signed_int_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_signed_int;
+ B : c_int;
+ C : int_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_unsigned_int;
+ B : c_int;
+ C : vector_unsigned_int_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_unsigned_int;
+ B : c_int;
+ C : unsigned_int_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_bool_int;
+ B : c_int;
+ C : vector_bool_int_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_bool_int;
+ B : c_int;
+ C : unsigned_int_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_bool_int;
+ B : c_int;
+ C : int_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_signed_short;
+ B : c_int;
+ C : vector_signed_short_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_signed_short;
+ B : c_int;
+ C : short_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_unsigned_short;
+ B : c_int;
+ C : vector_unsigned_short_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_unsigned_short;
+ B : c_int;
+ C : unsigned_short_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_bool_short;
+ B : c_int;
+ C : vector_bool_short_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_bool_short;
+ B : c_int;
+ C : unsigned_short_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_bool_short;
+ B : c_int;
+ C : short_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_pixel;
+ B : c_int;
+ C : vector_pixel_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_pixel;
+ B : c_int;
+ C : unsigned_short_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_pixel;
+ B : c_int;
+ C : short_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_signed_char;
+ B : c_int;
+ C : vector_signed_char_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_signed_char;
+ B : c_int;
+ C : signed_char_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_unsigned_char;
+ B : c_int;
+ C : vector_unsigned_char_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_unsigned_char;
+ B : c_int;
+ C : unsigned_char_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_bool_char;
+ B : c_int;
+ C : vector_bool_char_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_bool_char;
+ B : c_int;
+ C : unsigned_char_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ procedure vec_stl
+ (A : vector_bool_char;
+ B : c_int;
+ C : signed_char_ptr)
+ is
+ begin
+ stvxl (To_LL_VSI (A), B, To_PTR (C));
+ end vec_stl;
+
+ -- vec_sub --
+
+ function vec_sub
+ (A : vector_bool_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsububm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_sub;
+
+ function vec_sub
+ (A : vector_signed_char;
+ B : vector_bool_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsububm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_sub;
+
+ function vec_sub
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsububm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_sub;
+
+ function vec_sub
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsububm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_sub;
+
+ function vec_sub
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsububm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_sub;
+
+ function vec_sub
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsububm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_sub;
+
+ function vec_sub
+ (A : vector_bool_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsubuhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_sub;
+
+ function vec_sub
+ (A : vector_signed_short;
+ B : vector_bool_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsubuhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_sub;
+
+ function vec_sub
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsubuhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_sub;
+
+ function vec_sub
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsubuhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_sub;
+
+ function vec_sub
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsubuhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_sub;
+
+ function vec_sub
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsubuhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_sub;
+
+ function vec_sub
+ (A : vector_bool_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsubuwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sub;
+
+ function vec_sub
+ (A : vector_signed_int;
+ B : vector_bool_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsubuwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sub;
+
+ function vec_sub
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsubuwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sub;
+
+ function vec_sub
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsubuwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sub;
+
+ function vec_sub
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsubuwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sub;
+
+ function vec_sub
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsubuwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sub;
+
+ function vec_sub
+ (A : vector_float;
+ B : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vsubfp (To_LL_VF (A), To_LL_VF (B)));
+ end vec_sub;
+
+ -- vec_vsubfp --
+
+ function vec_vsubfp
+ (A : vector_float;
+ B : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vsubfp (To_LL_VF (A), To_LL_VF (B)));
+ end vec_vsubfp;
+
+ -- vec_vsubuwm --
+
+ function vec_vsubuwm
+ (A : vector_bool_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsubuwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vsubuwm;
+
+ function vec_vsubuwm
+ (A : vector_signed_int;
+ B : vector_bool_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsubuwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vsubuwm;
+
+ function vec_vsubuwm
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsubuwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vsubuwm;
+
+ function vec_vsubuwm
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsubuwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vsubuwm;
+
+ function vec_vsubuwm
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsubuwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vsubuwm;
+
+ function vec_vsubuwm
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsubuwm (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vsubuwm;
+
+ -- vec_vsubuhm --
+
+ function vec_vsubuhm
+ (A : vector_bool_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsubuhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vsubuhm;
+
+ function vec_vsubuhm
+ (A : vector_signed_short;
+ B : vector_bool_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsubuhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vsubuhm;
+
+ function vec_vsubuhm
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsubuhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vsubuhm;
+
+ function vec_vsubuhm
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsubuhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vsubuhm;
+
+ function vec_vsubuhm
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsubuhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vsubuhm;
+
+ function vec_vsubuhm
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsubuhm (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vsubuhm;
+
+ -- vec_vsububm --
+
+ function vec_vsububm
+ (A : vector_bool_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsububm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vsububm;
+
+ function vec_vsububm
+ (A : vector_signed_char;
+ B : vector_bool_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsububm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vsububm;
+
+ function vec_vsububm
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsububm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vsububm;
+
+ function vec_vsububm
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsububm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vsububm;
+
+ function vec_vsububm
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsububm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vsububm;
+
+ function vec_vsububm
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsububm (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vsububm;
+
+ -- vec_subc --
+
+ function vec_subc
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsubcuw (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_subc;
+
+ -- vec_subs --
+
+ function vec_subs
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsububs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_subs;
+
+ function vec_subs
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsububs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_subs;
+
+ function vec_subs
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsububs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_subs;
+
+ function vec_subs
+ (A : vector_bool_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsubsbs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_subs;
+
+ function vec_subs
+ (A : vector_signed_char;
+ B : vector_bool_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsubsbs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_subs;
+
+ function vec_subs
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsubsbs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_subs;
+
+ function vec_subs
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsubuhs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_subs;
+
+ function vec_subs
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsubuhs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_subs;
+
+ function vec_subs
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsubuhs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_subs;
+
+ function vec_subs
+ (A : vector_bool_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsubshs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_subs;
+
+ function vec_subs
+ (A : vector_signed_short;
+ B : vector_bool_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsubshs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_subs;
+
+ function vec_subs
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsubshs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_subs;
+
+ function vec_subs
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsubuws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_subs;
+
+ function vec_subs
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsubuws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_subs;
+
+ function vec_subs
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsubuws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_subs;
+
+ function vec_subs
+ (A : vector_bool_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsubsws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_subs;
+
+ function vec_subs
+ (A : vector_signed_int;
+ B : vector_bool_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsubsws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_subs;
+
+ function vec_subs
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsubsws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_subs;
+
+ -- vec_vsubsws --
+
+ function vec_vsubsws
+ (A : vector_bool_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsubsws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vsubsws;
+
+ function vec_vsubsws
+ (A : vector_signed_int;
+ B : vector_bool_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsubsws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vsubsws;
+
+ function vec_vsubsws
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsubsws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vsubsws;
+
+ -- vec_vsubuws --
+
+ function vec_vsubuws
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsubuws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vsubuws;
+
+ function vec_vsubuws
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsubuws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vsubuws;
+
+ function vec_vsubuws
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsubuws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_vsubuws;
+
+ -- vec_vsubshs --
+
+ function vec_vsubshs
+ (A : vector_bool_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsubshs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vsubshs;
+
+ function vec_vsubshs
+ (A : vector_signed_short;
+ B : vector_bool_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsubshs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vsubshs;
+
+ function vec_vsubshs
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vsubshs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vsubshs;
+
+ -- vec_vsubuhs --
+
+ function vec_vsubuhs
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsubuhs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vsubuhs;
+
+ function vec_vsubuhs
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsubuhs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vsubuhs;
+
+ function vec_vsubuhs
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vsubuhs (To_LL_VSS (A), To_LL_VSS (B)));
+ end vec_vsubuhs;
+
+ -- vec_vsubsbs --
+
+ function vec_vsubsbs
+ (A : vector_bool_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsubsbs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vsubsbs;
+
+ function vec_vsubsbs
+ (A : vector_signed_char;
+ B : vector_bool_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsubsbs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vsubsbs;
+
+ function vec_vsubsbs
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vsubsbs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vsubsbs;
+
+ -- vec_vsububs --
+
+ function vec_vsububs
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsububs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vsububs;
+
+ function vec_vsububs
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsububs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vsububs;
+
+ function vec_vsububs
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vsububs (To_LL_VSC (A), To_LL_VSC (B)));
+ end vec_vsububs;
+
+ -- vec_sum4s --
+
+ function vec_sum4s
+ (A : vector_unsigned_char;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsum4ubs (To_LL_VSC (A), To_LL_VSI (B)));
+ end vec_sum4s;
+
+ function vec_sum4s
+ (A : vector_signed_char;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsum4sbs (To_LL_VSC (A), To_LL_VSI (B)));
+ end vec_sum4s;
+
+ function vec_sum4s
+ (A : vector_signed_short;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsum4shs (To_LL_VSS (A), To_LL_VSI (B)));
+ end vec_sum4s;
+
+ -- vec_vsum4shs --
+
+ function vec_vsum4shs
+ (A : vector_signed_short;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsum4shs (To_LL_VSS (A), To_LL_VSI (B)));
+ end vec_vsum4shs;
+
+ -- vec_vsum4sbs --
+
+ function vec_vsum4sbs
+ (A : vector_signed_char;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsum4sbs (To_LL_VSC (A), To_LL_VSI (B)));
+ end vec_vsum4sbs;
+
+ -- vec_vsum4ubs --
+
+ function vec_vsum4ubs
+ (A : vector_unsigned_char;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vsum4ubs (To_LL_VSC (A), To_LL_VSI (B)));
+ end vec_vsum4ubs;
+
+ -- vec_sum2s --
+
+ function vec_sum2s
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsum2sws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sum2s;
+
+ -- vec_sums --
+
+ function vec_sums
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vsumsws (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_sums;
+
+ -- vec_trunc --
+
+ function vec_trunc
+ (A : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vrfiz (To_LL_VF (A)));
+ end vec_trunc;
+
+ -- vec_unpackh --
+
+ function vec_unpackh
+ (A : vector_signed_char) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vupkhsb (To_LL_VSC (A)));
+ end vec_unpackh;
+
+ function vec_unpackh
+ (A : vector_bool_char) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vupkhsb (To_LL_VSC (A)));
+ end vec_unpackh;
+
+ function vec_unpackh
+ (A : vector_signed_short) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vupkhsh (To_LL_VSS (A)));
+ end vec_unpackh;
+
+ function vec_unpackh
+ (A : vector_bool_short) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vupkhsh (To_LL_VSS (A)));
+ end vec_unpackh;
+
+ function vec_unpackh
+ (A : vector_pixel) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vupkhpx (To_LL_VSS (A)));
+ end vec_unpackh;
+
+ -- vec_vupkhsh --
+
+ function vec_vupkhsh
+ (A : vector_bool_short) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vupkhsh (To_LL_VSS (A)));
+ end vec_vupkhsh;
+
+ function vec_vupkhsh
+ (A : vector_signed_short) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vupkhsh (To_LL_VSS (A)));
+ end vec_vupkhsh;
+
+ -- vec_vupkhpx --
+
+ function vec_vupkhpx
+ (A : vector_pixel) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vupkhpx (To_LL_VSS (A)));
+ end vec_vupkhpx;
+
+ -- vec_vupkhsb --
+
+ function vec_vupkhsb
+ (A : vector_bool_char) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vupkhsb (To_LL_VSC (A)));
+ end vec_vupkhsb;
+
+ function vec_vupkhsb
+ (A : vector_signed_char) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vupkhsb (To_LL_VSC (A)));
+ end vec_vupkhsb;
+
+ -- vec_unpackl --
+
+ function vec_unpackl
+ (A : vector_signed_char) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vupklsb (To_LL_VSC (A)));
+ end vec_unpackl;
+
+ function vec_unpackl
+ (A : vector_bool_char) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vupklsb (To_LL_VSC (A)));
+ end vec_unpackl;
+
+ function vec_unpackl
+ (A : vector_pixel) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vupklpx (To_LL_VSS (A)));
+ end vec_unpackl;
+
+ function vec_unpackl
+ (A : vector_signed_short) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vupklsh (To_LL_VSS (A)));
+ end vec_unpackl;
+
+ function vec_unpackl
+ (A : vector_bool_short) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vupklsh (To_LL_VSS (A)));
+ end vec_unpackl;
+
+ -- vec_vupklpx --
+
+ function vec_vupklpx
+ (A : vector_pixel) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vupklpx (To_LL_VSS (A)));
+ end vec_vupklpx;
+
+ -- vec_upklsh --
+
+ function vec_vupklsh
+ (A : vector_bool_short) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vupklsh (To_LL_VSS (A)));
+ end vec_vupklsh;
+
+ function vec_vupklsh
+ (A : vector_signed_short) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vupklsh (To_LL_VSS (A)));
+ end vec_vupklsh;
+
+ -- vec_vupklsb --
+
+ function vec_vupklsb
+ (A : vector_bool_char) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vupklsb (To_LL_VSC (A)));
+ end vec_vupklsb;
+
+ function vec_vupklsb
+ (A : vector_signed_char) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vupklsb (To_LL_VSC (A)));
+ end vec_vupklsb;
+
+ -- vec_xor --
+
+ function vec_xor
+ (A : vector_float;
+ B : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_float;
+ B : vector_bool_int) return vector_float
+ is
+ begin
+ return To_LL_VF (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_bool_int;
+ B : vector_float) return vector_float
+ is
+ begin
+ return To_LL_VF (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_bool_int;
+ B : vector_bool_int) return vector_bool_int
+ is
+ begin
+ return To_LL_VBI (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_bool_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_signed_int;
+ B : vector_bool_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ is
+ begin
+ return To_LL_VSI (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ is
+ begin
+ return To_LL_VUI (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_bool_short;
+ B : vector_bool_short) return vector_bool_short
+ is
+ begin
+ return To_LL_VBS (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_bool_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_signed_short;
+ B : vector_bool_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_signed_short;
+ B : vector_signed_short) return vector_signed_short
+ is
+ begin
+ return To_LL_VSS (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return vector_unsigned_short
+ is
+ begin
+ return To_LL_VUS (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_bool_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_bool_char;
+ B : vector_bool_char) return vector_bool_char
+ is
+ begin
+ return To_LL_VBC (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_signed_char;
+ B : vector_bool_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_signed_char;
+ B : vector_signed_char) return vector_signed_char
+ is
+ begin
+ return To_LL_VSC (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ function vec_xor
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return vector_unsigned_char
+ is
+ begin
+ return To_LL_VUC (vxor (To_LL_VSI (A), To_LL_VSI (B)));
+ end vec_xor;
+
+ -----------------------------------
+ -- Bodies for Altivec predicates --
+ -----------------------------------
+
+ -- vec_all_eq --
+
+ function vec_all_eq
+ (A : vector_signed_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_LT, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_signed_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_LT, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_LT, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_LT, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_bool_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_LT, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_LT, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_bool_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_LT, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_signed_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_LT, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_signed_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_LT, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_LT, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_LT, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_bool_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_LT, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_LT, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_bool_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_LT, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_pixel;
+ B : vector_pixel) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_LT, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_signed_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_LT, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_signed_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_LT, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_LT, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_LT, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_bool_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_LT, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_LT, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_bool_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_LT, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_eq;
+
+ function vec_all_eq
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpeqfp_p (CR6_LT, To_LL_VF (A), To_LL_VF (B));
+ end vec_all_eq;
+
+ -- vec_all_ge --
+
+ function vec_all_ge
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_EQ, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_all_ge;
+
+ function vec_all_ge
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_EQ, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_all_ge;
+
+ function vec_all_ge
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_EQ, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_all_ge;
+
+ function vec_all_ge
+ (A : vector_bool_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_EQ, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_all_ge;
+
+ function vec_all_ge
+ (A : vector_signed_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_EQ, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_all_ge;
+
+ function vec_all_ge
+ (A : vector_signed_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_EQ, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_all_ge;
+
+ function vec_all_ge
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_EQ, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_all_ge;
+
+ function vec_all_ge
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_EQ, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_all_ge;
+
+ function vec_all_ge
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_EQ, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_all_ge;
+
+ function vec_all_ge
+ (A : vector_signed_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_EQ, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_all_ge;
+
+ function vec_all_ge
+ (A : vector_bool_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_EQ, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_all_ge;
+
+ function vec_all_ge
+ (A : vector_signed_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_EQ, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_all_ge;
+
+ function vec_all_ge
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_EQ, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_all_ge;
+
+ function vec_all_ge
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_EQ, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_all_ge;
+
+ function vec_all_ge
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_EQ, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_all_ge;
+
+ function vec_all_ge
+ (A : vector_bool_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_EQ, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_all_ge;
+
+ function vec_all_ge
+ (A : vector_signed_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_EQ, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_all_ge;
+
+ function vec_all_ge
+ (A : vector_signed_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_EQ, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_all_ge;
+
+ function vec_all_ge
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpgefp_p (CR6_LT, To_LL_VF (A), To_LL_VF (B));
+ end vec_all_ge;
+
+ -- vec_all_gt --
+
+ function vec_all_gt
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_LT, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_gt;
+
+ function vec_all_gt
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_LT, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_gt;
+
+ function vec_all_gt
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_LT, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_gt;
+
+ function vec_all_gt
+ (A : vector_bool_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_LT, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_gt;
+
+ function vec_all_gt
+ (A : vector_signed_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_LT, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_gt;
+
+ function vec_all_gt
+ (A : vector_signed_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_LT, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_gt;
+
+ function vec_all_gt
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_LT, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_gt;
+
+ function vec_all_gt
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_LT, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_gt;
+
+ function vec_all_gt
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_LT, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_gt;
+
+ function vec_all_gt
+ (A : vector_bool_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_LT, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_gt;
+
+ function vec_all_gt
+ (A : vector_signed_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_LT, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_gt;
+
+ function vec_all_gt
+ (A : vector_signed_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_LT, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_gt;
+
+ function vec_all_gt
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_LT, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_gt;
+
+ function vec_all_gt
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_LT, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_gt;
+
+ function vec_all_gt
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_LT, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_gt;
+
+ function vec_all_gt
+ (A : vector_bool_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_LT, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_gt;
+
+ function vec_all_gt
+ (A : vector_signed_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_LT, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_gt;
+
+ function vec_all_gt
+ (A : vector_signed_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_LT, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_gt;
+
+ function vec_all_gt
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpgtfp_p (CR6_LT, To_LL_VF (A), To_LL_VF (B));
+ end vec_all_gt;
+
+ -- vec_all_in --
+
+ function vec_all_in
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpbfp_p (CR6_EQ, To_LL_VF (A), To_LL_VF (B));
+ end vec_all_in;
+
+ -- vec_all_le --
+
+ function vec_all_le
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_EQ, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_le;
+
+ function vec_all_le
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_EQ, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_le;
+
+ function vec_all_le
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_EQ, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_le;
+
+ function vec_all_le
+ (A : vector_bool_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_EQ, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_le;
+
+ function vec_all_le
+ (A : vector_signed_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_EQ, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_le;
+
+ function vec_all_le
+ (A : vector_signed_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_EQ, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_le;
+
+ function vec_all_le
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_EQ, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_le;
+
+ function vec_all_le
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_EQ, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_le;
+
+ function vec_all_le
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_EQ, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_le;
+
+ function vec_all_le
+ (A : vector_bool_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_EQ, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_le;
+
+ function vec_all_le
+ (A : vector_signed_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_EQ, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_le;
+
+ function vec_all_le
+ (A : vector_signed_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_EQ, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_le;
+
+ function vec_all_le
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_EQ, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_le;
+
+ function vec_all_le
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_EQ, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_le;
+
+ function vec_all_le
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_EQ, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_le;
+
+ function vec_all_le
+ (A : vector_bool_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_EQ, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_le;
+
+ function vec_all_le
+ (A : vector_signed_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_EQ, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_le;
+
+ function vec_all_le
+ (A : vector_signed_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_EQ, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_le;
+
+ function vec_all_le
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpgefp_p (CR6_LT, To_LL_VF (B), To_LL_VF (A));
+ end vec_all_le;
+
+ -- vec_all_lt --
+
+ function vec_all_lt
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_LT, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_all_lt;
+
+ function vec_all_lt
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_LT, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_all_lt;
+
+ function vec_all_lt
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_LT, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_all_lt;
+
+ function vec_all_lt
+ (A : vector_bool_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_LT, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_all_lt;
+
+ function vec_all_lt
+ (A : vector_signed_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_LT, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_all_lt;
+
+ function vec_all_lt
+ (A : vector_signed_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_LT, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_all_lt;
+
+ function vec_all_lt
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_LT, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_all_lt;
+
+ function vec_all_lt
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_LT, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_all_lt;
+
+ function vec_all_lt
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_LT, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_all_lt;
+
+ function vec_all_lt
+ (A : vector_bool_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_LT, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_all_lt;
+
+ function vec_all_lt
+ (A : vector_signed_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_LT, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_all_lt;
+
+ function vec_all_lt
+ (A : vector_signed_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_LT, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_all_lt;
+
+ function vec_all_lt
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_LT, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_all_lt;
+
+ function vec_all_lt
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_LT, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_all_lt;
+
+ function vec_all_lt
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_LT, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_all_lt;
+
+ function vec_all_lt
+ (A : vector_bool_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_LT, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_all_lt;
+
+ function vec_all_lt
+ (A : vector_signed_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_LT, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_all_lt;
+
+ function vec_all_lt
+ (A : vector_signed_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_LT, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_all_lt;
+
+ function vec_all_lt
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpgtfp_p (CR6_LT, To_LL_VF (B), To_LL_VF (A));
+ end vec_all_lt;
+
+ -- vec_all_nan --
+
+ function vec_all_nan
+ (A : vector_float) return c_int
+ is
+ begin
+ return vcmpeqfp_p (CR6_EQ, To_LL_VF (A), To_LL_VF (A));
+ end vec_all_nan;
+
+ -- vec_all_ne --
+
+ function vec_all_ne
+ (A : vector_signed_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_EQ, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_signed_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_EQ, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_EQ, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_EQ, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_bool_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_EQ, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_EQ, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_bool_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_EQ, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_signed_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_EQ, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_signed_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_EQ, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_EQ, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_EQ, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_bool_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_EQ, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_EQ, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_bool_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_EQ, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_pixel;
+ B : vector_pixel) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_EQ, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_signed_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_EQ, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_signed_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_EQ, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_EQ, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_EQ, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_bool_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_EQ, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_EQ, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_bool_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_EQ, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_all_ne;
+
+ function vec_all_ne
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpeqfp_p (CR6_EQ, To_LL_VF (A), To_LL_VF (B));
+ end vec_all_ne;
+
+ -- vec_all_nge --
+
+ function vec_all_nge
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpgefp_p (CR6_EQ, To_LL_VF (A), To_LL_VF (B));
+ end vec_all_nge;
+
+ -- vec_all_ngt --
+
+ function vec_all_ngt
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpgtfp_p (CR6_EQ, To_LL_VF (A), To_LL_VF (B));
+ end vec_all_ngt;
+
+ -- vec_all_nle --
+
+ function vec_all_nle
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpgefp_p (CR6_EQ, To_LL_VF (B), To_LL_VF (A));
+ end vec_all_nle;
+
+ -- vec_all_nlt --
+
+ function vec_all_nlt
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpgtfp_p (CR6_EQ, To_LL_VF (B), To_LL_VF (A));
+ end vec_all_nlt;
+
+ -- vec_all_numeric --
+
+ function vec_all_numeric
+ (A : vector_float) return c_int
+ is
+ begin
+ return vcmpeqfp_p (CR6_LT, To_LL_VF (A), To_LL_VF (A));
+ end vec_all_numeric;
+
+ -- vec_any_eq --
+
+ function vec_any_eq
+ (A : vector_signed_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_EQ_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_signed_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_EQ_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_EQ_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_EQ_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_bool_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_EQ_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_EQ_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_bool_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_EQ_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_signed_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_EQ_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_signed_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_EQ_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_EQ_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_EQ_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_bool_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_EQ_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_EQ_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_bool_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_EQ_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_pixel;
+ B : vector_pixel) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_EQ_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_signed_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_EQ_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_signed_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_EQ_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_EQ_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_EQ_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_bool_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_EQ_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_EQ_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_bool_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_EQ_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_eq;
+
+ function vec_any_eq
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpeqfp_p (CR6_EQ_REV, To_LL_VF (A), To_LL_VF (B));
+ end vec_any_eq;
+
+ -- vec_any_ge --
+
+ function vec_any_ge
+ (A : vector_signed_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_LT_REV, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_any_ge;
+
+ function vec_any_ge
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_LT_REV, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_any_ge;
+
+ function vec_any_ge
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_LT_REV, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_any_ge;
+
+ function vec_any_ge
+ (A : vector_signed_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_LT_REV, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_any_ge;
+
+ function vec_any_ge
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_LT_REV, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_any_ge;
+
+ function vec_any_ge
+ (A : vector_bool_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_LT_REV, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_any_ge;
+
+ function vec_any_ge
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_LT_REV, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_any_ge;
+
+ function vec_any_ge
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_LT_REV, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_any_ge;
+
+ function vec_any_ge
+ (A : vector_signed_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_LT_REV, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_any_ge;
+
+ function vec_any_ge
+ (A : vector_signed_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_LT_REV, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_any_ge;
+
+ function vec_any_ge
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_LT_REV, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_any_ge;
+
+ function vec_any_ge
+ (A : vector_bool_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_LT_REV, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_any_ge;
+
+ function vec_any_ge
+ (A : vector_signed_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_LT_REV, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_any_ge;
+
+ function vec_any_ge
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_LT_REV, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_any_ge;
+
+ function vec_any_ge
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_LT_REV, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_any_ge;
+
+ function vec_any_ge
+ (A : vector_signed_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_LT_REV, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_any_ge;
+
+ function vec_any_ge
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_LT_REV, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_any_ge;
+
+ function vec_any_ge
+ (A : vector_bool_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_LT_REV, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_any_ge;
+
+ function vec_any_ge
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpgefp_p (CR6_EQ_REV, To_LL_VF (A), To_LL_VF (B));
+ end vec_any_ge;
+
+ -- vec_any_gt --
+
+ function vec_any_gt
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_EQ_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_gt;
+
+ function vec_any_gt
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_EQ_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_gt;
+
+ function vec_any_gt
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_EQ_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_gt;
+
+ function vec_any_gt
+ (A : vector_bool_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_EQ_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_gt;
+
+ function vec_any_gt
+ (A : vector_signed_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_EQ_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_gt;
+
+ function vec_any_gt
+ (A : vector_signed_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_EQ_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_gt;
+
+ function vec_any_gt
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_EQ_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_gt;
+
+ function vec_any_gt
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_EQ_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_gt;
+
+ function vec_any_gt
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_EQ_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_gt;
+
+ function vec_any_gt
+ (A : vector_bool_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_EQ_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_gt;
+
+ function vec_any_gt
+ (A : vector_signed_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_EQ_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_gt;
+
+ function vec_any_gt
+ (A : vector_signed_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_EQ_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_gt;
+
+ function vec_any_gt
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_EQ_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_gt;
+
+ function vec_any_gt
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_EQ_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_gt;
+
+ function vec_any_gt
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_EQ_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_gt;
+
+ function vec_any_gt
+ (A : vector_bool_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_EQ_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_gt;
+
+ function vec_any_gt
+ (A : vector_signed_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_EQ_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_gt;
+
+ function vec_any_gt
+ (A : vector_signed_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_EQ_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_gt;
+
+ function vec_any_gt
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpgtfp_p (CR6_EQ_REV, To_LL_VF (A), To_LL_VF (B));
+ end vec_any_gt;
+
+ -- vec_any_le --
+
+ function vec_any_le
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_LT_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_le;
+
+ function vec_any_le
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_LT_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_le;
+
+ function vec_any_le
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_LT_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_le;
+
+ function vec_any_le
+ (A : vector_bool_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_LT_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_le;
+
+ function vec_any_le
+ (A : vector_signed_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_LT_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_le;
+
+ function vec_any_le
+ (A : vector_signed_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_LT_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_le;
+
+ function vec_any_le
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_LT_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_le;
+
+ function vec_any_le
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_LT_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_le;
+
+ function vec_any_le
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_LT_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_le;
+
+ function vec_any_le
+ (A : vector_bool_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_LT_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_le;
+
+ function vec_any_le
+ (A : vector_signed_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_LT_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_le;
+
+ function vec_any_le
+ (A : vector_signed_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_LT_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_le;
+
+ function vec_any_le
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_LT_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_le;
+
+ function vec_any_le
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_LT_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_le;
+
+ function vec_any_le
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_LT_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_le;
+
+ function vec_any_le
+ (A : vector_bool_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_LT_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_le;
+
+ function vec_any_le
+ (A : vector_signed_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_LT_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_le;
+
+ function vec_any_le
+ (A : vector_signed_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_LT_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_le;
+
+ function vec_any_le
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpgefp_p (CR6_EQ_REV, To_LL_VF (B), To_LL_VF (A));
+ end vec_any_le;
+
+ -- vec_any_lt --
+
+ function vec_any_lt
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_EQ_REV, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_any_lt;
+
+ function vec_any_lt
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_EQ_REV, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_any_lt;
+
+ function vec_any_lt
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpgtub_p (CR6_EQ_REV, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_any_lt;
+
+ function vec_any_lt
+ (A : vector_bool_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_EQ_REV, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_any_lt;
+
+ function vec_any_lt
+ (A : vector_signed_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_EQ_REV, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_any_lt;
+
+ function vec_any_lt
+ (A : vector_signed_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpgtsb_p (CR6_EQ_REV, To_LL_VSC (B), To_LL_VSC (A));
+ end vec_any_lt;
+
+ function vec_any_lt
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_EQ_REV, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_any_lt;
+
+ function vec_any_lt
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_EQ_REV, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_any_lt;
+
+ function vec_any_lt
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpgtuh_p (CR6_EQ_REV, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_any_lt;
+
+ function vec_any_lt
+ (A : vector_bool_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_EQ_REV, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_any_lt;
+
+ function vec_any_lt
+ (A : vector_signed_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_EQ_REV, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_any_lt;
+
+ function vec_any_lt
+ (A : vector_signed_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpgtsh_p (CR6_EQ_REV, To_LL_VSS (B), To_LL_VSS (A));
+ end vec_any_lt;
+
+ function vec_any_lt
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_EQ_REV, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_any_lt;
+
+ function vec_any_lt
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_EQ_REV, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_any_lt;
+
+ function vec_any_lt
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpgtuw_p (CR6_EQ_REV, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_any_lt;
+
+ function vec_any_lt
+ (A : vector_bool_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_EQ_REV, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_any_lt;
+
+ function vec_any_lt
+ (A : vector_signed_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_EQ_REV, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_any_lt;
+
+ function vec_any_lt
+ (A : vector_signed_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpgtsw_p (CR6_EQ_REV, To_LL_VSI (B), To_LL_VSI (A));
+ end vec_any_lt;
+
+ function vec_any_lt
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpgtfp_p (CR6_EQ_REV, To_LL_VF (B), To_LL_VF (A));
+ end vec_any_lt;
+
+ -- vec_any_nan --
+
+ function vec_any_nan
+ (A : vector_float) return c_int
+ is
+ begin
+ return vcmpeqfp_p (CR6_LT_REV, To_LL_VF (A), To_LL_VF (A));
+ end vec_any_nan;
+
+ -- vec_any_ne --
+
+ function vec_any_ne
+ (A : vector_signed_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_LT_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_signed_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_LT_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_unsigned_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_LT_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_LT_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_bool_char;
+ B : vector_bool_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_LT_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_bool_char;
+ B : vector_unsigned_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_LT_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_bool_char;
+ B : vector_signed_char) return c_int
+ is
+ begin
+ return vcmpequb_p (CR6_LT_REV, To_LL_VSC (A), To_LL_VSC (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_signed_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_LT_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_signed_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_LT_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_unsigned_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_LT_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_LT_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_bool_short;
+ B : vector_bool_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_LT_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_bool_short;
+ B : vector_unsigned_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_LT_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_bool_short;
+ B : vector_signed_short) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_LT_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_pixel;
+ B : vector_pixel) return c_int
+ is
+ begin
+ return vcmpequh_p (CR6_LT_REV, To_LL_VSS (A), To_LL_VSS (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_signed_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_LT_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_signed_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_LT_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_unsigned_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_LT_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_LT_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_bool_int;
+ B : vector_bool_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_LT_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_bool_int;
+ B : vector_unsigned_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_LT_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_bool_int;
+ B : vector_signed_int) return c_int
+ is
+ begin
+ return vcmpequw_p (CR6_LT_REV, To_LL_VSI (A), To_LL_VSI (B));
+ end vec_any_ne;
+
+ function vec_any_ne
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpeqfp_p (CR6_LT_REV, To_LL_VF (A), To_LL_VF (B));
+ end vec_any_ne;
+
+ -- vec_any_nge --
+
+ function vec_any_nge
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpgefp_p (CR6_LT_REV, To_LL_VF (A), To_LL_VF (B));
+ end vec_any_nge;
+
+ -- vec_any_ngt --
+
+ function vec_any_ngt
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpgtfp_p (CR6_LT_REV, To_LL_VF (A), To_LL_VF (B));
+ end vec_any_ngt;
+
+ -- vec_any_nle --
+
+ function vec_any_nle
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpgefp_p (CR6_LT_REV, To_LL_VF (B), To_LL_VF (A));
+ end vec_any_nle;
+
+ -- vec_any_nlt --
+
+ function vec_any_nlt
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpgtfp_p (CR6_LT_REV, To_LL_VF (B), To_LL_VF (A));
+ end vec_any_nlt;
+
+ -- vec_any_numeric --
+
+ function vec_any_numeric
+ (A : vector_float) return c_int
+ is
+ begin
+ return vcmpeqfp_p (CR6_EQ_REV, To_LL_VF (A), To_LL_VF (A));
+ end vec_any_numeric;
+
+ -- vec_any_out --
+
+ function vec_any_out
+ (A : vector_float;
+ B : vector_float) return c_int
+ is
+ begin
+ return vcmpbfp_p (CR6_EQ_REV, To_LL_VF (A), To_LL_VF (B));
+ end vec_any_out;
+
+ -- vec_step --
+
+ function vec_step
+ (V : vector_unsigned_char) return Integer
+ is
+ pragma Unreferenced (V);
+ begin
+ return 16;
+ end vec_step;
+
+ function vec_step
+ (V : vector_signed_char) return Integer
+ is
+ pragma Unreferenced (V);
+ begin
+ return 16;
+ end vec_step;
+
+ function vec_step
+ (V : vector_bool_char) return Integer
+ is
+ pragma Unreferenced (V);
+ begin
+ return 16;
+ end vec_step;
+
+ function vec_step
+ (V : vector_unsigned_short) return Integer
+ is
+ pragma Unreferenced (V);
+ begin
+ return 8;
+ end vec_step;
+
+ function vec_step
+ (V : vector_signed_short) return Integer
+ is
+ pragma Unreferenced (V);
+ begin
+ return 8;
+ end vec_step;
+
+ function vec_step
+ (V : vector_bool_short) return Integer
+ is
+ pragma Unreferenced (V);
+ begin
+ return 8;
+ end vec_step;
+
+ function vec_step
+ (V : vector_unsigned_int) return Integer
+ is
+ pragma Unreferenced (V);
+ begin
+ return 4;
+ end vec_step;
+
+ function vec_step
+ (V : vector_signed_int) return Integer
+ is
+ pragma Unreferenced (V);
+ begin
+ return 4;
+ end vec_step;
+
+ function vec_step
+ (V : vector_bool_int) return Integer
+ is
+ pragma Unreferenced (V);
+ begin
+ return 4;
+ end vec_step;
+
+ function vec_step
+ (V : vector_float) return Integer
+ is
+ pragma Unreferenced (V);
+ begin
+ return 4;
+ end vec_step;
+
+ function vec_step
+ (V : vector_pixel) return Integer
+ is
+ pragma Unreferenced (V);
+ begin
+ return 4;
+ end vec_step;
+
+end GNAT.Altivec.Vector_Operations;
--- /dev/null
+------------------------------------------------------------------------------
+-- --
+-- 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-2005, 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 2, 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. See the GNU General Public License --
+-- for more details. You should have received a copy of the GNU General --
+-- Public License distributed with GNAT; see file COPYING. If not, write --
+-- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
+-- MA 02111-1307, USA. --
+-- --
+-- As a special exception, if other files instantiate generics from this --
+-- unit, or you link this unit with other files to produce an executable, --
+-- this unit does not by itself cause the resulting executable to be --
+-- covered by the GNU General Public License. This exception does not --
+-- however invalidate any other reasons why the executable file might be --
+-- covered by the GNU Public License. --
+-- --
+-- 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_Interface; use GNAT.Altivec.Low_Level_Interface;
+
+package GNAT.Altivec.Vector_Operations is
+
+ -- The vast majority of the operations exposed here are overloads over a
+ -- much smaller set of low level primitives with type conversions around.
+ --
+ -- In some cases, a direct binding without any intermediate body is
+ -- possible or even even mandatory for technical reasons. What we provide
+ -- here for such cases are renamings of straight imports exposed by
+ -- Altivec.Low_Level_Interface. See the comments in the private part for
+ -- additional details.
+
+ -------------------------------------------------------
+ -- [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;
+
+ -- vec_cmpeq --
+
+ 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_ctf --
+
+ function vec_ctf
+ (A : vector_unsigned_int;
+ B : c_int) return vector_float
+ renames Low_Level_Interface.vec_ctf_vui_cint_r_vf;
+
+ function vec_ctf
+ (A : vector_signed_int;
+ B : c_int) return vector_float
+ renames Low_Level_Interface.vec_ctf_vsi_cint_r_vf;
+
+ -- vec_vcfsx --
+
+ function vec_vcfsx
+ (A : vector_signed_int;
+ B : c_int) return vector_float
+ renames Low_Level_Interface.vec_vcfsx_vsi_cint_r_vf;
+
+ -- vec_vcfux --
+
+ function vec_vcfux
+ (A : vector_unsigned_int;
+ B : c_int) return vector_float
+ renames Low_Level_Interface.vec_vcfux_vui_cint_r_vf;
+
+ -- vec_cts --
+
+ function vec_cts
+ (A : vector_float;
+ B : c_int) return vector_signed_int
+ renames Low_Level_Interface.vec_cts_vf_cint_r_vsi;
+
+ -- vec_ctu --
+
+ function vec_ctu
+ (A : vector_float;
+ B : c_int) return vector_unsigned_int
+ renames Low_Level_Interface.vec_ctu_vf_cint_r_vui;
+
+ -- vec_dss --
+
+ procedure vec_dss
+ (A : c_int)
+ renames Low_Level_Interface.vec_dss_cint;
+
+ -- vec_dssall --
+
+ procedure vec_dssall
+ renames Low_Level_Interface.vec_dssall;
+
+ -- vec_dst --
+
+ procedure vec_dst
+ (A : const_vector_unsigned_char_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dst_kvucp_cint_cint;
+
+ procedure vec_dst
+ (A : const_vector_signed_char_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dst_kvscp_cint_cint;
+
+ procedure vec_dst
+ (A : const_vector_bool_char_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dst_kvbcp_cint_cint;
+
+ procedure vec_dst
+ (A : const_vector_unsigned_short_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dst_kvusp_cint_cint;
+
+ procedure vec_dst
+ (A : const_vector_signed_short_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dst_kvssp_cint_cint;
+
+ procedure vec_dst
+ (A : const_vector_bool_short_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dst_kvbsp_cint_cint;
+
+ procedure vec_dst
+ (A : const_vector_pixel_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dst_kvxp_cint_cint;
+
+ procedure vec_dst
+ (A : const_vector_unsigned_int_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dst_kvuip_cint_cint;
+
+ procedure vec_dst
+ (A : const_vector_signed_int_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dst_kvsip_cint_cint;
+
+ procedure vec_dst
+ (A : const_vector_bool_int_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dst_kvbip_cint_cint;
+
+ procedure vec_dst
+ (A : const_vector_float_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dst_kvfp_cint_cint;
+
+ procedure vec_dst
+ (A : const_unsigned_char_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dst_kucp_cint_cint;
+
+ procedure vec_dst
+ (A : const_signed_char_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dst_kscp_cint_cint;
+
+ procedure vec_dst
+ (A : const_unsigned_short_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dst_kusp_cint_cint;
+
+ procedure vec_dst
+ (A : const_short_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dst_ksp_cint_cint;
+
+ procedure vec_dst
+ (A : const_unsigned_int_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dst_kuip_cint_cint;
+
+ procedure vec_dst
+ (A : const_int_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dst_kip_cint_cint;
+
+ procedure vec_dst
+ (A : const_unsigned_long_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dst_kulongp_cint_cint;
+
+ procedure vec_dst
+ (A : const_long_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dst_klongp_cint_cint;
+
+ procedure vec_dst
+ (A : const_float_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dst_kfp_cint_cint;
+
+ -- vec_dstst --
+
+ procedure vec_dstst
+ (A : const_vector_unsigned_char_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstst_kvucp_cint_cint;
+
+ procedure vec_dstst
+ (A : const_vector_signed_char_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstst_kvscp_cint_cint;
+
+ procedure vec_dstst
+ (A : const_vector_bool_char_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstst_kvbcp_cint_cint;
+
+ procedure vec_dstst
+ (A : const_vector_unsigned_short_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstst_kvusp_cint_cint;
+
+ procedure vec_dstst
+ (A : const_vector_signed_short_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstst_kvssp_cint_cint;
+
+ procedure vec_dstst
+ (A : const_vector_bool_short_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstst_kvbsp_cint_cint;
+
+ procedure vec_dstst
+ (A : const_vector_pixel_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstst_kvxp_cint_cint;
+
+ procedure vec_dstst
+ (A : const_vector_unsigned_int_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstst_kvuip_cint_cint;
+
+ procedure vec_dstst
+ (A : const_vector_signed_int_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstst_kvsip_cint_cint;
+
+ procedure vec_dstst
+ (A : const_vector_bool_int_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstst_kvbip_cint_cint;
+
+ procedure vec_dstst
+ (A : const_vector_float_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstst_kvfp_cint_cint;
+
+ procedure vec_dstst
+ (A : const_unsigned_char_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstst_kucp_cint_cint;
+
+ procedure vec_dstst
+ (A : const_signed_char_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstst_kscp_cint_cint;
+
+ procedure vec_dstst
+ (A : const_unsigned_short_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstst_kusp_cint_cint;
+
+ procedure vec_dstst
+ (A : const_short_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstst_ksp_cint_cint;
+
+ procedure vec_dstst
+ (A : const_unsigned_int_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstst_kuip_cint_cint;
+
+ procedure vec_dstst
+ (A : const_int_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstst_kip_cint_cint;
+
+ procedure vec_dstst
+ (A : const_unsigned_long_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstst_kulongp_cint_cint;
+
+ procedure vec_dstst
+ (A : const_long_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstst_klongp_cint_cint;
+
+ procedure vec_dstst
+ (A : const_float_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstst_kfp_cint_cint;
+
+ -- vec_dststt --
+
+ procedure vec_dststt
+ (A : const_vector_unsigned_char_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dststt_kvucp_cint_cint;
+
+ procedure vec_dststt
+ (A : const_vector_signed_char_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dststt_kvscp_cint_cint;
+
+ procedure vec_dststt
+ (A : const_vector_bool_char_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dststt_kvbcp_cint_cint;
+
+ procedure vec_dststt
+ (A : const_vector_unsigned_short_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dststt_kvusp_cint_cint;
+
+ procedure vec_dststt
+ (A : const_vector_signed_short_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dststt_kvssp_cint_cint;
+
+ procedure vec_dststt
+ (A : const_vector_bool_short_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dststt_kvbsp_cint_cint;
+
+ procedure vec_dststt
+ (A : const_vector_pixel_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dststt_kvxp_cint_cint;
+
+ procedure vec_dststt
+ (A : const_vector_unsigned_int_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dststt_kvuip_cint_cint;
+
+ procedure vec_dststt
+ (A : const_vector_signed_int_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dststt_kvsip_cint_cint;
+
+ procedure vec_dststt
+ (A : const_vector_bool_int_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dststt_kvbip_cint_cint;
+
+ procedure vec_dststt
+ (A : const_vector_float_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dststt_kvfp_cint_cint;
+
+ procedure vec_dststt
+ (A : const_unsigned_char_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dststt_kucp_cint_cint;
+
+ procedure vec_dststt
+ (A : const_signed_char_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dststt_kscp_cint_cint;
+
+ procedure vec_dststt
+ (A : const_unsigned_short_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dststt_kusp_cint_cint;
+
+ procedure vec_dststt
+ (A : const_short_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dststt_ksp_cint_cint;
+
+ procedure vec_dststt
+ (A : const_unsigned_int_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dststt_kuip_cint_cint;
+
+ procedure vec_dststt
+ (A : const_int_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dststt_kip_cint_cint;
+
+ procedure vec_dststt
+ (A : const_unsigned_long_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dststt_kulongp_cint_cint;
+
+ procedure vec_dststt
+ (A : const_long_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dststt_klongp_cint_cint;
+
+ procedure vec_dststt
+ (A : const_float_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dststt_kfp_cint_cint;
+
+ -- vec_dstt --
+
+ procedure vec_dstt
+ (A : const_vector_unsigned_char_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstt_kvucp_cint_cint;
+
+ procedure vec_dstt
+ (A : const_vector_signed_char_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstt_kvscp_cint_cint;
+
+ procedure vec_dstt
+ (A : const_vector_bool_char_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstt_kvbcp_cint_cint;
+
+ procedure vec_dstt
+ (A : const_vector_unsigned_short_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstt_kvusp_cint_cint;
+
+ procedure vec_dstt
+ (A : const_vector_signed_short_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstt_kvssp_cint_cint;
+
+ procedure vec_dstt
+ (A : const_vector_bool_short_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstt_kvbsp_cint_cint;
+
+ procedure vec_dstt
+ (A : const_vector_pixel_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstt_kvxp_cint_cint;
+
+ procedure vec_dstt
+ (A : const_vector_unsigned_int_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstt_kvuip_cint_cint;
+
+ procedure vec_dstt
+ (A : const_vector_signed_int_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstt_kvsip_cint_cint;
+
+ procedure vec_dstt
+ (A : const_vector_bool_int_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstt_kvbip_cint_cint;
+
+ procedure vec_dstt
+ (A : const_vector_float_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstt_kvfp_cint_cint;
+
+ procedure vec_dstt
+ (A : const_unsigned_char_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstt_kucp_cint_cint;
+
+ procedure vec_dstt
+ (A : const_signed_char_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstt_kscp_cint_cint;
+
+ procedure vec_dstt
+ (A : const_unsigned_short_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstt_kusp_cint_cint;
+
+ procedure vec_dstt
+ (A : const_short_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstt_ksp_cint_cint;
+
+ procedure vec_dstt
+ (A : const_unsigned_int_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstt_kuip_cint_cint;
+
+ procedure vec_dstt
+ (A : const_int_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstt_kip_cint_cint;
+
+ procedure vec_dstt
+ (A : const_unsigned_long_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstt_kulongp_cint_cint;
+
+ procedure vec_dstt
+ (A : const_long_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstt_klongp_cint_cint;
+
+ procedure vec_dstt
+ (A : const_float_ptr;
+ B : c_int;
+ C : c_int)
+ renames Low_Level_Interface.vec_dstt_kfp_cint_cint;
+
+ -- 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;
+
+ -- vec_vmsumshs --
+
+ 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_float;
+ B : vector_float;
+ C : c_int) return vector_float
+ renames Low_Level_Interface.vec_sld_vf_vf_cint_r_vf;
+
+ function vec_sld
+ (A : vector_signed_int;
+ B : vector_signed_int;
+ C : c_int) return vector_signed_int
+ renames Low_Level_Interface.vec_sld_vsi_vsi_cint_r_vsi;
+
+ function vec_sld
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int;
+ C : c_int) return vector_unsigned_int
+ renames Low_Level_Interface.vec_sld_vui_vui_cint_r_vui;
+
+ function vec_sld
+ (A : vector_bool_int;
+ B : vector_bool_int;
+ C : c_int) return vector_bool_int
+ renames Low_Level_Interface.vec_sld_vbi_vbi_cint_r_vbi;
+
+ function vec_sld
+ (A : vector_signed_short;
+ B : vector_signed_short;
+ C : c_int) return vector_signed_short
+ renames Low_Level_Interface.vec_sld_vss_vss_cint_r_vss;
+
+ function vec_sld
+ (A : vector_unsigned_short;
+ B : vector_unsigned_short;
+ C : c_int) return vector_unsigned_short
+ renames Low_Level_Interface.vec_sld_vus_vus_cint_r_vus;
+
+ function vec_sld
+ (A : vector_bool_short;
+ B : vector_bool_short;
+ C : c_int) return vector_bool_short
+ renames Low_Level_Interface.vec_sld_vbs_vbs_cint_r_vbs;
+
+ function vec_sld
+ (A : vector_pixel;
+ B : vector_pixel;
+ C : c_int) return vector_pixel
+ renames Low_Level_Interface.vec_sld_vx_vx_cint_r_vx;
+
+ function vec_sld
+ (A : vector_signed_char;
+ B : vector_signed_char;
+ C : c_int) return vector_signed_char
+ renames Low_Level_Interface.vec_sld_vsc_vsc_cint_r_vsc;
+
+ function vec_sld
+ (A : vector_unsigned_char;
+ B : vector_unsigned_char;
+ C : c_int) return vector_unsigned_char
+ renames Low_Level_Interface.vec_sld_vuc_vuc_cint_r_vuc;
+
+ function vec_sld
+ (A : vector_bool_char;
+ B : vector_bool_char;
+ C : c_int) return vector_bool_char
+ renames Low_Level_Interface.vec_sld_vbc_vbc_cint_r_vbc;
+
+ -- 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_splat --
+
+ function vec_splat
+ (A : vector_signed_char;
+ B : c_int) return vector_signed_char
+ renames Low_Level_Interface.vec_splat_vsc_cint_r_vsc;
+
+ function vec_splat
+ (A : vector_unsigned_char;
+ B : c_int) return vector_unsigned_char
+ renames Low_Level_Interface.vec_splat_vuc_cint_r_vuc;
+
+ function vec_splat
+ (A : vector_bool_char;
+ B : c_int) return vector_bool_char
+ renames Low_Level_Interface.vec_splat_vbc_cint_r_vbc;
+
+ function vec_splat
+ (A : vector_signed_short;
+ B : c_int) return vector_signed_short
+ renames Low_Level_Interface.vec_splat_vss_cint_r_vss;
+
+ function vec_splat
+ (A : vector_unsigned_short;
+ B : c_int) return vector_unsigned_short
+ renames Low_Level_Interface.vec_splat_vus_cint_r_vus;
+
+ function vec_splat
+ (A : vector_bool_short;
+ B : c_int) return vector_bool_short
+ renames Low_Level_Interface.vec_splat_vbs_cint_r_vbs;
+
+ function vec_splat
+ (A : vector_pixel;
+ B : c_int) return vector_pixel
+ renames Low_Level_Interface.vec_splat_vx_cint_r_vx;
+
+ function vec_splat
+ (A : vector_float;
+ B : c_int) return vector_float
+ renames Low_Level_Interface.vec_splat_vf_cint_r_vf;
+
+ function vec_splat
+ (A : vector_signed_int;
+ B : c_int) return vector_signed_int
+ renames Low_Level_Interface.vec_splat_vsi_cint_r_vsi;
+
+ function vec_splat
+ (A : vector_unsigned_int;
+ B : c_int) return vector_unsigned_int
+ renames Low_Level_Interface.vec_splat_vui_cint_r_vui;
+
+ function vec_splat
+ (A : vector_bool_int;
+ B : c_int) return vector_bool_int
+ renames Low_Level_Interface.vec_splat_vbi_cint_r_vbi;
+
+ -- vec_vspltw --
+
+ function vec_vspltw
+ (A : vector_float;
+ B : c_int) return vector_float
+ renames Low_Level_Interface.vec_vspltw_vf_cint_r_vf;
+
+ function vec_vspltw
+ (A : vector_signed_int;
+ B : c_int) return vector_signed_int
+ renames Low_Level_Interface.vec_vspltw_vsi_cint_r_vsi;
+
+ function vec_vspltw
+ (A : vector_unsigned_int;
+ B : c_int) return vector_unsigned_int
+ renames Low_Level_Interface.vec_vspltw_vui_cint_r_vui;
+
+ function vec_vspltw
+ (A : vector_bool_int;
+ B : c_int) return vector_bool_int
+ renames Low_Level_Interface.vec_vspltw_vbi_cint_r_vbi;
+
+ -- vec_vsplth --
+
+ function vec_vsplth
+ (A : vector_bool_short;
+ B : c_int) return vector_bool_short
+ renames Low_Level_Interface.vec_vsplth_vbs_cint_r_vbs;
+
+ function vec_vsplth
+ (A : vector_signed_short;
+ B : c_int) return vector_signed_short
+ renames Low_Level_Interface.vec_vsplth_vss_cint_r_vss;
+
+ function vec_vsplth
+ (A : vector_unsigned_short;
+ B : c_int) return vector_unsigned_short
+ renames Low_Level_Interface.vec_vsplth_vus_cint_r_vus;
+
+ function vec_vsplth
+ (A : vector_pixel;
+ B : c_int) return vector_pixel
+ renames Low_Level_Interface.vec_vsplth_vx_cint_r_vx;
+
+ -- vec_vspltb --
+
+ function vec_vspltb
+ (A : vector_signed_char;
+ B : c_int) return vector_signed_char
+ renames Low_Level_Interface.vec_vspltb_vsc_cint_r_vsc;
+
+ function vec_vspltb
+ (A : vector_unsigned_char;
+ B : c_int) return vector_unsigned_char
+ renames Low_Level_Interface.vec_vspltb_vuc_cint_r_vuc;
+
+ function vec_vspltb
+ (A : vector_bool_char;
+ B : c_int) return vector_bool_char
+ renames Low_Level_Interface.vec_vspltb_vbc_cint_r_vbc;
+
+ -- vec_splat_s8 --
+
+ function vec_splat_s8
+ (A : c_int) return vector_signed_char
+ renames Low_Level_Interface.vec_splat_s8_cint_r_vsc;
+
+ -- vec_splat_s16 --
+
+ function vec_splat_s16
+ (A : c_int) return vector_signed_short
+ renames Low_Level_Interface.vec_splat_s16_cint_r_vss;
+
+ -- vec_splat_s32 --
+
+ function vec_splat_s32
+ (A : c_int) return vector_signed_int
+ renames Low_Level_Interface.vec_splat_s32_cint_r_vsi;
+
+ -- vec_splat_u8 --
+
+ function vec_splat_u8
+ (A : c_int) return vector_unsigned_char
+ renames Low_Level_Interface.vec_splat_u8_cint_r_vuc;
+
+ -- vec_splat_u16 --
+
+ function vec_splat_u16
+ (A : c_int) return vector_unsigned_short
+ renames Low_Level_Interface.vec_splat_u16_cint_r_vus;
+
+ -- vec_splat_u32 --
+
+ function vec_splat_u32
+ (A : c_int) return vector_unsigned_int
+ renames Low_Level_Interface.vec_splat_u32_cint_r_vui;
+
+ -- 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;
+
+ -- vec_vsrah --
+
+ 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;
+
+ -- vec_vsrab --
+
+ 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;
+
+ -- vec_sro --
+
+ 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;
+
+ -- vec_st --
+
+ 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);
+
+ -- vec_stvehx --
+
+ 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);
+
+ -- vec_stvebx --
+
+ 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);
+
+ -- vec_stl --
+
+ 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;
+
+ -- vec_trunc --
+
+ function vec_trunc
+ (A : vector_float) return vector_float;
+
+ -- vec_unpackh --
+
+ 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;
+
+ -- vec_vupkhsh --
+
+ function vec_vupkhsh
+ (A : vector_bool_short) return vector_bool_int;
+
+ function vec_vupkhsh
+ (A : vector_signed_short) return vector_signed_int;
+
+ -- vec_vupkhpx --
+
+ function vec_vupkhpx
+ (A : vector_pixel) return vector_unsigned_int;
+
+ -- vec_vupkhsb --
+
+ function vec_vupkhsb
+ (A : vector_bool_char) return vector_bool_short;
+
+ function vec_vupkhsb
+ (A : vector_signed_char) return vector_signed_short;
+
+ -- vec_unpackl --
+
+ 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;
+
+ -- vec_vupklpx --
+
+ function vec_vupklpx
+ (A : vector_pixel) return vector_unsigned_int;
+
+ -- vec_upklsh --
+
+ 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;
+
+ ----------------------------------
+ -- [PIM-4.5 AltiVec predicates] --
+ ----------------------------------
+
+ -- 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;
+
+ -- vec_any_le --
+
+ 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;
+
+ -- vec_any_lt --
+
+ 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;
+
+ -- vec_any_nan --
+
+ function vec_any_nan
+ (A : vector_float) return c_int;
+
+ -- vec_any_ne --
+
+ 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;
+
+ -- vec_any_ngt --
+
+ function vec_any_ngt
+ (A : vector_float;
+ B : vector_float) return c_int;
+
+ -- vec_any_nle --
+
+ function vec_any_nle
+ (A : vector_float;
+ B : vector_float) return c_int;
+
+ -- vec_any_nlt --
+
+ function vec_any_nlt
+ (A : vector_float;
+ B : vector_float) return c_int;
+
+ -- vec_any_numeric --
+
+ function vec_any_numeric
+ (A : vector_float) return c_int;
+
+ -- vec_any_out --
+
+ function vec_any_out
+ (A : vector_float;
+ B : vector_float) return c_int;
+
+ -------------------------------------------
+ -- Straight overloads of routines aboves --
+ -------------------------------------------
+
+ -- vec_vaddcuw --
+
+ function vec_vaddcuw
+ (A : vector_unsigned_int;
+ B : vector_unsigned_int) return vector_unsigned_int
+ renames vec_addc;
+
+ -- vec_vand --
+
+ 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;
+
+ -- vec_vcmpgefp --
+
+ function vec_vcmpgefp
+ (A : vector_float;
+ B : vector_float) return vector_bool_int
+ renames vec_cmpge;
+
+ -- vec_vctsxs --
+
+ function vec_vctsxs
+ (A : vector_float;
+ B : c_int) return vector_signed_int
+ renames vec_cts;
+
+ -- vec_vctuxs --
+
+ function vec_vctuxs
+ (A : vector_float;
+ B : c_int) return vector_unsigned_int
+ renames vec_ctu;
+
+ -- vec_vexptefp --
+
+ 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;
+
+ -- vec_lvx --
+
+ 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;
+
+ -- vec_lvxl --
+
+ 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;
+
+ -- vec_vlogefp --
+
+ 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;
+
+ -- vec_vrsqrtefp --
+
+ function vec_vrsqrtefp
+ (A : vector_float) return vector_float
+ renames vec_rsqrte;
+
+ -- vec_vsel --
+
+ 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;
+
+ -- vec_vspltisb --
+
+ function vec_vspltisb
+ (A : c_int) return vector_signed_char
+ renames vec_splat_s8;
+
+ -- vec_vspltish --
+
+ function vec_vspltish
+ (A : c_int) return vector_signed_short
+ renames vec_splat_s16;
+
+ -- vec_vspltisw --
+
+ function vec_vspltisw
+ (A : c_int) return vector_signed_int
+ renames vec_splat_s32;
+
+ -- vec_vsr --
+
+ 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;
+
+ -- vec_vsro --
+
+ 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;
+
+ -- vec_vsubcuw --
+
+ 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;
+
+ -- vec_vsumsws --
+
+ function vec_vsumsws
+ (A : vector_signed_int;
+ B : vector_signed_int) return vector_signed_int
+ renames vec_sums;
+
+ -- vec_vrfiz --
+
+ 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;
+
+ ----------------------------------------------
+ -- [PIM 2.5.3 Value for adjusting pointers] --
+ ----------------------------------------------
+
+ -- "At compile time, vec_step (vec_data) produces the integer value
+ -- representing the amount by which a pointer to a component of an AltiVec
+ -- data type should increment to cause a pointer increment to increment by
+ -- 16 bytes".
+
+ 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
+
+ -------------------------------------
+ -- 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;
+ --
+ -- Conversely, a direct (without wrapper) binding is sometimes mandatory
+ -- in the Hard binding case, because the corresponding low level code
+ -- accept only literal values for some arguments. Inlined calls to the
+ -- wrapper with proper arguments would be fine, but the wrapper body
+ -- itself would not be compilable. These can of course also be used in the
+ -- Soft binding, and so are naturally in this common unit.
+ --
+ -- Fortunately, the sets of operations for which a wrapper is required
+ -- and the set of operations for which a wrapper would not be compilable
+ -- do not intersect.
+
+ -----------------------------
+ -- 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 the user visible subprograms shall be
+ -- inlined. 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, so...
+
+ 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);
+
+ -- Similarily, vec_step is expected to be turned into a compile time
+ -- constant, so ...
+
+ pragma Inline_Always (vec_step);
+
+end GNAT.Altivec.Vector_Operations;
--- /dev/null
+------------------------------------------------------------------------------
+-- --
+-- GNAT COMPILER COMPONENTS --
+-- --
+-- G N A T . A L T I V E C . V E C T O R _ T Y P E S --
+-- --
+-- S p e c --
+-- --
+-- Copyright (C) 2004-2005, 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 2, 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. See the GNU General Public License --
+-- for more details. You should have received a copy of the GNU General --
+-- Public License distributed with GNAT; see file COPYING. If not, write --
+-- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
+-- MA 02111-1307, USA. --
+-- --
+-- As a special exception, if other files instantiate generics from this --
+-- unit, or you link this unit with other files to produce an executable, --
+-- this unit does not by itself cause the resulting executable to be --
+-- covered by the GNU General Public License. This exception does not --
+-- however invalidate any other reasons why the executable file might be --
+-- covered by the GNU Public License. --
+-- --
+-- GNAT was originally developed by the GNAT team at New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc. --
+-- --
+------------------------------------------------------------------------------
+
+-- This unit exposes the various vector types part of the Ada binding to
+-- Altivec facilities.
+
+with GNAT.Altivec.Low_Level_Vectors;
+
+package GNAT.Altivec.Vector_Types is
+
+ use GNAT.Altivec.Low_Level_Vectors;
+
+ ---------------------------------------------------
+ -- Vector type declarations [PIM-2.1 Data Types] --
+ ---------------------------------------------------
+
+ -- Except for assignments and pointer creation/dereference, operations
+ -- on vectors are only performed via subprograms. The vector types are
+ -- then private, and non-limited since assignments are allowed.
+
+ -- The Hard/Soft binding type-structure differentiation is achieved in
+ -- Low_Level_Vectors. Each version only exposes private vector types, that
+ -- we just sub-type here. This is fine from the design standpoint and
+ -- reduces the amount of explicit conversion required in various places
+ -- internally.
+
+ subtype vector_unsigned_char is Low_Level_Vectors.LL_VUC;
+ subtype vector_signed_char is Low_Level_Vectors.LL_VSC;
+ subtype vector_bool_char is Low_Level_Vectors.LL_VBC;
+
+ subtype vector_unsigned_short is Low_Level_Vectors.LL_VUS;
+ subtype vector_signed_short is Low_Level_Vectors.LL_VSS;
+ subtype vector_bool_short is Low_Level_Vectors.LL_VBS;
+
+ subtype vector_unsigned_int is Low_Level_Vectors.LL_VUI;
+ subtype vector_signed_int is Low_Level_Vectors.LL_VSI;
+ subtype vector_bool_int is Low_Level_Vectors.LL_VBI;
+
+ subtype vector_float is Low_Level_Vectors.LL_VF;
+ subtype vector_pixel is Low_Level_Vectors.LL_VP;
+
+ -- [PIM-2.1] shows groups of declarations with exact same component types,
+ -- e.g. vector unsigned short together with vector unsigned short int. It
+ -- so appears tempting to define subtypes for those matches here.
+ --
+ -- [PIM-2.1] does not qualify items in those groups as "the same types",
+ -- though, and [PIM-2.4.2 Assignments] reads: "if either the left hand
+ -- side or the right hand side of an expression has a vector type, then
+ -- both sides of the expression must be of the same vector type".
+ --
+ -- Not so clear what is exactly right, then. We go with subtypes for now
+ -- and can adjust later if need be.
+
+ subtype vector_unsigned_short_int is vector_unsigned_short;
+ subtype vector_signed_short_int is vector_signed_short;
+
+ subtype vector_char is vector_signed_char;
+ subtype vector_short is vector_signed_short;
+ subtype vector_int is vector_signed_int;
+
+ --------------------------------
+ -- Corresponding access types --
+ --------------------------------
+
+ type vector_unsigned_char_ptr is access all vector_unsigned_char;
+ type vector_signed_char_ptr is access all vector_signed_char;
+ type vector_bool_char_ptr is access all vector_bool_char;
+
+ type vector_unsigned_short_ptr is access all vector_unsigned_short;
+ type vector_signed_short_ptr is access all vector_signed_short;
+ type vector_bool_short_ptr is access all vector_bool_short;
+
+ type vector_unsigned_int_ptr is access all vector_unsigned_int;
+ type vector_signed_int_ptr is access all vector_signed_int;
+ type vector_bool_int_ptr is access all vector_bool_int;
+
+ type vector_float_ptr is access all vector_float;
+ type vector_pixel_ptr is access all vector_pixel;
+
+ --------------------------------------------------------------------
+ -- Additional access types, for the sake of some argument passing --
+ --------------------------------------------------------------------
+
+ -- ... because some of the operations expect pointers to possibly
+ -- constant objects.
+
+ type const_vector_bool_char_ptr is access constant vector_bool_char;
+ type const_vector_signed_char_ptr is access constant vector_signed_char;
+ type const_vector_unsigned_char_ptr is access constant vector_unsigned_char;
+
+ type const_vector_bool_short_ptr is access constant vector_bool_short;
+ type const_vector_signed_short_ptr is access constant vector_signed_short;
+ type const_vector_unsigned_short_ptr is access
+ constant vector_unsigned_short;
+
+ type const_vector_bool_int_ptr is access constant vector_bool_int;
+ type const_vector_signed_int_ptr is access constant vector_signed_int;
+ type const_vector_unsigned_int_ptr is access constant vector_unsigned_int;
+
+ type const_vector_float_ptr is access constant vector_float;
+ type const_vector_pixel_ptr is access constant vector_pixel;
+
+ ----------------------
+ -- Useful shortcuts --
+ ----------------------
+
+ subtype VUC is vector_unsigned_char;
+ subtype VSC is vector_signed_char;
+ subtype VBC is vector_bool_char;
+
+ subtype VUS is vector_unsigned_short;
+ subtype VSS is vector_signed_short;
+ subtype VBS is vector_bool_short;
+
+ subtype VUI is vector_unsigned_int;
+ subtype VSI is vector_signed_int;
+ subtype VBI is vector_bool_int;
+
+ subtype VP is vector_pixel;
+ subtype VF is vector_float;
+
+end GNAT.Altivec.Vector_Types;
--- /dev/null
+------------------------------------------------------------------------------
+-- --
+-- GNAT COMPILER COMPONENTS --
+-- --
+-- G N A T . A L T I V E C . V E C T O R _ V I E W S --
+-- --
+-- S p e c --
+-- --
+-- Copyright (C) 2005, 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 2, 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. See the GNU General Public License --
+-- for more details. You should have received a copy of the GNU General --
+-- Public License distributed with GNAT; see file COPYING. If not, write --
+-- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
+-- MA 02111-1307, USA. --
+-- --
+-- As a special exception, if other files instantiate generics from this --
+-- unit, or you link this unit with other files to produce an executable, --
+-- this unit does not by itself cause the resulting executable to be --
+-- covered by the GNU General Public License. This exception does not --
+-- however invalidate any other reasons why the executable file might be --
+-- covered by the GNU Public License. --
+-- --
+-- GNAT was originally developed by the GNAT team at New York University. --
+-- Extensive contributions were provided by Ada Core Technologies Inc. --
+-- --
+------------------------------------------------------------------------------
+
+-- This unit provides public 'View' data types from/to which private vector
+-- representations can be converted via Altivec.Conversions. This allows
+-- convenient access to individual vector elements and provides a simple way
+-- to initialize vector objects.
+
+-- Accessing vector contents with direct memory overlays should be avoided
+-- because actual vector representations may vary across configurations, for
+-- instance to accomodate different target endianness.
+
+-- The natural representation of a vector is an array indexed by vector
+-- component number, which is materialized by the Varray type definitions
+-- below. The 16byte alignment constraint is unfortunately sometimes not
+-- properly honored for constant array aggregates, so the View types are
+-- actually records enclosing such arrays.
+
+package GNAT.Altivec.Vector_Views is
+
+ ---------------------
+ -- char components --
+ ---------------------
+
+ type Vchar_Range is range 1 .. 16;
+
+ type Varray_unsigned_char is array (Vchar_Range) of unsigned_char;
+ for Varray_unsigned_char'Alignment use VECTOR_ALIGNMENT;
+
+ type VUC_View is record
+ Values : Varray_unsigned_char;
+ end record;
+
+ type Varray_signed_char is array (Vchar_Range) of signed_char;
+ for Varray_signed_char'Alignment use VECTOR_ALIGNMENT;
+
+ type VSC_View is record
+ Values : Varray_signed_char;
+ end record;
+
+ type Varray_bool_char is array (Vchar_Range) of bool_char;
+ for Varray_bool_char'Alignment use VECTOR_ALIGNMENT;
+
+ type VBC_View is record
+ Values : Varray_bool_char;
+ end record;
+
+ ----------------------
+ -- short components --
+ ----------------------
+
+ type Vshort_Range is range 1 .. 8;
+
+ type Varray_unsigned_short is array (Vshort_Range) of unsigned_short;
+ for Varray_unsigned_short'Alignment use VECTOR_ALIGNMENT;
+
+ type VUS_View is record
+ Values : Varray_unsigned_short;
+ end record;
+
+ type Varray_signed_short is array (Vshort_Range) of signed_short;
+ for Varray_signed_short'Alignment use VECTOR_ALIGNMENT;
+
+ type VSS_View is record
+ Values : Varray_signed_short;
+ end record;
+
+ type Varray_bool_short is array (Vshort_Range) of bool_short;
+ for Varray_bool_short'Alignment use VECTOR_ALIGNMENT;
+
+ type VBS_View is record
+ Values : Varray_bool_short;
+ end record;
+
+ --------------------
+ -- int components --
+ --------------------
+
+ type Vint_Range is range 1 .. 4;
+
+ type Varray_unsigned_int is array (Vint_Range) of unsigned_int;
+ for Varray_unsigned_int'Alignment use VECTOR_ALIGNMENT;
+
+ type VUI_View is record
+ Values : Varray_unsigned_int;
+ end record;
+
+ type Varray_signed_int is array (Vint_Range) of signed_int;
+ for Varray_signed_int'Alignment use VECTOR_ALIGNMENT;
+
+ type VSI_View is record
+ Values : Varray_signed_int;
+ end record;
+
+ type Varray_bool_int is array (Vint_Range) of bool_int;
+ for Varray_bool_int'Alignment use VECTOR_ALIGNMENT;
+
+ type VBI_View is record
+ Values : Varray_bool_int;
+ end record;
+
+ ----------------------
+ -- float components --
+ ----------------------
+
+ type Vfloat_Range is range 1 .. 4;
+
+ type Varray_float is array (Vfloat_Range) of C_float;
+ for Varray_float'Alignment use VECTOR_ALIGNMENT;
+
+ type VF_View is record
+ Values : Varray_float;
+ end record;
+
+ ----------------------
+ -- pixel components --
+ ----------------------
+
+ type Vpixel_Range is range 1 .. 8;
+
+ type Varray_pixel is array (Vpixel_Range) of pixel;
+ for Varray_pixel'Alignment use VECTOR_ALIGNMENT;
+
+ type VP_View is record
+ Values : Varray_pixel;
+ end record;
+
+end GNAT.Altivec.Vector_Views;
-- GNAT Library Units --
------------------------
+ "g-altive", -- GNAT.Altivec
+ "g-alvety", -- GNAT.Altivec.Vector_Types
+ "g-alvevi", -- GNAT.Altivec.Vector_Views
+ "g-alveop", -- GNAT.Altivec.Vector_Operations
+ "g-altcon", -- GNAT.Altivec.Conversions
"g-arrspl", -- GNAT.Array_Split
"g-awk ", -- GNAT.AWK
"g-boubuf", -- GNAT.Bounded_Buffers
"a-stzmap", -- Ada.Strings.Wide_Wide_Maps
"a-stzunb", -- Ada.Strings.Wide_Wide_Unbounded
"a-swuwha", -- Ada.Strings.Wide_Unbounded.Wide_Hash
- "a-szmzco", -- Ada.Strings.Wide_Wide_Maps.Wide_Wide_Constants;
+ "a-szmzco", -- Ada.Strings.Wide_Wide_Maps.Wide_Wide_Constants
"a-szuzha", -- Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Hash
- "a-tgdico", -- Ada.Tags.Generic_Dispatching_Constructor;
- "a-tiunio", -- Ada.Text_IO.Unbounded_IO;
+ "a-taster", -- Ada.Task_Termination
+ "a-tgdico", -- Ada.Tags.Generic_Dispatching_Constructor
+ "a-tiunio", -- Ada.Text_IO.Unbounded_IO
"a-wichun", -- Ada.Wide_Characters.Unicode
- "a-wwunio", -- Ada.Wide_Text_IO.Wide_Unbounded_IO;
+ "a-wwunio", -- Ada.Wide_Text_IO.Wide_Unbounded_IO
"a-zchara", -- Ada.Wide_Wide_Characters
"a-zttest", -- Ada.Wide_Wide_Text_IO.Text_Streams
"a-ztexio", -- Ada.Wide_Wide_Text_IO
-- Set True for dynamic elaboration checking mode, as set by the -gnatE
-- switch or by the use of pragma Elaboration_Checks (Dynamic).
+ Dynamic_Stack_Measurement : Boolean := False;
+ -- GNATBIND
+ -- Set True to enable dynamic stack measurement (-u flag for gnatbind)
+
+ Dynamic_Stack_Measurement_Array_Size : Nat := 100;
+ -- GNATBIND
+ -- Number of measurements we want to store during dynamic stack analysis.
+ -- When the buffer is full, non-storable results will be output on the fly.
+ -- The value is relevant only if Dynamic_Stack_Measurement is set. Set
+ -- by processing of -u flag for gnatbind.
+
Elab_Dependency_Output : Boolean := False;
-- GNATBIND
-- Set to True to output complete list of elaboration constraints
-- extension, as set by the appropriate switch. If no switch is given,
-- then this value is initialized by Osint to the appropriate value.
- Max_Line_Length : Int := Hostparm.Max_Line_Length;
- -- This is a copy of Max_Line_Length used by the scanner. It is usually
- -- set to be a copy of Hostparm.Max_Line_Length, and is used to check
- -- the maximum line length in the scanner when style checking is inactive.
- -- The only time it is set to a different value is during the scanning of
- -- configuration pragma files, where we want to turn off all checking and
- -- in particular we want to allow long lines. So we reset this value to
- -- Column_Number'Last during scanning of configuration pragma files.
-
Maximum_Processes : Positive := 1;
-- GNATMAKE, GPRMAKE
-- Maximum number of processes that should be spawned to carry out
-- Initialization of package, set Adafinal soft link
begin
- SSL.Adafinal := Finalize_Global_List'Access;
+ SSL.Finalize_Global_List := Finalize_Global_List'Access;
end System.Finalization_Implementation;
-- --
-- B o d y --
-- --
--- Copyright (C) 1992-2005 Free Software Foundation, Inc. --
+-- Copyright (C) 1992-2005, 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- --
package body System.IO is
+ Current_Out : File_Type := Stdout;
+ pragma Atomic (Current_Out);
+ -- Current output file (modified by Set_Output)
+
--------------
-- New_Line --
--------------
---------
procedure Put (X : Integer) is
-
procedure Put_Int (X : Integer);
pragma Import (C, Put_Int, "put_int");
+ procedure Put_Int_Err (X : Integer);
+ pragma Import (C, Put_Int_Err, "put_int_stderr");
+
begin
- Put_Int (X);
+ case Current_Out is
+ when Stdout =>
+ Put_Int (X);
+ when Stderr =>
+ Put_Int_Err (X);
+ end case;
end Put;
procedure Put (C : Character) is
-
procedure Put_Char (C : Character);
pragma Import (C, Put_Char, "put_char");
+ procedure Put_Char_Stderr (C : Character);
+ pragma Import (C, Put_Char_Stderr, "put_char_stderr");
+
begin
- Put_Char (C);
+ case Current_Out is
+ when Stdout =>
+ Put_Char (C);
+ when Stderr =>
+ Put_Char_Stderr (C);
+ end case;
end Put;
procedure Put (S : String) is
New_Line;
end Put_Line;
+ ---------------------
+ -- Standard_Output --
+ ---------------------
+
+ function Standard_Output return File_Type is
+ begin
+ return Stdout;
+ end Standard_Output;
+
+ --------------------
+ -- Standard_Error --
+ --------------------
+
+ function Standard_Error return File_Type is
+ begin
+ return Stderr;
+ end Standard_Error;
+
+ ----------------
+ -- Set_Output --
+ ----------------
+
+ procedure Set_Output (File : in File_Type) is
+ begin
+ Current_Out := File;
+ end Set_Output;
+
end System.IO;
-- --
-- S p e c --
-- --
--- Copyright (C) 1992-2005 Free Software Foundation, Inc. --
+-- Copyright (C) 1992-2005, 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- --
procedure New_Line (Spacing : Positive := 1);
+ type File_Type is limited private;
+
+ function Standard_Error return File_Type;
+ function Standard_Output return File_Type;
+
+ procedure Set_Output (File : in File_Type);
+
+private
+
+ type File_Type is (Stdout, Stderr);
+ -- Stdout = Standard_Output, Stderr = Standard_Error
+
+ pragma Inline (Standard_Error);
+ pragma Inline (Standard_Output);
+
end System.IO;
null;
end Abort_Undefer_NT;
+ -----------------
+ -- Adafinal_NT --
+ -----------------
+
+ procedure Adafinal_NT is
+ begin
+ -- Handle normal task termination by the environment task, but only
+ -- for the normal task termination. In the case of Abnormal and
+ -- Unhandled_Exception they must have been handled before, and the
+ -- task termination soft link must have been changed so the task
+ -- termination routine is not executed twice.
+
+ Task_Termination_Handler.all (Ada.Exceptions.Null_Occurrence);
+
+ -- Finalize the global list for controlled objects if needed
+
+ Finalize_Global_List.all;
+ end Adafinal_NT;
+
---------------------------
-- Check_Abort_Status_NT --
---------------------------
return NT_TSD.Pri_Stack_Info'Access;
end Get_Stack_Info_NT;
- -------------------
- -- Null_Adafinal --
- -------------------
+ -------------------------------
+ -- Null_Finalize_Global_List --
+ -------------------------------
- procedure Null_Adafinal is
+ procedure Null_Finalize_Global_List is
begin
null;
- end Null_Adafinal;
+ end Null_Finalize_Global_List;
---------------------------
-- Set_Jmpbuf_Address_NT --
end Task_Unlock_NT;
-------------------------
+ -- Task_Termination_NT --
+ -------------------------
+
+ procedure Task_Termination_NT (Excep : EO) is
+ pragma Warnings (Off, Excep);
+ begin
+ null;
+ end Task_Termination_NT;
+
+ -------------------------
-- Update_Exception_NT --
-------------------------
type No_Param_Proc is access procedure;
type Addr_Param_Proc is access procedure (Addr : Address);
+ type EO_Param_Proc is access procedure (Excep : EO);
type Get_Address_Call is access function return Address;
type Set_Address_Call is access procedure (Addr : Address);
pragma Suppress (Access_Check, No_Param_Proc);
pragma Suppress (Access_Check, Addr_Param_Proc);
+ pragma Suppress (Access_Check, EO_Param_Proc);
pragma Suppress (Access_Check, Get_Address_Call);
pragma Suppress (Access_Check, Set_Address_Call);
pragma Suppress (Access_Check, Set_Address_Call2);
procedure Task_Unlock_NT;
-- Release lock set by Task_Lock (non-tasking case, does nothing)
- procedure Null_Adafinal;
- -- Shuts down the runtime system (non-tasking no-finalization case,
- -- does nothing)
+ procedure Task_Termination_NT (Excep : EO);
+ -- Handle task termination routines for the environment task (non-tasking
+ -- case, does nothing).
+
+ procedure Null_Finalize_Global_List;
+ -- Finalize global list for controlled objects (does nothing)
+
+ procedure Adafinal_NT;
+ -- Shuts down the runtime system (non-tasking case)
Abort_Defer : No_Param_Proc := Abort_Defer_NT'Access;
pragma Suppress (Access_Check, Abort_Defer);
-- This ensures that the lock is not left set if an exception is raised
-- explicitly or implicitly during the critical locked region.
- Adafinal : No_Param_Proc := Null_Adafinal'Access;
+ Task_Termination_Handler : EO_Param_Proc := Task_Termination_NT'Access;
+ -- Handle task termination routines (task/non-task case as appropriate)
+
+ Finalize_Global_List : No_Param_Proc := Null_Finalize_Global_List'Access;
+ -- Performs finalization of global list for controlled objects
+
+ Adafinal : No_Param_Proc := Adafinal_NT'Access;
-- Performs the finalization of the Ada Runtime
function Get_Jmpbuf_Address_NT return Address;
with System.Tasking;
-- Used for Task_Id
+-- Cause_Of_Termination
+
+with Ada.Exceptions;
+-- Used for Exception_Id
+-- Exception_Occurrence
+-- Save_Occurrence
+
+with Ada.Exceptions.Is_Null_Occurrence;
package body System.Soft_Links.Tasking is
package STPO renames System.Task_Primitives.Operations;
package SSL renames System.Soft_Links;
+ use Ada.Exceptions;
+
+ use type System.Tasking.Task_Id;
+ use type System.Tasking.Termination_Handler;
+
----------------
-- Local Data --
----------------
procedure Timed_Delay_T (Time : Duration; Mode : Integer);
-- Task-safe version of SSL.Timed_Delay
+ procedure Task_Termination_Handler_T (Excep : SSL.EO);
+ -- Task-safe version of the task termination procedure
+
--------------------------
-- Soft-Link Get Bodies --
--------------------------
end if;
end Timed_Delay_T;
+ --------------------------------
+ -- Task_Termination_Handler_T --
+ --------------------------------
+
+ procedure Task_Termination_Handler_T (Excep : SSL.EO) is
+ Self_Id : constant System.Tasking.Task_Id := STPO.Self;
+ Cause : System.Tasking.Cause_Of_Termination;
+ EO : Ada.Exceptions.Exception_Occurrence;
+
+ begin
+ -- We can only be here because we are terminating the environment task.
+ -- Task termination for the rest of the tasks is handled in the
+ -- Task_Wrapper.
+
+ pragma Assert (Self_Id = STPO.Environment_Task);
+
+ -- Normal task termination
+
+ if Is_Null_Occurrence (Excep) then
+ Cause := System.Tasking.Normal;
+ Ada.Exceptions.Save_Occurrence (EO, Ada.Exceptions.Null_Occurrence);
+
+ -- Abnormal task termination
+
+ elsif Exception_Identity (Excep) = Standard'Abort_Signal'Identity then
+ Cause := System.Tasking.Abnormal;
+ Ada.Exceptions.Save_Occurrence (EO, Ada.Exceptions.Null_Occurrence);
+
+ -- Termination because of an unhandled exception
+
+ else
+ Cause := System.Tasking.Unhandled_Exception;
+ Ada.Exceptions.Save_Occurrence (EO, Excep);
+ end if;
+
+ if Self_Id.Common.Specific_Handler /= null then
+ Self_Id.Common.Specific_Handler.all (Cause, Self_Id, EO);
+ elsif Self_Id.Common.Fall_Back_Handler /= null then
+ Self_Id.Common.Fall_Back_Handler.all (Cause, Self_Id, EO);
+ end if;
+ end Task_Termination_Handler_T;
+
-----------------------------
-- Init_Tasking_Soft_Links --
-----------------------------
-- The application being executed uses tasking so that the tasking
-- version of the following soft links need to be used.
- SSL.Get_Jmpbuf_Address := Get_Jmpbuf_Address'Access;
- SSL.Set_Jmpbuf_Address := Set_Jmpbuf_Address'Access;
- SSL.Get_Sec_Stack_Addr := Get_Sec_Stack_Addr'Access;
- SSL.Set_Sec_Stack_Addr := Set_Sec_Stack_Addr'Access;
- SSL.Get_Current_Excep := Get_Current_Excep'Access;
- SSL.Timed_Delay := Timed_Delay_T'Access;
+ SSL.Get_Jmpbuf_Address := Get_Jmpbuf_Address'Access;
+ SSL.Set_Jmpbuf_Address := Set_Jmpbuf_Address'Access;
+ SSL.Get_Sec_Stack_Addr := Get_Sec_Stack_Addr'Access;
+ SSL.Set_Sec_Stack_Addr := Set_Sec_Stack_Addr'Access;
+ SSL.Get_Current_Excep := Get_Current_Excep'Access;
+ SSL.Timed_Delay := Timed_Delay_T'Access;
+ SSL.Task_Termination_Handler := Task_Termination_Handler_T'Access;
-- No need to create a new Secondary Stack, since we will use the
-- default one created in s-secsta.adb
with System.Address_To_Access_Conversions;
package System.Stack_Usage is
+ pragma Preelaborate;
package SSE renames System.Storage_Elements;
for Word_32'Alignment use 4;
subtype Stack_Address is SSE.Integer_Address;
- -- Address on the stack.
+ -- Address on the stack
--
- -- NOTE:
- -- *****
- --
- -- in this package, when comparing two addresses on the
- -- stack, the comments use the terms "outer", "inner", "outermost"
- -- and "innermost" instead of the ambigous "higher", "lower",
- -- "highest" and "lowest". "inner" means "closer to the bottom of
- -- stack" and is the contrary of "outer". "innermost" means "closest
- -- address to the bottom of stack". The stack is growing from the
- -- innermost addresses to the outermost addresses.
+ -- Note: in this package, when comparing two addresses on the stack, the
+ -- comments use the terms "outer", "inner", "outermost" and "innermost"
+ -- instead of the ambigous "higher", "lower", "highest" and "lowest".
+ -- "inner" means "closer to the bottom of stack" and is the contrary of
+ -- "outer". "innermost" means "closest address to the bottom of stack". The
+ -- stack is growing from the inner to the outer.
+
+ -- Top/Bottom would be much better than inner and outer ???
- function To_Stack_Address (Value : Address) return Stack_Address
- renames System.Storage_Elements.To_Integer;
+ function To_Stack_Address (Value : System.Address) return Stack_Address
+ renames System.Storage_Elements.To_Integer;
type Stack_Analyzer is private;
-- Type of the stack analyzer tool. It is used to fill a portion of
-- the stack with Pattern, and to compute the stack used after some
-- execution.
- --
- -- USAGE:
- -- ******
- --
- -- -- A typical use of the package is something like:
- --
+
+ -- Usage:
+
+ -- A typical use of the package is something like:
+
-- A : Stack_Analyzer;
- --
+
-- task T is
-- pragma Storage_Size (A_Storage_Size);
-- end T;
- --
+
-- [...]
- --
+
-- Bottom_Of_Stack : aliased Integer;
-- -- Bottom_Of_Stack'Address will be used as an approximation of
-- -- the bottom of stack. A good practise is to avoid allocating
-- -- other local variables on this stack, as it would degrade
-- -- the quality of this approximation.
- --
+
-- begin
-- Initialize_Analyzer (A,
-- "Task t",
-- Compute_Result (A);
-- Report_Result (A);
-- end T;
- --
- --
+
-- Errors:
- -- *******
--
-- We are instrumenting the code to measure the stack used by the user
-- code. This method has a number of systematic errors, but several
-- methods can be used to evaluate or reduce those errors. Here are
-- those errors and the strategy that we use to deal with them:
- --
- -- * Bottom offset:
- -- - Description: The procedure used to fill the stack with a given
- -- pattern will itself have a stack frame. The value of the stack pointer
- -- in this procedure is, therefore, different from the value before the
- -- call to the instrumentation procedure.
- -- - Strategy: The user of this package shall measure the bottom of stack
- -- before the call to Fill_Stack and pass it in parameter.
- --
- -- * Instrumentation threshold at writing:
- -- - Description: The procedure used to fill the stack with a given
- -- pattern will itself have a stack frame. Therefore, it will
- -- fill the stack after this stack frame. This part of the stack will
- -- appear as used in the final measure.
- -- - Strategy: As the user pass the value of the bottom of stack to
- -- the instrumentation to deal with the bottom offset error, and as
- -- as the instrumentation procedure knows where the pattern filling
- -- start on the stack, the difference between the two values is the
- -- minimum stack usage that the method can measure. If, when the results
- -- are computed, the pattern zone has been left untouched, we conclude
- -- that the stack usage is inferior to this minimum stack usage.
- --
- -- * Instrumentation threshold at reading:
- -- - Description: The procedure used to read the stack at the end of the
- -- execution clobbers the stack by allocating its stack frame. If this
- -- stack frame is bigger than the total stack used by the user code at
- -- this point, it will increase the measured stack size.
- -- - Strategy: We could augment this stack frame and see if it changes the
- -- measure. However, this error should be negligeable.
- --
- -- * Pattern zone overflow:
- -- - Description: The stack grows outer than the outermost bound of the
- -- pattern zone. In that case, the outermost region modified in the
- -- pattern is not the maximum value of the stack pointer during the
- -- execution.
- -- - Strategy: At the end of the execution, the difference between the
- -- outermost memory region modified in the pattern zone and the
- -- outermost bound of the pattern zone can be understood as the
- -- biggest allocation that the method could have detect, provided
- -- that there is no "Untouched allocated zone" error and no "Pattern
- -- usage in user code" error. If no object in the user code is likely
- -- to have this size, this is not likely to happen.
- --
- -- * Pattern usage in user code:
- -- - Description: The pattern can be found in the object of the user
- -- code. Therefore, the address space where this object has been
- -- allocated will appear as untouched.
- -- - Strategy: Choose a pattern that is uncommon. 16#0000_0000# is the
- -- worst choice; 16#DEAD_BEEF# can be a good one. A good choice is an
- -- address which is not a multiple of 2, and which is not in the
- -- target address space. You can also change the pattern to see if
- -- it changes the measure. Note that this error *very* rarely influence
- -- the measure of the total stack usage: to have some influence, the
- -- pattern has to be used in the object that has been allocated on the
- -- outermost address of the used stack.
- --
- -- * Stack overflow:
- -- - Description: The pattern zone does not fit on the stack.
- -- This may lead to an erroneous execution.
- -- - Strategy: Specify a storage size that is bigger than the
- -- size of the pattern. 2 times bigger should be enough.
- --
- -- * Augmentation of the user stack frames:
- -- - Description: The use of instrumentation object or procedure may
- -- augment the stack frame of the caller.
- -- - Strategy: Do *not* inline the instrumentation procedures. Do *not*
- -- allocate the Stack_Analyzer object on the stack.
- --
- -- * Untouched allocated zone:
- -- - Description: The user code may allocate objects that it will never
- -- touch. In that case, the pattern will not be changed.
- -- - Strategy: There are no way to detect this error. Fortunately, this
- -- error is really rare, and it is most probably a bug in the user code,
- -- e.g. some uninitialized variable. It is (most of the time) harmless:
- -- it influences the measure only if the untouched allocated zone
- -- happens to be located at the outermost value of the stack pointer
- -- for the whole execution.
+
+ -- Bottom offset:
+
+ -- Description: The procedure used to fill the stack with a given
+ -- pattern will itself have a stack frame. The value of the stack
+ -- pointer in this procedure is, therefore, different from the value
+ -- before the call to the instrumentation procedure.
+
+ -- Strategy: The user of this package should measure the bottom of stack
+ -- before the call to Fill_Stack and pass it in parameter.
+
+ -- Instrumentation threshold at writing:
+
+ -- Description: The procedure used to fill the stack with a given
+ -- pattern will itself have a stack frame. Therefore, it will
+ -- fill the stack after this stack frame. This part of the stack will
+ -- appear as used in the final measure.
+
+ -- Strategy: As the user passes the value of the bottom of stack to
+ -- the instrumentation to deal with the bottom offset error, and as as
+ -- the instrumentation procedure knows where the pattern filling start
+ -- on the stack, the difference between the two values is the minimum
+ -- stack usage that the method can measure. If, when the results are
+ -- computed, the pattern zone has been left untouched, we conclude
+ -- that the stack usage is inferior to this minimum stack usage.
+
+ -- Instrumentation threshold at reading:
+
+ -- Description: The procedure used to read the stack at the end of the
+ -- execution clobbers the stack by allocating its stack frame. If this
+ -- stack frame is bigger than the total stack used by the user code at
+ -- this point, it will increase the measured stack size.
+
+ -- Strategy: We could augment this stack frame and see if it changes the
+ -- measure. However, this error should be negligeable.
+
+ -- Pattern zone overflow:
+
+ -- Description: The stack grows outer than the outermost bound of the
+ -- pattern zone. In that case, the outermost region modified in the
+ -- pattern is not the maximum value of the stack pointer during the
+ -- execution.
+
+ -- Strategy: At the end of the execution, the difference between the
+ -- outermost memory region modified in the pattern zone and the
+ -- outermost bound of the pattern zone can be understood as the
+ -- biggest allocation that the method could have detect, provided
+ -- that there is no "Untouched allocated zone" error and no "Pattern
+ -- usage in user code" error. If no object in the user code is likely
+ -- to have this size, this is not likely to happen.
+
+ -- Pattern usage in user code:
+
+ -- Description: The pattern can be found in the object of the user code.
+ -- Therefore, the address space where this object has been allocated
+ -- will appear as untouched.
+
+ -- Strategy: Choose a pattern that is uncommon. 16#0000_0000# is the
+ -- worst choice; 16#DEAD_BEEF# can be a good one. A good choice is an
+ -- address which is not a multiple of 2, and which is not in the
+ -- target address space. You can also change the pattern to see if it
+ -- changes the measure. Note that this error *very* rarely influence
+ -- the measure of the total stack usage: to have some influence, the
+ -- pattern has to be used in the object that has been allocated on the
+ -- outermost address of the used stack.
+
+ -- Stack overflow:
+
+ -- Description: The pattern zone does not fit on the stack. This may
+ -- lead to an erroneous execution.
+
+ -- Strategy: Specify a storage size that is bigger than the size of the
+ -- pattern. 2 times bigger should be enough.
+
+ -- Augmentation of the user stack frames:
+
+ -- Description: The use of instrumentation object or procedure may
+ -- augment the stack frame of the caller.
+
+ -- Strategy: Do *not* inline the instrumentation procedures. Do *not*
+ -- allocate the Stack_Analyzer object on the stack.
+
+ -- Untouched allocated zone:
+
+ -- Description: The user code may allocate objects that it will never
+ -- touch. In that case, the pattern will not be changed.
+
+ -- Strategy: There are no way to detect this error. Fortunately, this
+ -- error is really rare, and it is most probably a bug in the user
+ -- code, e.g. some uninitialized variable. It is (most of the time)
+ -- harmless: it influences the measure only if the untouched allocated
+ -- zone happens to be located at the outermost value of the stack
+ -- pointer for the whole execution.
+
+ procedure Initialize (Buffer_Size : Natural);
+ pragma Export (C, Initialize, "__gnat_stack_usage_initialize");
+ -- Initializes the size of the buffer that stores the results. Only the
+ -- first Buffer_Size results are stored. Any results that do not fit in
+ -- this buffer will be displayed on the fly.
procedure Fill_Stack (Analyzer : in out Stack_Analyzer);
-- Fill an area of the stack with the pattern Analyzer.Pattern. The size
-- Analyzer.Inner_Pattern_Mark ^
-- Analyzer.Outer_Pattern_Mark
+ procedure Initialize_Analyzer
+ (Analyzer : in out Stack_Analyzer;
+ Task_Name : String;
+ Size : Natural;
+ Bottom : Stack_Address;
+ Pattern : Word_32 := 16#DEAD_BEEF#);
+ -- Should be called before any use of a Stack_Analyzer, to initialize it.
+ -- Size is the size of the pattern zone. Bottom should be a close
+ -- approximation of the caller base frame address.
+
+ Is_Enabled : Boolean := False;
+ -- When this flag is true, then stack analysis is enabled
+
procedure Compute_Result (Analyzer : in out Stack_Analyzer);
- -- Read the patern zone and deduce the stack usage. It should
- -- be called from the same frame as Fill_Stack. If Analyzer.Probe is not
- -- null, an array of Word_32 with Analyzer.Probe elements is allocated on
- -- Compute_Result's stack frame. Probe can be used to detect an
- -- "instrumentation threshold at reading" error; See above.
- -- After the call to this procedure, the memory will look like:
+ -- Read the patern zone and deduce the stack usage. It should be called
+ -- from the same frame as Fill_Stack. If Analyzer.Probe is not null, an
+ -- array of Word_32 with Analyzer.Probe elements is allocated on
+ -- Compute_Result's stack frame. Probe can be used to detect the error:
+ -- "instrumentation threshold at reading". See above. After the call
+ -- to this procedure, the memory will look like:
--
-- Stack growing
-- ----------------------------------------------------------------------->
procedure Report_Result (Analyzer : Stack_Analyzer);
-- Store the results of the computation in memory, at the address
- -- corresponding to the symbol __gnat_stack_usage_results.
-
- type Parameterless_Procedure is access procedure;
-
- procedure Initialize_Analyzer
- (Analyzer : in out Stack_Analyzer;
- Task_Name : String;
- Size : Natural;
- Bottom : Stack_Address;
- Pattern : Word_32 := 16#DEAD_BEEF#);
- -- Should be called before any use of a Stack_Analyzer, to initialize it.
- -- Size is the size of the pattern zone.
- -- Bottom should be a close approximation of the caller base
- -- frame address.
+ -- corresponding to the symbol __gnat_stack_usage_results. This is not
+ -- done inside Compute_Resuls in order to use as less stack as possible
+ -- within a task.
procedure Output_Results;
-- Print the results computed so far on the standard output. Should be
-- called when all tasks are dead.
+ pragma Export (C, Output_Results, "__gnat_stack_usage_output_results");
+
private
+ Task_Name_Length : constant := 32;
+
package Word_32_Addr is
- new System.Address_To_Access_Conversions (Word_32);
+ new System.Address_To_Access_Conversions (Word_32);
- type Result_Array_Id is range 0 .. 1_023;
+ type Stack_Analyzer is record
+ Task_Name : String (1 .. Task_Name_Length);
+ -- Name of the task
- type Stack_Analyzer
- is record
- Size : Natural;
- -- Size of the pattern zone.
+ Size : Natural;
+ -- Size of the pattern zone
- Pattern : Word_32 := 16#DEAD_BEEF#;
- -- Pattern used to recognize untouched memory.
+ Pattern : Word_32;
+ -- Pattern used to recognize untouched memory
- Inner_Pattern_Mark : Stack_Address;
- -- Innermost bound of the pattern area on the stack.
+ Inner_Pattern_Mark : Stack_Address;
+ -- Innermost bound of the pattern area on the stack
- Outer_Pattern_Mark : Stack_Address;
- -- Outermost bound of the pattern area on the stack.
+ Outer_Pattern_Mark : Stack_Address;
+ -- Outermost bound of the pattern area on the stack
Outermost_Touched_Mark : Stack_Address;
-- Outermost address of the pattern area whose value it is pointing
-- compensated, it is the outermost value of the stack pointer during
-- the execution.
- Bottom_Of_Stack : Stack_Address;
+ Bottom_Of_Stack : Stack_Address;
-- Address of the bottom of the stack, as given by the caller of
-- Initialize_Analyzer.
- Array_Address : Address;
- -- Address of the array of Word_32 that represents the pattern zone.
+ Array_Address : System.Address;
+ -- Address of the array of Word_32 that represents the pattern zone
- First_Is_Outermost : Boolean;
+ First_Is_Outermost : Boolean;
-- Set to true if the first element of the array of Word_32 that
-- represents the pattern zone is at the outermost address of the
-- pattern zone; false if it is the innermost address.
- Result_Id : Result_Array_Id;
- -- Location in the result array of the result for the current task.
+ Result_Id : Positive;
+ -- Id of the result. If less than value given to gnatbind -u corresponds
+ -- to the location in the result array of result for the current task.
+ end record;
+
+ Environment_Task_Analyzer : Stack_Analyzer;
+
+ Compute_Environment_Task : Boolean;
+
+ type Task_Result is record
+ Task_Name : String (1 .. Task_Name_Length);
+ Measure : Natural;
+ Max_Size : Natural;
end record;
+ type Result_Array_Type is array (Positive range <>) of Task_Result;
+ type Result_Array_Ptr is access all Result_Array_Type;
+
+ Result_Array : Result_Array_Ptr;
+ pragma Export (C, Result_Array, "__gnat_stack_usage_results");
+ -- Exported in order to have an easy accessible symbol in when debugging
+
+ Next_Id : Positive := 1;
+ -- Id of the next stack analyzer
+
+ function Stack_Size
+ (SP_Low : Stack_Address;
+ SP_High : Stack_Address) return Natural;
+ pragma Inline (Stack_Size);
+ -- Return the size of a portion of stack delimeted by SP_High and SP_Low
+ -- (), i.e. the difference between SP_High and SP_Low. The storage element
+ -- pointed by SP_Low is not included in the size. Inlined to reduce the
+ -- size of the stack used by the instrumentation code.
+
end System.Stack_Usage;
-- Turn off polling, we do not want ATC polling to take place during
-- tasking operations. It causes infinite loops and other problems.
+with Ada.Exceptions;
+-- used for Exception_Occurrence
+
with System.Parameters;
-- used for Size_Type
-- Single_Lock
package SSE renames System.Storage_Elements;
package SST renames System.Secondary_Stack;
+ use Ada.Exceptions;
+
use Parameters;
use Task_Primitives.Operations;
use Task_Info;
---------------
procedure Task_Lock is
+ Self_ID : constant Task_Id := STPO.Self;
+
begin
- STPO.Write_Lock (Global_Task_Lock'Access, Global_Lock => True);
+ Self_ID.Common.Global_Task_Lock_Nesting :=
+ Self_ID.Common.Global_Task_Lock_Nesting + 1;
+
+ if Self_ID.Common.Global_Task_Lock_Nesting = 1 then
+ STPO.Write_Lock (Global_Task_Lock'Access, Global_Lock => True);
+ end if;
end Task_Lock;
-----------------
-----------------
procedure Task_Unlock is
+ Self_ID : constant Task_Id := STPO.Self;
+
begin
- STPO.Unlock (Global_Task_Lock'Access, Global_Lock => True);
+ pragma Assert (Self_ID.Common.Global_Task_Lock_Nesting > 0);
+ Self_ID.Common.Global_Task_Lock_Nesting :=
+ Self_ID.Common.Global_Task_Lock_Nesting - 1;
+
+ if Self_ID.Common.Global_Task_Lock_Nesting = 0 then
+ STPO.Unlock (Global_Task_Lock'Access, Global_Lock => True);
+ end if;
end Task_Unlock;
------------------
procedure Task_Wrapper (Self_ID : Task_Id) is
ID : Task_Id := Self_ID;
pragma Volatile (ID);
-
pragma Warnings (Off, ID);
- -- Turn off warnings (stand alone volatile constant has to be
- -- imported, so we cannot just make ID constant).
-
- -- Do not delete this variable.
- -- In some targets, we need this variable to implement a fast Self.
+ -- Variable used on some targets to implement a fast self. We turn off
+ -- warnings because a stand alone volatile constant has to be imported,
+ -- so we don't want warnings about ID not being referenced, and volatile
+ -- having no effect.
+ --
+ -- DO NOT delete ID. As noted, it is needed on some targets.
use type System.Parameters.Size_Type;
use type SSE.Storage_Offset;
Secondary_Stack : aliased SSE.Storage_Array
(1 .. Self_ID.Common.Compiler_Data.Pri_Stack_Info.Size *
- SSE.Storage_Offset (Parameters.Sec_Stack_Ratio) / 100);
+ SSE.Storage_Offset (Parameters.Sec_Stack_Ratio) / 100);
+
+ pragma Warnings (Off);
Secondary_Stack_Address : System.Address := Secondary_Stack'Address;
+ pragma Warnings (On);
+ -- Address of secondary stack. In the fixed secondary stack case, this
+ -- value is not modified, causing a warning, hence the bracketing with
+ -- Warnings (Off/On).
+
+ Cause : Cause_Of_Termination := Normal;
+ -- Indicates the reason why this task terminates. Normal corresponds to
+ -- a task terminating due to completing the last statement of its body.
+ -- If the task terminates because of an exception raised by the
+ -- execution of its task body, then Cause is set to Unhandled_Exception.
+ -- Aborts are not allowed in the restriced profile to which this file
+ -- belongs.
+
+ EO : Exception_Occurrence;
+ -- If the task terminates because of an exception raised by the
+ -- execution of its task body, then EO will contain the associated
+ -- exception occurrence. Otherwise, it will contain Null_Occurrence.
begin
if not Parameters.Sec_Stack_Dynamic then
Enter_Task (Self_ID);
- -- Call the task body procedure.
+ -- Call the task body procedure
begin
-- We are separating the following portion of the code in order to
- -- place the exception handlers in a different block.
- -- In this way we do not call Set_Jmpbuf_Address (which needs
- -- Self) before we set Self in Enter_Task.
+ -- place the exception handlers in a different block. In this way we
+ -- do not call Set_Jmpbuf_Address (which needs Self) before we set
+ -- Self in Enter_Task.
+
-- Note that in the case of Ravenscar HI-E where there are no
-- exception handlers, the exception handler is suppressed.
- -- Call the task body procedure.
+ -- Call the task body procedure
Self_ID.Common.Task_Entry_Point (Self_ID.Common.Task_Arg);
- Terminate_Task (Self_ID);
+
+ -- Normal task termination
+
+ Cause := Normal;
+ Save_Occurrence (EO, Ada.Exceptions.Null_Occurrence);
exception
- when others =>
- Terminate_Task (Self_ID);
+ when E : others =>
+
+ -- Task terminating because of an unhandled exception
+
+ Cause := Unhandled_Exception;
+ Save_Occurrence (EO, E);
end;
+
+ -- Look for a fall-back handler. It can be either in the task itself
+ -- or in the environment task. Note that this code is always executed
+ -- by a task whose master is the environment task. The task termination
+ -- code for the environment task is executed by
+ -- SSL.Task_Termination_Handler.
+
+ -- This package is part of the restricted run time which supports
+ -- neither task hierarchies (No_Task_Hierarchy) nor specific task
+ -- termination handlers (No_Specific_Termination_Handlers).
+
+ if Self_ID.Common.Fall_Back_Handler /= null then
+ Self_ID.Common.Fall_Back_Handler.all (Cause, Self_ID, EO);
+ elsif Self_ID.Common.Parent.Common.Fall_Back_Handler /= null then
+ Self_ID.Common.Parent.Common.Fall_Back_Handler.all
+ (Cause, Self_ID, EO);
+ end if;
+
+ Terminate_Task (Self_ID);
end Task_Wrapper;
-----------------------
-- Activate_Restricted_Tasks --
-------------------------------
- -- Note that locks of activator and activated task are both locked
- -- here. This is necessary because C.State and Self.Wait_Count
- -- have to be synchronized. This is safe from deadlock because
- -- the activator is always created before the activated task.
- -- That satisfies our in-order-of-creation ATCB locking policy.
+ -- Note that locks of activator and activated task are both locked here.
+ -- This is necessary because C.State and Self.Wait_Count have to be
+ -- synchronized. This is safe from deadlock because the activator is always
+ -- created before the activated task. That satisfies our
+ -- in-order-of-creation ATCB locking policy.
procedure Activate_Restricted_Tasks
(Chain_Access : Activation_Chain_Access)
Lock_RTS;
end if;
- -- Lock self, to prevent activated tasks
- -- from racing ahead before we finish activating the chain.
+ -- Lock self, to prevent activated tasks from racing ahead before we
+ -- finish activating the chain.
Write_Lock (Self_ID);
- -- Activate all the tasks in the chain.
- -- Creation of the thread of control was deferred until
- -- activation. So create it now.
+ -- Activate all the tasks in the chain. Creation of the thread of
+ -- control was deferred until activation. So create it now.
C := Chain_Access.T_ID;
Self_ID.Common.State := Activator_Sleep;
- -- Wait for the activated tasks to complete activation.
- -- It is unsafe to abort any of these tasks until the count goes to
- -- zero.
+ -- Wait for the activated tasks to complete activation. It is unsafe to
+ -- abort any of these tasks until the count goes to zero.
loop
exit when Self_ID.Common.Wait_Count = 0;
Unlock_RTS;
end if;
- -- Remove the tasks from the chain.
+ -- Remove the tasks from the chain
Chain_Access.T_ID := null;
end Activate_Restricted_Tasks;
Write_Lock (Activator);
Write_Lock (Self_ID);
- -- Remove dangling reference to Activator,
- -- since a task may outlive its activator.
+ -- Remove dangling reference to Activator, since a task may outlive its
+ -- activator.
Self_ID.Common.Activator := null;
- -- Wake up the activator, if it is waiting for a chain
- -- of tasks to activate, and we are the last in the chain
- -- to complete activation
+ -- Wake up the activator, if it is waiting for a chain of tasks to
+ -- activate, and we are the last in the chain to complete activation
if Activator.Common.State = Activator_Sleep then
Activator.Common.Wait_Count := Activator.Common.Wait_Count - 1;
Unlock_RTS;
end if;
- -- After the activation, active priority should be the same
- -- as base priority. We must unlock the Activator first,
- -- though, since it should not wait if we have lower priority.
+ -- After the activation, active priority should be the same as base
+ -- priority. We must unlock the Activator first, though, since it should
+ -- not wait if we have lower priority.
if Get_Priority (Self_ID) /= Self_ID.Common.Base_Priority then
Set_Priority (Self_ID, Self_ID.Common.Base_Priority);
Success : Boolean;
begin
- -- Stack is not preallocated on this target, so that
- -- Stack_Address must be null.
+ -- Stack is not preallocated on this target, so that Stack_Address must
+ -- be null.
pragma Assert (Stack_Address = Null_Address);
(Self_ID, State, Discriminants, Self_ID, Elaborated, Base_Priority,
Task_Info, Size, Created_Task, Success);
- -- If we do our job right then there should never be any failures,
- -- which was probably said about the Titanic; so just to be safe,
- -- let's retain this code for now
+ -- If we do our job right then there should never be any failures, which
+ -- was probably said about the Titanic; so just to be safe, let's retain
+ -- this code for now
if not Success then
Unlock (Self_ID);
Lock_RTS;
end if;
+ -- Handle normal task termination by the environment task, but only for
+ -- the normal task termination. In the case of Abnormal and
+ -- Unhandled_Exception they must have been handled before, and the task
+ -- termination soft link must have been changed so the task termination
+ -- routine is not executed twice.
+
+ -- Note that in the "normal" implementation in s-tassta.adb the task
+ -- termination procedure for the environment task should be executed
+ -- after termination of library-level tasks. However, this
+ -- implementation is to be used when the Ravenscar restrictions are in
+ -- effect, and AI-394 says that if there is a fall-back handler set for
+ -- the partition it should be called when the first task (including the
+ -- environment task) attempts to terminate.
+
+ SSL.Task_Termination_Handler.all (Ada.Exceptions.Null_Occurrence);
+
Write_Lock (Self_ID);
Sleep (Self_ID, Master_Completion_Sleep);
Unlock (Self_ID);
procedure Final_Task_Unlock (Self_ID : Task_Id) is
begin
- pragma Assert (Self_ID.Global_Task_Lock_Nesting = 1);
+ pragma Assert (Self_ID.Common.Global_Task_Lock_Nesting = 1);
Unlock (Global_Task_Lock'Access, Global_Lock => True);
end Final_Task_Unlock;
procedure Task_Lock (Self_ID : Task_Id) is
begin
- Self_ID.Global_Task_Lock_Nesting := Self_ID.Global_Task_Lock_Nesting + 1;
+ Self_ID.Common.Global_Task_Lock_Nesting :=
+ Self_ID.Common.Global_Task_Lock_Nesting + 1;
- if Self_ID.Global_Task_Lock_Nesting = 1 then
+ if Self_ID.Common.Global_Task_Lock_Nesting = 1 then
Defer_Abort_Nestable (Self_ID);
Write_Lock (Global_Task_Lock'Access, Global_Lock => True);
end if;
procedure Task_Unlock (Self_ID : Task_Id) is
begin
- pragma Assert (Self_ID.Global_Task_Lock_Nesting > 0);
- Self_ID.Global_Task_Lock_Nesting := Self_ID.Global_Task_Lock_Nesting - 1;
+ pragma Assert (Self_ID.Common.Global_Task_Lock_Nesting > 0);
+ Self_ID.Common.Global_Task_Lock_Nesting :=
+ Self_ID.Common.Global_Task_Lock_Nesting - 1;
- if Self_ID.Global_Task_Lock_Nesting = 0 then
+ if Self_ID.Common.Global_Task_Lock_Nesting = 0 then
Unlock (Global_Task_Lock'Access, Global_Lock => True);
Undefer_Abort_Nestable (Self_ID);
end if;
T.Common.Elaborated := Elaborated;
T.Common.Activation_Failed := False;
T.Common.Task_Info := Task_Info;
+ T.Common.Global_Task_Lock_Nesting := 0;
+ T.Common.Fall_Back_Handler := null;
+ T.Common.Specific_Handler := null;
if T.Common.Parent = null then
-- For the environment task, the adjusted stack size is
-- Any changes to this interface may require corresponding compiler changes.
with Ada.Exceptions;
--- Used for: Exception_Id
+-- Used for Exception_Id
+-- Exception_Occurrence
with System.Parameters;
-- used for Size_Type
with System.Task_Primitives;
-- used for Private_Data
+with System.Stack_Usage;
+-- used for Stack_Analyzer
+
with Unchecked_Conversion;
package System.Tasking is
end record;
pragma Suppress_Initialization (Restricted_Entry_Call_Record);
+ -------------------------------------------
+ -- Task termination procedure definition --
+ -------------------------------------------
+
+ -- We need to redefine here these types (already defined in
+ -- Ada.Task_Termination) for avoiding circular dependencies.
+
+ type Cause_Of_Termination is (Normal, Abnormal, Unhandled_Exception);
+ -- Possible causes for task termination:
+ --
+ -- Normal means that the task terminates due to completing the
+ -- last sentence of its body, or as a result of waiting on a
+ -- terminate alternative.
+
+ -- Abnormal means that the task terminates because it is being aborted
+
+ -- handled_Exception means that the task terminates because of exception
+ -- raised by by the execution of its task_body.
+
+ type Termination_Handler is access protected procedure
+ (Cause : in Cause_Of_Termination;
+ T : in Task_Id;
+ X : in Ada.Exceptions.Exception_Occurrence);
+ -- Used to represent protected procedures to be executed when task
+ -- terminates.
+
------------------------------------
-- Task related other definitions --
------------------------------------
Task_Info : System.Task_Info.Task_Info_Type;
-- System-specific attributes of the task as specified by the
-- Task_Info pragma.
+
+ Analyzer : System.Stack_Usage.Stack_Analyzer;
+ -- For storing informations used to measure the stack usage.
+
+ Global_Task_Lock_Nesting : Natural;
+ -- This is the current nesting level of calls to
+ -- System.Tasking.Initialization.Lock_Task. This allows a task to call
+ -- Lock_Task multiple times without deadlocking. A task only locks
+ -- Global_Task_Lock when its Global_Task_Lock_Nesting goes from 0 to 1,
+ -- and only unlocked when it goes from 1 to 0.
+ --
+ -- Protection: Only accessed by Self
+
+ Fall_Back_Handler : Termination_Handler;
+ pragma Atomic (Fall_Back_Handler);
+ -- This is the fall-back handler that applies to the dependent tasks of
+ -- the task.
+ --
+ -- Protection: atomic access
+
+ Specific_Handler : Termination_Handler;
+ pragma Atomic (Specific_Handler);
+ -- This is the specific handler that applies only to this task, and not
+ -- any of its dependent tasks.
+ --
+ -- Protection: atomic access
end record;
---------------------------------------
--
-- Protection: Self.L
- Global_Task_Lock_Nesting : Natural := 0;
- -- This is the current nesting level of calls to
- -- System.Tasking.Stages.Lock_Task_T. This allows a task to call
- -- Lock_Task_T multiple times without deadlocking. A task only locks
- -- All_Task_Lock when its All_Tasks_Nesting goes from 0 to 1, and only
- -- unlocked when it goes from 1 to 0.
- --
- -- Protection: Only accessed by Self
-
Open_Accepts : Accept_List_Access;
-- This points to the Open_Accepts array of accept alternatives passed
-- to the RTS by the compiler-generated code to Selective_Wait. It is
-- specific data. In the absence of tasking, these routines refer to global
-- data. In the presense of tasking, they must be replaced with pointers to
-- task-specific versions. Also used for Create_TSD, Destroy_TSD,
--- Get_Current_Excep
+-- Get_Current_Excep, Finalize_Global_List, Task_Termination, Handler.
with System.Tasking.Initialization;
-- Used for Remove_From_All_Tasks_List
with System.Tasking.Utilities;
-- Used for Make_Passive
-- Abort_One_Task
+-- Abort_Tasks
with System.Tasking.Queuing;
-- Used for Dequeue_Head
with System.OS_Primitives;
-- Used for Delay_Modes
-with System.Finalization_Implementation;
--- Used for System.Finalization_Implementation.Finalize_Global_List
-
with System.Secondary_Stack;
-- Used for SS_Init
with Unchecked_Deallocation;
-- To recover from failure of ATCB initialization
+with System.Stack_Usage;
+
package body System.Tasking.Stages is
package STPO renames System.Task_Primitives.Operations;
procedure Abort_Tasks (Tasks : Task_List) is
begin
- -- If pragma Detect_Blocking is active then Program_Error must be
- -- raised if this potentially blocking operation is called from a
- -- protected action.
-
- if System.Tasking.Detect_Blocking
- and then STPO.Self.Common.Protected_Action_Nesting > 0
- then
- Ada.Exceptions.Raise_Exception
- (Program_Error'Identity, "potentially blocking operation");
- end if;
-
Utilities.Abort_Tasks (Tasks);
end Abort_Tasks;
Vulnerable_Complete_Task (Self_ID);
- System.Finalization_Implementation.Finalize_Global_List;
+ -- Handle normal task termination by the environment task, but only
+ -- for the normal task termination. In the case of Abnormal and
+ -- Unhandled_Exception they must have been handled before, and the
+ -- task termination soft link must have been changed so the task
+ -- termination routine is not executed twice.
+
+ SSL.Task_Termination_Handler.all (Ada.Exceptions.Null_Occurrence);
+
+ -- Finalize the global list for controlled objects if needed
+
+ SSL.Finalize_Global_List.all;
+
+ -- Reset the soft links to non-tasking
SSL.Abort_Defer := SSL.Abort_Defer_NT'Access;
SSL.Abort_Undefer := SSL.Abort_Undefer_NT'Access;
use type System.Parameters.Size_Type;
use type SSE.Storage_Offset;
use System.Standard_Library;
+ use System.Stack_Usage;
+
+ Bottom_Of_Stack : aliased Integer;
+
+ Secondary_Stack_Size :
+ constant SSE.Storage_Offset :=
+ Self_ID.Common.Compiler_Data.Pri_Stack_Info.Size *
+ SSE.Storage_Offset (Parameters.Sec_Stack_Ratio) / 100;
Secondary_Stack :
aliased SSE.Storage_Array
- (1 .. Self_ID.Common.Compiler_Data.Pri_Stack_Info.Size *
- SSE.Storage_Offset (Parameters.Sec_Stack_Ratio) / 100);
+ (1 .. Secondary_Stack_Size);
+ pragma Warnings (Off);
Secondary_Stack_Address : System.Address := Secondary_Stack'Address;
+ Overflow_Guard : constant := 16#1_000#;
+
+ Size :
+ Natural := Natural (Self_ID.Common.Compiler_Data.Pri_Stack_Info.Size);
+
+ pragma Warnings (On);
+ -- Address of secondary stack. In the fixed secondary stack case, this
+ -- value is not modified, causing a warning, hence the bracketing with
+ -- Warnings (Off/On).
+
SEH_Table : aliased SSE.Storage_Array (1 .. 8);
-- Structured Exception Registration table (2 words)
pragma Import (C, Install_SEH_Handler, "__gnat_install_SEH_handler");
-- Install the SEH (Structured Exception Handling) handler
+ Cause : Cause_Of_Termination := Normal;
+ -- Indicates the reason why this task terminates. Normal corresponds to
+ -- a task terminating due to completing the last statement of its body,
+ -- or as a result of waiting on a terminate alternative. If the task
+ -- terminates because it is being aborted then Cause will be set to
+ -- Abnormal. If the task terminates because of an exception raised by
+ -- the execution of its task body, then Cause is set to
+ -- Unhandled_Exception.
+
+ EO : Exception_Occurrence;
+ -- If the task terminates because of an exception raised by the
+ -- execution of its task body, then EO will contain the associated
+ -- exception occurrence. Otherwise, it will contain Null_Occurrence.
+
+ procedure Search_Fall_Back_Handler (ID : Task_Id);
+ -- Procedure that searches recursively a fall-back handler through the
+ -- master relationship.
+
+ procedure Search_Fall_Back_Handler (ID : Task_Id) is
+ begin
+ -- If there is a fall back handler, execute it
+
+ if ID.Common.Fall_Back_Handler /= null then
+ ID.Common.Fall_Back_Handler.all (Cause, Self_ID, EO);
+
+ -- Otherwise look for a fall back handler in the parent
+
+ elsif ID.Common.Parent /= null then
+ Search_Fall_Back_Handler (ID.Common.Parent);
+
+ -- Otherwise, do nothing
+
+ else
+ return;
+ end if;
+ end Search_Fall_Back_Handler;
+
begin
pragma Assert (Self_ID.Deferral_Level = 1);
Self_ID.Common.Compiler_Data.Sec_Stack_Addr :=
Secondary_Stack'Address;
SST.SS_Init (Secondary_Stack_Address, Integer (Secondary_Stack'Last));
+ Size := Size - Natural (Secondary_Stack_Size);
+ end if;
+
+ Size := Size - Overflow_Guard;
+
+ if System.Stack_Usage.Is_Enabled then
+ STPO.Lock_RTS;
+ Initialize_Analyzer (Self_ID.Common.Analyzer,
+ Self_ID.Common.Task_Image
+ (1 .. Self_ID.Common.Task_Image_Len),
+ Size,
+ SSE.To_Integer (Bottom_Of_Stack'Address));
+ STPO.Unlock_RTS;
+ Fill_Stack (Self_ID.Common.Analyzer);
end if;
- -- Set the guard page at the bottom of the stack. The call to
- -- unprotect the page is done in Terminate_Task
+ -- Set the guard page at the bottom of the stack. The call to unprotect
+ -- the page is done in Terminate_Task
Stack_Guard (Self_ID, True);
Install_SEH_Handler (SEH_Table'Address);
- -- We lock RTS_Lock to wait for activator to finish activating
- -- the rest of the chain, so that everyone in the chain comes out
- -- in priority order.
+ -- Initialize exception occurrence
+
+ Save_Occurrence (EO, Ada.Exceptions.Null_Occurrence);
+
+ -- We lock RTS_Lock to wait for activator to finish activating the rest
+ -- of the chain, so that everyone in the chain comes out in priority
+ -- order.
-- This also protects the value of
-- Self_ID.Common.Activator.Common.Wait_Count.
when Standard'Abort_Signal =>
Initialization.Defer_Abort_Nestable (Self_ID);
+ -- Update the cause that motivated the task termination so that
+ -- the appropriate information is passed to the task termination
+ -- procedure. Task termination as a result of waiting on a
+ -- terminate alternative is a normal termination, although it is
+ -- implemented using the abort mechanisms.
+
+ if Self_ID.Terminate_Alternative then
+ Cause := Normal;
+ else
+ Cause := Abnormal;
+ end if;
when others =>
-- ??? Using an E : others here causes CD2C11A to fail on
-- DEC Unix, see 7925-005.
if Exception_Trace = Unhandled_Raise then
Trace_Unhandled_Exception_In_Task (Self_ID);
end if;
+
+ -- Update the cause that motivated the task termination so that
+ -- the appropriate information is passed to the task termination
+ -- procedure, as well as the associated Exception_Occurrence.
+
+ Cause := Unhandled_Exception;
+ Save_Occurrence (EO, SSL.Get_Current_Excep.all.all);
end;
+ -- Look for a task termination handler. This code is for all tasks but
+ -- the environment task. The task termination code for the environment
+ -- task is executed by SSL.Task_Termination_Handler.
+
+ if Self_ID.Common.Specific_Handler /= null then
+ Self_ID.Common.Specific_Handler.all (Cause, Self_ID, EO);
+ else
+ -- Look for a fall-back handler following the master relationship
+ -- for the task.
+
+ Search_Fall_Back_Handler (Self_ID);
+ end if;
+
+ if System.Stack_Usage.Is_Enabled then
+ Compute_Result (Self_ID.Common.Analyzer);
+ Report_Result (Self_ID.Common.Analyzer);
+ end if;
+
Terminate_Task (Self_ID);
end Task_Wrapper;
-- We can't call Destroy_TSD while we are holding any other locks, because
-- it locks Global_Task_Lock, and our deadlock prevention rules require
-- that to be the outermost lock. Our first "solution" was to just lock
- -- Global_Task_Lock in addition to the other locks, and force the parent
- -- to also lock this lock between its wakeup and its freeing of the ATCB.
- -- See Complete_Task for the parent-side of the code that has the matching
+ -- Global_Task_Lock in addition to the other locks, and force the parent to
+ -- also lock this lock between its wakeup and its freeing of the ATCB. See
+ -- Complete_Task for the parent-side of the code that has the matching
-- calls to Task_Lock and Task_Unlock. That was not really a solution,
-- since the operation Task_Unlock continued to access the ATCB after
- -- unlocking, after which the parent was observed to race ahead,
- -- deallocate the ATCB, and then reallocate it to another task. The
- -- call to Undefer_Abortion in Task_Unlock by the "terminated" task was
- -- overwriting the data of the new task that reused the ATCB! To solve
- -- this problem, we introduced the new operation Final_Task_Unlock.
+ -- unlocking, after which the parent was observed to race ahead, deallocate
+ -- the ATCB, and then reallocate it to another task. The call to
+ -- Undefer_Abortion in Task_Unlock by the "terminated" task was overwriting
+ -- the data of the new task that reused the ATCB! To solve this problem, we
+ -- introduced the new operation Final_Task_Unlock.
procedure Terminate_Task (Self_ID : Task_Id) is
Environment_Task : constant Task_Id := STPO.Environment_Task;
-- Abort_Tasks --
-----------------
- -- Compiler interface only: Do not call from within the RTS,
-
- -- except in the implementation of Ada.Task_Identification.
-- This must be called to implement the abort statement.
-- Much of the actual work of the abort is done by the abortee,
-- via the Abort_Handler signal handler, and propagation of the
P : Task_Id;
begin
+ -- If pragma Detect_Blocking is active then Program_Error must be
+ -- raised if this potentially blocking operation is called from a
+ -- protected action.
+
+ if System.Tasking.Detect_Blocking
+ and then Self_Id.Common.Protected_Action_Nesting > 0
+ then
+ Ada.Exceptions.Raise_Exception
+ (Program_Error'Identity, "potentially blocking operation");
+ end if;
+
Initialization.Defer_Abort_Nestable (Self_Id);
-- ?????
Scan_Nat (Switch_Chars, Max, Ptr, Time_Slice_Value, C);
Time_Slice_Value := Time_Slice_Value * 1_000;
+ -- Processing for u switch
+
+ when 'u' =>
+ Ptr := Ptr + 1;
+ Dynamic_Stack_Measurement := True;
+ Scan_Nat
+ (Switch_Chars,
+ Max,
+ Ptr,
+ Dynamic_Stack_Measurement_Array_Size,
+ C);
+
-- Processing for v switch
when 'v' =>
projects / platform / upstream / linaro-gcc.git / commitdiff