Initial import.
authorReto Buerki <reet@codelabs.ch>
Thu, 20 Oct 2011 19:29:51 +0000 (21:29 +0200)
committerReto Buerki <reet@codelabs.ch>
Thu, 20 Oct 2011 19:31:13 +0000 (21:31 +0200)
30 files changed:
.gitignore [new file with mode: 0644]
Makefile [new file with mode: 0644]
cuda_ada.gpr [new file with mode: 0644]
doc/article.lyx [new file with mode: 0644]
src/add.adb [new file with mode: 0644]
src/cuda-compiler.adb [new file with mode: 0644]
src/cuda-compiler.ads [new file with mode: 0644]
src/cuda.ads [new file with mode: 0644]
src/enum_devices.adb [new file with mode: 0644]
thin/alloca_h.ads [new file with mode: 0644]
thin/bits_pthreadtypes_h.ads [new file with mode: 0644]
thin/bits_sigset_h.ads [new file with mode: 0644]
thin/bits_time_h.ads [new file with mode: 0644]
thin/bits_types_h.ads [new file with mode: 0644]
thin/bits_waitstatus_h.ads [new file with mode: 0644]
thin/cuda_h.ads [new file with mode: 0644]
thin/cuda_runtime_api_h.ads [new file with mode: 0644]
thin/device_types_h.ads [new file with mode: 0644]
thin/driver_functions_h.ads [new file with mode: 0644]
thin/driver_types_h.ads [new file with mode: 0644]
thin/stddef_h.ads [new file with mode: 0644]
thin/stdlib_h.ads [new file with mode: 0644]
thin/surface_types_h.ads [new file with mode: 0644]
thin/sys_select_h.ads [new file with mode: 0644]
thin/sys_sysmacros_h.ads [new file with mode: 0644]
thin/sys_types_h.ads [new file with mode: 0644]
thin/texture_types_h.ads [new file with mode: 0644]
thin/time_h.ads [new file with mode: 0644]
thin/vector_functions_h.ads [new file with mode: 0644]
thin/vector_types_h.ads [new file with mode: 0644]

diff --git a/.gitignore b/.gitignore
new file mode 100644 (file)
index 0000000..8c97bed
--- /dev/null
@@ -0,0 +1 @@
+*.lyx~
diff --git a/Makefile b/Makefile
new file mode 100644 (file)
index 0000000..a8b6cd3
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,11 @@
+CUDASDK = /usr/local/cuda
+
+LIBRARY_PATH=$(CUDASDK)/lib:$(CUDASDK)/lib64
+
+all:
+       LIBRARY_PATH=$(LIBRARY_PATH) gnatmake -p -Pcuda_ada
+
+clean:
+       @rm -rf obj
+
+.PHONY: all clean
diff --git a/cuda_ada.gpr b/cuda_ada.gpr
new file mode 100644 (file)
index 0000000..1b219fa
--- /dev/null
@@ -0,0 +1,8 @@
+project Cuda_Ada is
+
+   for Object_Dir use "obj";
+   for Main use ("enum_devices.adb", "add.adb");
+   for Source_Dirs use ("src", "thin");
+
+end Cuda_Ada;
+
diff --git a/doc/article.lyx b/doc/article.lyx
new file mode 100644 (file)
index 0000000..51e880b
--- /dev/null
@@ -0,0 +1,447 @@
+#LyX 1.6.7 created this file. For more info see http://www.lyx.org/
+\lyxformat 345
+\begin_document
+\begin_header
+\textclass article
+\use_default_options true
+\language english
+\inputencoding auto
+\font_roman default
+\font_sans default
+\font_typewriter default
+\font_default_family default
+\font_sc false
+\font_osf false
+\font_sf_scale 100
+\font_tt_scale 100
+
+\graphics default
+\paperfontsize default
+\spacing single
+\use_hyperref false
+\pdf_title "pyCUDA"
+\pdf_author "Reto Buerki"
+\pdf_subject "pyCUDA"
+\pdf_keywords "CUDA python pyCUDA GPU"
+\pdf_bookmarks true
+\pdf_bookmarksnumbered false
+\pdf_bookmarksopen false
+\pdf_bookmarksopenlevel 1
+\pdf_breaklinks false
+\pdf_pdfborder false
+\pdf_colorlinks false
+\pdf_backref false
+\pdf_pdfusetitle true
+\papersize a4paper
+\use_geometry false
+\use_amsmath 1
+\use_esint 1
+\cite_engine basic
+\use_bibtopic false
+\paperorientation portrait
+\secnumdepth 3
+\tocdepth 3
+\paragraph_separation indent
+\defskip medskip
+\quotes_language english
+\papercolumns 1
+\papersides 2
+\paperpagestyle fancy
+\tracking_changes false
+\output_changes false
+\author "" 
+\author "" 
+\end_header
+
+\begin_body
+
+\begin_layout Title
+Implementing a (minimal) Ada binding to CUDA (using PyCUDA as example)
+\end_layout
+
+\begin_layout Author
+Reto Bürki
+\end_layout
+
+\begin_layout Standard
+\align center
+University of Applied Sciences Rapperswil (HSR), Switzerland
+\end_layout
+
+\begin_layout Abstract
+Abstract about PyCUDA, Ada, ...
+\end_layout
+
+\begin_layout Section
+Introduction
+\end_layout
+
+\begin_layout Standard
+The aim of this article is to outline the design and the functionality of
+ a CUDA binding
+\begin_inset Foot
+status open
+
+\begin_layout Plain Layout
+Wrapper = binding
+\end_layout
+
+\end_inset
+
+ for the Ada programming language.
+ In order to do this PyCUDA, a CUDA wrapper for python, is examined and
+ the functionality is explained.
+\end_layout
+
+\begin_layout Standard
+The main characteristics of PyCUDA are then transferred to the Ada language
+ domain.
+ Since the time constraints of the project do not permit to write a fully
+ functional binding, only the main features of PyCUDA are implemented to
+ demonstrate the concepts of PyCUDA.
+ Nevertheless, the resulting Ada binding could serve as foundation for further
+ work.
+\end_layout
+
+\begin_layout Standard
+The article also documents the steps needed to write a thick binding for
+ Ada using a compiler generated thin binding.
+\end_layout
+
+\begin_layout Section
+CUDA
+\end_layout
+
+\begin_layout Standard
+Short introduction to CUDA in general.
+ References to further CUDA material.
+ Driver API vs.
+ Runtime API.
+\end_layout
+
+\begin_layout Section
+PyCUDA
+\end_layout
+
+\begin_layout Standard
+Introduction to PyCUDA.
+ Why this wrapper? Why another CUDA wrapper anyway?
+\end_layout
+
+\begin_layout Itemize
+PyCUDA is based on the driver API, not the higher-level CUDA runtime API
+\end_layout
+
+\begin_layout Itemize
+\begin_inset Quotes eld
+\end_inset
+
+GPU programming therefore relies extensively on experimentation and microbenchma
+rking to overcome missing knowledge of causes by obtaining measurements
+ of symptoms.
+\begin_inset Quotes eld
+\end_inset
+
+
+\end_layout
+
+\begin_layout Subsection
+Advantages
+\end_layout
+
+\begin_layout Itemize
+RAII (Object cleanup tied to lifetime of objects)
+\end_layout
+
+\begin_layout Itemize
+Convenience and abstraction
+\end_layout
+
+\begin_deeper
+\begin_layout Itemize
+pycuda.compiler.SourceModule
+\end_layout
+
+\begin_layout Itemize
+pycuda.gpuarray.GPUArray
+\end_layout
+
+\end_deeper
+\begin_layout Itemize
+Completeness
+\end_layout
+
+\begin_layout Itemize
+Automatic error checking
+\end_layout
+
+\begin_layout Itemize
+Speed (base layer is written in C
+\family typewriter
+++
+\family default
+)
+\end_layout
+
+\begin_layout Itemize
+pycuda.gpuarray
+\end_layout
+
+\begin_layout Itemize
+Simplifies memory transfers
+\end_layout
+
+\begin_deeper
+\begin_layout Itemize
+pycuda.driver.In, pycuda.driver.Out, and pycuda.driver.InOut
+\end_layout
+
+\end_deeper
+\begin_layout Itemize
+Helpful documentation
+\end_layout
+
+\begin_layout Subsection
+Concepts
+\end_layout
+
+\begin_layout Subsubsection
+Code is data
+\end_layout
+
+\begin_layout Standard
+It wants to be reasoned about at run time
+\end_layout
+
+\begin_layout Subsubsection
+GPU run-time code generation (RTCG) 
+\end_layout
+
+\begin_layout Standard
+\begin_inset Quotes eld
+\end_inset
+
+PyCUDA augments the CUDA runtime system by a critical capability: It allows
+ the user to easily create on-GPU binaries simply by providing C-like CUDA
+ source code as a simple character string.
+ This is what enables GPU run-time code generation.
+\begin_inset Quotes erd
+\end_inset
+
+
+\end_layout
+
+\begin_layout Subsection
+Overview
+\end_layout
+
+\begin_layout Subsubsection
+Call-chain
+\end_layout
+
+\begin_layout Itemize
+pycuda → ../src/wrapper (C
+\family typewriter
+++
+\family default
+) → ../src/cpp → cuda API
+\end_layout
+
+\begin_layout Subsection
+pycuda.autoinit
+\end_layout
+
+\begin_layout Standard
+Takes care of CUDA init/cleanup and context creation: When imported, automatical
+ly performs all the steps necessary to get CUDA ready for submission of
+ compute kernels.
+ It uses pycuda.tools.make_default_context() to create a compute context.
+\end_layout
+
+\begin_layout Itemize
+cuda.Init() (cuda.hpp)
+\end_layout
+
+\begin_deeper
+\begin_layout Itemize
+cuInit
+\end_layout
+
+\end_deeper
+\begin_layout Itemize
+make_default_context
+\end_layout
+
+\begin_deeper
+\begin_layout Itemize
+check cuda.Device.count() /= 0
+\end_layout
+
+\begin_layout Itemize
+device::make_context()
+\end_layout
+
+\begin_layout Itemize
+CUcontext ctx
+\end_layout
+
+\begin_layout Itemize
+cuCtxCreate, (&ctx, flags, m_device)
+\end_layout
+
+\end_deeper
+\begin_layout Itemize
+clear_context_caches (cleanup)
+\end_layout
+
+\begin_layout Subsection
+Just-in-time Compilation
+\end_layout
+
+\begin_layout Itemize
+SourceModule
+\end_layout
+
+\begin_deeper
+\begin_layout Itemize
+compile()/compile_plain()
+\end_layout
+
+\begin_layout Itemize
+Check cache first if already done (using hashing)
+\end_layout
+
+\begin_layout Itemize
+Write source to ''cachedir/file.cu''
+\end_layout
+
+\begin_layout Itemize
+nvidia's nvcc (Open64) (
+\family typewriter
+./nvcc --cubin cachedir/file.cu
+\family default
+)
+\end_layout
+
+\begin_deeper
+\begin_layout Itemize
+Check return code and error messages
+\end_layout
+
+\begin_layout Itemize
+Read cubin file to buffer
+\end_layout
+
+\end_deeper
+\begin_layout Itemize
+module_from_buffer
+\end_layout
+
+\begin_layout Itemize
+cuModuleLoadDataEx
+\end_layout
+
+\begin_layout Itemize
+get_function
+\end_layout
+
+\begin_deeper
+\begin_layout Itemize
+function module::get_function (C
+\family typewriter
+++
+\family default
+, cuda.hpp)
+\end_layout
+
+\begin_layout Itemize
+CUfunction func
+\end_layout
+
+\begin_layout Itemize
+cuModuleGetFunction
+\end_layout
+
+\end_deeper
+\begin_layout Itemize
+driver.function_call
+\end_layout
+
+\begin_deeper
+\begin_layout Itemize
+_launch_grid
+\end_layout
+
+\begin_layout Itemize
+cuLaunchGrid
+\end_layout
+
+\begin_layout Itemize
+(cuLaunchKernel, CUDA >= 4)
+\end_layout
+
+\end_deeper
+\end_deeper
+\begin_layout Subsection
+Automatic error checking
+\end_layout
+
+\begin_layout Section
+CUDA/Ada
+\end_layout
+
+\begin_layout Subsection
+Limitations
+\end_layout
+
+\begin_layout Standard
+Ada does not support introspection so the Binding will not be as comfortable
+ to use as PyCUDA.
+\end_layout
+
+\begin_layout Section
+Optional (if not Ada)
+\end_layout
+
+\begin_layout Standard
+Explain PyCUDA architecture/features in more detail.
+\end_layout
+
+\begin_layout Subsection
+Debugging
+\end_layout
+
+\begin_layout Subsection
+Profiling
+\end_layout
+
+\begin_layout Subsection
+Metaprogramming with PyCUDA
+\end_layout
+
+\begin_layout Subsubsection
+Jinja 2 
+\end_layout
+
+\begin_layout Subsubsection
+Cheetah
+\end_layout
+
+\begin_layout Subsubsection
+CodePy
+\end_layout
+
+\begin_layout Subsection
+Copperhead
+\end_layout
+
+\begin_layout Standard
+Uses PyCUDA, CodePy and Thrust
+\end_layout
+
+\begin_layout Section
+Conclusions
+\end_layout
+
+\end_body
+\end_document
diff --git a/src/add.adb b/src/add.adb
new file mode 100644 (file)
index 0000000..3927c85
--- /dev/null
@@ -0,0 +1,137 @@
+with Ada.Text_IO;
+
+with System;
+
+with Interfaces.C.Strings;
+
+with cuda_h;
+with cuda_runtime_api_h;
+with driver_types_h;
+
+with CUDA.Compiler;
+
+procedure Add
+is
+   pragma Linker_Options ("-lcuda");
+   pragma Linker_Options ("-lcudart");
+
+   package IC renames Interfaces.C;
+
+   CUDA_Error : exception;
+
+   type Kernel_Param_Type is array (1 .. 3) of System.Address;
+
+   procedure Check_Result
+     (Code : cuda_h.CUresult;
+      Msg  : String)
+   is
+      use type cuda_h.CUresult;
+   begin
+      if Code /= driver_types_h.cudaSuccess then
+         raise CUDA_Error with Msg & " (" & Code'Img & ")";
+      end if;
+   end Check_Result;
+
+   Dev : aliased IC.int;
+   Ctx : cuda_h.CUcontext;
+begin
+   Check_Result (Code => cuda_h.cuInit (arg1 => 0),
+                 Msg  => "CUDA init failed");
+   Check_Result (Code => cuda_runtime_api_h.cudaGetDevice (arg1 => Dev'Access),
+                 Msg  => "Could not get device");
+   Check_Result
+     (Code => cuda_h.cuCtxCreate_v2
+        (arg1 => Ctx'Address,
+         arg2 => 0,
+         arg3 => Dev),
+      Msg  => "Context creation failed");
+
+   declare
+      use type IC.unsigned;
+      use type IC.int;
+
+      A         : IC.int := 123123;
+      B         : IC.int := 6;
+      C         : IC.int := 0;
+      Params    : Kernel_Param_Type;
+      Dev_A     : aliased cuda_h.CUdeviceptr;
+      Dev_B     : aliased cuda_h.CUdeviceptr;
+      Dev_C     : aliased cuda_h.CUdeviceptr;
+      CU_Func   : cuda_h.CUfunction;
+      CU_Module : cuda_h.CUmodule;
+      Module    : CUDA.Compiler.Buffer_Type
+        := CUDA.Compiler.Compile
+          (Source =>
+           "extern ""C"" { __global__ void add_them(int a, int b, int *c) {" &
+           "    *c = 10;" &
+           "}}");
+   begin
+      Check_Result (Code => cuda_h.cuModuleLoadData
+                    (arg1 => CU_Module'Address,
+                     arg2 => Module'Address),
+                    Msg  => "Could not load module");
+      Check_Result (Code => cuda_h.cuModuleGetFunction
+                    (arg1 => CU_Func'Address,
+                     arg2 => CU_Module,
+                     arg3 => IC.Strings.New_String ("add_them")),
+                    Msg  => "Could not get function");
+
+      --  Prepare for function call.
+
+      Check_Result (Code => cuda_h.cuMemAlloc_v2
+                    (arg1 => Dev_A'Access,
+                     arg2 => IC.int'Size / 8),
+                    Msg  => "Could not allocate memory for a");
+      Check_Result (Code => cuda_h.cuMemcpyHtoD_v2
+                    (arg1 => Dev_A,
+                     arg2 => A'Address,
+                     arg3 => IC.int'Size / 8),
+                    Msg  => "Unable to copy A");
+
+      Check_Result (Code => cuda_h.cuMemAlloc_v2
+                    (arg1 => Dev_B'Access,
+                     arg2 => IC.int'size / 8),
+                    Msg  => "Could not allocate memory for b");
+      Check_Result (Code => cuda_h.cuMemcpyHtoD_v2
+                    (arg1 => Dev_B,
+                     arg2 => B'Address,
+                     arg3 => IC.int'size / 8),
+                    Msg  => "Unable to copy B");
+
+      Check_Result (Code => cuda_h.cuMemAlloc_v2
+                    (arg1 => Dev_C'Access,
+                     arg2 => (IC.int'size / 8)),
+                    Msg  => "Could not allocate memory for c");
+
+      Params (1) := Dev_A'Address;
+      Params (2) := Dev_B'Address;
+      Params (3) := Dev_C'Address;
+
+      --  Call it.
+
+      Check_Result (Code => cuda_h.cuLaunchKernel
+                    (arg1  => CU_Func,
+                     arg2  => 1,
+                     arg3  => 1,
+                     arg4  => 1,
+                     arg5  => 1,
+                     arg6  => 1,
+                     arg7  => 1,
+                     arg8  => 0,
+                     arg9  => cuda_h.CUStream (System.Null_Address),
+                     arg10 => Params'Address,
+                     arg11 => System.Null_Address),
+                    Msg  => "Could not launch function");
+
+      Check_Result (Code => cuda_h.cuMemcpyDtoH_v2
+                    (arg1 => C'Address,
+                     arg2 => Dev_C,
+                     arg3 => (IC.int'size / 8)),
+                    Msg  => "Unable to copy c to host");
+
+      Ada.Text_IO.Put_Line ("C is" & C'Img);
+   end;
+
+   Check_Result (Code => cuda_h.cuCtxDestroy_v2 (arg1 => Ctx),
+                 Msg  => "Context destroy failed");
+end Add;
diff --git a/src/cuda-compiler.adb b/src/cuda-compiler.adb
new file mode 100644 (file)
index 0000000..50de3eb
--- /dev/null
@@ -0,0 +1,82 @@
+with Ada.Directories;
+with Ada.Direct_IO;
+
+with System.OS_Lib;
+
+package body CUDA.Compiler is
+
+   package C renames Interfaces.C;
+
+   package D_IO is new Ada.Direct_IO (Element_Type => C.char);
+
+   Nvcc : constant String :=
+     "/usr/local/cuda/bin/nvcc";
+
+   Cache_Dir : constant String := "./cache";
+
+   -------------------------------------------------------------------------
+
+   function Compile (Source : String) return Buffer_Type
+   is
+      Source_Path : constant String := Cache_Dir & "/kernel.cu";
+      Kernel_Path : constant String := Cache_Dir & "/kernel.cubin";
+      File        : D_IO.File_Type;
+   begin
+      if not Ada.Directories.Exists (Name => Cache_Dir) then
+         Ada.Directories.Create_Directory (New_Directory => Cache_Dir);
+      end if;
+
+      D_IO.Create (File => File,
+                   Mode => D_IO.Out_File,
+                   Name => Source_Path);
+
+      for I in Source'Range loop
+         D_IO.Write (File => File,
+                     Item => C.char (Source (I)));
+      end loop;
+
+      D_IO.Close (File => File);
+
+      declare
+         Args : System.OS_Lib.Argument_List (1 .. 4);
+         Res  : Boolean;
+      begin
+         Args (1) := new String'("-cubin");
+         Args (2) := new String'(Source_Path);
+         Args (3) := new String'("-o");
+         Args (4) := new String'(Kernel_Path);
+         System.OS_Lib.Spawn (Program_Name => Nvcc,
+                              Args         => Args,
+                              Success      => Res);
+
+         if not Res then
+            raise Program_Error with "Error calling nvcc";
+         end if;
+      end;
+
+      D_IO.Open (File => File,
+                 Mode => D_IO.In_File,
+                 Name => Kernel_Path);
+
+      declare
+         Result : Buffer_Type (1 .. Positive (D_IO.Size (File => File)));
+      begin
+         for I in Result'Range loop
+            D_IO.Read (File => File,
+                       Item => Result (I));
+         end loop;
+
+         D_IO.Close (File => File);
+         return Result;
+      end;
+   end Compile;
+
+   -------------------------------------------------------------------------
+
+   procedure Load
+   is
+   begin
+      null;
+   end Load;
+
+end CUDA.Compiler;
diff --git a/src/cuda-compiler.ads b/src/cuda-compiler.ads
new file mode 100644 (file)
index 0000000..f890030
--- /dev/null
@@ -0,0 +1,13 @@
+with Interfaces.C;
+
+package CUDA.Compiler is
+
+   type Buffer_Type is array (Positive range <>) of aliased Interfaces.C.char;
+
+   function Compile (Source : String) return Buffer_Type;
+   --  Compile given CUDA code to cubin. Return result in buffer.
+
+   procedure Load;
+   --  Load previously compiled code to GPU.
+
+end CUDA.Compiler;
diff --git a/src/cuda.ads b/src/cuda.ads
new file mode 100644 (file)
index 0000000..66f0686
--- /dev/null
@@ -0,0 +1,2 @@
+package CUDA is
+end CUDA;
diff --git a/src/enum_devices.adb b/src/enum_devices.adb
new file mode 100644 (file)
index 0000000..3af2ff8
--- /dev/null
@@ -0,0 +1,53 @@
+with Ada.Text_IO;
+
+with Interfaces.C;
+
+with cuda_runtime_api_h;
+with driver_types_h;
+
+procedure Enum_Devices
+is
+   pragma Linker_Options ("-lcudart");
+
+   package C renames Interfaces.C;
+
+   use type C.unsigned;
+
+   Devices : aliased C.int;
+   Res     : driver_types_h.cudaError_t;
+begin
+   Res := cuda_runtime_api_h.cudaGetDeviceCount (arg1 => Devices'Access);
+
+   if Res /= driver_types_h.cudaSuccess then
+      Ada.Text_IO.Put_Line ("Error getting device count:" & Res'Img);
+      return;
+   end if;
+
+   Ada.Text_IO.Put_Line ("Found" & Devices'Img & " CUDA aware device(s):");
+
+   declare
+      Curr_Dev : aliased C.int;
+      Props    : aliased driver_types_h.cudaDeviceProp;
+   begin
+      Res := cuda_runtime_api_h.cudaGetDevice (arg1 => Curr_Dev'Access);
+
+      if Res /= driver_types_h.cudaSuccess then
+         Ada.Text_IO.Put_Line ("Unable to get device:" & Res'Img);
+         return;
+      end if;
+
+      Res := cuda_runtime_api_h.cudaGetDeviceProperties
+        (arg1 => Props'Access,
+         arg2 => Curr_Dev);
+
+      if Res /= driver_types_h.cudaSuccess then
+         Ada.Text_IO.Put_Line ("Error getting device props:" & Res'Img);
+         return;
+      end if;
+
+      Ada.Text_IO.Put_Line ("Name       : " & C.To_Ada (Props.name));
+      Ada.Text_IO.Put_Line ("Global mem :" & Props.totalGlobalMem'Img);
+      Ada.Text_IO.Put_Line ("Clock rate :" & Props.clockRate'Img);
+   end;
+
+end Enum_Devices;
diff --git a/thin/alloca_h.ads b/thin/alloca_h.ads
new file mode 100644 (file)
index 0000000..369197d
--- /dev/null
@@ -0,0 +1,12 @@
+with Interfaces.C; use Interfaces.C;
+with stddef_h;
+with System;
+
+package alloca_h is
+
+   --  arg-macro: procedure alloca (size)
+   --    __builtin_alloca (size)
+   function alloca (arg1 : stddef_h.size_t) return System.Address;  -- /usr/include/alloca.h:33
+   pragma Import (C, alloca, "alloca");
+
+end alloca_h;
diff --git a/thin/bits_pthreadtypes_h.ads b/thin/bits_pthreadtypes_h.ads
new file mode 100644 (file)
index 0000000..c96b6fb
--- /dev/null
@@ -0,0 +1,235 @@
+with Interfaces.C; use Interfaces.C;
+with Interfaces.C.Extensions;
+with System;
+
+package bits_pthreadtypes_h is
+
+   subtype pthread_t is unsigned_long;  -- /usr/include/bits/pthreadtypes.h:50
+
+   subtype pthread_attr_t_uu_size_array is Interfaces.C.char_array (0 .. 35);
+   type pthread_attr_t (discr : unsigned := 0) is record
+      case discr is
+         when 0 =>
+            uu_size : aliased pthread_attr_t_uu_size_array;  -- /usr/include/bits/pthreadtypes.h:55
+         when others =>
+            uu_align : aliased long;  -- /usr/include/bits/pthreadtypes.h:56
+      end case;
+   end record;
+   pragma Convention (C_Pass_By_Copy, pthread_attr_t);
+   pragma Unchecked_Union (pthread_attr_t);  -- /usr/include/bits/pthreadtypes.h:57
+
+   type uu_pthread_internal_slist is record
+      uu_next : access uu_pthread_internal_slist;  -- /usr/include/bits/pthreadtypes.h:69
+   end record;
+   pragma Convention (C_Pass_By_Copy, uu_pthread_internal_slist);  -- /usr/include/bits/pthreadtypes.h:67
+
+   subtype uu_pthread_slist_t is uu_pthread_internal_slist;
+
+   type anon_792 (discr : unsigned := 0) is record
+      case discr is
+         when 0 =>
+            uu_spins : aliased int;  -- /usr/include/bits/pthreadtypes.h:97
+         when others =>
+            uu_list : aliased uu_pthread_slist_t;  -- /usr/include/bits/pthreadtypes.h:98
+      end case;
+   end record;
+   pragma Convention (C_Pass_By_Copy, anon_792);
+   pragma Unchecked_Union (anon_792);  -- /usr/include/bits/pthreadtypes.h:95
+
+   type anon791_anon792_union (discr : unsigned := 0) is record
+      case discr is
+         when 0 =>
+            uu_spins : aliased int;  -- /usr/include/bits/pthreadtypes.h:97
+         when others =>
+            uu_list : aliased uu_pthread_slist_t;  -- /usr/include/bits/pthreadtypes.h:98
+      end case;
+   end record;
+   pragma Convention (C_Pass_By_Copy, anon791_anon792_union);
+   pragma Unchecked_Union (anon791_anon792_union);
+   type uu_pthread_mutex_s is record
+      uu_lock : aliased int;  -- /usr/include/bits/pthreadtypes.h:80
+      uu_count : aliased unsigned;  -- /usr/include/bits/pthreadtypes.h:81
+      uu_owner : aliased int;  -- /usr/include/bits/pthreadtypes.h:82
+      uu_kind : aliased int;  -- /usr/include/bits/pthreadtypes.h:88
+      uu_nusers : aliased unsigned;  -- /usr/include/bits/pthreadtypes.h:94
+      anon1441 : anon791_anon792_union;  -- /usr/include/bits/pthreadtypes.h:99
+   end record;
+   pragma Convention (C_Pass_By_Copy, uu_pthread_mutex_s);  -- /usr/include/bits/pthreadtypes.h:78
+
+   subtype anon790_anon794_array is Interfaces.C.char_array (0 .. 23);
+   type anon_790 (discr : unsigned := 0) is record
+      case discr is
+         when 0 =>
+            uu_data : aliased uu_pthread_mutex_s;  -- /usr/include/bits/pthreadtypes.h:101
+         when 1 =>
+            uu_size : aliased anon790_anon794_array;  -- /usr/include/bits/pthreadtypes.h:102
+         when others =>
+            uu_align : aliased long;  -- /usr/include/bits/pthreadtypes.h:103
+      end case;
+   end record;
+   pragma Convention (C_Pass_By_Copy, anon_790);
+   pragma Unchecked_Union (anon_790);  -- /usr/include/bits/pthreadtypes.h:76
+
+   subtype pthread_mutex_t_uu_size_array is Interfaces.C.char_array (0 .. 23);
+   type pthread_mutex_t (discr : unsigned := 0) is record
+      case discr is
+         when 0 =>
+            uu_data : aliased uu_pthread_mutex_s;  -- /usr/include/bits/pthreadtypes.h:101
+         when 1 =>
+            uu_size : aliased pthread_mutex_t_uu_size_array;  -- /usr/include/bits/pthreadtypes.h:102
+         when others =>
+            uu_align : aliased long;  -- /usr/include/bits/pthreadtypes.h:103
+      end case;
+   end record;
+   pragma Convention (C_Pass_By_Copy, pthread_mutex_t);
+   pragma Unchecked_Union (pthread_mutex_t);  -- /usr/include/bits/pthreadtypes.h:104
+
+   subtype pthread_mutexattr_t_uu_size_array is Interfaces.C.char_array (0 .. 3);
+   type pthread_mutexattr_t (discr : unsigned := 0) is record
+      case discr is
+         when 0 =>
+            uu_size : aliased pthread_mutexattr_t_uu_size_array;  -- /usr/include/bits/pthreadtypes.h:108
+         when others =>
+            uu_align : aliased int;  -- /usr/include/bits/pthreadtypes.h:109
+      end case;
+   end record;
+   pragma Convention (C_Pass_By_Copy, pthread_mutexattr_t);
+   pragma Unchecked_Union (pthread_mutexattr_t);  -- /usr/include/bits/pthreadtypes.h:110
+
+   type anon_801 is record
+      uu_lock : aliased int;  -- /usr/include/bits/pthreadtypes.h:119
+      uu_futex : aliased unsigned;  -- /usr/include/bits/pthreadtypes.h:120
+      uu_total_seq : aliased Extensions.unsigned_long_long;  -- /usr/include/bits/pthreadtypes.h:121
+      uu_wakeup_seq : aliased Extensions.unsigned_long_long;  -- /usr/include/bits/pthreadtypes.h:122
+      uu_woken_seq : aliased Extensions.unsigned_long_long;  -- /usr/include/bits/pthreadtypes.h:123
+      uu_mutex : System.Address;  -- /usr/include/bits/pthreadtypes.h:124
+      uu_nwaiters : aliased unsigned;  -- /usr/include/bits/pthreadtypes.h:125
+      uu_broadcast_seq : aliased unsigned;  -- /usr/include/bits/pthreadtypes.h:126
+   end record;
+   pragma Convention (C_Pass_By_Copy, anon_801);  -- /usr/include/bits/pthreadtypes.h:117
+
+   type pthread_cond_t;
+   type pthread_cond_t_uu_data_struct is record
+      uu_lock : aliased int;  -- /usr/include/bits/pthreadtypes.h:119
+      uu_futex : aliased unsigned;  -- /usr/include/bits/pthreadtypes.h:120
+      uu_total_seq : aliased Extensions.unsigned_long_long;  -- /usr/include/bits/pthreadtypes.h:121
+      uu_wakeup_seq : aliased Extensions.unsigned_long_long;  -- /usr/include/bits/pthreadtypes.h:122
+      uu_woken_seq : aliased Extensions.unsigned_long_long;  -- /usr/include/bits/pthreadtypes.h:123
+      uu_mutex : System.Address;  -- /usr/include/bits/pthreadtypes.h:124
+      uu_nwaiters : aliased unsigned;  -- /usr/include/bits/pthreadtypes.h:125
+      uu_broadcast_seq : aliased unsigned;  -- /usr/include/bits/pthreadtypes.h:126
+   end record;
+   pragma Convention (C_Pass_By_Copy, pthread_cond_t_uu_data_struct);
+   subtype pthread_cond_t_uu_size_array is Interfaces.C.char_array (0 .. 47);
+   type pthread_cond_t (discr : unsigned := 0) is record
+      case discr is
+         when 0 =>
+            uu_data : aliased anon_801;  -- /usr/include/bits/pthreadtypes.h:127
+         when 1 =>
+            uu_size : aliased pthread_cond_t_uu_size_array;  -- /usr/include/bits/pthreadtypes.h:128
+         when others =>
+            uu_align : aliased Long_Long_Integer;  -- /usr/include/bits/pthreadtypes.h:129
+      end case;
+   end record;
+   pragma Convention (C_Pass_By_Copy, pthread_cond_t);
+   pragma Unchecked_Union (pthread_cond_t);  -- /usr/include/bits/pthreadtypes.h:130
+
+   subtype pthread_condattr_t_uu_size_array is Interfaces.C.char_array (0 .. 3);
+   type pthread_condattr_t (discr : unsigned := 0) is record
+      case discr is
+         when 0 =>
+            uu_size : aliased pthread_condattr_t_uu_size_array;  -- /usr/include/bits/pthreadtypes.h:134
+         when others =>
+            uu_align : aliased int;  -- /usr/include/bits/pthreadtypes.h:135
+      end case;
+   end record;
+   pragma Convention (C_Pass_By_Copy, pthread_condattr_t);
+   pragma Unchecked_Union (pthread_condattr_t);  -- /usr/include/bits/pthreadtypes.h:136
+
+   subtype pthread_key_t is unsigned;  -- /usr/include/bits/pthreadtypes.h:140
+
+   subtype pthread_once_t is int;  -- /usr/include/bits/pthreadtypes.h:144
+
+   type anon_812 is record
+      uu_lock : aliased int;  -- /usr/include/bits/pthreadtypes.h:172
+      uu_nr_readers : aliased unsigned;  -- /usr/include/bits/pthreadtypes.h:173
+      uu_readers_wakeup : aliased unsigned;  -- /usr/include/bits/pthreadtypes.h:174
+      uu_writer_wakeup : aliased unsigned;  -- /usr/include/bits/pthreadtypes.h:175
+      uu_nr_readers_queued : aliased unsigned;  -- /usr/include/bits/pthreadtypes.h:176
+      uu_nr_writers_queued : aliased unsigned;  -- /usr/include/bits/pthreadtypes.h:177
+      uu_flags : aliased unsigned_char;  -- /usr/include/bits/pthreadtypes.h:180
+      uu_shared : aliased unsigned_char;  -- /usr/include/bits/pthreadtypes.h:181
+      uu_pad1 : aliased unsigned_char;  -- /usr/include/bits/pthreadtypes.h:182
+      uu_pad2 : aliased unsigned_char;  -- /usr/include/bits/pthreadtypes.h:183
+      uu_writer : aliased int;  -- /usr/include/bits/pthreadtypes.h:184
+   end record;
+   pragma Convention (C_Pass_By_Copy, anon_812);  -- /usr/include/bits/pthreadtypes.h:170
+
+   type pthread_rwlock_t;
+   type pthread_rwlock_t_uu_data_struct is record
+      uu_lock : aliased int;  -- /usr/include/bits/pthreadtypes.h:172
+      uu_nr_readers : aliased unsigned;  -- /usr/include/bits/pthreadtypes.h:173
+      uu_readers_wakeup : aliased unsigned;  -- /usr/include/bits/pthreadtypes.h:174
+      uu_writer_wakeup : aliased unsigned;  -- /usr/include/bits/pthreadtypes.h:175
+      uu_nr_readers_queued : aliased unsigned;  -- /usr/include/bits/pthreadtypes.h:176
+      uu_nr_writers_queued : aliased unsigned;  -- /usr/include/bits/pthreadtypes.h:177
+      uu_flags : aliased unsigned_char;  -- /usr/include/bits/pthreadtypes.h:180
+      uu_shared : aliased unsigned_char;  -- /usr/include/bits/pthreadtypes.h:181
+      uu_pad1 : aliased unsigned_char;  -- /usr/include/bits/pthreadtypes.h:182
+      uu_pad2 : aliased unsigned_char;  -- /usr/include/bits/pthreadtypes.h:183
+      uu_writer : aliased int;  -- /usr/include/bits/pthreadtypes.h:184
+   end record;
+   pragma Convention (C_Pass_By_Copy, pthread_rwlock_t_uu_data_struct);
+   subtype pthread_rwlock_t_uu_size_array is Interfaces.C.char_array (0 .. 31);
+   type pthread_rwlock_t (discr : unsigned := 0) is record
+      case discr is
+         when 0 =>
+            uu_data : aliased anon_812;  -- /usr/include/bits/pthreadtypes.h:185
+         when 1 =>
+            uu_size : aliased pthread_rwlock_t_uu_size_array;  -- /usr/include/bits/pthreadtypes.h:187
+         when others =>
+            uu_align : aliased long;  -- /usr/include/bits/pthreadtypes.h:188
+      end case;
+   end record;
+   pragma Convention (C_Pass_By_Copy, pthread_rwlock_t);
+   pragma Unchecked_Union (pthread_rwlock_t);  -- /usr/include/bits/pthreadtypes.h:189
+
+   subtype pthread_rwlockattr_t_uu_size_array is Interfaces.C.char_array (0 .. 7);
+   type pthread_rwlockattr_t (discr : unsigned := 0) is record
+      case discr is
+         when 0 =>
+            uu_size : aliased pthread_rwlockattr_t_uu_size_array;  -- /usr/include/bits/pthreadtypes.h:193
+         when others =>
+            uu_align : aliased long;  -- /usr/include/bits/pthreadtypes.h:194
+      end case;
+   end record;
+   pragma Convention (C_Pass_By_Copy, pthread_rwlockattr_t);
+   pragma Unchecked_Union (pthread_rwlockattr_t);  -- /usr/include/bits/pthreadtypes.h:195
+
+   subtype pthread_spinlock_t is int;  -- /usr/include/bits/pthreadtypes.h:201
+
+   subtype pthread_barrier_t_uu_size_array is Interfaces.C.char_array (0 .. 19);
+   type pthread_barrier_t (discr : unsigned := 0) is record
+      case discr is
+         when 0 =>
+            uu_size : aliased pthread_barrier_t_uu_size_array;  -- /usr/include/bits/pthreadtypes.h:208
+         when others =>
+            uu_align : aliased long;  -- /usr/include/bits/pthreadtypes.h:209
+      end case;
+   end record;
+   pragma Convention (C_Pass_By_Copy, pthread_barrier_t);
+   pragma Unchecked_Union (pthread_barrier_t);  -- /usr/include/bits/pthreadtypes.h:210
+
+   subtype pthread_barrierattr_t_uu_size_array is Interfaces.C.char_array (0 .. 3);
+   type pthread_barrierattr_t (discr : unsigned := 0) is record
+      case discr is
+         when 0 =>
+            uu_size : aliased pthread_barrierattr_t_uu_size_array;  -- /usr/include/bits/pthreadtypes.h:214
+         when others =>
+            uu_align : aliased int;  -- /usr/include/bits/pthreadtypes.h:215
+      end case;
+   end record;
+   pragma Convention (C_Pass_By_Copy, pthread_barrierattr_t);
+   pragma Unchecked_Union (pthread_barrierattr_t);  -- /usr/include/bits/pthreadtypes.h:216
+
+end bits_pthreadtypes_h;
diff --git a/thin/bits_sigset_h.ads b/thin/bits_sigset_h.ads
new file mode 100644 (file)
index 0000000..09c61da
--- /dev/null
@@ -0,0 +1,13 @@
+with Interfaces.C; use Interfaces.C;
+
+package bits_sigset_h is
+
+   subtype uu_sig_atomic_t is int;  -- /usr/include/bits/sigset.h:24
+
+   type uu_sigset_t_uu_val_array is array (0 .. 31) of aliased unsigned_long;
+   type uu_sigset_t is record
+      uu_val : aliased uu_sigset_t_uu_val_array;  -- /usr/include/bits/sigset.h:31
+   end record;
+   pragma Convention (C_Pass_By_Copy, uu_sigset_t);  -- /usr/include/bits/sigset.h:32
+
+end bits_sigset_h;
diff --git a/thin/bits_time_h.ads b/thin/bits_time_h.ads
new file mode 100644 (file)
index 0000000..9522e63
--- /dev/null
@@ -0,0 +1,12 @@
+with Interfaces.C; use Interfaces.C;
+with bits_types_h;
+
+package bits_time_h is
+
+   type timeval is record
+      tv_sec : aliased bits_types_h.uu_time_t;  -- /usr/include/bits/time.h:77
+      tv_usec : aliased bits_types_h.uu_suseconds_t;  -- /usr/include/bits/time.h:78
+   end record;
+   pragma Convention (C_Pass_By_Copy, timeval);  -- /usr/include/bits/time.h:75
+
+end bits_time_h;
diff --git a/thin/bits_types_h.ads b/thin/bits_types_h.ads
new file mode 100644 (file)
index 0000000..15fdab3
--- /dev/null
@@ -0,0 +1,112 @@
+with Interfaces.C; use Interfaces.C;
+with Interfaces.C.Extensions;
+with System;
+with Interfaces.C.Strings;
+
+package bits_types_h is
+
+   subtype uu_u_char is unsigned_char;  -- /usr/include/bits/types.h:31
+
+   subtype uu_u_short is unsigned_short;  -- /usr/include/bits/types.h:32
+
+   subtype uu_u_int is unsigned;  -- /usr/include/bits/types.h:33
+
+   subtype uu_u_long is unsigned_long;  -- /usr/include/bits/types.h:34
+
+   subtype uu_int8_t is signed_char;  -- /usr/include/bits/types.h:37
+
+   subtype uu_uint8_t is unsigned_char;  -- /usr/include/bits/types.h:38
+
+   subtype uu_int16_t is short;  -- /usr/include/bits/types.h:39
+
+   subtype uu_uint16_t is unsigned_short;  -- /usr/include/bits/types.h:40
+
+   subtype uu_int32_t is int;  -- /usr/include/bits/types.h:41
+
+   subtype uu_uint32_t is unsigned;  -- /usr/include/bits/types.h:42
+
+   subtype uu_int64_t is Long_Long_Integer;  -- /usr/include/bits/types.h:47
+
+   subtype uu_uint64_t is Extensions.unsigned_long_long;  -- /usr/include/bits/types.h:48
+
+   subtype uu_quad_t is Long_Long_Integer;  -- /usr/include/bits/types.h:56
+
+   subtype uu_u_quad_t is Extensions.unsigned_long_long;  -- /usr/include/bits/types.h:57
+
+   subtype uu_dev_t is uu_u_quad_t;  -- /usr/include/bits/types.h:134
+
+   subtype uu_uid_t is unsigned;  -- /usr/include/bits/types.h:135
+
+   subtype uu_gid_t is unsigned;  -- /usr/include/bits/types.h:136
+
+   subtype uu_ino_t is unsigned_long;  -- /usr/include/bits/types.h:137
+
+   subtype uu_ino64_t is uu_u_quad_t;  -- /usr/include/bits/types.h:138
+
+   subtype uu_mode_t is unsigned;  -- /usr/include/bits/types.h:139
+
+   subtype uu_nlink_t is unsigned;  -- /usr/include/bits/types.h:140
+
+   subtype uu_off_t is long;  -- /usr/include/bits/types.h:141
+
+   subtype uu_off64_t is uu_quad_t;  -- /usr/include/bits/types.h:142
+
+   subtype uu_pid_t is int;  -- /usr/include/bits/types.h:143
+
+   type uu_fsid_t_uu_val_array is array (0 .. 1) of aliased int;
+   type uu_fsid_t is record
+      uu_val : aliased uu_fsid_t_uu_val_array;  -- /usr/include/bits/types.h:144
+   end record;
+   pragma Convention (C_Pass_By_Copy, uu_fsid_t);  -- /usr/include/bits/types.h:144
+
+   subtype uu_clock_t is long;  -- /usr/include/bits/types.h:145
+
+   subtype uu_rlim_t is unsigned_long;  -- /usr/include/bits/types.h:146
+
+   subtype uu_rlim64_t is uu_u_quad_t;  -- /usr/include/bits/types.h:147
+
+   subtype uu_id_t is unsigned;  -- /usr/include/bits/types.h:148
+
+   subtype uu_time_t is long;  -- /usr/include/bits/types.h:149
+
+   subtype uu_useconds_t is unsigned;  -- /usr/include/bits/types.h:150
+
+   subtype uu_suseconds_t is long;  -- /usr/include/bits/types.h:151
+
+   subtype uu_daddr_t is int;  -- /usr/include/bits/types.h:153
+
+   subtype uu_swblk_t is long;  -- /usr/include/bits/types.h:154
+
+   subtype uu_key_t is int;  -- /usr/include/bits/types.h:155
+
+   subtype uu_clockid_t is int;  -- /usr/include/bits/types.h:158
+
+   type uu_timer_t is new System.Address;  -- /usr/include/bits/types.h:161
+
+   subtype uu_blksize_t is long;  -- /usr/include/bits/types.h:164
+
+   subtype uu_blkcnt_t is long;  -- /usr/include/bits/types.h:169
+
+   subtype uu_blkcnt64_t is uu_quad_t;  -- /usr/include/bits/types.h:170
+
+   subtype uu_fsblkcnt_t is unsigned_long;  -- /usr/include/bits/types.h:173
+
+   subtype uu_fsblkcnt64_t is uu_u_quad_t;  -- /usr/include/bits/types.h:174
+
+   subtype uu_fsfilcnt_t is unsigned_long;  -- /usr/include/bits/types.h:177
+
+   subtype uu_fsfilcnt64_t is uu_u_quad_t;  -- /usr/include/bits/types.h:178
+
+   subtype uu_ssize_t is int;  -- /usr/include/bits/types.h:180
+
+   subtype uu_loff_t is uu_off64_t;  -- /usr/include/bits/types.h:184
+
+   type uu_qaddr_t is access all uu_quad_t;  -- /usr/include/bits/types.h:185
+
+   type uu_caddr_t is new Interfaces.C.Strings.chars_ptr;  -- /usr/include/bits/types.h:186
+
+   subtype uu_intptr_t is int;  -- /usr/include/bits/types.h:189
+
+   subtype uu_socklen_t is unsigned;  -- /usr/include/bits/types.h:192
+
+end bits_types_h;
diff --git a/thin/bits_waitstatus_h.ads b/thin/bits_waitstatus_h.ads
new file mode 100644 (file)
index 0000000..0965f00
--- /dev/null
@@ -0,0 +1,54 @@
+with Interfaces.C; use Interfaces.C;
+with Interfaces.C.Extensions;
+
+package bits_waitstatus_h is
+
+   --  unsupported macro: w_termsig __wait_terminated.__w_termsig
+   --  unsupported macro: w_coredump __wait_terminated.__w_coredump
+   --  unsupported macro: w_retcode __wait_terminated.__w_retcode
+   --  unsupported macro: w_stopsig __wait_stopped.__w_stopsig
+   --  unsupported macro: w_stopval __wait_stopped.__w_stopval
+   type anon_598 is record
+      uu_w_termsig : Extensions.Unsigned_7;  -- /usr/include/bits/waitstatus.h:73
+      uu_w_coredump : Extensions.Unsigned_1;  -- /usr/include/bits/waitstatus.h:74
+      uu_w_retcode : aliased unsigned_char;  -- /usr/include/bits/waitstatus.h:75
+      field_4 : unsigned_short;
+   end record;
+   pragma Convention (C_Pass_By_Copy, anon_598);
+   pragma Pack (anon_598);  -- /usr/include/bits/waitstatus.h:70
+
+   type anon_601 is record
+      uu_w_stopval : aliased unsigned_char;  -- /usr/include/bits/waitstatus.h:88
+      uu_w_stopsig : aliased unsigned_char;  -- /usr/include/bits/waitstatus.h:89
+      field_3 : unsigned_short;
+   end record;
+   pragma Convention (C_Pass_By_Copy, anon_601);  -- /usr/include/bits/waitstatus.h:85
+
+   type wait;
+   type anon597_anon598_struct is record
+      uu_w_termsig : Extensions.Unsigned_7;  -- /usr/include/bits/waitstatus.h:73
+      uu_w_coredump : Extensions.Unsigned_1;  -- /usr/include/bits/waitstatus.h:74
+      uu_w_retcode : aliased unsigned_char;  -- /usr/include/bits/waitstatus.h:75
+      field_4 : unsigned_short;
+   end record;
+   pragma Convention (C_Pass_By_Copy, anon597_anon598_struct);
+   type anon597_anon601_struct is record
+      uu_w_stopval : aliased unsigned_char;  -- /usr/include/bits/waitstatus.h:88
+      uu_w_stopsig : aliased unsigned_char;  -- /usr/include/bits/waitstatus.h:89
+      field_3 : unsigned_short;
+   end record;
+   pragma Convention (C_Pass_By_Copy, anon597_anon601_struct);
+   type wait (discr : unsigned := 0) is record
+      case discr is
+         when 0 =>
+            w_status : aliased int;  -- /usr/include/bits/waitstatus.h:69
+         when 1 =>
+            uu_wait_terminated : aliased anon_598;  -- /usr/include/bits/waitstatus.h:84
+         when others =>
+            uu_wait_stopped : aliased anon_601;  -- /usr/include/bits/waitstatus.h:97
+      end case;
+   end record;
+   pragma Convention (C_Pass_By_Copy, wait);
+   pragma Unchecked_Union (wait);  -- /usr/include/bits/waitstatus.h:67
+
+end bits_waitstatus_h;
diff --git a/thin/cuda_h.ads b/thin/cuda_h.ads
new file mode 100644 (file)
index 0000000..f583bda
--- /dev/null
@@ -0,0 +1,1196 @@
+with Interfaces.C; use Interfaces.C;
+with System;
+with stddef_h;
+with Interfaces.C.Strings;
+
+package cuda_h is
+
+   --  unsupported macro: cuDeviceTotalMem cuDeviceTotalMem_v2
+   --  unsupported macro: cuCtxCreate cuCtxCreate_v2
+   --  unsupported macro: cuModuleGetGlobal cuModuleGetGlobal_v2
+   --  unsupported macro: cuMemGetInfo cuMemGetInfo_v2
+   --  unsupported macro: cuMemAlloc cuMemAlloc_v2
+   --  unsupported macro: cuMemAllocPitch cuMemAllocPitch_v2
+   --  unsupported macro: cuMemFree cuMemFree_v2
+   --  unsupported macro: cuMemGetAddressRange cuMemGetAddressRange_v2
+   --  unsupported macro: cuMemAllocHost cuMemAllocHost_v2
+   --  unsupported macro: cuMemHostGetDevicePointer cuMemHostGetDevicePointer_v2
+   --  unsupported macro: cuMemcpyHtoD cuMemcpyHtoD_v2
+   --  unsupported macro: cuMemcpyDtoH cuMemcpyDtoH_v2
+   --  unsupported macro: cuMemcpyDtoD cuMemcpyDtoD_v2
+   --  unsupported macro: cuMemcpyDtoA cuMemcpyDtoA_v2
+   --  unsupported macro: cuMemcpyAtoD cuMemcpyAtoD_v2
+   --  unsupported macro: cuMemcpyHtoA cuMemcpyHtoA_v2
+   --  unsupported macro: cuMemcpyAtoH cuMemcpyAtoH_v2
+   --  unsupported macro: cuMemcpyAtoA cuMemcpyAtoA_v2
+   --  unsupported macro: cuMemcpyHtoAAsync cuMemcpyHtoAAsync_v2
+   --  unsupported macro: cuMemcpyAtoHAsync cuMemcpyAtoHAsync_v2
+   --  unsupported macro: cuMemcpy2D cuMemcpy2D_v2
+   --  unsupported macro: cuMemcpy2DUnaligned cuMemcpy2DUnaligned_v2
+   --  unsupported macro: cuMemcpy3D cuMemcpy3D_v2
+   --  unsupported macro: cuMemcpyHtoDAsync cuMemcpyHtoDAsync_v2
+   --  unsupported macro: cuMemcpyDtoHAsync cuMemcpyDtoHAsync_v2
+   --  unsupported macro: cuMemcpyDtoDAsync cuMemcpyDtoDAsync_v2
+   --  unsupported macro: cuMemcpy2DAsync cuMemcpy2DAsync_v2
+   --  unsupported macro: cuMemcpy3DAsync cuMemcpy3DAsync_v2
+   --  unsupported macro: cuMemsetD8 cuMemsetD8_v2
+   --  unsupported macro: cuMemsetD16 cuMemsetD16_v2
+   --  unsupported macro: cuMemsetD32 cuMemsetD32_v2
+   --  unsupported macro: cuMemsetD2D8 cuMemsetD2D8_v2
+   --  unsupported macro: cuMemsetD2D16 cuMemsetD2D16_v2
+   --  unsupported macro: cuMemsetD2D32 cuMemsetD2D32_v2
+   --  unsupported macro: cuArrayCreate cuArrayCreate_v2
+   --  unsupported macro: cuArrayGetDescriptor cuArrayGetDescriptor_v2
+   --  unsupported macro: cuArray3DCreate cuArray3DCreate_v2
+   --  unsupported macro: cuArray3DGetDescriptor cuArray3DGetDescriptor_v2
+   --  unsupported macro: cuTexRefSetAddress cuTexRefSetAddress_v2
+   --  unsupported macro: cuTexRefSetAddress2D cuTexRefSetAddress2D_v2
+   --  unsupported macro: cuTexRefGetAddress cuTexRefGetAddress_v2
+   --  unsupported macro: cuGraphicsResourceGetMappedPointer cuGraphicsResourceGetMappedPointer_v2
+   --  unsupported macro: cuCtxDestroy cuCtxDestroy_v2
+   --  unsupported macro: cuCtxPopCurrent cuCtxPopCurrent_v2
+   --  unsupported macro: cuCtxPushCurrent cuCtxPushCurrent_v2
+   --  unsupported macro: cuStreamDestroy cuStreamDestroy_v2
+   --  unsupported macro: cuEventDestroy cuEventDestroy_v2
+
+   CUDA_VERSION : constant := 4000;  --  cuda.h:137
+
+   CU_MEMHOSTALLOC_PORTABLE : constant := 16#01#;  --  cuda.h:834
+
+   CU_MEMHOSTALLOC_DEVICEMAP : constant := 16#02#;  --  cuda.h:841
+
+   CU_MEMHOSTALLOC_WRITECOMBINED : constant := 16#04#;  --  cuda.h:849
+
+   CU_MEMHOSTREGISTER_PORTABLE : constant := 16#01#;  --  cuda.h:855
+
+   CU_MEMHOSTREGISTER_DEVICEMAP : constant := 16#02#;  --  cuda.h:862
+
+   CUDA_ARRAY3D_LAYERED : constant := 16#01#;  --  cuda.h:991
+
+   CUDA_ARRAY3D_2DARRAY : constant := 16#01#;  --  cuda.h:996
+
+   CUDA_ARRAY3D_SURFACE_LDST : constant := 16#02#;  --  cuda.h:1002
+
+   CU_TRSA_OVERRIDE_FORMAT : constant := 16#01#;  --  cuda.h:1008
+
+   CU_TRSF_READ_AS_INTEGER : constant := 16#01#;  --  cuda.h:1015
+
+   CU_TRSF_NORMALIZED_COORDINATES : constant := 16#02#;  --  cuda.h:1021
+
+   CU_TRSF_SRGB : constant := 16#10#;  --  cuda.h:1027
+   --  unsupported macro: CU_LAUNCH_PARAM_END ((void*)0x00)
+   --  unsupported macro: CU_LAUNCH_PARAM_BUFFER_POINTER ((void*)0x01)
+   --  unsupported macro: CU_LAUNCH_PARAM_BUFFER_SIZE ((void*)0x02)
+
+   CU_PARAM_TR_DEFAULT : constant := -1;  --  cuda.h:1060
+
+   subtype CUdeviceptr is unsigned;  -- cuda.h:151
+
+   subtype CUdevice is int;  -- cuda.h:156
+
+   --  skipped empty struct CUctx_st
+
+   type CUcontext is new System.Address;  -- cuda.h:157
+
+   --  skipped empty struct CUmod_st
+
+   type CUmodule is new System.Address;  -- cuda.h:158
+
+   --  skipped empty struct CUfunc_st
+
+   type CUfunction is new System.Address;  -- cuda.h:159
+
+   --  skipped empty struct CUarray_st
+
+   type CUarray is new System.Address;  -- cuda.h:160
+
+   --  skipped empty struct CUtexref_st
+
+   type CUtexref is new System.Address;  -- cuda.h:161
+
+   --  skipped empty struct CUsurfref_st
+
+   type CUsurfref is new System.Address;  -- cuda.h:162
+
+   --  skipped empty struct CUevent_st
+
+   type CUevent is new System.Address;  -- cuda.h:163
+
+   --  skipped empty struct CUstream_st
+
+   type CUstream is new System.Address;  -- cuda.h:164
+
+   --  skipped empty struct CUgraphicsResource_st
+
+   type CUgraphicsResource is new System.Address;  -- cuda.h:165
+
+   subtype anon1074_anon1076_array is Interfaces.C.char_array (0 .. 15);
+   type CUuuid_st is record
+      bytes : aliased anon1074_anon1076_array;  -- cuda.h:168
+   end record;
+   pragma Convention (C_Pass_By_Copy, CUuuid_st);  -- cuda.h:167
+
+   subtype CUuuid is CUuuid_st;
+
+   subtype CUctx_flags_enum is unsigned;
+   CU_CTX_SCHED_AUTO : constant CUctx_flags_enum := 0;
+   CU_CTX_SCHED_SPIN : constant CUctx_flags_enum := 1;
+   CU_CTX_SCHED_YIELD : constant CUctx_flags_enum := 2;
+   CU_CTX_SCHED_BLOCKING_SYNC : constant CUctx_flags_enum := 4;
+   CU_CTX_BLOCKING_SYNC : constant CUctx_flags_enum := 4;
+   CU_CTX_SCHED_MASK : constant CUctx_flags_enum := 7;
+   CU_CTX_MAP_HOST : constant CUctx_flags_enum := 8;
+   CU_CTX_LMEM_RESIZE_TO_MAX : constant CUctx_flags_enum := 16;
+   CU_CTX_FLAGS_MASK : constant CUctx_flags_enum := 31;  -- cuda.h:174
+
+   subtype CUctx_flags is CUctx_flags_enum;
+
+   type CUevent_flags_enum is
+     (CU_EVENT_DEFAULT,
+      CU_EVENT_BLOCKING_SYNC,
+      CU_EVENT_DISABLE_TIMING);
+   pragma Convention (C, CUevent_flags_enum);  -- cuda.h:189
+
+   subtype CUevent_flags is CUevent_flags_enum;
+
+   subtype CUarray_format_enum is unsigned;
+   CU_AD_FORMAT_UNSIGNED_INT8 : constant CUarray_format_enum := 1;
+   CU_AD_FORMAT_UNSIGNED_INT16 : constant CUarray_format_enum := 2;
+   CU_AD_FORMAT_UNSIGNED_INT32 : constant CUarray_format_enum := 3;
+   CU_AD_FORMAT_SIGNED_INT8 : constant CUarray_format_enum := 8;
+   CU_AD_FORMAT_SIGNED_INT16 : constant CUarray_format_enum := 9;
+   CU_AD_FORMAT_SIGNED_INT32 : constant CUarray_format_enum := 10;
+   CU_AD_FORMAT_HALF : constant CUarray_format_enum := 16;
+   CU_AD_FORMAT_FLOAT : constant CUarray_format_enum := 32;  -- cuda.h:198
+
+   subtype CUarray_format is CUarray_format_enum;
+
+   type CUaddress_mode_enum is
+     (CU_TR_ADDRESS_MODE_WRAP,
+      CU_TR_ADDRESS_MODE_CLAMP,
+      CU_TR_ADDRESS_MODE_MIRROR,
+      CU_TR_ADDRESS_MODE_BORDER);
+   pragma Convention (C, CUaddress_mode_enum);  -- cuda.h:212
+
+   subtype CUaddress_mode is CUaddress_mode_enum;
+
+   type CUfilter_mode_enum is
+     (CU_TR_FILTER_MODE_POINT,
+      CU_TR_FILTER_MODE_LINEAR);
+   pragma Convention (C, CUfilter_mode_enum);  -- cuda.h:222
+
+   subtype CUfilter_mode is CUfilter_mode_enum;
+
+   subtype CUdevice_attribute_enum is unsigned;
+   CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK : constant CUdevice_attribute_enum := 1;
+   CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X : constant CUdevice_attribute_enum := 2;
+   CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y : constant CUdevice_attribute_enum := 3;
+   CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z : constant CUdevice_attribute_enum := 4;
+   CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X : constant CUdevice_attribute_enum := 5;
+   CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y : constant CUdevice_attribute_enum := 6;
+   CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z : constant CUdevice_attribute_enum := 7;
+   CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK : constant CUdevice_attribute_enum := 8;
+   CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK : constant CUdevice_attribute_enum := 8;
+   CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY : constant CUdevice_attribute_enum := 9;
+   CU_DEVICE_ATTRIBUTE_WARP_SIZE : constant CUdevice_attribute_enum := 10;
+   CU_DEVICE_ATTRIBUTE_MAX_PITCH : constant CUdevice_attribute_enum := 11;
+   CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK : constant CUdevice_attribute_enum := 12;
+   CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK : constant CUdevice_attribute_enum := 12;
+   CU_DEVICE_ATTRIBUTE_CLOCK_RATE : constant CUdevice_attribute_enum := 13;
+   CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT : constant CUdevice_attribute_enum := 14;
+   CU_DEVICE_ATTRIBUTE_GPU_OVERLAP : constant CUdevice_attribute_enum := 15;
+   CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT : constant CUdevice_attribute_enum := 16;
+   CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT : constant CUdevice_attribute_enum := 17;
+   CU_DEVICE_ATTRIBUTE_INTEGRATED : constant CUdevice_attribute_enum := 18;
+   CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY : constant CUdevice_attribute_enum := 19;
+   CU_DEVICE_ATTRIBUTE_COMPUTE_MODE : constant CUdevice_attribute_enum := 20;
+   CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH : constant CUdevice_attribute_enum := 21;
+   CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH : constant CUdevice_attribute_enum := 22;
+   CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT : constant CUdevice_attribute_enum := 23;
+   CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH : constant CUdevice_attribute_enum := 24;
+   CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT : constant CUdevice_attribute_enum := 25;
+   CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH : constant CUdevice_attribute_enum := 26;
+   CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH : constant CUdevice_attribute_enum := 27;
+   CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT : constant CUdevice_attribute_enum := 28;
+   CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS : constant CUdevice_attribute_enum := 29;
+   CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH : constant CUdevice_attribute_enum := 27;
+   CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT : constant CUdevice_attribute_enum := 28;
+   CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES : constant CUdevice_attribute_enum := 29;
+   CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT : constant CUdevice_attribute_enum := 30;
+   CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS : constant CUdevice_attribute_enum := 31;
+   CU_DEVICE_ATTRIBUTE_ECC_ENABLED : constant CUdevice_attribute_enum := 32;
+   CU_DEVICE_ATTRIBUTE_PCI_BUS_ID : constant CUdevice_attribute_enum := 33;
+   CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID : constant CUdevice_attribute_enum := 34;
+   CU_DEVICE_ATTRIBUTE_TCC_DRIVER : constant CUdevice_attribute_enum := 35;
+   CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE : constant CUdevice_attribute_enum := 36;
+   CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH : constant CUdevice_attribute_enum := 37;
+   CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE : constant CUdevice_attribute_enum := 38;
+   CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR : constant CUdevice_attribute_enum := 39;
+   CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT : constant CUdevice_attribute_enum := 40;
+   CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING : constant CUdevice_attribute_enum := 41;
+   CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH : constant CUdevice_attribute_enum := 42;
+   CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS : constant CUdevice_attribute_enum := 43;
+   CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID : constant CUdevice_attribute_enum := 50;  -- cuda.h:230
+
+   subtype CUdevice_attribute is CUdevice_attribute_enum;
+
+   type anon1090_anon1092_array is array (0 .. 2) of aliased int;
+   type CUdevprop_st is record
+      maxThreadsPerBlock : aliased int;  -- cuda.h:286
+      maxThreadsDim : aliased anon1090_anon1092_array;  -- cuda.h:287
+      maxGridSize : aliased anon1090_anon1092_array;  -- cuda.h:288
+      sharedMemPerBlock : aliased int;  -- cuda.h:289
+      totalConstantMemory : aliased int;  -- cuda.h:290
+      SIMDWidth : aliased int;  -- cuda.h:291
+      memPitch : aliased int;  -- cuda.h:292
+      regsPerBlock : aliased int;  -- cuda.h:293
+      clockRate : aliased int;  -- cuda.h:294
+      textureAlign : aliased int;  -- cuda.h:295
+   end record;
+   pragma Convention (C_Pass_By_Copy, CUdevprop_st);  -- cuda.h:285
+
+   subtype CUdevprop is CUdevprop_st;
+
+   subtype CUpointer_attribute_enum is unsigned;
+   CU_POINTER_ATTRIBUTE_CONTEXT : constant CUpointer_attribute_enum := 1;
+   CU_POINTER_ATTRIBUTE_MEMORY_TYPE : constant CUpointer_attribute_enum := 2;
+   CU_POINTER_ATTRIBUTE_DEVICE_POINTER : constant CUpointer_attribute_enum := 3;
+   CU_POINTER_ATTRIBUTE_HOST_POINTER : constant CUpointer_attribute_enum := 4;  -- cuda.h:301
+
+   subtype CUpointer_attribute is CUpointer_attribute_enum;
+
+   type CUfunction_attribute_enum is
+     (CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK,
+      CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES,
+      CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES,
+      CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES,
+      CU_FUNC_ATTRIBUTE_NUM_REGS,
+      CU_FUNC_ATTRIBUTE_PTX_VERSION,
+      CU_FUNC_ATTRIBUTE_BINARY_VERSION,
+      CU_FUNC_ATTRIBUTE_MAX);
+   pragma Convention (C, CUfunction_attribute_enum);  -- cuda.h:311
+
+   subtype CUfunction_attribute is CUfunction_attribute_enum;
+
+   type CUfunc_cache_enum is
+     (CU_FUNC_CACHE_PREFER_NONE,
+      CU_FUNC_CACHE_PREFER_SHARED,
+      CU_FUNC_CACHE_PREFER_L1);
+   pragma Convention (C, CUfunc_cache_enum);  -- cuda.h:366
+
+   subtype CUfunc_cache is CUfunc_cache_enum;
+
+   subtype CUmemorytype_enum is unsigned;
+   CU_MEMORYTYPE_HOST : constant CUmemorytype_enum := 1;
+   CU_MEMORYTYPE_DEVICE : constant CUmemorytype_enum := 2;
+   CU_MEMORYTYPE_ARRAY : constant CUmemorytype_enum := 3;
+   CU_MEMORYTYPE_UNIFIED : constant CUmemorytype_enum := 4;  -- cuda.h:375
+
+   subtype CUmemorytype is CUmemorytype_enum;
+
+   type CUcomputemode_enum is
+     (CU_COMPUTEMODE_DEFAULT,
+      CU_COMPUTEMODE_EXCLUSIVE,
+      CU_COMPUTEMODE_PROHIBITED,
+      CU_COMPUTEMODE_EXCLUSIVE_PROCESS);
+   pragma Convention (C, CUcomputemode_enum);  -- cuda.h:385
+
+   subtype CUcomputemode is CUcomputemode_enum;
+
+   type CUjit_option_enum is
+     (CU_JIT_MAX_REGISTERS,
+      CU_JIT_THREADS_PER_BLOCK,
+      CU_JIT_WALL_TIME,
+      CU_JIT_INFO_LOG_BUFFER,
+      CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES,
+      CU_JIT_ERROR_LOG_BUFFER,
+      CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES,
+      CU_JIT_OPTIMIZATION_LEVEL,
+      CU_JIT_TARGET_FROM_CUCONTEXT,
+      CU_JIT_TARGET,
+      CU_JIT_FALLBACK_STRATEGY);
+   pragma Convention (C, CUjit_option_enum);  -- cuda.h:395
+
+   subtype CUjit_option is CUjit_option_enum;
+
+   type CUjit_target_enum is
+     (CU_TARGET_COMPUTE_10,
+      CU_TARGET_COMPUTE_11,
+      CU_TARGET_COMPUTE_12,
+      CU_TARGET_COMPUTE_13,
+      CU_TARGET_COMPUTE_20,
+      CU_TARGET_COMPUTE_21);
+   pragma Convention (C, CUjit_target_enum);  -- cuda.h:487
+
+   subtype CUjit_target is CUjit_target_enum;
+
+   type CUjit_fallback_enum is
+     (CU_PREFER_PTX,
+      CU_PREFER_BINARY);
+   pragma Convention (C, CUjit_fallback_enum);  -- cuda.h:500
+
+   subtype CUjit_fallback is CUjit_fallback_enum;
+
+   subtype CUgraphicsRegisterFlags_enum is unsigned;
+   CU_GRAPHICS_REGISTER_FLAGS_NONE : constant CUgraphicsRegisterFlags_enum := 0;
+   CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY : constant CUgraphicsRegisterFlags_enum := 1;
+   CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD : constant CUgraphicsRegisterFlags_enum := 2;
+   CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST : constant CUgraphicsRegisterFlags_enum := 4;  -- cuda.h:511
+
+   subtype CUgraphicsRegisterFlags is CUgraphicsRegisterFlags_enum;
+
+   type CUgraphicsMapResourceFlags_enum is
+     (CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE,
+      CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY,
+      CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD);
+   pragma Convention (C, CUgraphicsMapResourceFlags_enum);  -- cuda.h:521
+
+   subtype CUgraphicsMapResourceFlags is CUgraphicsMapResourceFlags_enum;
+
+   type CUarray_cubemap_face_enum is
+     (CU_CUBEMAP_FACE_POSITIVE_X,
+      CU_CUBEMAP_FACE_NEGATIVE_X,
+      CU_CUBEMAP_FACE_POSITIVE_Y,
+      CU_CUBEMAP_FACE_NEGATIVE_Y,
+      CU_CUBEMAP_FACE_POSITIVE_Z,
+      CU_CUBEMAP_FACE_NEGATIVE_Z);
+   pragma Convention (C, CUarray_cubemap_face_enum);  -- cuda.h:530
+
+   subtype CUarray_cubemap_face is CUarray_cubemap_face_enum;
+
+   type CUlimit_enum is
+     (CU_LIMIT_STACK_SIZE,
+      CU_LIMIT_PRINTF_FIFO_SIZE,
+      CU_LIMIT_MALLOC_HEAP_SIZE);
+   pragma Convention (C, CUlimit_enum);  -- cuda.h:542
+
+   subtype CUlimit is CUlimit_enum;
+
+   subtype cudaError_enum is unsigned;
+   CUDA_SUCCESS : constant cudaError_enum := 0;
+   CUDA_ERROR_INVALID_VALUE : constant cudaError_enum := 1;
+   CUDA_ERROR_OUT_OF_MEMORY : constant cudaError_enum := 2;
+   CUDA_ERROR_NOT_INITIALIZED : constant cudaError_enum := 3;
+   CUDA_ERROR_DEINITIALIZED : constant cudaError_enum := 4;
+   CUDA_ERROR_PROFILER_DISABLED : constant cudaError_enum := 5;
+   CUDA_ERROR_PROFILER_NOT_INITIALIZED : constant cudaError_enum := 6;
+   CUDA_ERROR_PROFILER_ALREADY_STARTED : constant cudaError_enum := 7;
+   CUDA_ERROR_PROFILER_ALREADY_STOPPED : constant cudaError_enum := 8;
+   CUDA_ERROR_NO_DEVICE : constant cudaError_enum := 100;
+   CUDA_ERROR_INVALID_DEVICE : constant cudaError_enum := 101;
+   CUDA_ERROR_INVALID_IMAGE : constant cudaError_enum := 200;
+   CUDA_ERROR_INVALID_CONTEXT : constant cudaError_enum := 201;
+   CUDA_ERROR_CONTEXT_ALREADY_CURRENT : constant cudaError_enum := 202;
+   CUDA_ERROR_MAP_FAILED : constant cudaError_enum := 205;
+   CUDA_ERROR_UNMAP_FAILED : constant cudaError_enum := 206;
+   CUDA_ERROR_ARRAY_IS_MAPPED : constant cudaError_enum := 207;
+   CUDA_ERROR_ALREADY_MAPPED : constant cudaError_enum := 208;
+   CUDA_ERROR_NO_BINARY_FOR_GPU : constant cudaError_enum := 209;
+   CUDA_ERROR_ALREADY_ACQUIRED : constant cudaError_enum := 210;
+   CUDA_ERROR_NOT_MAPPED : constant cudaError_enum := 211;
+   CUDA_ERROR_NOT_MAPPED_AS_ARRAY : constant cudaError_enum := 212;
+   CUDA_ERROR_NOT_MAPPED_AS_POINTER : constant cudaError_enum := 213;
+   CUDA_ERROR_ECC_UNCORRECTABLE : constant cudaError_enum := 214;
+   CUDA_ERROR_UNSUPPORTED_LIMIT : constant cudaError_enum := 215;
+   CUDA_ERROR_CONTEXT_ALREADY_IN_USE : constant cudaError_enum := 216;
+   CUDA_ERROR_INVALID_SOURCE : constant cudaError_enum := 300;
+   CUDA_ERROR_FILE_NOT_FOUND : constant cudaError_enum := 301;
+   CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND : constant cudaError_enum := 302;
+   CUDA_ERROR_SHARED_OBJECT_INIT_FAILED : constant cudaError_enum := 303;
+   CUDA_ERROR_OPERATING_SYSTEM : constant cudaError_enum := 304;
+   CUDA_ERROR_INVALID_HANDLE : constant cudaError_enum := 400;
+   CUDA_ERROR_NOT_FOUND : constant cudaError_enum := 500;
+   CUDA_ERROR_NOT_READY : constant cudaError_enum := 600;
+   CUDA_ERROR_LAUNCH_FAILED : constant cudaError_enum := 700;
+   CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES : constant cudaError_enum := 701;
+   CUDA_ERROR_LAUNCH_TIMEOUT : constant cudaError_enum := 702;
+   CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING : constant cudaError_enum := 703;
+   CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED : constant cudaError_enum := 704;
+   CUDA_ERROR_PEER_ACCESS_NOT_ENABLED : constant cudaError_enum := 705;
+   CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE : constant cudaError_enum := 708;
+   CUDA_ERROR_CONTEXT_IS_DESTROYED : constant cudaError_enum := 709;
+   CUDA_ERROR_UNKNOWN : constant cudaError_enum := 999;  -- cuda.h:551
+
+   subtype CUresult is cudaError_enum;
+
+   type CUDA_MEMCPY2D_st is record
+      srcXInBytes : aliased stddef_h.size_t;  -- cuda.h:870
+      srcY : aliased stddef_h.size_t;  -- cuda.h:871
+      srcMemoryType : aliased CUmemorytype;  -- cuda.h:873
+      srcHost : System.Address;  -- cuda.h:874
+      srcDevice : aliased CUdeviceptr;  -- cuda.h:875
+      srcArray : CUarray;  -- cuda.h:876
+      srcPitch : aliased stddef_h.size_t;  -- cuda.h:877
+      dstXInBytes : aliased stddef_h.size_t;  -- cuda.h:879
+      dstY : aliased stddef_h.size_t;  -- cuda.h:880
+      dstMemoryType : aliased CUmemorytype;  -- cuda.h:882
+      dstHost : System.Address;  -- cuda.h:883
+      dstDevice : aliased CUdeviceptr;  -- cuda.h:884
+      dstArray : CUarray;  -- cuda.h:885
+      dstPitch : aliased stddef_h.size_t;  -- cuda.h:886
+      WidthInBytes : aliased stddef_h.size_t;  -- cuda.h:888
+      Height : aliased stddef_h.size_t;  -- cuda.h:889
+   end record;
+   pragma Convention (C_Pass_By_Copy, CUDA_MEMCPY2D_st);  -- cuda.h:869
+
+   subtype CUDA_MEMCPY2D is CUDA_MEMCPY2D_st;
+
+   type CUDA_MEMCPY3D_st is record
+      srcXInBytes : aliased stddef_h.size_t;  -- cuda.h:896
+      srcY : aliased stddef_h.size_t;  -- cuda.h:897
+      srcZ : aliased stddef_h.size_t;  -- cuda.h:898
+      srcLOD : aliased stddef_h.size_t;  -- cuda.h:899
+      srcMemoryType : aliased CUmemorytype;  -- cuda.h:900
+      srcHost : System.Address;  -- cuda.h:901
+      srcDevice : aliased CUdeviceptr;  -- cuda.h:902
+      srcArray : CUarray;  -- cuda.h:903
+      reserved0 : System.Address;  -- cuda.h:904
+      srcPitch : aliased stddef_h.size_t;  -- cuda.h:905
+      srcHeight : aliased stddef_h.size_t;  -- cuda.h:906
+      dstXInBytes : aliased stddef_h.size_t;  -- cuda.h:908
+      dstY : aliased stddef_h.size_t;  -- cuda.h:909
+      dstZ : aliased stddef_h.size_t;  -- cuda.h:910
+      dstLOD : aliased stddef_h.size_t;  -- cuda.h:911
+      dstMemoryType : aliased CUmemorytype;  -- cuda.h:912
+      dstHost : System.Address;  -- cuda.h:913
+      dstDevice : aliased CUdeviceptr;  -- cuda.h:914
+      dstArray : CUarray;  -- cuda.h:915
+      reserved1 : System.Address;  -- cuda.h:916
+      dstPitch : aliased stddef_h.size_t;  -- cuda.h:917
+      dstHeight : aliased stddef_h.size_t;  -- cuda.h:918
+      WidthInBytes : aliased stddef_h.size_t;  -- cuda.h:920
+      Height : aliased stddef_h.size_t;  -- cuda.h:921
+      Depth : aliased stddef_h.size_t;  -- cuda.h:922
+   end record;
+   pragma Convention (C_Pass_By_Copy, CUDA_MEMCPY3D_st);  -- cuda.h:895
+
+   subtype CUDA_MEMCPY3D is CUDA_MEMCPY3D_st;
+
+   type CUDA_MEMCPY3D_PEER_st is record
+      srcXInBytes : aliased stddef_h.size_t;  -- cuda.h:929
+      srcY : aliased stddef_h.size_t;  -- cuda.h:930
+      srcZ : aliased stddef_h.size_t;  -- cuda.h:931
+      srcLOD : aliased stddef_h.size_t;  -- cuda.h:932
+      srcMemoryType : aliased CUmemorytype;  -- cuda.h:933
+      srcHost : System.Address;  -- cuda.h:934
+      srcDevice : aliased CUdeviceptr;  -- cuda.h:935
+      srcArray : CUarray;  -- cuda.h:936
+      srcContext : CUcontext;  -- cuda.h:937
+      srcPitch : aliased stddef_h.size_t;  -- cuda.h:938
+      srcHeight : aliased stddef_h.size_t;  -- cuda.h:939
+      dstXInBytes : aliased stddef_h.size_t;  -- cuda.h:941
+      dstY : aliased stddef_h.size_t;  -- cuda.h:942
+      dstZ : aliased stddef_h.size_t;  -- cuda.h:943
+      dstLOD : aliased stddef_h.size_t;  -- cuda.h:944
+      dstMemoryType : aliased CUmemorytype;  -- cuda.h:945
+      dstHost : System.Address;  -- cuda.h:946
+      dstDevice : aliased CUdeviceptr;  -- cuda.h:947
+      dstArray : CUarray;  -- cuda.h:948
+      dstContext : CUcontext;  -- cuda.h:949
+      dstPitch : aliased stddef_h.size_t;  -- cuda.h:950
+      dstHeight : aliased stddef_h.size_t;  -- cuda.h:951
+      WidthInBytes : aliased stddef_h.size_t;  -- cuda.h:953
+      Height : aliased stddef_h.size_t;  -- cuda.h:954
+      Depth : aliased stddef_h.size_t;  -- cuda.h:955
+   end record;
+   pragma Convention (C_Pass_By_Copy, CUDA_MEMCPY3D_PEER_st);  -- cuda.h:928
+
+   subtype CUDA_MEMCPY3D_PEER is CUDA_MEMCPY3D_PEER_st;
+
+   type CUDA_ARRAY_DESCRIPTOR_st is record
+      Width : aliased stddef_h.size_t;  -- cuda.h:963
+      Height : aliased stddef_h.size_t;  -- cuda.h:964
+      Format : aliased CUarray_format;  -- cuda.h:966
+      NumChannels : aliased unsigned;  -- cuda.h:967
+   end record;
+   pragma Convention (C_Pass_By_Copy, CUDA_ARRAY_DESCRIPTOR_st);  -- cuda.h:961
+
+   subtype CUDA_ARRAY_DESCRIPTOR is CUDA_ARRAY_DESCRIPTOR_st;
+
+   type CUDA_ARRAY3D_DESCRIPTOR_st is record
+      Width : aliased stddef_h.size_t;  -- cuda.h:975
+      Height : aliased stddef_h.size_t;  -- cuda.h:976
+      Depth : aliased stddef_h.size_t;  -- cuda.h:977
+      Format : aliased CUarray_format;  -- cuda.h:979
+      NumChannels : aliased unsigned;  -- cuda.h:980
+      Flags : aliased unsigned;  -- cuda.h:981
+   end record;
+   pragma Convention (C_Pass_By_Copy, CUDA_ARRAY3D_DESCRIPTOR_st);  -- cuda.h:973
+
+   subtype CUDA_ARRAY3D_DESCRIPTOR is CUDA_ARRAY3D_DESCRIPTOR_st;
+
+   function cuInit (arg1 : unsigned) return CUresult;  -- cuda.h:1095
+   pragma Import (C, cuInit, "cuInit");
+
+   function cuDriverGetVersion (arg1 : access int) return CUresult;  -- cuda.h:1122
+   pragma Import (C, cuDriverGetVersion, "cuDriverGetVersion");
+
+   function cuDeviceGet (arg1 : access CUdevice; arg2 : int) return CUresult;  -- cuda.h:1160
+   pragma Import (C, cuDeviceGet, "cuDeviceGet");
+
+   function cuDeviceGetCount (arg1 : access int) return CUresult;  -- cuda.h:1186
+   pragma Import (C, cuDeviceGetCount, "cuDeviceGetCount");
+
+   function cuDeviceGetName
+     (arg1 : Interfaces.C.Strings.chars_ptr;
+      arg2 : int;
+      arg3 : CUdevice) return CUresult;  -- cuda.h:1215
+   pragma Import (C, cuDeviceGetName, "cuDeviceGetName");
+
+   function cuDeviceComputeCapability
+     (arg1 : access int;
+      arg2 : access int;
+      arg3 : CUdevice) return CUresult;  -- cuda.h:1244
+   pragma Import (C, cuDeviceComputeCapability, "cuDeviceComputeCapability");
+
+   function cuDeviceTotalMem_v2 (arg1 : access stddef_h.size_t; arg2 : CUdevice) return CUresult;  -- cuda.h:1272
+   pragma Import (C, cuDeviceTotalMem_v2, "cuDeviceTotalMem_v2");
+
+   function cuDeviceGetProperties (arg1 : access CUdevprop; arg2 : CUdevice) return CUresult;  -- cuda.h:1332
+   pragma Import (C, cuDeviceGetProperties, "cuDeviceGetProperties");
+
+   function cuDeviceGetAttribute
+     (arg1 : access int;
+      arg2 : CUdevice_attribute;
+      arg3 : CUdevice) return CUresult;  -- cuda.h:1444
+   pragma Import (C, cuDeviceGetAttribute, "cuDeviceGetAttribute");
+
+   function cuCtxCreate_v2
+     (arg1 : System.Address;
+      arg2 : unsigned;
+      arg3 : CUdevice) return CUresult;  -- cuda.h:1544
+   pragma Import (C, cuCtxCreate_v2, "cuCtxCreate_v2");
+
+   function cuCtxDestroy_v2 (arg1 : CUcontext) return CUresult;  -- cuda.h:1583
+   pragma Import (C, cuCtxDestroy_v2, "cuCtxDestroy_v2");
+
+   function cuCtxAttach (arg1 : System.Address; arg2 : unsigned) return CUresult;  -- cuda.h:1633
+   pragma Import (C, cuCtxAttach, "cuCtxAttach");
+
+   function cuCtxDetach (arg1 : CUcontext) return CUresult;  -- cuda.h:1668
+   pragma Import (C, cuCtxDetach, "cuCtxDetach");
+
+   function cuCtxPushCurrent_v2 (arg1 : CUcontext) return CUresult;  -- cuda.h:1704
+   pragma Import (C, cuCtxPushCurrent_v2, "cuCtxPushCurrent_v2");
+
+   function cuCtxPopCurrent_v2 (arg1 : System.Address) return CUresult;  -- cuda.h:1737
+   pragma Import (C, cuCtxPopCurrent_v2, "cuCtxPopCurrent_v2");
+
+   function cuCtxSetCurrent (arg1 : CUcontext) return CUresult;  -- cuda.h:1763
+   pragma Import (C, cuCtxSetCurrent, "cuCtxSetCurrent");
+
+   function cuCtxGetCurrent (arg1 : System.Address) return CUresult;  -- cuda.h:1782
+   pragma Import (C, cuCtxGetCurrent, "cuCtxGetCurrent");
+
+   function cuCtxGetDevice (arg1 : access CUdevice) return CUresult;  -- cuda.h:1811
+   pragma Import (C, cuCtxGetDevice, "cuCtxGetDevice");
+
+   function cuCtxSynchronize return CUresult;  -- cuda.h:1839
+   pragma Import (C, cuCtxSynchronize, "cuCtxSynchronize");
+
+   function cuCtxSetLimit (arg1 : CUlimit; arg2 : stddef_h.size_t) return CUresult;  -- cuda.h:1900
+   pragma Import (C, cuCtxSetLimit, "cuCtxSetLimit");
+
+   function cuCtxGetLimit (arg1 : access stddef_h.size_t; arg2 : CUlimit) return CUresult;  -- cuda.h:1933
+   pragma Import (C, cuCtxGetLimit, "cuCtxGetLimit");
+
+   function cuCtxGetCacheConfig (arg1 : access CUfunc_cache) return CUresult;  -- cuda.h:1974
+   pragma Import (C, cuCtxGetCacheConfig, "cuCtxGetCacheConfig");
+
+   function cuCtxSetCacheConfig (arg1 : CUfunc_cache) return CUresult;  -- cuda.h:2022
+   pragma Import (C, cuCtxSetCacheConfig, "cuCtxSetCacheConfig");
+
+   function cuCtxGetApiVersion (arg1 : CUcontext; arg2 : access unsigned) return CUresult;  -- cuda.h:2057
+   pragma Import (C, cuCtxGetApiVersion, "cuCtxGetApiVersion");
+
+   function cuModuleLoad (arg1 : System.Address; arg2 : Interfaces.C.Strings.chars_ptr) return CUresult;  -- cuda.h:2106
+   pragma Import (C, cuModuleLoad, "cuModuleLoad");
+
+   function cuModuleLoadData (arg1 : System.Address; arg2 : System.Address) return CUresult;  -- cuda.h:2140
+   pragma Import (C, cuModuleLoadData, "cuModuleLoadData");
+
+   function cuModuleLoadDataEx
+     (arg1 : System.Address;
+      arg2 : System.Address;
+      arg3 : unsigned;
+      arg4 : access CUjit_option;
+      arg5 : System.Address) return CUresult;  -- cuda.h:2219
+   pragma Import (C, cuModuleLoadDataEx, "cuModuleLoadDataEx");
+
+   function cuModuleLoadFatBinary (arg1 : System.Address; arg2 : System.Address) return CUresult;  -- cuda.h:2259
+   pragma Import (C, cuModuleLoadFatBinary, "cuModuleLoadFatBinary");
+
+   function cuModuleUnload (arg1 : CUmodule) return CUresult;  -- cuda.h:2284
+   pragma Import (C, cuModuleUnload, "cuModuleUnload");
+
+   function cuModuleGetFunction
+     (arg1 : System.Address;
+      arg2 : CUmodule;
+      arg3 : Interfaces.C.Strings.chars_ptr) return CUresult;  -- cuda.h:2314
+   pragma Import (C, cuModuleGetFunction, "cuModuleGetFunction");
+
+   function cuModuleGetGlobal_v2
+     (arg1 : access CUdeviceptr;
+      arg2 : access stddef_h.size_t;
+      arg3 : CUmodule;
+      arg4 : Interfaces.C.Strings.chars_ptr) return CUresult;  -- cuda.h:2348
+   pragma Import (C, cuModuleGetGlobal_v2, "cuModuleGetGlobal_v2");
+
+   function cuModuleGetTexRef
+     (arg1 : System.Address;
+      arg2 : CUmodule;
+      arg3 : Interfaces.C.Strings.chars_ptr) return CUresult;  -- cuda.h:2382
+   pragma Import (C, cuModuleGetTexRef, "cuModuleGetTexRef");
+
+   function cuModuleGetSurfRef
+     (arg1 : System.Address;
+      arg2 : CUmodule;
+      arg3 : Interfaces.C.Strings.chars_ptr) return CUresult;  -- cuda.h:2413
+   pragma Import (C, cuModuleGetSurfRef, "cuModuleGetSurfRef");
+
+   function cuMemGetInfo_v2 (arg1 : access stddef_h.size_t; arg2 : access stddef_h.size_t) return CUresult;  -- cuda.h:2456
+   pragma Import (C, cuMemGetInfo_v2, "cuMemGetInfo_v2");
+
+   function cuMemAlloc_v2 (arg1 : access CUdeviceptr; arg2 : stddef_h.size_t) return CUresult;  -- cuda.h:2489
+   pragma Import (C, cuMemAlloc_v2, "cuMemAlloc_v2");
+
+   function cuMemAllocPitch_v2
+     (arg1 : access CUdeviceptr;
+      arg2 : access stddef_h.size_t;
+      arg3 : stddef_h.size_t;
+      arg4 : stddef_h.size_t;
+      arg5 : unsigned) return CUresult;  -- cuda.h:2550
+   pragma Import (C, cuMemAllocPitch_v2, "cuMemAllocPitch_v2");
+
+   function cuMemFree_v2 (arg1 : CUdeviceptr) return CUresult;  -- cuda.h:2579
+   pragma Import (C, cuMemFree_v2, "cuMemFree_v2");
+
+   function cuMemGetAddressRange_v2
+     (arg1 : access CUdeviceptr;
+      arg2 : access stddef_h.size_t;
+      arg3 : CUdeviceptr) return CUresult;  -- cuda.h:2612
+   pragma Import (C, cuMemGetAddressRange_v2, "cuMemGetAddressRange_v2");
+
+   function cuMemAllocHost_v2 (arg1 : System.Address; arg2 : stddef_h.size_t) return CUresult;  -- cuda.h:2658
+   pragma Import (C, cuMemAllocHost_v2, "cuMemAllocHost_v2");
+
+   function cuMemFreeHost (arg1 : System.Address) return CUresult;  -- cuda.h:2688
+   pragma Import (C, cuMemFreeHost, "cuMemFreeHost");
+
+   function cuMemHostAlloc
+     (arg1 : System.Address;
+      arg2 : stddef_h.size_t;
+      arg3 : unsigned) return CUresult;  -- cuda.h:2770
+   pragma Import (C, cuMemHostAlloc, "cuMemHostAlloc");
+
+   function cuMemHostGetDevicePointer_v2
+     (arg1 : access CUdeviceptr;
+      arg2 : System.Address;
+      arg3 : unsigned) return CUresult;  -- cuda.h:2808
+   pragma Import (C, cuMemHostGetDevicePointer_v2, "cuMemHostGetDevicePointer_v2");
+
+   function cuMemHostGetFlags (arg1 : access unsigned; arg2 : System.Address) return CUresult;  -- cuda.h:2833
+   pragma Import (C, cuMemHostGetFlags, "cuMemHostGetFlags");
+
+   function cuMemHostRegister
+     (arg1 : System.Address;
+      arg2 : stddef_h.size_t;
+      arg3 : unsigned) return CUresult;  -- cuda.h:2896
+   pragma Import (C, cuMemHostRegister, "cuMemHostRegister");
+
+   function cuMemHostUnregister (arg1 : System.Address) return CUresult;  -- cuda.h:2919
+   pragma Import (C, cuMemHostUnregister, "cuMemHostUnregister");
+
+   function cuMemcpy
+     (arg1 : CUdeviceptr;
+      arg2 : CUdeviceptr;
+      arg3 : stddef_h.size_t) return CUresult;  -- cuda.h:2955
+   pragma Import (C, cuMemcpy, "cuMemcpy");
+
+   function cuMemcpyPeer
+     (arg1 : CUdeviceptr;
+      arg2 : CUcontext;
+      arg3 : CUdeviceptr;
+      arg4 : CUcontext;
+      arg5 : stddef_h.size_t) return CUresult;  -- cuda.h:2988
+   pragma Import (C, cuMemcpyPeer, "cuMemcpyPeer");
+
+   function cuMemcpyHtoD_v2
+     (arg1 : CUdeviceptr;
+      arg2 : System.Address;
+      arg3 : stddef_h.size_t) return CUresult;  -- cuda.h:3026
+   pragma Import (C, cuMemcpyHtoD_v2, "cuMemcpyHtoD_v2");
+
+   function cuMemcpyDtoH_v2
+     (arg1 : System.Address;
+      arg2 : CUdeviceptr;
+      arg3 : stddef_h.size_t) return CUresult;  -- cuda.h:3059
+   pragma Import (C, cuMemcpyDtoH_v2, "cuMemcpyDtoH_v2");
+
+   function cuMemcpyDtoD_v2
+     (arg1 : CUdeviceptr;
+      arg2 : CUdeviceptr;
+      arg3 : stddef_h.size_t) return CUresult;  -- cuda.h:3092
+   pragma Import (C, cuMemcpyDtoD_v2, "cuMemcpyDtoD_v2");
+
+   function cuMemcpyDtoA_v2
+     (arg1 : CUarray;
+      arg2 : stddef_h.size_t;
+      arg3 : CUdeviceptr;
+      arg4 : stddef_h.size_t) return CUresult;  -- cuda.h:3126
+   pragma Import (C, cuMemcpyDtoA_v2, "cuMemcpyDtoA_v2");
+
+   function cuMemcpyAtoD_v2
+     (arg1 : CUdeviceptr;
+      arg2 : CUarray;
+      arg3 : stddef_h.size_t;
+      arg4 : stddef_h.size_t) return CUresult;  -- cuda.h:3162
+   pragma Import (C, cuMemcpyAtoD_v2, "cuMemcpyAtoD_v2");
+
+   function cuMemcpyHtoA_v2
+     (arg1 : CUarray;
+      arg2 : stddef_h.size_t;
+      arg3 : System.Address;
+      arg4 : stddef_h.size_t) return CUresult;  -- cuda.h:3196
+   pragma Import (C, cuMemcpyHtoA_v2, "cuMemcpyHtoA_v2");
+
+   function cuMemcpyAtoH_v2
+     (arg1 : System.Address;
+      arg2 : CUarray;
+      arg3 : stddef_h.size_t;
+      arg4 : stddef_h.size_t) return CUresult;  -- cuda.h:3230
+   pragma Import (C, cuMemcpyAtoH_v2, "cuMemcpyAtoH_v2");
+
+   function cuMemcpyAtoA_v2
+     (arg1 : CUarray;
+      arg2 : stddef_h.size_t;
+      arg3 : CUarray;
+      arg4 : stddef_h.size_t;
+      arg5 : stddef_h.size_t) return CUresult;  -- cuda.h:3268
+   pragma Import (C, cuMemcpyAtoA_v2, "cuMemcpyAtoA_v2");
+
+   function cuMemcpy2D_v2 (arg1 : System.Address) return CUresult;  -- cuda.h:3428
+   pragma Import (C, cuMemcpy2D_v2, "cuMemcpy2D_v2");
+
+   function cuMemcpy2DUnaligned_v2 (arg1 : System.Address) return CUresult;  -- cuda.h:3586
+   pragma Import (C, cuMemcpy2DUnaligned_v2, "cuMemcpy2DUnaligned_v2");
+
+   function cuMemcpy3D_v2 (arg1 : System.Address) return CUresult;  -- cuda.h:3753
+   pragma Import (C, cuMemcpy3D_v2, "cuMemcpy3D_v2");
+
+   function cuMemcpy3DPeer (arg1 : System.Address) return CUresult;  -- cuda.h:3784
+   pragma Import (C, cuMemcpy3DPeer, "cuMemcpy3DPeer");
+
+   function cuMemcpyAsync
+     (arg1 : CUdeviceptr;
+      arg2 : CUdeviceptr;
+      arg3 : stddef_h.size_t;
+      arg4 : CUstream) return CUresult;  -- cuda.h:3824
+   pragma Import (C, cuMemcpyAsync, "cuMemcpyAsync");
+
+   function cuMemcpyPeerAsync
+     (arg1 : CUdeviceptr;
+      arg2 : CUcontext;
+      arg3 : CUdeviceptr;
+      arg4 : CUcontext;
+      arg5 : stddef_h.size_t;
+      arg6 : CUstream) return CUresult;  -- cuda.h:3855
+   pragma Import (C, cuMemcpyPeerAsync, "cuMemcpyPeerAsync");
+
+   function cuMemcpyHtoDAsync_v2
+     (arg1 : CUdeviceptr;
+      arg2 : System.Address;
+      arg3 : stddef_h.size_t;
+      arg4 : CUstream) return CUresult;  -- cuda.h:3897
+   pragma Import (C, cuMemcpyHtoDAsync_v2, "cuMemcpyHtoDAsync_v2");
+
+   function cuMemcpyDtoHAsync_v2
+     (arg1 : System.Address;
+      arg2 : CUdeviceptr;
+      arg3 : stddef_h.size_t;
+      arg4 : CUstream) return CUresult;  -- cuda.h:3937
+   pragma Import (C, cuMemcpyDtoHAsync_v2, "cuMemcpyDtoHAsync_v2");
+
+   function cuMemcpyDtoDAsync_v2
+     (arg1 : CUdeviceptr;
+      arg2 : CUdeviceptr;
+      arg3 : stddef_h.size_t;
+      arg4 : CUstream) return CUresult;  -- cuda.h:3974
+   pragma Import (C, cuMemcpyDtoDAsync_v2, "cuMemcpyDtoDAsync_v2");
+
+   function cuMemcpyHtoAAsync_v2
+     (arg1 : CUarray;
+      arg2 : stddef_h.size_t;
+      arg3 : System.Address;
+      arg4 : stddef_h.size_t;
+      arg5 : CUstream) return CUresult;  -- cuda.h:4016
+   pragma Import (C, cuMemcpyHtoAAsync_v2, "cuMemcpyHtoAAsync_v2");
+
+   function cuMemcpyAtoHAsync_v2
+     (arg1 : System.Address;
+      arg2 : CUarray;
+      arg3 : stddef_h.size_t;
+      arg4 : stddef_h.size_t;
+      arg5 : CUstream) return CUresult;  -- cuda.h:4058
+   pragma Import (C, cuMemcpyAtoHAsync_v2, "cuMemcpyAtoHAsync_v2");
+
+   function cuMemcpy2DAsync_v2 (arg1 : System.Address; arg2 : CUstream) return CUresult;  -- cuda.h:4229
+   pragma Import (C, cuMemcpy2DAsync_v2, "cuMemcpy2DAsync_v2");
+
+   function cuMemcpy3DAsync_v2 (arg1 : System.Address; arg2 : CUstream) return CUresult;  -- cuda.h:4404
+   pragma Import (C, cuMemcpy3DAsync_v2, "cuMemcpy3DAsync_v2");
+
+   function cuMemcpy3DPeerAsync (arg1 : System.Address; arg2 : CUstream) return CUresult;  -- cuda.h:4429
+   pragma Import (C, cuMemcpy3DPeerAsync, "cuMemcpy3DPeerAsync");
+
+   function cuMemsetD8_v2
+     (arg1 : CUdeviceptr;
+      arg2 : unsigned_char;
+      arg3 : stddef_h.size_t) return CUresult;  -- cuda.h:4464
+   pragma Import (C, cuMemsetD8_v2, "cuMemsetD8_v2");
+
+   function cuMemsetD16_v2
+     (arg1 : CUdeviceptr;
+      arg2 : unsigned_short;
+      arg3 : stddef_h.size_t) return CUresult;  -- cuda.h:4497
+   pragma Import (C, cuMemsetD16_v2, "cuMemsetD16_v2");
+
+   function cuMemsetD32_v2
+     (arg1 : CUdeviceptr;
+      arg2 : unsigned;
+      arg3 : stddef_h.size_t) return CUresult;  -- cuda.h:4530
+   pragma Import (C, cuMemsetD32_v2, "cuMemsetD32_v2");
+
+   function cuMemsetD2D8_v2
+     (arg1 : CUdeviceptr;
+      arg2 : stddef_h.size_t;
+      arg3 : unsigned_char;
+      arg4 : stddef_h.size_t;
+      arg5 : stddef_h.size_t) return CUresult;  -- cuda.h:4568
+   pragma Import (C, cuMemsetD2D8_v2, "cuMemsetD2D8_v2");
+
+   function cuMemsetD2D16_v2
+     (arg1 : CUdeviceptr;
+      arg2 : stddef_h.size_t;
+      arg3 : unsigned_short;
+      arg4 : stddef_h.size_t;
+      arg5 : stddef_h.size_t) return CUresult;  -- cuda.h:4606
+   pragma Import (C, cuMemsetD2D16_v2, "cuMemsetD2D16_v2");
+
+   function cuMemsetD2D32_v2
+     (arg1 : CUdeviceptr;
+      arg2 : stddef_h.size_t;
+      arg3 : unsigned;
+      arg4 : stddef_h.size_t;
+      arg5 : stddef_h.size_t) return CUresult;  -- cuda.h:4644
+   pragma Import (C, cuMemsetD2D32_v2, "cuMemsetD2D32_v2");
+
+   function cuMemsetD8Async
+     (arg1 : CUdeviceptr;
+      arg2 : unsigned_char;
+      arg3 : stddef_h.size_t;
+      arg4 : CUstream) return CUresult;  -- cuda.h:4681
+   pragma Import (C, cuMemsetD8Async, "cuMemsetD8Async");
+
+   function cuMemsetD16Async
+     (arg1 : CUdeviceptr;
+      arg2 : unsigned_short;
+      arg3 : stddef_h.size_t;
+      arg4 : CUstream) return CUresult;  -- cuda.h:4718
+   pragma Import (C, cuMemsetD16Async, "cuMemsetD16Async");
+
+   function cuMemsetD32Async
+     (arg1 : CUdeviceptr;
+      arg2 : unsigned;
+      arg3 : stddef_h.size_t;
+      arg4 : CUstream) return CUresult;  -- cuda.h:4754
+   pragma Import (C, cuMemsetD32Async, "cuMemsetD32Async");
+
+   function cuMemsetD2D8Async
+     (arg1 : CUdeviceptr;
+      arg2 : stddef_h.size_t;
+      arg3 : unsigned_char;
+      arg4 : stddef_h.size_t;
+      arg5 : stddef_h.size_t;
+      arg6 : CUstream) return CUresult;  -- cuda.h:4796
+   pragma Import (C, cuMemsetD2D8Async, "cuMemsetD2D8Async");
+
+   function cuMemsetD2D16Async
+     (arg1 : CUdeviceptr;
+      arg2 : stddef_h.size_t;
+      arg3 : unsigned_short;
+      arg4 : stddef_h.size_t;
+      arg5 : stddef_h.size_t;
+      arg6 : CUstream) return CUresult;  -- cuda.h:4838
+   pragma Import (C, cuMemsetD2D16Async, "cuMemsetD2D16Async");
+
+   function cuMemsetD2D32Async
+     (arg1 : CUdeviceptr;
+      arg2 : stddef_h.size_t;
+      arg3 : unsigned;
+      arg4 : stddef_h.size_t;
+      arg5 : stddef_h.size_t;
+      arg6 : CUstream) return CUresult;  -- cuda.h:4880
+   pragma Import (C, cuMemsetD2D32Async, "cuMemsetD2D32Async");
+
+   function cuArrayCreate_v2 (arg1 : System.Address; arg2 : System.Address) return CUresult;  -- cuda.h:4983
+   pragma Import (C, cuArrayCreate_v2, "cuArrayCreate_v2");
+
+   function cuArrayGetDescriptor_v2 (arg1 : access CUDA_ARRAY_DESCRIPTOR; arg2 : CUarray) return CUresult;  -- cuda.h:5016
+   pragma Import (C, cuArrayGetDescriptor_v2, "cuArrayGetDescriptor_v2");
+
+   function cuArrayDestroy (arg1 : CUarray) return CUresult;  -- cuda.h:5047
+   pragma Import (C, cuArrayDestroy, "cuArrayDestroy");
+
+   function cuArray3DCreate_v2 (arg1 : System.Address; arg2 : System.Address) return CUresult;  -- cuda.h:5155
+   pragma Import (C, cuArray3DCreate_v2, "cuArray3DCreate_v2");
+
+   function cuArray3DGetDescriptor_v2 (arg1 : access CUDA_ARRAY3D_DESCRIPTOR; arg2 : CUarray) return CUresult;  -- cuda.h:5191
+   pragma Import (C, cuArray3DGetDescriptor_v2, "cuArray3DGetDescriptor_v2");
+
+   function cuPointerGetAttribute
+     (arg1 : System.Address;
+      arg2 : CUpointer_attribute;
+      arg3 : CUdeviceptr) return CUresult;  -- cuda.h:5398
+   pragma Import (C, cuPointerGetAttribute, "cuPointerGetAttribute");
+
+   function cuStreamCreate (arg1 : System.Address; arg2 : unsigned) return CUresult;  -- cuda.h:5435
+   pragma Import (C, cuStreamCreate, "cuStreamCreate");
+
+   function cuStreamWaitEvent
+     (arg1 : CUstream;
+      arg2 : CUevent;
+      arg3 : unsigned) return CUresult;  -- cuda.h:5477
+   pragma Import (C, cuStreamWaitEvent, "cuStreamWaitEvent");
+
+   function cuStreamQuery (arg1 : CUstream) return CUresult;  -- cuda.h:5501
+   pragma Import (C, cuStreamQuery, "cuStreamQuery");
+
+   function cuStreamSynchronize (arg1 : CUstream) return CUresult;  -- cuda.h:5526
+   pragma Import (C, cuStreamSynchronize, "cuStreamSynchronize");
+
+   function cuStreamDestroy_v2 (arg1 : CUstream) return CUresult;  -- cuda.h:5554
+   pragma Import (C, cuStreamDestroy_v2, "cuStreamDestroy_v2");
+
+   function cuEventCreate (arg1 : System.Address; arg2 : unsigned) return CUresult;  -- cuda.h:5603
+   pragma Import (C, cuEventCreate, "cuEventCreate");
+
+   function cuEventRecord (arg1 : CUevent; arg2 : CUstream) return CUresult;  -- cuda.h:5641
+   pragma Import (C, cuEventRecord, "cuEventRecord");
+
+   function cuEventQuery (arg1 : CUevent) return CUresult;  -- cuda.h:5672
+   pragma Import (C, cuEventQuery, "cuEventQuery");
+
+   function cuEventSynchronize (arg1 : CUevent) return CUresult;  -- cuda.h:5706
+   pragma Import (C, cuEventSynchronize, "cuEventSynchronize");
+
+   function cuEventDestroy_v2 (arg1 : CUevent) return CUresult;  -- cuda.h:5735
+   pragma Import (C, cuEventDestroy_v2, "cuEventDestroy_v2");
+
+   function cuEventElapsedTime
+     (arg1 : access float;
+      arg2 : CUevent;
+      arg3 : CUevent) return CUresult;  -- cuda.h:5779
+   pragma Import (C, cuEventElapsedTime, "cuEventElapsedTime");
+
+   function cuFuncGetAttribute
+     (arg1 : access int;
+      arg2 : CUfunction_attribute;
+      arg3 : CUfunction) return CUresult;  -- cuda.h:5842
+   pragma Import (C, cuFuncGetAttribute, "cuFuncGetAttribute");
+
+   function cuFuncSetCacheConfig (arg1 : CUfunction; arg2 : CUfunc_cache) return CUresult;  -- cuda.h:5883
+   pragma Import (C, cuFuncSetCacheConfig, "cuFuncSetCacheConfig");
+
+   function cuLaunchKernel
+     (arg1 : CUfunction;
+      arg2 : unsigned;
+      arg3 : unsigned;
+      arg4 : unsigned;
+      arg5 : unsigned;
+      arg6 : unsigned;
+      arg7 : unsigned;
+      arg8 : unsigned;
+      arg9 : CUstream;
+      arg10 : System.Address;
+      arg11 : System.Address) return CUresult;  -- cuda.h:5999
+   pragma Import (C, cuLaunchKernel, "cuLaunchKernel");
+
+   function cuFuncSetBlockShape
+     (arg1 : CUfunction;
+      arg2 : int;
+      arg3 : int;
+      arg4 : int) return CUresult;  -- cuda.h:6055
+   pragma Import (C, cuFuncSetBlockShape, "cuFuncSetBlockShape");
+
+   function cuFuncSetSharedSize (arg1 : CUfunction; arg2 : unsigned) return CUresult;  -- cuda.h:6089
+   pragma Import (C, cuFuncSetSharedSize, "cuFuncSetSharedSize");
+
+   function cuParamSetSize (arg1 : CUfunction; arg2 : unsigned) return CUresult;  -- cuda.h:6121
+   pragma Import (C, cuParamSetSize, "cuParamSetSize");
+
+   function cuParamSeti
+     (arg1 : CUfunction;
+      arg2 : int;
+      arg3 : unsigned) return CUresult;  -- cuda.h:6154
+   pragma Import (C, cuParamSeti, "cuParamSeti");
+
+   function cuParamSetf
+     (arg1 : CUfunction;
+      arg2 : int;
+      arg3 : float) return CUresult;  -- cuda.h:6187
+   pragma Import (C, cuParamSetf, "cuParamSetf");
+
+   function cuParamSetv
+     (arg1 : CUfunction;
+      arg2 : int;
+      arg3 : System.Address;
+      arg4 : unsigned) return CUresult;  -- cuda.h:6222
+   pragma Import (C, cuParamSetv, "cuParamSetv");
+
+   function cuLaunch (arg1 : CUfunction) return CUresult;  -- cuda.h:6259
+   pragma Import (C, cuLaunch, "cuLaunch");
+
+   function cuLaunchGrid
+     (arg1 : CUfunction;
+      arg2 : int;
+      arg3 : int) return CUresult;  -- cuda.h:6298
+   pragma Import (C, cuLaunchGrid, "cuLaunchGrid");
+
+   function cuLaunchGridAsync
+     (arg1 : CUfunction;
+      arg2 : int;
+      arg3 : int;
+      arg4 : CUstream) return CUresult;  -- cuda.h:6342
+   pragma Import (C, cuLaunchGridAsync, "cuLaunchGridAsync");
+
+   function cuParamSetTexRef
+     (arg1 : CUfunction;
+      arg2 : int;
+      arg3 : CUtexref) return CUresult;  -- cuda.h:6367
+   pragma Import (C, cuParamSetTexRef, "cuParamSetTexRef");
+
+   function cuTexRefSetArray
+     (arg1 : CUtexref;
+      arg2 : CUarray;
+      arg3 : unsigned) return CUresult;  -- cuda.h:6408
+   pragma Import (C, cuTexRefSetArray, "cuTexRefSetArray");
+
+   function cuTexRefSetAddress_v2
+     (arg1 : access stddef_h.size_t;
+      arg2 : CUtexref;
+      arg3 : CUdeviceptr;
+      arg4 : stddef_h.size_t) return CUresult;  -- cuda.h:6446
+   pragma Import (C, cuTexRefSetAddress_v2, "cuTexRefSetAddress_v2");
+
+   function cuTexRefSetAddress2D_v2
+     (arg1 : CUtexref;
+      arg2 : System.Address;
+      arg3 : CUdeviceptr;
+      arg4 : stddef_h.size_t) return CUresult;  -- cuda.h:6487
+   pragma Import (C, cuTexRefSetAddress2D_v2, "cuTexRefSetAddress2D_v2");
+
+   function cuTexRefSetFormat
+     (arg1 : CUtexref;
+      arg2 : CUarray_format;
+      arg3 : int) return CUresult;  -- cuda.h:6516
+   pragma Import (C, cuTexRefSetFormat, "cuTexRefSetFormat");
+
+   function cuTexRefSetAddressMode
+     (arg1 : CUtexref;
+      arg2 : int;
+      arg3 : CUaddress_mode) return CUresult;  -- cuda.h:6556
+   pragma Import (C, cuTexRefSetAddressMode, "cuTexRefSetAddressMode");
+
+   function cuTexRefSetFilterMode (arg1 : CUtexref; arg2 : CUfilter_mode) return CUresult;  -- cuda.h:6589
+   pragma Import (C, cuTexRefSetFilterMode, "cuTexRefSetFilterMode");
+
+   function cuTexRefSetFlags (arg1 : CUtexref; arg2 : unsigned) return CUresult;  -- cuda.h:6621
+   pragma Import (C, cuTexRefSetFlags, "cuTexRefSetFlags");
+
+   function cuTexRefGetAddress_v2 (arg1 : access CUdeviceptr; arg2 : CUtexref) return CUresult;  -- cuda.h:6647
+   pragma Import (C, cuTexRefGetAddress_v2, "cuTexRefGetAddress_v2");
+
+   function cuTexRefGetArray (arg1 : System.Address; arg2 : CUtexref) return CUresult;  -- cuda.h:6673
+   pragma Import (C, cuTexRefGetArray, "cuTexRefGetArray");
+
+   function cuTexRefGetAddressMode
+     (arg1 : access CUaddress_mode;
+      arg2 : CUtexref;
+      arg3 : int) return CUresult;  -- cuda.h:6699
+   pragma Import (C, cuTexRefGetAddressMode, "cuTexRefGetAddressMode");
+
+   function cuTexRefGetFilterMode (arg1 : access CUfilter_mode; arg2 : CUtexref) return CUresult;  -- cuda.h:6723
+   pragma Import (C, cuTexRefGetFilterMode, "cuTexRefGetFilterMode");
+
+   function cuTexRefGetFormat
+     (arg1 : access CUarray_format;
+      arg2 : access int;
+      arg3 : CUtexref) return CUresult;  -- cuda.h:6749
+   pragma Import (C, cuTexRefGetFormat, "cuTexRefGetFormat");
+
+   function cuTexRefGetFlags (arg1 : access unsigned; arg2 : CUtexref) return CUresult;  -- cuda.h:6772
+   pragma Import (C, cuTexRefGetFlags, "cuTexRefGetFlags");
+
+   function cuTexRefCreate (arg1 : System.Address) return CUresult;  -- cuda.h:6806
+   pragma Import (C, cuTexRefCreate, "cuTexRefCreate");
+
+   function cuTexRefDestroy (arg1 : CUtexref) return CUresult;  -- cuda.h:6826
+   pragma Import (C, cuTexRefDestroy, "cuTexRefDestroy");
+
+   function cuSurfRefSetArray
+     (arg1 : CUsurfref;
+      arg2 : CUarray;
+      arg3 : unsigned) return CUresult;  -- cuda.h:6864
+   pragma Import (C, cuSurfRefSetArray, "cuSurfRefSetArray");
+
+   function cuSurfRefGetArray (arg1 : System.Address; arg2 : CUsurfref) return CUresult;  -- cuda.h:6885
+   pragma Import (C, cuSurfRefGetArray, "cuSurfRefGetArray");
+
+   function cuDeviceCanAccessPeer
+     (arg1 : access int;
+      arg2 : CUdevice;
+      arg3 : CUdevice) return CUresult;  -- cuda.h:6923
+   pragma Import (C, cuDeviceCanAccessPeer, "cuDeviceCanAccessPeer");
+
+   function cuCtxEnablePeerAccess (arg1 : CUcontext; arg2 : unsigned) return CUresult;  -- cuda.h:6966
+   pragma Import (C, cuCtxEnablePeerAccess, "cuCtxEnablePeerAccess");
+
+   function cuCtxDisablePeerAccess (arg1 : CUcontext) return CUresult;  -- cuda.h:6991
+   pragma Import (C, cuCtxDisablePeerAccess, "cuCtxDisablePeerAccess");
+
+   function cuGraphicsUnregisterResource (arg1 : CUgraphicsResource) return CUresult;  -- cuda.h:7032
+   pragma Import (C, cuGraphicsUnregisterResource, "cuGraphicsUnregisterResource");
+
+   function cuGraphicsSubResourceGetMappedArray
+     (arg1 : System.Address;
+      arg2 : CUgraphicsResource;
+      arg3 : unsigned;
+      arg4 : unsigned) return CUresult;  -- cuda.h:7070
+   pragma Import (C, cuGraphicsSubResourceGetMappedArray, "cuGraphicsSubResourceGetMappedArray");
+
+   function cuGraphicsResourceGetMappedPointer_v2
+     (arg1 : access CUdeviceptr;
+      arg2 : access stddef_h.size_t;
+      arg3 : CUgraphicsResource) return CUresult;  -- cuda.h:7104
+   pragma Import (C, cuGraphicsResourceGetMappedPointer_v2, "cuGraphicsResourceGetMappedPointer_v2");
+
+   function cuGraphicsResourceSetMapFlags (arg1 : CUgraphicsResource; arg2 : unsigned) return CUresult;  -- cuda.h:7145
+   pragma Import (C, cuGraphicsResourceSetMapFlags, "cuGraphicsResourceSetMapFlags");
+
+   function cuGraphicsMapResources
+     (arg1 : unsigned;
+      arg2 : System.Address;
+      arg3 : CUstream) return CUresult;  -- cuda.h:7183
+   pragma Import (C, cuGraphicsMapResources, "cuGraphicsMapResources");
+
+   function cuGraphicsUnmapResources
+     (arg1 : unsigned;
+      arg2 : System.Address;
+      arg3 : CUstream) return CUresult;  -- cuda.h:7218
+   pragma Import (C, cuGraphicsUnmapResources, "cuGraphicsUnmapResources");
+
+   function cuGetExportTable (arg1 : System.Address; arg2 : System.Address) return CUresult;  -- cuda.h:7222
+   pragma Import (C, cuGetExportTable, "cuGetExportTable");
+
+end cuda_h;
diff --git a/thin/cuda_runtime_api_h.ads b/thin/cuda_runtime_api_h.ads
new file mode 100644 (file)
index 0000000..bd3e2b3
--- /dev/null
@@ -0,0 +1,579 @@
+with Interfaces.C; use Interfaces.C;
+with driver_types_h;
+with stddef_h;
+with Interfaces.C.Strings;
+with System;
+with vector_types_h;
+
+package cuda_runtime_api_h is
+
+
+   CUDART_VERSION : constant := 4000;  --  cuda_runtime_api.h:82
+
+   function cudaDeviceReset return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:134
+   pragma Import (C, cudaDeviceReset, "cudaDeviceReset");
+
+   function cudaDeviceSynchronize return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:151
+   pragma Import (C, cudaDeviceSynchronize, "cudaDeviceSynchronize");
+
+   function cudaDeviceSetLimit (arg1 : driver_types_h.cudaLimit; arg2 : stddef_h.size_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:203
+   pragma Import (C, cudaDeviceSetLimit, "cudaDeviceSetLimit");
+
+   function cudaDeviceGetLimit (arg1 : access stddef_h.size_t; arg2 : driver_types_h.cudaLimit) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:227
+   pragma Import (C, cudaDeviceGetLimit, "cudaDeviceGetLimit");
+
+   function cudaDeviceGetCacheConfig (arg1 : access driver_types_h.cudaFuncCache) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:257
+   pragma Import (C, cudaDeviceGetCacheConfig, "cudaDeviceGetCacheConfig");
+
+   function cudaDeviceSetCacheConfig (arg1 : driver_types_h.cudaFuncCache) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:298
+   pragma Import (C, cudaDeviceSetCacheConfig, "cudaDeviceSetCacheConfig");
+
+   function cudaThreadExit return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:332
+   pragma Import (C, cudaThreadExit, "cudaThreadExit");
+
+   function cudaThreadSynchronize return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:356
+   pragma Import (C, cudaThreadSynchronize, "cudaThreadSynchronize");
+
+   function cudaThreadSetLimit (arg1 : driver_types_h.cudaLimit; arg2 : stddef_h.size_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:415
+   pragma Import (C, cudaThreadSetLimit, "cudaThreadSetLimit");
+
+   function cudaThreadGetLimit (arg1 : access stddef_h.size_t; arg2 : driver_types_h.cudaLimit) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:446
+   pragma Import (C, cudaThreadGetLimit, "cudaThreadGetLimit");
+
+   function cudaThreadGetCacheConfig (arg1 : access driver_types_h.cudaFuncCache) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:481
+   pragma Import (C, cudaThreadGetCacheConfig, "cudaThreadGetCacheConfig");
+
+   function cudaThreadSetCacheConfig (arg1 : driver_types_h.cudaFuncCache) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:527
+   pragma Import (C, cudaThreadSetCacheConfig, "cudaThreadSetCacheConfig");
+
+   function cudaGetLastError return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:581
+   pragma Import (C, cudaGetLastError, "cudaGetLastError");
+
+   function cudaPeekAtLastError return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:624
+   pragma Import (C, cudaPeekAtLastError, "cudaPeekAtLastError");
+
+   function cudaGetErrorString (arg1 : driver_types_h.cudaError_t) return Interfaces.C.Strings.chars_ptr;  -- cuda_runtime_api.h:638
+   pragma Import (C, cudaGetErrorString, "cudaGetErrorString");
+
+   function cudaGetDeviceCount (arg1 : access int) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:668
+   pragma Import (C, cudaGetDeviceCount, "cudaGetDeviceCount");
+
+   function cudaGetDeviceProperties (arg1 : access driver_types_h.cudaDeviceProp; arg2 : int) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:829
+   pragma Import (C, cudaGetDeviceProperties, "cudaGetDeviceProperties");
+
+   function cudaChooseDevice (arg1 : access int; arg2 : System.Address) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:848
+   pragma Import (C, cudaChooseDevice, "cudaChooseDevice");
+
+   function cudaSetDevice (arg1 : int) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:881
+   pragma Import (C, cudaSetDevice, "cudaSetDevice");
+
+   function cudaGetDevice (arg1 : access int) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:898
+   pragma Import (C, cudaGetDevice, "cudaGetDevice");
+
+   function cudaSetValidDevices (arg1 : access int; arg2 : int) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:927
+   pragma Import (C, cudaSetValidDevices, "cudaSetValidDevices");
+
+   function cudaSetDeviceFlags (arg1 : unsigned) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:987
+   pragma Import (C, cudaSetDeviceFlags, "cudaSetDeviceFlags");
+
+   function cudaStreamCreate (arg1 : System.Address) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1013
+   pragma Import (C, cudaStreamCreate, "cudaStreamCreate");
+
+   function cudaStreamDestroy (arg1 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1034
+   pragma Import (C, cudaStreamDestroy, "cudaStreamDestroy");
+
+   function cudaStreamWaitEvent
+     (arg1 : driver_types_h.cudaStream_t;
+      arg2 : driver_types_h.cudaEvent_t;
+      arg3 : unsigned) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1070
+   pragma Import (C, cudaStreamWaitEvent, "cudaStreamWaitEvent");
+
+   function cudaStreamSynchronize (arg1 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1089
+   pragma Import (C, cudaStreamSynchronize, "cudaStreamSynchronize");
+
+   function cudaStreamQuery (arg1 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1107
+   pragma Import (C, cudaStreamQuery, "cudaStreamQuery");
+
+   function cudaEventCreate (arg1 : System.Address) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1139
+   pragma Import (C, cudaEventCreate, "cudaEventCreate");
+
+   function cudaEventCreateWithFlags (arg1 : System.Address; arg2 : unsigned) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1170
+   pragma Import (C, cudaEventCreateWithFlags, "cudaEventCreateWithFlags");
+
+   function cudaEventRecord (arg1 : driver_types_h.cudaEvent_t; arg2 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1203
+   pragma Import (C, cudaEventRecord, "cudaEventRecord");
+
+   function cudaEventQuery (arg1 : driver_types_h.cudaEvent_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1232
+   pragma Import (C, cudaEventQuery, "cudaEventQuery");
+
+   function cudaEventSynchronize (arg1 : driver_types_h.cudaEvent_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1264
+   pragma Import (C, cudaEventSynchronize, "cudaEventSynchronize");
+
+   function cudaEventDestroy (arg1 : driver_types_h.cudaEvent_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1289
+   pragma Import (C, cudaEventDestroy, "cudaEventDestroy");
+
+   function cudaEventElapsedTime
+     (arg1 : access float;
+      arg2 : driver_types_h.cudaEvent_t;
+      arg3 : driver_types_h.cudaEvent_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1330
+   pragma Import (C, cudaEventElapsedTime, "cudaEventElapsedTime");
+
+   function cudaConfigureCall
+     (arg1 : vector_types_h.dim3;
+      arg2 : vector_types_h.dim3;
+      arg3 : stddef_h.size_t;
+      arg4 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1369
+   pragma Import (C, cudaConfigureCall, "cudaConfigureCall");
+
+   function cudaSetupArgument
+     (arg1 : System.Address;
+      arg2 : stddef_h.size_t;
+      arg3 : stddef_h.size_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1396
+   pragma Import (C, cudaSetupArgument, "cudaSetupArgument");
+
+   function cudaFuncSetCacheConfig (arg1 : Interfaces.C.Strings.chars_ptr; arg2 : driver_types_h.cudaFuncCache) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1442
+   pragma Import (C, cudaFuncSetCacheConfig, "cudaFuncSetCacheConfig");
+
+   function cudaLaunch (arg1 : Interfaces.C.Strings.chars_ptr) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1477
+   pragma Import (C, cudaLaunch, "cudaLaunch");
+
+   function cudaFuncGetAttributes (arg1 : access driver_types_h.cudaFuncAttributes; arg2 : Interfaces.C.Strings.chars_ptr) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1510
+   pragma Import (C, cudaFuncGetAttributes, "cudaFuncGetAttributes");
+
+   function cudaSetDoubleForDevice (arg1 : access double) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1532
+   pragma Import (C, cudaSetDoubleForDevice, "cudaSetDoubleForDevice");
+
+   function cudaSetDoubleForHost (arg1 : access double) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1554
+   pragma Import (C, cudaSetDoubleForHost, "cudaSetDoubleForHost");
+
+   function cudaMalloc (arg1 : System.Address; arg2 : stddef_h.size_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1586
+   pragma Import (C, cudaMalloc, "cudaMalloc");
+
+   function cudaMallocHost (arg1 : System.Address; arg2 : stddef_h.size_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1615
+   pragma Import (C, cudaMallocHost, "cudaMallocHost");
+
+   function cudaMallocPitch
+     (arg1 : System.Address;
+      arg2 : access stddef_h.size_t;
+      arg3 : stddef_h.size_t;
+      arg4 : stddef_h.size_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1654
+   pragma Import (C, cudaMallocPitch, "cudaMallocPitch");
+
+   function cudaMallocArray
+     (arg1 : System.Address;
+      arg2 : System.Address;
+      arg3 : stddef_h.size_t;
+      arg4 : stddef_h.size_t;
+      arg5 : unsigned) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1693
+   pragma Import (C, cudaMallocArray, "cudaMallocArray");
+
+   function cudaFree (arg1 : System.Address) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1717
+   pragma Import (C, cudaFree, "cudaFree");
+
+   function cudaFreeHost (arg1 : System.Address) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1737
+   pragma Import (C, cudaFreeHost, "cudaFreeHost");
+
+   function cudaFreeArray (arg1 : System.Address) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1759
+   pragma Import (C, cudaFreeArray, "cudaFreeArray");
+
+   function cudaHostAlloc
+     (arg1 : System.Address;
+      arg2 : stddef_h.size_t;
+      arg3 : unsigned) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1818
+   pragma Import (C, cudaHostAlloc, "cudaHostAlloc");
+
+   function cudaHostRegister
+     (arg1 : System.Address;
+      arg2 : stddef_h.size_t;
+      arg3 : unsigned) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1874
+   pragma Import (C, cudaHostRegister, "cudaHostRegister");
+
+   function cudaHostUnregister (arg1 : System.Address) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1893
+   pragma Import (C, cudaHostUnregister, "cudaHostUnregister");
+
+   function cudaHostGetDevicePointer
+     (arg1 : System.Address;
+      arg2 : System.Address;
+      arg3 : unsigned) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1920
+   pragma Import (C, cudaHostGetDevicePointer, "cudaHostGetDevicePointer");
+
+   function cudaHostGetFlags (arg1 : access unsigned; arg2 : System.Address) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1939
+   pragma Import (C, cudaHostGetFlags, "cudaHostGetFlags");
+
+   function cudaMalloc3D (arg1 : access driver_types_h.cudaPitchedPtr; arg2 : driver_types_h.cudaExtent) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:1974
+   pragma Import (C, cudaMalloc3D, "cudaMalloc3D");
+
+   function cudaMalloc3DArray
+     (arg1 : System.Address;
+      arg2 : System.Address;
+      arg3 : driver_types_h.cudaExtent;
+      arg4 : unsigned) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2035
+   pragma Import (C, cudaMalloc3DArray, "cudaMalloc3DArray");
+
+   function cudaMemcpy3D (arg1 : System.Address) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2132
+   pragma Import (C, cudaMemcpy3D, "cudaMemcpy3D");
+
+   function cudaMemcpy3DPeer (arg1 : System.Address) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2159
+   pragma Import (C, cudaMemcpy3DPeer, "cudaMemcpy3DPeer");
+
+   function cudaMemcpy3DAsync (arg1 : System.Address; arg2 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2264
+   pragma Import (C, cudaMemcpy3DAsync, "cudaMemcpy3DAsync");
+
+   function cudaMemcpy3DPeerAsync (arg1 : System.Address; arg2 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2285
+   pragma Import (C, cudaMemcpy3DPeerAsync, "cudaMemcpy3DPeerAsync");
+
+   function cudaMemGetInfo (arg1 : access stddef_h.size_t; arg2 : access stddef_h.size_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2304
+   pragma Import (C, cudaMemGetInfo, "cudaMemGetInfo");
+
+   function cudaMemcpy
+     (arg1 : System.Address;
+      arg2 : System.Address;
+      arg3 : stddef_h.size_t;
+      arg4 : driver_types_h.cudaMemcpyKind) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2337
+   pragma Import (C, cudaMemcpy, "cudaMemcpy");
+
+   function cudaMemcpyPeer
+     (arg1 : System.Address;
+      arg2 : int;
+      arg3 : System.Address;
+      arg4 : int;
+      arg5 : stddef_h.size_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2368
+   pragma Import (C, cudaMemcpyPeer, "cudaMemcpyPeer");
+
+   function cudaMemcpyToArray
+     (arg1 : System.Address;
+      arg2 : stddef_h.size_t;
+      arg3 : stddef_h.size_t;
+      arg4 : System.Address;
+      arg5 : stddef_h.size_t;
+      arg6 : driver_types_h.cudaMemcpyKind) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2401
+   pragma Import (C, cudaMemcpyToArray, "cudaMemcpyToArray");
+
+   function cudaMemcpyFromArray
+     (arg1 : System.Address;
+      arg2 : System.Address;
+      arg3 : stddef_h.size_t;
+      arg4 : stddef_h.size_t;
+      arg5 : stddef_h.size_t;
+      arg6 : driver_types_h.cudaMemcpyKind) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2434
+   pragma Import (C, cudaMemcpyFromArray, "cudaMemcpyFromArray");
+
+   function cudaMemcpyArrayToArray
+     (arg1 : System.Address;
+      arg2 : stddef_h.size_t;
+      arg3 : stddef_h.size_t;
+      arg4 : System.Address;
+      arg5 : stddef_h.size_t;
+      arg6 : stddef_h.size_t;
+      arg7 : stddef_h.size_t;
+      arg8 : driver_types_h.cudaMemcpyKind) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2469
+   pragma Import (C, cudaMemcpyArrayToArray, "cudaMemcpyArrayToArray");
+
+   function cudaMemcpy2D
+     (arg1 : System.Address;
+      arg2 : stddef_h.size_t;
+      arg3 : System.Address;
+      arg4 : stddef_h.size_t;
+      arg5 : stddef_h.size_t;
+      arg6 : stddef_h.size_t;
+      arg7 : driver_types_h.cudaMemcpyKind) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2511
+   pragma Import (C, cudaMemcpy2D, "cudaMemcpy2D");
+
+   function cudaMemcpy2DToArray
+     (arg1 : System.Address;
+      arg2 : stddef_h.size_t;
+      arg3 : stddef_h.size_t;
+      arg4 : System.Address;
+      arg5 : stddef_h.size_t;
+      arg6 : stddef_h.size_t;
+      arg7 : stddef_h.size_t;
+      arg8 : driver_types_h.cudaMemcpyKind) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2552
+   pragma Import (C, cudaMemcpy2DToArray, "cudaMemcpy2DToArray");
+
+   function cudaMemcpy2DFromArray
+     (arg1 : System.Address;
+      arg2 : stddef_h.size_t;
+      arg3 : System.Address;
+      arg4 : stddef_h.size_t;
+      arg5 : stddef_h.size_t;
+      arg6 : stddef_h.size_t;
+      arg7 : stddef_h.size_t;
+      arg8 : driver_types_h.cudaMemcpyKind) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2593
+   pragma Import (C, cudaMemcpy2DFromArray, "cudaMemcpy2DFromArray");
+
+   function cudaMemcpy2DArrayToArray
+     (arg1 : System.Address;
+      arg2 : stddef_h.size_t;
+      arg3 : stddef_h.size_t;
+      arg4 : System.Address;
+      arg5 : stddef_h.size_t;
+      arg6 : stddef_h.size_t;
+      arg7 : stddef_h.size_t;
+      arg8 : stddef_h.size_t;
+      arg9 : driver_types_h.cudaMemcpyKind) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2632
+   pragma Import (C, cudaMemcpy2DArrayToArray, "cudaMemcpy2DArrayToArray");
+
+   function cudaMemcpyToSymbol
+     (arg1 : Interfaces.C.Strings.chars_ptr;
+      arg2 : System.Address;
+      arg3 : stddef_h.size_t;
+      arg4 : stddef_h.size_t;
+      arg5 : driver_types_h.cudaMemcpyKind) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2667
+   pragma Import (C, cudaMemcpyToSymbol, "cudaMemcpyToSymbol");
+
+   function cudaMemcpyFromSymbol
+     (arg1 : System.Address;
+      arg2 : Interfaces.C.Strings.chars_ptr;
+      arg3 : stddef_h.size_t;
+      arg4 : stddef_h.size_t;
+      arg5 : driver_types_h.cudaMemcpyKind) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2701
+   pragma Import (C, cudaMemcpyFromSymbol, "cudaMemcpyFromSymbol");
+
+   function cudaMemcpyAsync
+     (arg1 : System.Address;
+      arg2 : System.Address;
+      arg3 : stddef_h.size_t;
+      arg4 : driver_types_h.cudaMemcpyKind;
+      arg5 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2744
+   pragma Import (C, cudaMemcpyAsync, "cudaMemcpyAsync");
+
+   function cudaMemcpyPeerAsync
+     (arg1 : System.Address;
+      arg2 : int;
+      arg3 : System.Address;
+      arg4 : int;
+      arg5 : stddef_h.size_t;
+      arg6 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2774
+   pragma Import (C, cudaMemcpyPeerAsync, "cudaMemcpyPeerAsync");
+
+   function cudaMemcpyToArrayAsync
+     (arg1 : System.Address;
+      arg2 : stddef_h.size_t;
+      arg3 : stddef_h.size_t;
+      arg4 : System.Address;
+      arg5 : stddef_h.size_t;
+      arg6 : driver_types_h.cudaMemcpyKind;
+      arg7 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2816
+   pragma Import (C, cudaMemcpyToArrayAsync, "cudaMemcpyToArrayAsync");
+
+   function cudaMemcpyFromArrayAsync
+     (arg1 : System.Address;
+      arg2 : System.Address;
+      arg3 : stddef_h.size_t;
+      arg4 : stddef_h.size_t;
+      arg5 : stddef_h.size_t;
+      arg6 : driver_types_h.cudaMemcpyKind;
+      arg7 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2858
+   pragma Import (C, cudaMemcpyFromArrayAsync, "cudaMemcpyFromArrayAsync");
+
+   function cudaMemcpy2DAsync
+     (arg1 : System.Address;
+      arg2 : stddef_h.size_t;
+      arg3 : System.Address;
+      arg4 : stddef_h.size_t;
+      arg5 : stddef_h.size_t;
+      arg6 : stddef_h.size_t;
+      arg7 : driver_types_h.cudaMemcpyKind;
+      arg8 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2909
+   pragma Import (C, cudaMemcpy2DAsync, "cudaMemcpy2DAsync");
+
+   function cudaMemcpy2DToArrayAsync
+     (arg1 : System.Address;
+      arg2 : stddef_h.size_t;
+      arg3 : stddef_h.size_t;
+      arg4 : System.Address;
+      arg5 : stddef_h.size_t;
+      arg6 : stddef_h.size_t;
+      arg7 : stddef_h.size_t;
+      arg8 : driver_types_h.cudaMemcpyKind;
+      arg9 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:2959
+   pragma Import (C, cudaMemcpy2DToArrayAsync, "cudaMemcpy2DToArrayAsync");
+
+   function cudaMemcpy2DFromArrayAsync
+     (arg1 : System.Address;
+      arg2 : stddef_h.size_t;
+      arg3 : System.Address;
+      arg4 : stddef_h.size_t;
+      arg5 : stddef_h.size_t;
+      arg6 : stddef_h.size_t;
+      arg7 : stddef_h.size_t;
+      arg8 : driver_types_h.cudaMemcpyKind;
+      arg9 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3009
+   pragma Import (C, cudaMemcpy2DFromArrayAsync, "cudaMemcpy2DFromArrayAsync");
+
+   function cudaMemcpyToSymbolAsync
+     (arg1 : Interfaces.C.Strings.chars_ptr;
+      arg2 : System.Address;
+      arg3 : stddef_h.size_t;
+      arg4 : stddef_h.size_t;
+      arg5 : driver_types_h.cudaMemcpyKind;
+      arg6 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3053
+   pragma Import (C, cudaMemcpyToSymbolAsync, "cudaMemcpyToSymbolAsync");
+
+   function cudaMemcpyFromSymbolAsync
+     (arg1 : System.Address;
+      arg2 : Interfaces.C.Strings.chars_ptr;
+      arg3 : stddef_h.size_t;
+      arg4 : stddef_h.size_t;
+      arg5 : driver_types_h.cudaMemcpyKind;
+      arg6 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3096
+   pragma Import (C, cudaMemcpyFromSymbolAsync, "cudaMemcpyFromSymbolAsync");
+
+   function cudaMemset
+     (arg1 : System.Address;
+      arg2 : int;
+      arg3 : stddef_h.size_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3118
+   pragma Import (C, cudaMemset, "cudaMemset");
+
+   function cudaMemset2D
+     (arg1 : System.Address;
+      arg2 : stddef_h.size_t;
+      arg3 : int;
+      arg4 : stddef_h.size_t;
+      arg5 : stddef_h.size_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3144
+   pragma Import (C, cudaMemset2D, "cudaMemset2D");
+
+   function cudaMemset3D
+     (arg1 : driver_types_h.cudaPitchedPtr;
+      arg2 : int;
+      arg3 : driver_types_h.cudaExtent) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3183
+   pragma Import (C, cudaMemset3D, "cudaMemset3D");
+
+   function cudaMemsetAsync
+     (arg1 : System.Address;
+      arg2 : int;
+      arg3 : stddef_h.size_t;
+      arg4 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3210
+   pragma Import (C, cudaMemsetAsync, "cudaMemsetAsync");
+
+   function cudaMemset2DAsync
+     (arg1 : System.Address;
+      arg2 : stddef_h.size_t;
+      arg3 : int;
+      arg4 : stddef_h.size_t;
+      arg5 : stddef_h.size_t;
+      arg6 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3242
+   pragma Import (C, cudaMemset2DAsync, "cudaMemset2DAsync");
+
+   function cudaMemset3DAsync
+     (arg1 : driver_types_h.cudaPitchedPtr;
+      arg2 : int;
+      arg3 : driver_types_h.cudaExtent;
+      arg4 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3287
+   pragma Import (C, cudaMemset3DAsync, "cudaMemset3DAsync");
+
+   function cudaGetSymbolAddress (arg1 : System.Address; arg2 : Interfaces.C.Strings.chars_ptr) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3314
+   pragma Import (C, cudaGetSymbolAddress, "cudaGetSymbolAddress");
+
+   function cudaGetSymbolSize (arg1 : access stddef_h.size_t; arg2 : Interfaces.C.Strings.chars_ptr) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3337
+   pragma Import (C, cudaGetSymbolSize, "cudaGetSymbolSize");
+
+   function cudaPointerGetAttributes (arg1 : access driver_types_h.cudaPointerAttributes; arg2 : System.Address) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3482
+   pragma Import (C, cudaPointerGetAttributes, "cudaPointerGetAttributes");
+
+   function cudaDeviceCanAccessPeer
+     (arg1 : access int;
+      arg2 : int;
+      arg3 : int) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3516
+   pragma Import (C, cudaDeviceCanAccessPeer, "cudaDeviceCanAccessPeer");
+
+   function cudaDeviceEnablePeerAccess (arg1 : int; arg2 : unsigned) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3557
+   pragma Import (C, cudaDeviceEnablePeerAccess, "cudaDeviceEnablePeerAccess");
+
+   function cudaDeviceDisablePeerAccess (arg1 : int) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3582
+   pragma Import (C, cudaDeviceDisablePeerAccess, "cudaDeviceDisablePeerAccess");
+
+   function cudaGraphicsUnregisterResource (arg1 : driver_types_h.cudaGraphicsResource_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3628
+   pragma Import (C, cudaGraphicsUnregisterResource, "cudaGraphicsUnregisterResource");
+
+   function cudaGraphicsResourceSetMapFlags (arg1 : driver_types_h.cudaGraphicsResource_t; arg2 : unsigned) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3660
+   pragma Import (C, cudaGraphicsResourceSetMapFlags, "cudaGraphicsResourceSetMapFlags");
+
+   function cudaGraphicsMapResources
+     (arg1 : int;
+      arg2 : System.Address;
+      arg3 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3695
+   pragma Import (C, cudaGraphicsMapResources, "cudaGraphicsMapResources");
+
+   function cudaGraphicsUnmapResources
+     (arg1 : int;
+      arg2 : System.Address;
+      arg3 : driver_types_h.cudaStream_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3726
+   pragma Import (C, cudaGraphicsUnmapResources, "cudaGraphicsUnmapResources");
+
+   function cudaGraphicsResourceGetMappedPointer
+     (arg1 : System.Address;
+      arg2 : access stddef_h.size_t;
+      arg3 : driver_types_h.cudaGraphicsResource_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3755
+   pragma Import (C, cudaGraphicsResourceGetMappedPointer, "cudaGraphicsResourceGetMappedPointer");
+
+   function cudaGraphicsSubResourceGetMappedArray
+     (arg1 : System.Address;
+      arg2 : driver_types_h.cudaGraphicsResource_t;
+      arg3 : unsigned;
+      arg4 : unsigned) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3789
+   pragma Import (C, cudaGraphicsSubResourceGetMappedArray, "cudaGraphicsSubResourceGetMappedArray");
+
+   function cudaGetChannelDesc (arg1 : access driver_types_h.cudaChannelFormatDesc; arg2 : System.Address) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3822
+   pragma Import (C, cudaGetChannelDesc, "cudaGetChannelDesc");
+
+   function cudaCreateChannelDesc
+     (arg1 : int;
+      arg2 : int;
+      arg3 : int;
+      arg4 : int;
+      arg5 : driver_types_h.cudaChannelFormatKind) return driver_types_h.cudaChannelFormatDesc;  -- cuda_runtime_api.h:3857
+   pragma Import (C, cudaCreateChannelDesc, "cudaCreateChannelDesc");
+
+   function cudaBindTexture
+     (arg1 : access stddef_h.size_t;
+      arg2 : System.Address;
+      arg3 : System.Address;
+      arg4 : System.Address;
+      arg5 : stddef_h.size_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3899
+   pragma Import (C, cudaBindTexture, "cudaBindTexture");
+
+   function cudaBindTexture2D
+     (arg1 : access stddef_h.size_t;
+      arg2 : System.Address;
+      arg3 : System.Address;
+      arg4 : System.Address;
+      arg5 : stddef_h.size_t;
+      arg6 : stddef_h.size_t;
+      arg7 : stddef_h.size_t) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3942
+   pragma Import (C, cudaBindTexture2D, "cudaBindTexture2D");
+
+   function cudaBindTextureToArray
+     (arg1 : System.Address;
+      arg2 : System.Address;
+      arg3 : System.Address) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3970
+   pragma Import (C, cudaBindTextureToArray, "cudaBindTextureToArray");
+
+   function cudaUnbindTexture (arg1 : System.Address) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:3991
+   pragma Import (C, cudaUnbindTexture, "cudaUnbindTexture");
+
+   function cudaGetTextureAlignmentOffset (arg1 : access stddef_h.size_t; arg2 : System.Address) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:4016
+   pragma Import (C, cudaGetTextureAlignmentOffset, "cudaGetTextureAlignmentOffset");
+
+   function cudaGetTextureReference (arg1 : System.Address; arg2 : Interfaces.C.Strings.chars_ptr) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:4040
+   pragma Import (C, cudaGetTextureReference, "cudaGetTextureReference");
+
+   function cudaBindSurfaceToArray
+     (arg1 : System.Address;
+      arg2 : System.Address;
+      arg3 : System.Address) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:4073
+   pragma Import (C, cudaBindSurfaceToArray, "cudaBindSurfaceToArray");
+
+   function cudaGetSurfaceReference (arg1 : System.Address; arg2 : Interfaces.C.Strings.chars_ptr) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:4091
+   pragma Import (C, cudaGetSurfaceReference, "cudaGetSurfaceReference");
+
+   function cudaDriverGetVersion (arg1 : access int) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:4118
+   pragma Import (C, cudaDriverGetVersion, "cudaDriverGetVersion");
+
+   function cudaRuntimeGetVersion (arg1 : access int) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:4135
+   pragma Import (C, cudaRuntimeGetVersion, "cudaRuntimeGetVersion");
+
+   function cudaGetExportTable (arg1 : System.Address; arg2 : System.Address) return driver_types_h.cudaError_t;  -- cuda_runtime_api.h:4140
+   pragma Import (C, cudaGetExportTable, "cudaGetExportTable");
+
+end cuda_runtime_api_h;
diff --git a/thin/device_types_h.ads b/thin/device_types_h.ads
new file mode 100644 (file)
index 0000000..d24224f
--- /dev/null
@@ -0,0 +1,12 @@
+with Interfaces.C; use Interfaces.C;
+
+package device_types_h is
+
+   type cudaRoundMode is 
+     (cudaRoundNearest,
+      cudaRoundZero,
+      cudaRoundPosInf,
+      cudaRoundMinInf);
+   pragma Convention (C, cudaRoundMode);  -- device_types.h:60
+
+end device_types_h;
diff --git a/thin/driver_functions_h.ads b/thin/driver_functions_h.ads
new file mode 100644 (file)
index 0000000..4877598
--- /dev/null
@@ -0,0 +1,27 @@
+with Interfaces.C; use Interfaces.C;
+with System;
+with stddef_h;
+with driver_types_h;
+
+package driver_functions_h is
+
+   function make_cudaPitchedPtr
+     (d : System.Address;
+      p : stddef_h.size_t;
+      xsz : stddef_h.size_t;
+      ysz : stddef_h.size_t) return driver_types_h.cudaPitchedPtr;  -- driver_functions.h:79
+   pragma Import (C, make_cudaPitchedPtr, "make_cudaPitchedPtr");
+
+   function make_cudaPos
+     (x : stddef_h.size_t;
+      y : stddef_h.size_t;
+      z : stddef_h.size_t) return driver_types_h.cudaPos;  -- driver_functions.h:106
+   pragma Import (C, make_cudaPos, "make_cudaPos");
+
+   function make_cudaExtent
+     (w : stddef_h.size_t;
+      h : stddef_h.size_t;
+      d : stddef_h.size_t) return driver_types_h.cudaExtent;  -- driver_functions.h:132
+   pragma Import (C, make_cudaExtent, "make_cudaExtent");
+
+end driver_functions_h;
diff --git a/thin/driver_types_h.ads b/thin/driver_types_h.ads
new file mode 100644 (file)
index 0000000..dd86095
--- /dev/null
@@ -0,0 +1,304 @@
+with Interfaces.C; use Interfaces.C;
+with System;
+with stddef_h;
+
+package driver_types_h is
+
+
+   cudaHostAllocDefault : constant := 16#00#;  --  driver_types.h:77
+   cudaHostAllocPortable : constant := 16#01#;  --  driver_types.h:78
+   cudaHostAllocMapped : constant := 16#02#;  --  driver_types.h:79
+   cudaHostAllocWriteCombined : constant := 16#04#;  --  driver_types.h:80
+
+   cudaHostRegisterDefault : constant := 16#00#;  --  driver_types.h:82
+   cudaHostRegisterPortable : constant := 16#01#;  --  driver_types.h:83
+   cudaHostRegisterMapped : constant := 16#02#;  --  driver_types.h:84
+
+   cudaPeerAccessDefault : constant := 16#00#;  --  driver_types.h:86
+
+   cudaEventDefault : constant := 16#00#;  --  driver_types.h:88
+   cudaEventBlockingSync : constant := 16#01#;  --  driver_types.h:89
+   cudaEventDisableTiming : constant := 16#02#;  --  driver_types.h:90
+
+   cudaDeviceScheduleAuto : constant := 16#00#;  --  driver_types.h:92
+   cudaDeviceScheduleSpin : constant := 16#01#;  --  driver_types.h:93
+   cudaDeviceScheduleYield : constant := 16#02#;  --  driver_types.h:94
+   cudaDeviceScheduleBlockingSync : constant := 16#04#;  --  driver_types.h:95
+   cudaDeviceBlockingSync : constant := 16#04#;  --  driver_types.h:96
+   cudaDeviceMapHost : constant := 16#08#;  --  driver_types.h:97
+   cudaDeviceLmemResizeToMax : constant := 16#10#;  --  driver_types.h:98
+   cudaDeviceMask : constant := 16#1f#;  --  driver_types.h:99
+
+   cudaArrayDefault : constant := 16#00#;  --  driver_types.h:101
+   cudaArrayLayered : constant := 16#01#;  --  driver_types.h:102
+   cudaArraySurfaceLoadStore : constant := 16#02#;  --  driver_types.h:103
+   --  unsupported macro: cudaDevicePropDontCare { {'\0'}, 0, 0, 0, 0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0, -1, -1, 0, -1, 0, 0, 0, 0, 0, 0, {0, 0}, {0, 0, 0}, {0, 0}, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
+
+   subtype cudaError is unsigned;
+   cudaSuccess : constant cudaError := 0;
+   cudaErrorMissingConfiguration : constant cudaError := 1;
+   cudaErrorMemoryAllocation : constant cudaError := 2;
+   cudaErrorInitializationError : constant cudaError := 3;
+   cudaErrorLaunchFailure : constant cudaError := 4;
+   cudaErrorPriorLaunchFailure : constant cudaError := 5;
+   cudaErrorLaunchTimeout : constant cudaError := 6;
+   cudaErrorLaunchOutOfResources : constant cudaError := 7;
+   cudaErrorInvalidDeviceFunction : constant cudaError := 8;
+   cudaErrorInvalidConfiguration : constant cudaError := 9;
+   cudaErrorInvalidDevice : constant cudaError := 10;
+   cudaErrorInvalidValue : constant cudaError := 11;
+   cudaErrorInvalidPitchValue : constant cudaError := 12;
+   cudaErrorInvalidSymbol : constant cudaError := 13;
+   cudaErrorMapBufferObjectFailed : constant cudaError := 14;
+   cudaErrorUnmapBufferObjectFailed : constant cudaError := 15;
+   cudaErrorInvalidHostPointer : constant cudaError := 16;
+   cudaErrorInvalidDevicePointer : constant cudaError := 17;
+   cudaErrorInvalidTexture : constant cudaError := 18;
+   cudaErrorInvalidTextureBinding : constant cudaError := 19;
+   cudaErrorInvalidChannelDescriptor : constant cudaError := 20;
+   cudaErrorInvalidMemcpyDirection : constant cudaError := 21;
+   cudaErrorAddressOfConstant : constant cudaError := 22;
+   cudaErrorTextureFetchFailed : constant cudaError := 23;
+   cudaErrorTextureNotBound : constant cudaError := 24;
+   cudaErrorSynchronizationError : constant cudaError := 25;
+   cudaErrorInvalidFilterSetting : constant cudaError := 26;
+   cudaErrorInvalidNormSetting : constant cudaError := 27;
+   cudaErrorMixedDeviceExecution : constant cudaError := 28;
+   cudaErrorCudartUnloading : constant cudaError := 29;
+   cudaErrorUnknown : constant cudaError := 30;
+   cudaErrorNotYetImplemented : constant cudaError := 31;
+   cudaErrorMemoryValueTooLarge : constant cudaError := 32;
+   cudaErrorInvalidResourceHandle : constant cudaError := 33;
+   cudaErrorNotReady : constant cudaError := 34;
+   cudaErrorInsufficientDriver : constant cudaError := 35;
+   cudaErrorSetOnActiveProcess : constant cudaError := 36;
+   cudaErrorInvalidSurface : constant cudaError := 37;
+   cudaErrorNoDevice : constant cudaError := 38;
+   cudaErrorECCUncorrectable : constant cudaError := 39;
+   cudaErrorSharedObjectSymbolNotFound : constant cudaError := 40;
+   cudaErrorSharedObjectInitFailed : constant cudaError := 41;
+   cudaErrorUnsupportedLimit : constant cudaError := 42;
+   cudaErrorDuplicateVariableName : constant cudaError := 43;
+   cudaErrorDuplicateTextureName : constant cudaError := 44;
+   cudaErrorDuplicateSurfaceName : constant cudaError := 45;
+   cudaErrorDevicesUnavailable : constant cudaError := 46;
+   cudaErrorInvalidKernelImage : constant cudaError := 47;
+   cudaErrorNoKernelImageForDevice : constant cudaError := 48;
+   cudaErrorIncompatibleDriverContext : constant cudaError := 49;
+   cudaErrorPeerAccessAlreadyEnabled : constant cudaError := 50;
+   cudaErrorPeerAccessNotEnabled : constant cudaError := 51;
+   cudaErrorDeviceAlreadyInUse : constant cudaError := 54;
+   cudaErrorProfilerDisabled : constant cudaError := 55;
+   cudaErrorProfilerNotInitialized : constant cudaError := 56;
+   cudaErrorProfilerAlreadyStarted : constant cudaError := 57;
+   cudaErrorProfilerAlreadyStopped : constant cudaError := 58;
+   cudaErrorStartupFailure : constant cudaError := 127;
+   cudaErrorApiFailureBase : constant cudaError := 10000;  -- driver_types.h:118
+
+   type cudaChannelFormatKind is
+     (cudaChannelFormatKindSigned,
+      cudaChannelFormatKindUnsigned,
+      cudaChannelFormatKindFloat,
+      cudaChannelFormatKindNone);
+   pragma Convention (C, cudaChannelFormatKind);  -- driver_types.h:541
+
+   type cudaChannelFormatDesc is record
+      x : aliased int;  -- driver_types.h:555
+      y : aliased int;  -- driver_types.h:556
+      z : aliased int;  -- driver_types.h:557
+      w : aliased int;  -- driver_types.h:558
+      f : aliased cudaChannelFormatKind;  -- driver_types.h:559
+   end record;
+   pragma Convention (C_Pass_By_Copy, cudaChannelFormatDesc);  -- driver_types.h:553
+
+   --  skipped empty struct cudaArray
+
+   subtype cudaMemoryType is unsigned;
+   cudaMemoryTypeHost : constant cudaMemoryType := 1;
+   cudaMemoryTypeDevice : constant cudaMemoryType := 2;  -- driver_types.h:572
+
+   type cudaMemcpyKind is
+     (cudaMemcpyHostToHost,
+      cudaMemcpyHostToDevice,
+      cudaMemcpyDeviceToHost,
+      cudaMemcpyDeviceToDevice,
+      cudaMemcpyDefault);
+   pragma Convention (C, cudaMemcpyKind);  -- driver_types.h:582
+
+   type cudaPitchedPtr is record
+      ptr : System.Address;  -- driver_types.h:598
+      pitch : aliased stddef_h.size_t;  -- driver_types.h:599
+      xsize : aliased stddef_h.size_t;  -- driver_types.h:600
+      ysize : aliased stddef_h.size_t;  -- driver_types.h:601
+   end record;
+   pragma Convention (C_Pass_By_Copy, cudaPitchedPtr);  -- driver_types.h:596
+
+   type cudaExtent is record
+      width : aliased stddef_h.size_t;  -- driver_types.h:611
+      height : aliased stddef_h.size_t;  -- driver_types.h:612
+      depth : aliased stddef_h.size_t;  -- driver_types.h:613
+   end record;
+   pragma Convention (C_Pass_By_Copy, cudaExtent);  -- driver_types.h:609
+
+   type cudaPos is record
+      x : aliased stddef_h.size_t;  -- driver_types.h:623
+      y : aliased stddef_h.size_t;  -- driver_types.h:624
+      z : aliased stddef_h.size_t;  -- driver_types.h:625
+   end record;
+   pragma Convention (C_Pass_By_Copy, cudaPos);  -- driver_types.h:621
+
+   type cudaMemcpy3DParms is record
+      srcArray : System.Address;  -- driver_types.h:634
+      srcPos : aliased cudaPos;  -- driver_types.h:635
+      srcPtr : aliased cudaPitchedPtr;  -- driver_types.h:636
+      dstArray : System.Address;  -- driver_types.h:638
+      dstPos : aliased cudaPos;  -- driver_types.h:639
+      dstPtr : aliased cudaPitchedPtr;  -- driver_types.h:640
+      extent : aliased cudaExtent;  -- driver_types.h:642
+      kind : aliased cudaMemcpyKind;  -- driver_types.h:643
+   end record;
+   pragma Convention (C_Pass_By_Copy, cudaMemcpy3DParms);  -- driver_types.h:632
+
+   type cudaMemcpy3DPeerParms is record
+      srcArray : System.Address;  -- driver_types.h:652
+      srcPos : aliased cudaPos;  -- driver_types.h:653
+      srcPtr : aliased cudaPitchedPtr;  -- driver_types.h:654
+      srcDevice : aliased int;  -- driver_types.h:655
+      dstArray : System.Address;  -- driver_types.h:657
+      dstPos : aliased cudaPos;  -- driver_types.h:658
+      dstPtr : aliased cudaPitchedPtr;  -- driver_types.h:659
+      dstDevice : aliased int;  -- driver_types.h:660
+      extent : aliased cudaExtent;  -- driver_types.h:662
+   end record;
+   pragma Convention (C_Pass_By_Copy, cudaMemcpy3DPeerParms);  -- driver_types.h:650
+
+   --  skipped empty struct cudaGraphicsResource
+
+   subtype cudaGraphicsRegisterFlags is unsigned;
+   cudaGraphicsRegisterFlagsNone : constant cudaGraphicsRegisterFlags := 0;
+   cudaGraphicsRegisterFlagsReadOnly : constant cudaGraphicsRegisterFlags := 1;
+   cudaGraphicsRegisterFlagsWriteDiscard : constant cudaGraphicsRegisterFlags := 2;
+   cudaGraphicsRegisterFlagsSurfaceLoadStore : constant cudaGraphicsRegisterFlags := 4;  -- driver_types.h:675
+
+   type cudaGraphicsMapFlags is
+     (cudaGraphicsMapFlagsNone,
+      cudaGraphicsMapFlagsReadOnly,
+      cudaGraphicsMapFlagsWriteDiscard);
+   pragma Convention (C, cudaGraphicsMapFlags);  -- driver_types.h:687
+
+   type cudaGraphicsCubeFace is
+     (cudaGraphicsCubeFacePositiveX,
+      cudaGraphicsCubeFaceNegativeX,
+      cudaGraphicsCubeFacePositiveY,
+      cudaGraphicsCubeFaceNegativeY,
+      cudaGraphicsCubeFacePositiveZ,
+      cudaGraphicsCubeFaceNegativeZ);
+   pragma Convention (C, cudaGraphicsCubeFace);  -- driver_types.h:698
+
+   type cudaPointerAttributes is record
+      memoryType : aliased cudaMemoryType;  -- driver_types.h:717
+      device : aliased int;  -- driver_types.h:728
+      devicePointer : System.Address;  -- driver_types.h:734
+      hostPointer : System.Address;  -- driver_types.h:740
+   end record;
+   pragma Convention (C_Pass_By_Copy, cudaPointerAttributes);  -- driver_types.h:711
+
+   type cudaFuncAttributes is record
+      sharedSizeBytes : aliased stddef_h.size_t;  -- driver_types.h:754
+      constSizeBytes : aliased stddef_h.size_t;  -- driver_types.h:760
+      localSizeBytes : aliased stddef_h.size_t;  -- driver_types.h:765
+      maxThreadsPerBlock : aliased int;  -- driver_types.h:772
+      numRegs : aliased int;  -- driver_types.h:777
+      ptxVersion : aliased int;  -- driver_types.h:784
+      binaryVersion : aliased int;  -- driver_types.h:791
+   end record;
+   pragma Convention (C_Pass_By_Copy, cudaFuncAttributes);  -- driver_types.h:747
+
+   type cudaFuncCache is
+     (cudaFuncCachePreferNone,
+      cudaFuncCachePreferShared,
+      cudaFuncCachePreferL1);
+   pragma Convention (C, cudaFuncCache);  -- driver_types.h:798
+
+   type cudaComputeMode is
+     (cudaComputeModeDefault,
+      cudaComputeModeExclusive,
+      cudaComputeModeProhibited,
+      cudaComputeModeExclusiveProcess);
+   pragma Convention (C, cudaComputeMode);  -- driver_types.h:809
+
+   type cudaLimit is
+     (cudaLimitStackSize,
+      cudaLimitPrintfFifoSize,
+      cudaLimitMallocHeapSize);
+   pragma Convention (C, cudaLimit);  -- driver_types.h:821
+
+   type cudaOutputMode is
+     (cudaKeyValuePair,
+      cudaCSV);
+   pragma Convention (C, cudaOutputMode);  -- driver_types.h:832
+
+   subtype anon621_anon623_array is Interfaces.C.char_array (0 .. 255);
+   type anon621_anon625_array is array (0 .. 2) of aliased int;
+   type anon621_anon629_array is array (0 .. 1) of aliased int;
+   type cudaDeviceProp is record
+      name : aliased anon621_anon623_array;  -- driver_types.h:844
+      totalGlobalMem : aliased stddef_h.size_t;  -- driver_types.h:845
+      sharedMemPerBlock : aliased stddef_h.size_t;  -- driver_types.h:846
+      regsPerBlock : aliased int;  -- driver_types.h:847
+      warpSize : aliased int;  -- driver_types.h:848
+      memPitch : aliased stddef_h.size_t;  -- driver_types.h:849
+      maxThreadsPerBlock : aliased int;  -- driver_types.h:850
+      maxThreadsDim : aliased anon621_anon625_array;  -- driver_types.h:851
+      maxGridSize : aliased anon621_anon625_array;  -- driver_types.h:852
+      clockRate : aliased int;  -- driver_types.h:853
+      totalConstMem : aliased stddef_h.size_t;  -- driver_types.h:854
+      major : aliased int;  -- driver_types.h:855
+      minor : aliased int;  -- driver_types.h:856
+      textureAlignment : aliased stddef_h.size_t;  -- driver_types.h:857
+      deviceOverlap : aliased int;  -- driver_types.h:858
+      multiProcessorCount : aliased int;  -- driver_types.h:859
+      kernelExecTimeoutEnabled : aliased int;  -- driver_types.h:860
+      integrated : aliased int;  -- driver_types.h:861
+      canMapHostMemory : aliased int;  -- driver_types.h:862
+      computeMode : aliased int;  -- driver_types.h:863
+      maxTexture1D : aliased int;  -- driver_types.h:864
+      maxTexture2D : aliased anon621_anon629_array;  -- driver_types.h:865
+      maxTexture3D : aliased anon621_anon625_array;  -- driver_types.h:866
+      maxTexture1DLayered : aliased anon621_anon629_array;  -- driver_types.h:867
+      maxTexture2DLayered : aliased anon621_anon625_array;  -- driver_types.h:868
+      surfaceAlignment : aliased stddef_h.size_t;  -- driver_types.h:869
+      concurrentKernels : aliased int;  -- driver_types.h:870
+      ECCEnabled : aliased int;  -- driver_types.h:871
+      pciBusID : aliased int;  -- driver_types.h:872
+      pciDeviceID : aliased int;  -- driver_types.h:873
+      pciDomainID : aliased int;  -- driver_types.h:874
+      tccDriver : aliased int;  -- driver_types.h:875
+      asyncEngineCount : aliased int;  -- driver_types.h:876
+      unifiedAddressing : aliased int;  -- driver_types.h:877
+      memoryClockRate : aliased int;  -- driver_types.h:878
+      memoryBusWidth : aliased int;  -- driver_types.h:879
+      l2CacheSize : aliased int;  -- driver_types.h:880
+      maxThreadsPerMultiProcessor : aliased int;  -- driver_types.h:881
+   end record;
+   pragma Convention (C_Pass_By_Copy, cudaDeviceProp);  -- driver_types.h:842
+
+   subtype cudaError_t is cudaError;
+
+   --  skipped empty struct CUstream_st
+
+   type cudaStream_t is new System.Address;  -- driver_types.h:942
+
+   --  skipped empty struct CUevent_st
+
+   type cudaEvent_t is new System.Address;  -- driver_types.h:948
+
+   type cudaGraphicsResource_t is new System.Address;  -- driver_types.h:954
+
+   --  skipped empty struct CUuuid_st
+
+   --  skipped empty struct cudaUUID_t
+
+   subtype cudaOutputMode_t is cudaOutputMode;
+
+end driver_types_h;
diff --git a/thin/stddef_h.ads b/thin/stddef_h.ads
new file mode 100644 (file)
index 0000000..f8a3c59
--- /dev/null
@@ -0,0 +1,14 @@
+with Interfaces.C; use Interfaces.C;
+
+package stddef_h is
+
+   --  unsupported macro: NULL ((void *)0)
+   --  arg-macro: procedure offsetof (TYPE, MEMBER)
+   --    __builtin_offsetof (TYPE, MEMBER)
+   subtype ptrdiff_t is int;  -- /opt/gnat-2011-i686-gnu-linux-libc2.3-bin/bin/../lib/gcc/i686-pc-linux-gnu/4.5.3/include/stddef.h:149
+
+   subtype size_t is unsigned;  -- /opt/gnat-2011-i686-gnu-linux-libc2.3-bin/bin/../lib/gcc/i686-pc-linux-gnu/4.5.3/include/stddef.h:211
+
+   subtype wchar_t is long;  -- /opt/gnat-2011-i686-gnu-linux-libc2.3-bin/bin/../lib/gcc/i686-pc-linux-gnu/4.5.3/include/stddef.h:323
+
+end stddef_h;
diff --git a/thin/stdlib_h.ads b/thin/stdlib_h.ads
new file mode 100644 (file)
index 0000000..19d0999
--- /dev/null
@@ -0,0 +1,468 @@
+with Interfaces.C; use Interfaces.C;
+limited with bits_waitstatus_h;
+with Interfaces.C.Strings;
+with System;
+with Interfaces.C.Extensions;
+with stddef_h;
+with sys_types_h;
+
+package stdlib_h is
+
+   --  arg-macro: procedure WEXITSTATUS (status)
+   --    __WEXITSTATUS (__WAIT_INT (status))
+   --  arg-macro: procedure WTERMSIG (status)
+   --    __WTERMSIG (__WAIT_INT (status))
+   --  arg-macro: procedure WSTOPSIG (status)
+   --    __WSTOPSIG (__WAIT_INT (status))
+   --  arg-macro: procedure WIFEXITED (status)
+   --    __WIFEXITED (__WAIT_INT (status))
+   --  arg-macro: procedure WIFSIGNALED (status)
+   --    __WIFSIGNALED (__WAIT_INT (status))
+   --  arg-macro: procedure WIFSTOPPED (status)
+   --    __WIFSTOPPED (__WAIT_INT (status))
+   --  arg-macro: procedure WIFCONTINUED (status)
+   --    __WIFCONTINUED (__WAIT_INT (status))
+
+   RAND_MAX : constant := 2147483647;  --  /usr/include/stdlib.h:129
+
+   EXIT_FAILURE : constant := 1;  --  /usr/include/stdlib.h:134
+   EXIT_SUCCESS : constant := 0;  --  /usr/include/stdlib.h:135
+   --  unsupported macro: MB_CUR_MAX (__ctype_get_mb_cur_max ())
+
+   type uu_WAIT_STATUS (discr : unsigned := 0) is record
+      case discr is
+         when 0 =>
+            uu_uptr : access bits_waitstatus_h.wait;  -- /usr/include/stdlib.h:70
+         when others =>
+            uu_iptr : access int;  -- /usr/include/stdlib.h:71
+      end case;
+   end record;
+   pragma Convention (C_Pass_By_Copy, uu_WAIT_STATUS);
+   pragma Unchecked_Union (uu_WAIT_STATUS);  -- /usr/include/stdlib.h:72
+
+   type div_t is record
+      quot : aliased int;  -- /usr/include/stdlib.h:100
+      c_rem : aliased int;  -- /usr/include/stdlib.h:101
+   end record;
+   pragma Convention (C_Pass_By_Copy, div_t);  -- /usr/include/stdlib.h:102
+
+   type ldiv_t is record
+      quot : aliased long;  -- /usr/include/stdlib.h:108
+      c_rem : aliased long;  -- /usr/include/stdlib.h:109
+   end record;
+   pragma Convention (C_Pass_By_Copy, ldiv_t);  -- /usr/include/stdlib.h:110
+
+   type lldiv_t is record
+      quot : aliased Long_Long_Integer;  -- /usr/include/stdlib.h:120
+      c_rem : aliased Long_Long_Integer;  -- /usr/include/stdlib.h:121
+   end record;
+   pragma Convention (C_Pass_By_Copy, lldiv_t);  -- /usr/include/stdlib.h:122
+
+   function atof (arg1 : Interfaces.C.Strings.chars_ptr) return double;  -- /usr/include/stdlib.h:145
+   pragma Import (C, atof, "atof");
+
+   function atoi (arg1 : Interfaces.C.Strings.chars_ptr) return int;  -- /usr/include/stdlib.h:148
+   pragma Import (C, atoi, "atoi");
+
+   function atol (arg1 : Interfaces.C.Strings.chars_ptr) return long;  -- /usr/include/stdlib.h:151
+   pragma Import (C, atol, "atol");
+
+   function atoll (arg1 : Interfaces.C.Strings.chars_ptr) return Long_Long_Integer;  -- /usr/include/stdlib.h:158
+   pragma Import (C, atoll, "atoll");
+
+   function strtod (arg1 : Interfaces.C.Strings.chars_ptr; arg2 : System.Address) return double;  -- /usr/include/stdlib.h:165
+   pragma Import (C, strtod, "strtod");
+
+   function strtof (arg1 : Interfaces.C.Strings.chars_ptr; arg2 : System.Address) return float;  -- /usr/include/stdlib.h:173
+   pragma Import (C, strtof, "strtof");
+
+   function strtold (arg1 : Interfaces.C.Strings.chars_ptr; arg2 : System.Address) return long_double;  -- /usr/include/stdlib.h:176
+   pragma Import (C, strtold, "strtold");
+
+   function strtol
+     (arg1 : Interfaces.C.Strings.chars_ptr;
+      arg2 : System.Address;
+      arg3 : int) return long;  -- /usr/include/stdlib.h:184
+   pragma Import (C, strtol, "strtol");
+
+   function strtoul
+     (arg1 : Interfaces.C.Strings.chars_ptr;
+      arg2 : System.Address;
+      arg3 : int) return unsigned_long;  -- /usr/include/stdlib.h:188
+   pragma Import (C, strtoul, "strtoul");
+
+   function strtoq
+     (arg1 : Interfaces.C.Strings.chars_ptr;
+      arg2 : System.Address;
+      arg3 : int) return Long_Long_Integer;  -- /usr/include/stdlib.h:196
+   pragma Import (C, strtoq, "strtoq");
+
+   function strtouq
+     (arg1 : Interfaces.C.Strings.chars_ptr;
+      arg2 : System.Address;
+      arg3 : int) return Extensions.unsigned_long_long;  -- /usr/include/stdlib.h:201
+   pragma Import (C, strtouq, "strtouq");
+
+   function strtoll
+     (arg1 : Interfaces.C.Strings.chars_ptr;
+      arg2 : System.Address;
+      arg3 : int) return Long_Long_Integer;  -- /usr/include/stdlib.h:210
+   pragma Import (C, strtoll, "strtoll");
+
+   function strtoull
+     (arg1 : Interfaces.C.Strings.chars_ptr;
+      arg2 : System.Address;
+      arg3 : int) return Extensions.unsigned_long_long;  -- /usr/include/stdlib.h:215
+   pragma Import (C, strtoull, "strtoull");
+
+   function l64a (arg1 : long) return Interfaces.C.Strings.chars_ptr;  -- /usr/include/stdlib.h:311
+   pragma Import (C, l64a, "l64a");
+
+   function a64l (arg1 : Interfaces.C.Strings.chars_ptr) return long;  -- /usr/include/stdlib.h:314
+   pragma Import (C, a64l, "a64l");
+
+   function random return long;  -- /usr/include/stdlib.h:327
+   pragma Import (C, random, "random");
+
+   procedure srandom (arg1 : unsigned);  -- /usr/include/stdlib.h:330
+   pragma Import (C, srandom, "srandom");
+
+   function initstate
+     (arg1 : unsigned;
+      arg2 : Interfaces.C.Strings.chars_ptr;
+      arg3 : stddef_h.size_t) return Interfaces.C.Strings.chars_ptr;  -- /usr/include/stdlib.h:336
+   pragma Import (C, initstate, "initstate");
+
+   function setstate (arg1 : Interfaces.C.Strings.chars_ptr) return Interfaces.C.Strings.chars_ptr;  -- /usr/include/stdlib.h:341
+   pragma Import (C, setstate, "setstate");
+
+   type random_data is record
+      fptr : access sys_types_h.int32_t;  -- /usr/include/stdlib.h:351
+      rptr : access sys_types_h.int32_t;  -- /usr/include/stdlib.h:352
+      state : access sys_types_h.int32_t;  -- /usr/include/stdlib.h:353
+      rand_type : aliased int;  -- /usr/include/stdlib.h:354
+      rand_deg : aliased int;  -- /usr/include/stdlib.h:355
+      rand_sep : aliased int;  -- /usr/include/stdlib.h:356
+      end_ptr : access sys_types_h.int32_t;  -- /usr/include/stdlib.h:357
+   end record;
+   pragma Convention (C_Pass_By_Copy, random_data);  -- /usr/include/stdlib.h:349
+
+   function random_r (arg1 : access random_data; arg2 : access sys_types_h.int32_t) return int;  -- /usr/include/stdlib.h:360
+   pragma Import (C, random_r, "random_r");
+
+   function srandom_r (arg1 : unsigned; arg2 : access random_data) return int;  -- /usr/include/stdlib.h:363
+   pragma Import (C, srandom_r, "srandom_r");
+
+   function initstate_r
+     (arg1 : unsigned;
+      arg2 : Interfaces.C.Strings.chars_ptr;
+      arg3 : stddef_h.size_t;
+      arg4 : access random_data) return int;  -- /usr/include/stdlib.h:366
+   pragma Import (C, initstate_r, "initstate_r");
+
+   function setstate_r (arg1 : Interfaces.C.Strings.chars_ptr; arg2 : access random_data) return int;  -- /usr/include/stdlib.h:371
+   pragma Import (C, setstate_r, "setstate_r");
+
+   function rand return int;  -- /usr/include/stdlib.h:380
+   pragma Import (C, rand, "rand");
+
+   procedure srand (arg1 : unsigned);  -- /usr/include/stdlib.h:382
+   pragma Import (C, srand, "srand");
+
+   function rand_r (arg1 : access unsigned) return int;  -- /usr/include/stdlib.h:387
+   pragma Import (C, rand_r, "rand_r");
+
+   function drand48 return double;  -- /usr/include/stdlib.h:395
+   pragma Import (C, drand48, "drand48");
+
+   function erand48 (arg1 : access unsigned_short) return double;  -- /usr/include/stdlib.h:396
+   pragma Import (C, erand48, "erand48");
+
+   function lrand48 return long;  -- /usr/include/stdlib.h:399
+   pragma Import (C, lrand48, "lrand48");
+
+   function nrand48 (arg1 : access unsigned_short) return long;  -- /usr/include/stdlib.h:400
+   pragma Import (C, nrand48, "nrand48");
+
+   function mrand48 return long;  -- /usr/include/stdlib.h:404
+   pragma Import (C, mrand48, "mrand48");
+
+   function jrand48 (arg1 : access unsigned_short) return long;  -- /usr/include/stdlib.h:405
+   pragma Import (C, jrand48, "jrand48");
+
+   procedure srand48 (arg1 : long);  -- /usr/include/stdlib.h:409
+   pragma Import (C, srand48, "srand48");
+
+   function seed48 (arg1 : access unsigned_short) return access unsigned_short;  -- /usr/include/stdlib.h:410
+   pragma Import (C, seed48, "seed48");
+
+   procedure lcong48 (arg1 : access unsigned_short);  -- /usr/include/stdlib.h:412
+   pragma Import (C, lcong48, "lcong48");
+
+   type anon881_anon859_array is array (0 .. 2) of aliased unsigned_short;
+   type anon881_anon859_array is array (0 .. 2) of aliased unsigned_short;
+   type drand48_data is record
+      uu_x : aliased anon881_anon859_array;  -- /usr/include/stdlib.h:420
+      uu_old_x : aliased anon881_anon859_array;  -- /usr/include/stdlib.h:421
+      uu_c : aliased unsigned_short;  -- /usr/include/stdlib.h:422
+      uu_init : aliased unsigned_short;  -- /usr/include/stdlib.h:423
+      uu_a : aliased Extensions.unsigned_long_long;  -- /usr/include/stdlib.h:424
+   end record;
+   pragma Convention (C_Pass_By_Copy, drand48_data);  -- /usr/include/stdlib.h:418
+
+   function drand48_r (arg1 : access drand48_data; arg2 : access double) return int;  -- /usr/include/stdlib.h:428
+   pragma Import (C, drand48_r, "drand48_r");
+
+   function erand48_r
+     (arg1 : access unsigned_short;
+      arg2 : access drand48_data;
+      arg3 : access double) return int;  -- /usr/include/stdlib.h:430
+   pragma Import (C, erand48_r, "erand48_r");
+
+   function lrand48_r (arg1 : access drand48_data; arg2 : access long) return int;  -- /usr/include/stdlib.h:435
+   pragma Import (C, lrand48_r, "lrand48_r");
+
+   function nrand48_r
+     (arg1 : access unsigned_short;
+      arg2 : access drand48_data;
+      arg3 : access long) return int;  -- /usr/include/stdlib.h:438
+   pragma Import (C, nrand48_r, "nrand48_r");
+
+   function mrand48_r (arg1 : access drand48_data; arg2 : access long) return int;  -- /usr/include/stdlib.h:444
+   pragma Import (C, mrand48_r, "mrand48_r");
+
+   function jrand48_r
+     (arg1 : access unsigned_short;
+      arg2 : access drand48_data;
+      arg3 : access long) return int;  -- /usr/include/stdlib.h:447
+   pragma Import (C, jrand48_r, "jrand48_r");
+
+   function srand48_r (arg1 : long; arg2 : access drand48_data) return int;  -- /usr/include/stdlib.h:453
+   pragma Import (C, srand48_r, "srand48_r");
+
+   function seed48_r (arg1 : access unsigned_short; arg2 : access drand48_data) return int;  -- /usr/include/stdlib.h:456
+   pragma Import (C, seed48_r, "seed48_r");
+
+   function lcong48_r (arg1 : access unsigned_short; arg2 : access drand48_data) return int;  -- /usr/include/stdlib.h:459
+   pragma Import (C, lcong48_r, "lcong48_r");
+
+   function malloc (arg1 : stddef_h.size_t) return System.Address;  -- /usr/include/stdlib.h:471
+   pragma Import (C, malloc, "malloc");
+
+   function calloc (arg1 : stddef_h.size_t; arg2 : stddef_h.size_t) return System.Address;  -- /usr/include/stdlib.h:473
+   pragma Import (C, calloc, "calloc");
+
+   function realloc (arg1 : System.Address; arg2 : stddef_h.size_t) return System.Address;  -- /usr/include/stdlib.h:485
+   pragma Import (C, realloc, "realloc");
+
+   procedure free (arg1 : System.Address);  -- /usr/include/stdlib.h:488
+   pragma Import (C, free, "free");
+
+   procedure cfree (arg1 : System.Address);  -- /usr/include/stdlib.h:493
+   pragma Import (C, cfree, "cfree");
+
+   function valloc (arg1 : stddef_h.size_t) return System.Address;  -- /usr/include/stdlib.h:503
+   pragma Import (C, valloc, "valloc");
+
+   function posix_memalign
+     (arg1 : System.Address;
+      arg2 : stddef_h.size_t;
+      arg3 : stddef_h.size_t) return int;  -- /usr/include/stdlib.h:508
+   pragma Import (C, posix_memalign, "posix_memalign");
+
+   procedure c_abort;  -- /usr/include/stdlib.h:514
+   pragma Import (C, c_abort, "abort");
+
+   function atexit (arg1 : access procedure) return int;  -- /usr/include/stdlib.h:518
+   pragma Import (C, atexit, "atexit");
+
+   function on_exit (arg1 : access procedure (arg1 : int; arg2 : System.Address); arg2 : System.Address) return int;  -- /usr/include/stdlib.h:536
+   pragma Import (C, on_exit, "on_exit");
+
+   procedure c_exit (arg1 : int);  -- /usr/include/stdlib.h:544
+   pragma Import (C, c_exit, "exit");
+
+   function getenv (arg1 : Interfaces.C.Strings.chars_ptr) return Interfaces.C.Strings.chars_ptr;  -- /usr/include/stdlib.h:567
+   pragma Import (C, getenv, "getenv");
+
+   function putenv (arg1 : Interfaces.C.Strings.chars_ptr) return int;  -- /usr/include/stdlib.h:579
+   pragma Import (C, putenv, "putenv");
+
+   function setenv
+     (arg1 : Interfaces.C.Strings.chars_ptr;
+      arg2 : Interfaces.C.Strings.chars_ptr;
+      arg3 : int) return int;  -- /usr/include/stdlib.h:585
+   pragma Import (C, setenv, "setenv");
+
+   function unsetenv (arg1 : Interfaces.C.Strings.chars_ptr) return int;  -- /usr/include/stdlib.h:589
+   pragma Import (C, unsetenv, "unsetenv");
+
+   function clearenv return int;  -- /usr/include/stdlib.h:596
+   pragma Import (C, clearenv, "clearenv");
+
+   function mktemp (arg1 : Interfaces.C.Strings.chars_ptr) return Interfaces.C.Strings.chars_ptr;  -- /usr/include/stdlib.h:606
+   pragma Import (C, mktemp, "mktemp");
+
+   function mkstemp (arg1 : Interfaces.C.Strings.chars_ptr) return int;  -- /usr/include/stdlib.h:620
+   pragma Import (C, mkstemp, "mkstemp");
+
+   function mkstemps (arg1 : Interfaces.C.Strings.chars_ptr; arg2 : int) return int;  -- /usr/include/stdlib.h:642
+   pragma Import (C, mkstemps, "mkstemps");
+
+   function mkdtemp (arg1 : Interfaces.C.Strings.chars_ptr) return Interfaces.C.Strings.chars_ptr;  -- /usr/include/stdlib.h:663
+   pragma Import (C, mkdtemp, "mkdtemp");
+
+   function c_system (arg1 : Interfaces.C.Strings.chars_ptr) return int;  -- /usr/include/stdlib.h:717
+   pragma Import (C, c_system, "system");
+
+   function realpath (arg1 : Interfaces.C.Strings.chars_ptr; arg2 : Interfaces.C.Strings.chars_ptr) return Interfaces.C.Strings.chars_ptr;  -- /usr/include/stdlib.h:734
+   pragma Import (C, realpath, "realpath");
+
+   type uu_compar_fn_t is access function (arg1 : System.Address; arg2 : System.Address) return int;  -- /usr/include/stdlib.h:742
+
+   function bsearch
+     (arg1 : System.Address;
+      arg2 : System.Address;
+      arg3 : stddef_h.size_t;
+      arg4 : stddef_h.size_t;
+      arg5 : access function (arg1 : System.Address; arg2 : System.Address) return int) return System.Address;  -- /usr/include/stdlib.h:755
+   pragma Import (C, bsearch, "bsearch");
+
+   procedure qsort
+     (arg1 : System.Address;
+      arg2 : stddef_h.size_t;
+      arg3 : stddef_h.size_t;
+      arg4 : access function (arg1 : System.Address; arg2 : System.Address) return int);  -- /usr/include/stdlib.h:761
+   pragma Import (C, qsort, "qsort");
+
+   function c_abs (arg1 : int) return int;  -- /usr/include/stdlib.h:771
+   pragma Import (C, c_abs, "abs");
+
+   function labs (arg1 : long) return long;  -- /usr/include/stdlib.h:772
+   pragma Import (C, labs, "labs");
+
+   function llabs (arg1 : Long_Long_Integer) return Long_Long_Integer;  -- /usr/include/stdlib.h:776
+   pragma Import (C, llabs, "llabs");
+
+   function div (arg1 : int; arg2 : int) return div_t;  -- /usr/include/stdlib.h:785
+   pragma Import (C, div, "div");
+
+   function ldiv (arg1 : long; arg2 : long) return ldiv_t;  -- /usr/include/stdlib.h:787
+   pragma Import (C, ldiv, "ldiv");
+
+   function lldiv (arg1 : Long_Long_Integer; arg2 : Long_Long_Integer) return lldiv_t;  -- /usr/include/stdlib.h:793
+   pragma Import (C, lldiv, "lldiv");
+
+   function ecvt
+     (arg1 : double;
+      arg2 : int;
+      arg3 : access int;
+      arg4 : access int) return Interfaces.C.Strings.chars_ptr;  -- /usr/include/stdlib.h:808
+   pragma Import (C, ecvt, "ecvt");
+
+   function fcvt
+     (arg1 : double;
+      arg2 : int;
+      arg3 : access int;
+      arg4 : access int) return Interfaces.C.Strings.chars_ptr;  -- /usr/include/stdlib.h:814
+   pragma Import (C, fcvt, "fcvt");
+
+   function gcvt
+     (arg1 : double;
+      arg2 : int;
+      arg3 : Interfaces.C.Strings.chars_ptr) return Interfaces.C.Strings.chars_ptr;  -- /usr/include/stdlib.h:820
+   pragma Import (C, gcvt, "gcvt");
+
+   function qecvt
+     (arg1 : long_double;
+      arg2 : int;
+      arg3 : access int;
+      arg4 : access int) return Interfaces.C.Strings.chars_ptr;  -- /usr/include/stdlib.h:826
+   pragma Import (C, qecvt, "qecvt");
+
+   function qfcvt
+     (arg1 : long_double;
+      arg2 : int;
+      arg3 : access int;
+      arg4 : access int) return Interfaces.C.Strings.chars_ptr;  -- /usr/include/stdlib.h:829
+   pragma Import (C, qfcvt, "qfcvt");
+
+   function qgcvt
+     (arg1 : long_double;
+      arg2 : int;
+      arg3 : Interfaces.C.Strings.chars_ptr) return Interfaces.C.Strings.chars_ptr;  -- /usr/include/stdlib.h:832
+   pragma Import (C, qgcvt, "qgcvt");
+
+   function ecvt_r
+     (arg1 : double;
+      arg2 : int;
+      arg3 : access int;
+      arg4 : access int;
+      arg5 : Interfaces.C.Strings.chars_ptr;
+      arg6 : stddef_h.size_t) return int;  -- /usr/include/stdlib.h:838
+   pragma Import (C, ecvt_r, "ecvt_r");
+
+   function fcvt_r
+     (arg1 : double;
+      arg2 : int;
+      arg3 : access int;
+      arg4 : access int;
+      arg5 : Interfaces.C.Strings.chars_ptr;
+      arg6 : stddef_h.size_t) return int;  -- /usr/include/stdlib.h:841
+   pragma Import (C, fcvt_r, "fcvt_r");
+
+   function qecvt_r
+     (arg1 : long_double;
+      arg2 : int;
+      arg3 : access int;
+      arg4 : access int;
+      arg5 : Interfaces.C.Strings.chars_ptr;
+      arg6 : stddef_h.size_t) return int;  -- /usr/include/stdlib.h:845
+   pragma Import (C, qecvt_r, "qecvt_r");
+
+   function qfcvt_r
+     (arg1 : long_double;
+      arg2 : int;
+      arg3 : access int;
+      arg4 : access int;
+      arg5 : Interfaces.C.Strings.chars_ptr;
+      arg6 : stddef_h.size_t) return int;  -- /usr/include/stdlib.h:849
+   pragma Import (C, qfcvt_r, "qfcvt_r");
+
+   function mblen (arg1 : Interfaces.C.Strings.chars_ptr; arg2 : stddef_h.size_t) return int;  -- /usr/include/stdlib.h:860
+   pragma Import (C, mblen, "mblen");
+
+   function mbtowc
+     (arg1 : access stddef_h.wchar_t;
+      arg2 : Interfaces.C.Strings.chars_ptr;
+      arg3 : stddef_h.size_t) return int;  -- /usr/include/stdlib.h:863
+   pragma Import (C, mbtowc, "mbtowc");
+
+   function wctomb (arg1 : Interfaces.C.Strings.chars_ptr; arg2 : stddef_h.wchar_t) return int;  -- /usr/include/stdlib.h:867
+   pragma Import (C, wctomb, "wctomb");
+
+   function mbstowcs
+     (arg1 : access stddef_h.wchar_t;
+      arg2 : Interfaces.C.Strings.chars_ptr;
+      arg3 : stddef_h.size_t) return stddef_h.size_t;  -- /usr/include/stdlib.h:871
+   pragma Import (C, mbstowcs, "mbstowcs");
+
+   function wcstombs
+     (arg1 : Interfaces.C.Strings.chars_ptr;
+      arg2 : access stddef_h.wchar_t;
+      arg3 : stddef_h.size_t) return stddef_h.size_t;  -- /usr/include/stdlib.h:874
+   pragma Import (C, wcstombs, "wcstombs");
+
+   function rpmatch (arg1 : Interfaces.C.Strings.chars_ptr) return int;  -- /usr/include/stdlib.h:885
+   pragma Import (C, rpmatch, "rpmatch");
+
+   function getsubopt
+     (arg1 : System.Address;
+      arg2 : System.Address;
+      arg3 : System.Address) return int;  -- /usr/include/stdlib.h:896
+   pragma Import (C, getsubopt, "getsubopt");
+
+   function getloadavg (arg1 : access double; arg2 : int) return int;  -- /usr/include/stdlib.h:948
+   pragma Import (C, getloadavg, "getloadavg");
+
+end stdlib_h;
diff --git a/thin/surface_types_h.ads b/thin/surface_types_h.ads
new file mode 100644 (file)
index 0000000..4531c17
--- /dev/null
@@ -0,0 +1,22 @@
+with Interfaces.C; use Interfaces.C;
+with driver_types_h;
+
+package surface_types_h is
+
+   type cudaSurfaceBoundaryMode is 
+     (cudaBoundaryModeZero,
+      cudaBoundaryModeClamp,
+      cudaBoundaryModeTrap);
+   pragma Convention (C, cudaSurfaceBoundaryMode);  -- surface_types.h:77
+
+   type cudaSurfaceFormatMode is 
+     (cudaFormatModeForced,
+      cudaFormatModeAuto);
+   pragma Convention (C, cudaSurfaceFormatMode);  -- surface_types.h:88
+
+   type surfaceReference is record
+      channelDesc : aliased driver_types_h.cudaChannelFormatDesc;  -- surface_types.h:103
+   end record;
+   pragma Convention (C_Pass_By_Copy, surfaceReference);  -- surface_types.h:98
+
+end surface_types_h;
diff --git a/thin/sys_select_h.ads b/thin/sys_select_h.ads
new file mode 100644 (file)
index 0000000..6c6bf3e
--- /dev/null
@@ -0,0 +1,50 @@
+with Interfaces.C; use Interfaces.C;
+with bits_sigset_h;
+with bits_types_h;
+limited with bits_time_h;
+with System;
+
+package sys_select_h is
+
+   --  unsupported macro: FD_SETSIZE __FD_SETSIZE
+   --  unsupported macro: NFDBITS __NFDBITS
+   --  arg-macro: procedure FD_SET (fd, fdsetp)
+   --    __FD_SET (fd, fdsetp)
+   --  arg-macro: procedure FD_CLR (fd, fdsetp)
+   --    __FD_CLR (fd, fdsetp)
+   --  arg-macro: procedure FD_ISSET (fd, fdsetp)
+   --    __FD_ISSET (fd, fdsetp)
+   --  arg-macro: procedure FD_ZERO (fdsetp)
+   --    __FD_ZERO (fdsetp)
+   subtype sigset_t is bits_sigset_h.uu_sigset_t;  -- /usr/include/sys/select.h:38
+
+   subtype suseconds_t is bits_types_h.uu_suseconds_t;  -- /usr/include/sys/select.h:49
+
+   subtype uu_fd_mask is long;  -- /usr/include/sys/select.h:55
+
+   type fd_set_uu_fds_bits_array is array (0 .. 31) of aliased uu_fd_mask;
+   type fd_set is record
+      uu_fds_bits : aliased fd_set_uu_fds_bits_array;  -- /usr/include/sys/select.h:75
+   end record;
+   pragma Convention (C_Pass_By_Copy, fd_set);  -- /usr/include/sys/select.h:78
+
+   subtype fd_mask is uu_fd_mask;  -- /usr/include/sys/select.h:85
+
+   function c_select
+     (arg1 : int;
+      arg2 : access fd_set;
+      arg3 : access fd_set;
+      arg4 : access fd_set;
+      arg5 : access bits_time_h.timeval) return int;  -- /usr/include/sys/select.h:109
+   pragma Import (C, c_select, "select");
+
+   function pselect
+     (arg1 : int;
+      arg2 : access fd_set;
+      arg3 : access fd_set;
+      arg4 : access fd_set;
+      arg5 : System.Address;
+      arg6 : access constant bits_sigset_h.uu_sigset_t) return int;  -- /usr/include/sys/select.h:121
+   pragma Import (C, pselect, "pselect");
+
+end sys_select_h;
diff --git a/thin/sys_sysmacros_h.ads b/thin/sys_sysmacros_h.ads
new file mode 100644 (file)
index 0000000..7af6c3a
--- /dev/null
@@ -0,0 +1,21 @@
+with Interfaces.C; use Interfaces.C;
+with Interfaces.C.Extensions;
+
+package sys_sysmacros_h is
+
+   --  arg-macro: procedure major (dev)
+   --    gnu_dev_major (dev)
+   --  arg-macro: procedure minor (dev)
+   --    gnu_dev_minor (dev)
+   --  arg-macro: procedure makedev (maj, min)
+   --    gnu_dev_makedev (maj, min)
+   function gnu_dev_major (arg1 : Extensions.unsigned_long_long) return unsigned;  -- /usr/include/sys/sysmacros.h:31
+   pragma Import (C, gnu_dev_major, "gnu_dev_major");
+
+   function gnu_dev_minor (arg1 : Extensions.unsigned_long_long) return unsigned;  -- /usr/include/sys/sysmacros.h:34
+   pragma Import (C, gnu_dev_minor, "gnu_dev_minor");
+
+   function gnu_dev_makedev (arg1 : unsigned; arg2 : unsigned) return Extensions.unsigned_long_long;  -- /usr/include/sys/sysmacros.h:37
+   pragma Import (C, gnu_dev_makedev, "gnu_dev_makedev");
+
+end sys_sysmacros_h;
diff --git a/thin/sys_types_h.ads b/thin/sys_types_h.ads
new file mode 100644 (file)
index 0000000..2960fe9
--- /dev/null
@@ -0,0 +1,81 @@
+with Interfaces.C; use Interfaces.C;
+with bits_types_h;
+with Interfaces.C.Extensions;
+
+package sys_types_h is
+
+   subtype u_char is bits_types_h.uu_u_char;  -- /usr/include/sys/types.h:34
+
+   subtype u_short is bits_types_h.uu_u_short;  -- /usr/include/sys/types.h:35
+
+   subtype u_int is bits_types_h.uu_u_int;  -- /usr/include/sys/types.h:36
+
+   subtype u_long is bits_types_h.uu_u_long;  -- /usr/include/sys/types.h:37
+
+   subtype quad_t is bits_types_h.uu_quad_t;  -- /usr/include/sys/types.h:38
+
+   subtype u_quad_t is bits_types_h.uu_u_quad_t;  -- /usr/include/sys/types.h:39
+
+   subtype fsid_t is bits_types_h.uu_fsid_t;  -- /usr/include/sys/types.h:40
+
+   subtype loff_t is bits_types_h.uu_loff_t;  -- /usr/include/sys/types.h:45
+
+   subtype ino_t is bits_types_h.uu_ino_t;  -- /usr/include/sys/types.h:49
+
+   subtype dev_t is bits_types_h.uu_dev_t;  -- /usr/include/sys/types.h:61
+
+   subtype gid_t is bits_types_h.uu_gid_t;  -- /usr/include/sys/types.h:66
+
+   subtype mode_t is bits_types_h.uu_mode_t;  -- /usr/include/sys/types.h:71
+
+   subtype nlink_t is bits_types_h.uu_nlink_t;  -- /usr/include/sys/types.h:76
+
+   subtype uid_t is bits_types_h.uu_uid_t;  -- /usr/include/sys/types.h:81
+
+   subtype off_t is bits_types_h.uu_off_t;  -- /usr/include/sys/types.h:87
+
+   subtype pid_t is bits_types_h.uu_pid_t;  -- /usr/include/sys/types.h:99
+
+   subtype id_t is bits_types_h.uu_id_t;  -- /usr/include/sys/types.h:105
+
+   subtype ssize_t is bits_types_h.uu_ssize_t;  -- /usr/include/sys/types.h:110
+
+   subtype daddr_t is bits_types_h.uu_daddr_t;  -- /usr/include/sys/types.h:116
+
+   subtype caddr_t is bits_types_h.uu_caddr_t;  -- /usr/include/sys/types.h:117
+
+   subtype key_t is bits_types_h.uu_key_t;  -- /usr/include/sys/types.h:123
+
+   subtype ulong is unsigned_long;  -- /usr/include/sys/types.h:151
+
+   subtype ushort is unsigned_short;  -- /usr/include/sys/types.h:152
+
+   subtype uint is unsigned;  -- /usr/include/sys/types.h:153
+
+   subtype int8_t is signed_char;  -- /usr/include/sys/types.h:195
+
+   subtype int16_t is short;  -- /usr/include/sys/types.h:196
+
+   subtype int32_t is int;  -- /usr/include/sys/types.h:197
+
+   subtype int64_t is Long_Long_Integer;  -- /usr/include/sys/types.h:198
+
+   subtype u_int8_t is unsigned_char;  -- /usr/include/sys/types.h:201
+
+   subtype u_int16_t is unsigned_short;  -- /usr/include/sys/types.h:202
+
+   subtype u_int32_t is unsigned;  -- /usr/include/sys/types.h:203
+
+   subtype u_int64_t is Extensions.unsigned_long_long;  -- /usr/include/sys/types.h:204
+
+   subtype register_t is int;  -- /usr/include/sys/types.h:206
+
+   subtype blksize_t is bits_types_h.uu_blksize_t;  -- /usr/include/sys/types.h:229
+
+   subtype blkcnt_t is bits_types_h.uu_blkcnt_t;  -- /usr/include/sys/types.h:236
+
+   subtype fsblkcnt_t is bits_types_h.uu_fsblkcnt_t;  -- /usr/include/sys/types.h:240
+
+   subtype fsfilcnt_t is bits_types_h.uu_fsfilcnt_t;  -- /usr/include/sys/types.h:244
+
+end sys_types_h;
diff --git a/thin/texture_types_h.ads b/thin/texture_types_h.ads
new file mode 100644 (file)
index 0000000..2155763
--- /dev/null
@@ -0,0 +1,42 @@
+with Interfaces.C; use Interfaces.C;
+with driver_types_h;
+
+package texture_types_h is
+
+
+   cudaTextureType1D : constant := 16#01#;  --  texture_types.h:73
+   cudaTextureType2D : constant := 16#02#;  --  texture_types.h:74
+   cudaTextureType3D : constant := 16#03#;  --  texture_types.h:75
+   cudaTextureType1DLayered : constant := 16#F1#;  --  texture_types.h:76
+   cudaTextureType2DLayered : constant := 16#F2#;  --  texture_types.h:77
+
+   type cudaTextureAddressMode is 
+     (cudaAddressModeWrap,
+      cudaAddressModeClamp,
+      cudaAddressModeMirror,
+      cudaAddressModeBorder);
+   pragma Convention (C, cudaTextureAddressMode);  -- texture_types.h:83
+
+   type cudaTextureFilterMode is 
+     (cudaFilterModePoint,
+      cudaFilterModeLinear);
+   pragma Convention (C, cudaTextureFilterMode);  -- texture_types.h:95
+
+   type cudaTextureReadMode is 
+     (cudaReadModeElementType,
+      cudaReadModeNormalizedFloat);
+   pragma Convention (C, cudaTextureReadMode);  -- texture_types.h:105
+
+   type anon654_anon656_array is array (0 .. 2) of aliased cudaTextureAddressMode;
+   type anon654_anon659_array is array (0 .. 14) of aliased int;
+   type textureReference is record
+      normalized : aliased int;  -- texture_types.h:120
+      filterMode : aliased cudaTextureFilterMode;  -- texture_types.h:124
+      addressMode : aliased anon654_anon656_array;  -- texture_types.h:128
+      channelDesc : aliased driver_types_h.cudaChannelFormatDesc;  -- texture_types.h:132
+      sRGB : aliased int;  -- texture_types.h:136
+      uu_cudaReserved : aliased anon654_anon659_array;  -- texture_types.h:137
+   end record;
+   pragma Convention (C_Pass_By_Copy, textureReference);  -- texture_types.h:115
+
+end texture_types_h;
diff --git a/thin/time_h.ads b/thin/time_h.ads
new file mode 100644 (file)
index 0000000..cd425b0
--- /dev/null
@@ -0,0 +1,20 @@
+with Interfaces.C; use Interfaces.C;
+with bits_types_h;
+
+package time_h is
+
+   subtype clock_t is bits_types_h.uu_clock_t;  -- /usr/include/time.h:60
+
+   subtype time_t is bits_types_h.uu_time_t;  -- /usr/include/time.h:76
+
+   subtype clockid_t is bits_types_h.uu_clockid_t;  -- /usr/include/time.h:92
+
+   subtype timer_t is bits_types_h.uu_timer_t;  -- /usr/include/time.h:104
+
+   type timespec is record
+      tv_sec : aliased bits_types_h.uu_time_t;  -- /usr/include/time.h:122
+      tv_nsec : aliased long;  -- /usr/include/time.h:123
+   end record;
+   pragma Convention (C_Pass_By_Copy, timespec);  -- /usr/include/time.h:120
+
+end time_h;
diff --git a/thin/vector_functions_h.ads b/thin/vector_functions_h.ads
new file mode 100644 (file)
index 0000000..5e63749
--- /dev/null
@@ -0,0 +1,235 @@
+with Interfaces.C; use Interfaces.C;
+with vector_types_h;
+with Interfaces.C.Extensions;
+
+package vector_functions_h is
+
+   function make_char1 (x : signed_char) return vector_types_h.char1;  -- vector_functions.h:69
+   pragma Import (C, make_char1, "make_char1");
+
+   function make_uchar1 (x : unsigned_char) return vector_types_h.uchar1;  -- vector_functions.h:74
+   pragma Import (C, make_uchar1, "make_uchar1");
+
+   function make_char2 (x : signed_char; y : signed_char) return vector_types_h.char2;  -- vector_functions.h:79
+   pragma Import (C, make_char2, "make_char2");
+
+   function make_uchar2 (x : unsigned_char; y : unsigned_char) return vector_types_h.uchar2;  -- vector_functions.h:84
+   pragma Import (C, make_uchar2, "make_uchar2");
+
+   function make_char3
+     (x : signed_char;
+      y : signed_char;
+      z : signed_char) return vector_types_h.char3;  -- vector_functions.h:89
+   pragma Import (C, make_char3, "make_char3");
+
+   function make_uchar3
+     (x : unsigned_char;
+      y : unsigned_char;
+      z : unsigned_char) return vector_types_h.uchar3;  -- vector_functions.h:94
+   pragma Import (C, make_uchar3, "make_uchar3");
+
+   function make_char4
+     (x : signed_char;
+      y : signed_char;
+      z : signed_char;
+      w : signed_char) return vector_types_h.char4;  -- vector_functions.h:99
+   pragma Import (C, make_char4, "make_char4");
+
+   function make_uchar4
+     (x : unsigned_char;
+      y : unsigned_char;
+      z : unsigned_char;
+      w : unsigned_char) return vector_types_h.uchar4;  -- vector_functions.h:104
+   pragma Import (C, make_uchar4, "make_uchar4");
+
+   function make_short1 (x : short) return vector_types_h.short1;  -- vector_functions.h:109
+   pragma Import (C, make_short1, "make_short1");
+
+   function make_ushort1 (x : unsigned_short) return vector_types_h.ushort1;  -- vector_functions.h:114
+   pragma Import (C, make_ushort1, "make_ushort1");
+
+   function make_short2 (x : short; y : short) return vector_types_h.short2;  -- vector_functions.h:119
+   pragma Import (C, make_short2, "make_short2");
+
+   function make_ushort2 (x : unsigned_short; y : unsigned_short) return vector_types_h.ushort2;  -- vector_functions.h:124
+   pragma Import (C, make_ushort2, "make_ushort2");
+
+   function make_short3
+     (x : short;
+      y : short;
+      z : short) return vector_types_h.short3;  -- vector_functions.h:129
+   pragma Import (C, make_short3, "make_short3");
+
+   function make_ushort3
+     (x : unsigned_short;
+      y : unsigned_short;
+      z : unsigned_short) return vector_types_h.ushort3;  -- vector_functions.h:134
+   pragma Import (C, make_ushort3, "make_ushort3");
+
+   function make_short4
+     (x : short;
+      y : short;
+      z : short;
+      w : short) return vector_types_h.short4;  -- vector_functions.h:139
+   pragma Import (C, make_short4, "make_short4");
+
+   function make_ushort4
+     (x : unsigned_short;
+      y : unsigned_short;
+      z : unsigned_short;
+      w : unsigned_short) return vector_types_h.ushort4;  -- vector_functions.h:144
+   pragma Import (C, make_ushort4, "make_ushort4");
+
+   function make_int1 (x : int) return vector_types_h.int1;  -- vector_functions.h:149
+   pragma Import (C, make_int1, "make_int1");
+
+   function make_uint1 (x : unsigned) return vector_types_h.uint1;  -- vector_functions.h:154
+   pragma Import (C, make_uint1, "make_uint1");
+
+   function make_int2 (x : int; y : int) return vector_types_h.int2;  -- vector_functions.h:159
+   pragma Import (C, make_int2, "make_int2");
+
+   function make_uint2 (x : unsigned; y : unsigned) return vector_types_h.uint2;  -- vector_functions.h:164
+   pragma Import (C, make_uint2, "make_uint2");
+
+   function make_int3
+     (x : int;
+      y : int;
+      z : int) return vector_types_h.int3;  -- vector_functions.h:169
+   pragma Import (C, make_int3, "make_int3");
+
+   function make_uint3
+     (x : unsigned;
+      y : unsigned;
+      z : unsigned) return vector_types_h.uint3;  -- vector_functions.h:174
+   pragma Import (C, make_uint3, "make_uint3");
+
+   function make_int4
+     (x : int;
+      y : int;
+      z : int;
+      w : int) return vector_types_h.int4;  -- vector_functions.h:179
+   pragma Import (C, make_int4, "make_int4");
+
+   function make_uint4
+     (x : unsigned;
+      y : unsigned;
+      z : unsigned;
+      w : unsigned) return vector_types_h.uint4;  -- vector_functions.h:184
+   pragma Import (C, make_uint4, "make_uint4");
+
+   function make_long1 (x : long) return vector_types_h.long1;  -- vector_functions.h:189
+   pragma Import (C, make_long1, "make_long1");
+
+   function make_ulong1 (x : unsigned_long) return vector_types_h.ulong1;  -- vector_functions.h:194
+   pragma Import (C, make_ulong1, "make_ulong1");
+
+   function make_long2 (x : long; y : long) return vector_types_h.long2;  -- vector_functions.h:199
+   pragma Import (C, make_long2, "make_long2");
+
+   function make_ulong2 (x : unsigned_long; y : unsigned_long) return vector_types_h.ulong2;  -- vector_functions.h:204
+   pragma Import (C, make_ulong2, "make_ulong2");
+
+   function make_long3
+     (x : long;
+      y : long;
+      z : long) return vector_types_h.long3;  -- vector_functions.h:209
+   pragma Import (C, make_long3, "make_long3");
+
+   function make_ulong3
+     (x : unsigned_long;
+      y : unsigned_long;
+      z : unsigned_long) return vector_types_h.ulong3;  -- vector_functions.h:214
+   pragma Import (C, make_ulong3, "make_ulong3");
+
+   function make_long4
+     (x : long;
+      y : long;
+      z : long;
+      w : long) return vector_types_h.long4;  -- vector_functions.h:219
+   pragma Import (C, make_long4, "make_long4");
+
+   function make_ulong4
+     (x : unsigned_long;
+      y : unsigned_long;
+      z : unsigned_long;
+      w : unsigned_long) return vector_types_h.ulong4;  -- vector_functions.h:224
+   pragma Import (C, make_ulong4, "make_ulong4");
+
+   function make_float1 (x : float) return vector_types_h.float1;  -- vector_functions.h:229
+   pragma Import (C, make_float1, "make_float1");
+
+   function make_float2 (x : float; y : float) return vector_types_h.float2;  -- vector_functions.h:234
+   pragma Import (C, make_float2, "make_float2");
+
+   function make_float3
+     (x : float;
+      y : float;
+      z : float) return vector_types_h.float3;  -- vector_functions.h:239
+   pragma Import (C, make_float3, "make_float3");
+
+   function make_float4
+     (x : float;
+      y : float;
+      z : float;
+      w : float) return vector_types_h.float4;  -- vector_functions.h:244
+   pragma Import (C, make_float4, "make_float4");
+
+   function make_longlong1 (x : Long_Long_Integer) return vector_types_h.longlong1;  -- vector_functions.h:249
+   pragma Import (C, make_longlong1, "make_longlong1");
+
+   function make_ulonglong1 (x : Extensions.unsigned_long_long) return vector_types_h.ulonglong1;  -- vector_functions.h:254
+   pragma Import (C, make_ulonglong1, "make_ulonglong1");
+
+   function make_longlong2 (x : Long_Long_Integer; y : Long_Long_Integer) return vector_types_h.longlong2;  -- vector_functions.h:259
+   pragma Import (C, make_longlong2, "make_longlong2");
+
+   function make_ulonglong2 (x : Extensions.unsigned_long_long; y : Extensions.unsigned_long_long) return vector_types_h.ulonglong2;  -- vector_functions.h:264
+   pragma Import (C, make_ulonglong2, "make_ulonglong2");
+
+   function make_longlong3
+     (x : Long_Long_Integer;
+      y : Long_Long_Integer;
+      z : Long_Long_Integer) return vector_types_h.longlong3;  -- vector_functions.h:269
+   pragma Import (C, make_longlong3, "make_longlong3");
+
+   function make_ulonglong3
+     (x : Extensions.unsigned_long_long;
+      y : Extensions.unsigned_long_long;
+      z : Extensions.unsigned_long_long) return vector_types_h.ulonglong3;  -- vector_functions.h:274
+   pragma Import (C, make_ulonglong3, "make_ulonglong3");
+
+   function make_longlong4
+     (x : Long_Long_Integer;
+      y : Long_Long_Integer;
+      z : Long_Long_Integer;
+      w : Long_Long_Integer) return vector_types_h.longlong4;  -- vector_functions.h:279
+   pragma Import (C, make_longlong4, "make_longlong4");
+
+   function make_ulonglong4
+     (x : Extensions.unsigned_long_long;
+      y : Extensions.unsigned_long_long;
+      z : Extensions.unsigned_long_long;
+      w : Extensions.unsigned_long_long) return vector_types_h.ulonglong4;  -- vector_functions.h:284
+   pragma Import (C, make_ulonglong4, "make_ulonglong4");
+
+   function make_double1 (x : double) return vector_types_h.double1;  -- vector_functions.h:289
+   pragma Import (C, make_double1, "make_double1");
+
+   function make_double2 (x : double; y : double) return vector_types_h.double2;  -- vector_functions.h:294
+   pragma Import (C, make_double2, "make_double2");
+
+   function make_double3
+     (x : double;
+      y : double;
+      z : double) return vector_types_h.double3;  -- vector_functions.h:299
+   pragma Import (C, make_double3, "make_double3");
+
+   function make_double4
+     (x : double;
+      y : double;
+      z : double;
+      w : double) return vector_types_h.double4;  -- vector_functions.h:304
+   pragma Import (C, make_double4, "make_double4");
+
+end vector_functions_h;
diff --git a/thin/vector_types_h.ads b/thin/vector_types_h.ads
new file mode 100644 (file)
index 0000000..49b2e12
--- /dev/null
@@ -0,0 +1,325 @@
+with Interfaces.C; use Interfaces.C;
+with Interfaces.C.Extensions;
+
+package vector_types_h is
+
+   type char1 is record
+      x : aliased signed_char;  -- vector_types.h:94
+   end record;
+   pragma Convention (C_Pass_By_Copy, char1);  -- vector_types.h:92
+
+   type uchar1 is record
+      x : aliased unsigned_char;  -- vector_types.h:100
+   end record;
+   pragma Convention (C_Pass_By_Copy, uchar1);  -- vector_types.h:98
+
+   type char2 is record
+      x : aliased signed_char;  -- vector_types.h:106
+      y : aliased signed_char;  -- vector_types.h:106
+   end record;
+   pragma Convention (C_Pass_By_Copy, char2);  -- vector_types.h:104
+
+   type uchar2 is record
+      x : aliased unsigned_char;  -- vector_types.h:112
+      y : aliased unsigned_char;  -- vector_types.h:112
+   end record;
+   pragma Convention (C_Pass_By_Copy, uchar2);  -- vector_types.h:110
+
+   type char3 is record
+      x : aliased signed_char;  -- vector_types.h:118
+      y : aliased signed_char;  -- vector_types.h:118
+      z : aliased signed_char;  -- vector_types.h:118
+   end record;
+   pragma Convention (C_Pass_By_Copy, char3);  -- vector_types.h:116
+
+   type uchar3 is record
+      x : aliased unsigned_char;  -- vector_types.h:124
+      y : aliased unsigned_char;  -- vector_types.h:124
+      z : aliased unsigned_char;  -- vector_types.h:124
+   end record;
+   pragma Convention (C_Pass_By_Copy, uchar3);  -- vector_types.h:122
+
+   type char4 is record
+      x : aliased signed_char;  -- vector_types.h:130
+      y : aliased signed_char;  -- vector_types.h:130
+      z : aliased signed_char;  -- vector_types.h:130
+      w : aliased signed_char;  -- vector_types.h:130
+   end record;
+   pragma Convention (C_Pass_By_Copy, char4);  -- vector_types.h:128
+
+   type uchar4 is record
+      x : aliased unsigned_char;  -- vector_types.h:136
+      y : aliased unsigned_char;  -- vector_types.h:136
+      z : aliased unsigned_char;  -- vector_types.h:136
+      w : aliased unsigned_char;  -- vector_types.h:136
+   end record;
+   pragma Convention (C_Pass_By_Copy, uchar4);  -- vector_types.h:134
+
+   type short1 is record
+      x : aliased short;  -- vector_types.h:142
+   end record;
+   pragma Convention (C_Pass_By_Copy, short1);  -- vector_types.h:140
+
+   type ushort1 is record
+      x : aliased unsigned_short;  -- vector_types.h:148
+   end record;
+   pragma Convention (C_Pass_By_Copy, ushort1);  -- vector_types.h:146
+
+   type short2 is record
+      x : aliased short;  -- vector_types.h:154
+      y : aliased short;  -- vector_types.h:154
+   end record;
+   pragma Convention (C_Pass_By_Copy, short2);  -- vector_types.h:152
+
+   type ushort2 is record
+      x : aliased unsigned_short;  -- vector_types.h:160
+      y : aliased unsigned_short;  -- vector_types.h:160
+   end record;
+   pragma Convention (C_Pass_By_Copy, ushort2);  -- vector_types.h:158
+
+   type short3 is record
+      x : aliased short;  -- vector_types.h:166
+      y : aliased short;  -- vector_types.h:166
+      z : aliased short;  -- vector_types.h:166
+   end record;
+   pragma Convention (C_Pass_By_Copy, short3);  -- vector_types.h:164
+
+   type ushort3 is record
+      x : aliased unsigned_short;  -- vector_types.h:172
+      y : aliased unsigned_short;  -- vector_types.h:172
+      z : aliased unsigned_short;  -- vector_types.h:172
+   end record;
+   pragma Convention (C_Pass_By_Copy, ushort3);  -- vector_types.h:170
+
+   type short4 is record
+      x : aliased short;  -- vector_types.h:176
+      y : aliased short;  -- vector_types.h:176
+      z : aliased short;  -- vector_types.h:176
+      w : aliased short;  -- vector_types.h:176
+   end record;
+   pragma Convention (C_Pass_By_Copy, short4);  -- vector_types.h:176
+
+   type ushort4 is record
+      x : aliased unsigned_short;  -- vector_types.h:179
+      y : aliased unsigned_short;  -- vector_types.h:179
+      z : aliased unsigned_short;  -- vector_types.h:179
+      w : aliased unsigned_short;  -- vector_types.h:179
+   end record;
+   pragma Convention (C_Pass_By_Copy, ushort4);  -- vector_types.h:179
+
+   type int1 is record
+      x : aliased int;  -- vector_types.h:184
+   end record;
+   pragma Convention (C_Pass_By_Copy, int1);  -- vector_types.h:182
+
+   type uint1 is record
+      x : aliased unsigned;  -- vector_types.h:190
+   end record;
+   pragma Convention (C_Pass_By_Copy, uint1);  -- vector_types.h:188
+
+   type int2 is record
+      x : aliased int;  -- vector_types.h:194
+      y : aliased int;  -- vector_types.h:194
+   end record;
+   pragma Convention (C_Pass_By_Copy, int2);  -- vector_types.h:194
+
+   type uint2 is record
+      x : aliased unsigned;  -- vector_types.h:197
+      y : aliased unsigned;  -- vector_types.h:197
+   end record;
+   pragma Convention (C_Pass_By_Copy, uint2);  -- vector_types.h:197
+
+   type int3 is record
+      x : aliased int;  -- vector_types.h:202
+      y : aliased int;  -- vector_types.h:202
+      z : aliased int;  -- vector_types.h:202
+   end record;
+   pragma Convention (C_Pass_By_Copy, int3);  -- vector_types.h:200
+
+   type uint3 is record
+      x : aliased unsigned;  -- vector_types.h:208
+      y : aliased unsigned;  -- vector_types.h:208
+      z : aliased unsigned;  -- vector_types.h:208
+   end record;
+   pragma Convention (C_Pass_By_Copy, uint3);  -- vector_types.h:206
+
+   type int4 is record
+      x : aliased int;  -- vector_types.h:214
+      y : aliased int;  -- vector_types.h:214
+      z : aliased int;  -- vector_types.h:214
+      w : aliased int;  -- vector_types.h:214
+   end record;
+   pragma Convention (C_Pass_By_Copy, int4);  -- vector_types.h:212
+
+   type uint4 is record
+      x : aliased unsigned;  -- vector_types.h:220
+      y : aliased unsigned;  -- vector_types.h:220
+      z : aliased unsigned;  -- vector_types.h:220
+      w : aliased unsigned;  -- vector_types.h:220
+   end record;
+   pragma Convention (C_Pass_By_Copy, uint4);  -- vector_types.h:218
+
+   type long1 is record
+      x : aliased long;  -- vector_types.h:226
+   end record;
+   pragma Convention (C_Pass_By_Copy, long1);  -- vector_types.h:224
+
+   type ulong1 is record
+      x : aliased unsigned_long;  -- vector_types.h:232
+   end record;
+   pragma Convention (C_Pass_By_Copy, ulong1);  -- vector_types.h:230
+
+   type long2 is record
+      x : aliased long;  -- vector_types.h:248
+      y : aliased long;  -- vector_types.h:248
+   end record;
+   pragma Convention (C_Pass_By_Copy, long2);  -- vector_types.h:246
+
+   type ulong2 is record
+      x : aliased unsigned_long;  -- vector_types.h:254
+      y : aliased unsigned_long;  -- vector_types.h:254
+   end record;
+   pragma Convention (C_Pass_By_Copy, ulong2);  -- vector_types.h:252
+
+   type long3 is record
+      x : aliased long;  -- vector_types.h:262
+      y : aliased long;  -- vector_types.h:262
+      z : aliased long;  -- vector_types.h:262
+   end record;
+   pragma Convention (C_Pass_By_Copy, long3);  -- vector_types.h:260
+
+   type ulong3 is record
+      x : aliased unsigned_long;  -- vector_types.h:268
+      y : aliased unsigned_long;  -- vector_types.h:268
+      z : aliased unsigned_long;  -- vector_types.h:268
+   end record;
+   pragma Convention (C_Pass_By_Copy, ulong3);  -- vector_types.h:266
+
+   type long4 is record
+      x : aliased long;  -- vector_types.h:274
+      y : aliased long;  -- vector_types.h:274
+      z : aliased long;  -- vector_types.h:274
+      w : aliased long;  -- vector_types.h:274
+   end record;
+   pragma Convention (C_Pass_By_Copy, long4);  -- vector_types.h:272
+
+   type ulong4 is record
+      x : aliased unsigned_long;  -- vector_types.h:280
+      y : aliased unsigned_long;  -- vector_types.h:280
+      z : aliased unsigned_long;  -- vector_types.h:280
+      w : aliased unsigned_long;  -- vector_types.h:280
+   end record;
+   pragma Convention (C_Pass_By_Copy, ulong4);  -- vector_types.h:278
+
+   type float1 is record
+      x : aliased float;  -- vector_types.h:286
+   end record;
+   pragma Convention (C_Pass_By_Copy, float1);  -- vector_types.h:284
+
+   type float2 is record
+      x : aliased float;  -- vector_types.h:290
+      y : aliased float;  -- vector_types.h:290
+   end record;
+   pragma Convention (C_Pass_By_Copy, float2);  -- vector_types.h:290
+
+   type float3 is record
+      x : aliased float;  -- vector_types.h:295
+      y : aliased float;  -- vector_types.h:295
+      z : aliased float;  -- vector_types.h:295
+   end record;
+   pragma Convention (C_Pass_By_Copy, float3);  -- vector_types.h:293
+
+   type float4 is record
+      x : aliased float;  -- vector_types.h:301
+      y : aliased float;  -- vector_types.h:301
+      z : aliased float;  -- vector_types.h:301
+      w : aliased float;  -- vector_types.h:301
+   end record;
+   pragma Convention (C_Pass_By_Copy, float4);  -- vector_types.h:299
+
+   type longlong1 is record
+      x : aliased Long_Long_Integer;  -- vector_types.h:307
+   end record;
+   pragma Convention (C_Pass_By_Copy, longlong1);  -- vector_types.h:305
+
+   type ulonglong1 is record
+      x : aliased Extensions.unsigned_long_long;  -- vector_types.h:313
+   end record;
+   pragma Convention (C_Pass_By_Copy, ulonglong1);  -- vector_types.h:311
+
+   type longlong2 is record
+      x : aliased Long_Long_Integer;  -- vector_types.h:319
+      y : aliased Long_Long_Integer;  -- vector_types.h:319
+   end record;
+   pragma Convention (C_Pass_By_Copy, longlong2);  -- vector_types.h:317
+
+   type ulonglong2 is record
+      x : aliased Extensions.unsigned_long_long;  -- vector_types.h:325
+      y : aliased Extensions.unsigned_long_long;  -- vector_types.h:325
+   end record;
+   pragma Convention (C_Pass_By_Copy, ulonglong2);  -- vector_types.h:323
+
+   type longlong3 is record
+      x : aliased Long_Long_Integer;  -- vector_types.h:331
+      y : aliased Long_Long_Integer;  -- vector_types.h:331
+      z : aliased Long_Long_Integer;  -- vector_types.h:331
+   end record;
+   pragma Convention (C_Pass_By_Copy, longlong3);  -- vector_types.h:329
+
+   type ulonglong3 is record
+      x : aliased Extensions.unsigned_long_long;  -- vector_types.h:337
+      y : aliased Extensions.unsigned_long_long;  -- vector_types.h:337
+      z : aliased Extensions.unsigned_long_long;  -- vector_types.h:337
+   end record;
+   pragma Convention (C_Pass_By_Copy, ulonglong3);  -- vector_types.h:335
+
+   type longlong4 is record
+      x : aliased Long_Long_Integer;  -- vector_types.h:343
+      y : aliased Long_Long_Integer;  -- vector_types.h:343
+      z : aliased Long_Long_Integer;  -- vector_types.h:343
+      w : aliased Long_Long_Integer;  -- vector_types.h:343
+   end record;
+   pragma Convention (C_Pass_By_Copy, longlong4);  -- vector_types.h:341
+
+   type ulonglong4 is record
+      x : aliased Extensions.unsigned_long_long;  -- vector_types.h:349
+      y : aliased Extensions.unsigned_long_long;  -- vector_types.h:349
+      z : aliased Extensions.unsigned_long_long;  -- vector_types.h:349
+      w : aliased Extensions.unsigned_long_long;  -- vector_types.h:349
+   end record;
+   pragma Convention (C_Pass_By_Copy, ulonglong4);  -- vector_types.h:347
+
+   type double1 is record
+      x : aliased double;  -- vector_types.h:355
+   end record;
+   pragma Convention (C_Pass_By_Copy, double1);  -- vector_types.h:353
+
+   type double2 is record
+      x : aliased double;  -- vector_types.h:361
+      y : aliased double;  -- vector_types.h:361
+   end record;
+   pragma Convention (C_Pass_By_Copy, double2);  -- vector_types.h:359
+
+   type double3 is record
+      x : aliased double;  -- vector_types.h:367
+      y : aliased double;  -- vector_types.h:367
+      z : aliased double;  -- vector_types.h:367
+   end record;
+   pragma Convention (C_Pass_By_Copy, double3);  -- vector_types.h:365
+
+   type double4 is record
+      x : aliased double;  -- vector_types.h:373
+      y : aliased double;  -- vector_types.h:373
+      z : aliased double;  -- vector_types.h:373
+      w : aliased double;  -- vector_types.h:373
+   end record;
+   pragma Convention (C_Pass_By_Copy, double4);  -- vector_types.h:371
+
+   type dim3 is record
+      x : aliased unsigned;  -- vector_types.h:495
+      y : aliased unsigned;  -- vector_types.h:495
+      z : aliased unsigned;  -- vector_types.h:495
+   end record;
+   pragma Convention (C_Pass_By_Copy, dim3);  -- vector_types.h:493
+
+end vector_types_h;