OpenACC: Update libgomp.texi + openacc{.f90,_lib.h} for 3.1 arg-name changes

This commit handles the following OpenACC 3.1 changes:

First, several argument names were renamed: len -> bytes, a -> data_arg,
async -> async_arg, arg -> wait_arg, devicenum -> dev_num,
and devicetype -> dev_type.

Secondly, it also changed the slightly odd 'type, dimension(:[,:]...)'
to 'type(*), dimension(..)'.

The commit also fixes some minor issues as encountered (wrong function
name in Fortran part of 'acc_async_test_all', bogus 'void' for Fortran,
missing 'void' for C).

Those argument changes had to be also put into the Fortran files, which
this commit does.

NOTE: Those argument names *do* have an effect and can be a breaking
change as Fortran permits using the arg name in the call, e.g.,
   call acc_copyin(a=myVar)  ! old
must now be called either as
   call acc_copyin(data_arg=myVar)  ! new
or as
   call acc_copyin(myVar)  ! works with old and new names
As the latter is way more common, the spec change hopefully does not
break too many programs.

And, finally, it synced over all named constants from openacc.f90 to
config/accel/openacc.f90.

libgomp/ChangeLog:

	* libgomp.texi (OpenACC Runtime Library Routines): Minor fixes
	and update to 3.1 routine argument names.
	* openacc_lib.h: Update routine argument names.
	* openacc.f90: Likewise.
	* config/accel/openacc.f90: Likewise; add all named constants
	that have been accumulated so far.

 libgomp/config/accel/openacc.f90 |   42 +-
 libgomp/libgomp.texi             |  504 ++++++++--------
 libgomp/openacc.f90              | 1200 +++++++++++++++++++-------------------
 libgomp/openacc_lib.h            |  438 +++++++-------
 4 files changed, 1108 insertions(+), 1076 deletions(-)

diff --git a/libgomp/config/accel/openacc.f90 b/libgomp/config/accel/openacc.f90
index 63eaedc02c2..c7526311899 100644
--- a/libgomp/config/accel/openacc.f90
+++ b/libgomp/config/accel/openacc.f90
@@ -53,6 +53,23 @@ module openacc_kinds
   integer (acc_device_kind), parameter :: acc_device_nvidia = 5
   integer (acc_device_kind), parameter :: acc_device_radeon = 8
 
+  integer, parameter :: acc_device_property_kind = int32
+  ! OpenACC 2.6/2.7/3.0 used acc_device_property; in a spec update the
+  ! missing '_kind' was added for consistency.  For backward compatibility, keep:
+  integer, parameter :: acc_device_property = acc_device_property_kind
+
+  ! Keep in sync with 'libgomp/libgomp-plugin.h:goacc_property'.
+  integer (acc_device_property_kind), parameter :: acc_property_memory = 1
+  integer (acc_device_property_kind), parameter :: acc_property_free_memory = 2
+  integer (acc_device_property_kind), parameter :: acc_property_name = int(Z'10001')
+  integer (acc_device_property_kind), parameter :: acc_property_vendor = int(Z'10002')
+  integer (acc_device_property_kind), parameter :: acc_property_driver = int(Z'10003')
+
+  integer, parameter :: acc_handle_kind = int32
+
+  ! Keep in sync with include/gomp-constants.h.
+  integer (acc_handle_kind), parameter :: acc_async_noval = -1
+  integer (acc_handle_kind), parameter :: acc_async_sync = -2
 end module openacc_kinds
 
 module openacc_internal
@@ -60,19 +77,19 @@ module openacc_internal
   implicit none
 
   interface
-    function acc_on_device_h (devicetype)
+    function acc_on_device_h (dev_type)
       import
-      integer (acc_device_kind) devicetype
+      integer (acc_device_kind) dev_type
       logical acc_on_device_h
     end function
   end interface
 
   interface
-    function acc_on_device_l (devicetype) &
+    function acc_on_device_l (dev_type) &
         bind (C, name = "acc_on_device")
       use iso_c_binding, only: c_int
       integer (c_int) :: acc_on_device_l
-      integer (c_int), value :: devicetype
+      integer (c_int), value :: dev_type
     end function
   end interface
 end module openacc_internal
@@ -89,18 +106,29 @@ module openacc
   public :: acc_device_none, acc_device_default, acc_device_host
   public :: acc_device_not_host, acc_device_nvidia, acc_device_radeon
 
+  public :: acc_device_property_kind, acc_device_property
+  public :: acc_property_memory, acc_property_free_memory
+  public :: acc_property_name, acc_property_vendor, acc_property_driver
+
+  public :: acc_handle_kind
+  public :: acc_async_noval, acc_async_sync
+
+  public :: openacc_version
+
   public :: acc_on_device
 
+  integer, parameter :: openacc_version = 201711
+
   interface acc_on_device
     procedure :: acc_on_device_h
   end interface
 
 end module openacc
 
-function acc_on_device_h (devicetype)
+function acc_on_device_h (dev_type)
   use openacc_internal, only: acc_on_device_l
   use openacc_kinds
-  integer (acc_device_kind) devicetype
+  integer (acc_device_kind) dev_type
   logical acc_on_device_h
-  acc_on_device_h = acc_on_device_l (devicetype) /= 0
+  acc_on_device_h = acc_on_device_l (dev_type) /= 0
 end function
diff --git a/libgomp/libgomp.texi b/libgomp/libgomp.texi
index bf5c7a76fc9..226078e4cf1 100644
--- a/libgomp/libgomp.texi
+++ b/libgomp/libgomp.texi
@@ -4271,17 +4271,17 @@ API routines for the OpenACC Profiling Interface.
 @table @asis
 @item @emph{Description}
 This function returns a value indicating the number of devices available
-for the device type specified in @var{devicetype}. 
+for the device type specified in @var{dev_type}.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{int acc_get_num_devices(acc_device_t devicetype);}
+@item @emph{Prototype}: @tab @code{int acc_get_num_devices(acc_device_t dev_type);}
 @end multitable
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{integer function acc_get_num_devices(devicetype)}
-@item                  @tab @code{integer(kind=acc_device_kind) devicetype}
+@item @emph{Interface}: @tab @code{integer function acc_get_num_devices(dev_type)}
+@item                  @tab @code{integer(acc_device_kind) dev_type}
 @end multitable
 
 @item @emph{Reference}:
@@ -4296,17 +4296,17 @@ for the device type specified in @var{devicetype}.
 @table @asis
 @item @emph{Description}
 This function indicates to the runtime library which device type, specified
-in @var{devicetype}, to use when executing a parallel or kernels region. 
+in @var{dev_type}, to use when executing a parallel or kernels region.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_set_device_type(acc_device_t devicetype);}
+@item @emph{Prototype}: @tab @code{void acc_set_device_type(acc_device_t dev_type);}
 @end multitable
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_set_device_type(devicetype)}
-@item                   @tab @code{integer(kind=acc_device_kind) devicetype}
+@item @emph{Interface}: @tab @code{subroutine acc_set_device_type(dev_type)}
+@item                   @tab @code{integer(acc_device_kind) dev_type}
 @end multitable
 
 @item @emph{Reference}:
@@ -4336,8 +4336,8 @@ Interface}), that is, if the device is currently being initialized.
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{function acc_get_device_type(void)}
-@item                  @tab @code{integer(kind=acc_device_kind) acc_get_device_type}
+@item @emph{Interface}: @tab @code{function acc_get_device_type()}
+@item                  @tab @code{integer(acc_device_kind) acc_get_device_type}
 @end multitable
 
 @item @emph{Reference}:
@@ -4352,19 +4352,19 @@ Interface}), that is, if the device is currently being initialized.
 @table @asis
 @item @emph{Description}
 This function will indicate to the runtime which device number,
-specified by @var{devicenum}, associated with the specified device
-type @var{devicetype}.
+specified by @var{dev_num}, associated with the specified device
+type @var{dev_type}.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_set_device_num(int devicenum, acc_device_t devicetype);}
+@item @emph{Prototype}: @tab @code{void acc_set_device_num(int dev_num, acc_device_t dev_type);}
 @end multitable
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_set_device_num(devicenum, devicetype)}
-@item                   @tab @code{integer devicenum}
-@item                   @tab @code{integer(kind=acc_device_kind) devicetype}
+@item @emph{Interface}: @tab @code{subroutine acc_set_device_num(dev_num, dev_type)}
+@item                   @tab @code{integer dev_num}
+@item                   @tab @code{integer(acc_device_kind) dev_type}
 @end multitable
 
 @item @emph{Reference}:
@@ -4379,18 +4379,18 @@ type @var{devicetype}.
 @table @asis
 @item @emph{Description}
 This function returns which device number associated with the specified device
-type @var{devicetype}, will be used when executing a parallel or kernels
+type @var{dev_type}, will be used when executing a parallel or kernels
 region.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{int acc_get_device_num(acc_device_t devicetype);}
+@item @emph{Prototype}: @tab @code{int acc_get_device_num(acc_device_t dev_type);}
 @end multitable
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{function acc_get_device_num(devicetype)}
-@item                   @tab @code{integer(kind=acc_device_kind) devicetype}
+@item @emph{Interface}: @tab @code{function acc_get_device_num(dev_type)}
+@item                   @tab @code{integer(acc_device_kind) dev_type}
 @item                   @tab @code{integer acc_get_device_num}
 @end multitable
 
@@ -4408,7 +4408,7 @@ region.
 @table @asis
 @item @emph{Description}
 These routines return the value of the specified @var{property} for the
-device being queried according to @var{devicenum} and @var{devicetype}.
+device being queried according to @var{dev_num} and @var{dev_type}.
 Integer-valued and string-valued properties are returned by
 @code{acc_get_property} and @code{acc_get_property_string} respectively.
 The Fortran @code{acc_get_property_string} subroutine returns the string
@@ -4425,19 +4425,19 @@ but might be removed in a future version of GCC.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{size_t acc_get_property(int devicenum, acc_device_t devicetype, acc_device_property_t property);}
-@item @emph{Prototype}: @tab @code{const char *acc_get_property_string(int devicenum, acc_device_t devicetype, acc_device_property_t property);}
+@item @emph{Prototype}: @tab @code{size_t acc_get_property(int dev_num, acc_device_t dev_type, acc_device_property_t property);}
+@item @emph{Prototype}: @tab @code{const char *acc_get_property_string(int dev_num, acc_device_t dev_type, acc_device_property_t property);}
 @end multitable
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{function acc_get_property(devicenum, devicetype, property)}
-@item @emph{Interface}: @tab @code{subroutine acc_get_property_string(devicenum, devicetype, property, string)}
+@item @emph{Interface}: @tab @code{function acc_get_property(dev_num, dev_type, property)}
+@item @emph{Interface}: @tab @code{subroutine acc_get_property_string(dev_num, dev_type, property, string)}
 @item                   @tab @code{use ISO_C_Binding, only: c_size_t}
-@item                   @tab @code{integer devicenum}
-@item                   @tab @code{integer(kind=acc_device_kind) devicetype}
-@item                   @tab @code{integer(kind=acc_device_property_kind) property}
-@item                   @tab @code{integer(kind=c_size_t) acc_get_property}
+@item                   @tab @code{integer dev_num}
+@item                   @tab @code{integer(acc_device_kind) dev_type}
+@item                   @tab @code{integer(acc_device_property_kind) property}
+@item                   @tab @code{integer(c_size_t) acc_get_property}
 @item                   @tab @code{character(*) string}
 @end multitable
 
@@ -4453,20 +4453,20 @@ but might be removed in a future version of GCC.
 @table @asis
 @item @emph{Description}
 This function tests for completion of the asynchronous operation specified
-in @var{arg}. In C/C++, a non-zero value is returned to indicate
+in @var{wait_arg}. In C/C++, a non-zero value is returned to indicate
 the specified asynchronous operation has completed while Fortran returns
 @code{true}. If the asynchronous operation has not completed, C/C++ returns
 zero and Fortran returns @code{false}.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{int acc_async_test(int arg);}
+@item @emph{Prototype}: @tab @code{int acc_async_test(int wait_arg);}
 @end multitable
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{function acc_async_test(arg)}
-@item                   @tab @code{integer(kind=acc_handle_kind) arg}
+@item @emph{Interface}: @tab @code{function acc_async_test(wait_arg)}
+@item                   @tab @code{integer(acc_handle_kind) wait_arg}
 @item                   @tab @code{logical acc_async_test}
 @end multitable
 
@@ -4494,8 +4494,8 @@ Fortran returns @code{false}.
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{function acc_async_test()}
-@item                   @tab @code{logical acc_get_device_num}
+@item @emph{Interface}: @tab @code{function acc_async_test_all()}
+@item                   @tab @code{logical acc_async_test_all}
 @end multitable
 
 @item @emph{Reference}:
@@ -4510,20 +4510,20 @@ Fortran returns @code{false}.
 @table @asis
 @item @emph{Description}
 This function waits for completion of the asynchronous operation
-specified in @var{arg}.
+specified in @var{wait_arg}.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_wait(arg);}
-@item @emph{Prototype (OpenACC 1.0 compatibility)}: @tab @code{acc_async_wait(arg);}
+@item @emph{Prototype}: @tab @code{void acc_wait(wait_arg);}
+@item @emph{Prototype (OpenACC 1.0 compatibility)}: @tab @code{void acc_async_wait(wait_arg);}
 @end multitable
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_wait(arg)}
-@item                   @tab @code{integer(acc_handle_kind) arg}
-@item @emph{Interface (OpenACC 1.0 compatibility)}: @tab @code{subroutine acc_async_wait(arg)}
-@item                                               @tab @code{integer(acc_handle_kind) arg}
+@item @emph{Interface}: @tab @code{subroutine acc_wait(wait_arg)}
+@item                   @tab @code{integer(acc_handle_kind) wait_arg}
+@item @emph{Interface (OpenACC 1.0 compatibility)}: @tab @code{subroutine acc_async_wait(wait_arg)}
+@item                                               @tab @code{integer(acc_handle_kind) wait_arg}
 @end multitable
 
 @item @emph{Reference}:
@@ -4541,8 +4541,8 @@ This function waits for the completion of all asynchronous operations.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_wait_all(void);}
-@item @emph{Prototype (OpenACC 1.0 compatibility)}: @tab @code{acc_async_wait_all(void);}
+@item @emph{Prototype}: @tab @code{void acc_wait_all(void);}
+@item @emph{Prototype (OpenACC 1.0 compatibility)}: @tab @code{void acc_async_wait_all(void);}
 @end multitable
 
 @item @emph{Fortran}:
@@ -4562,19 +4562,19 @@ This function waits for the completion of all asynchronous operations.
 @section @code{acc_wait_all_async} -- Wait for completion of all asynchronous operations.
 @table @asis
 @item @emph{Description}
-This function enqueues a wait operation on the queue @var{async} for any
+This function enqueues a wait operation on the queue @var{async_arg} for any
 and all asynchronous operations that have been previously enqueued on
 any queue.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_wait_all_async(int async);}
+@item @emph{Prototype}: @tab @code{void acc_wait_all_async(int async_arg);}
 @end multitable
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_wait_all_async(async)}
-@item                   @tab @code{integer(acc_handle_kind) async}
+@item @emph{Interface}: @tab @code{subroutine acc_wait_all_async(async_arg)}
+@item                   @tab @code{integer(acc_handle_kind) async_arg}
 @end multitable
 
 @item @emph{Reference}:
@@ -4588,18 +4588,18 @@ any queue.
 @section @code{acc_wait_async} -- Wait for completion of asynchronous operations.
 @table @asis
 @item @emph{Description}
-This function enqueues a wait operation on queue @var{async} for any and all
-asynchronous operations enqueued on queue @var{arg}.
+This function enqueues a wait operation on queue @var{async_arg} for any and all
+asynchronous operations enqueued on queue @var{wait_arg}.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_wait_async(int arg, int async);}
+@item @emph{Prototype}: @tab @code{void acc_wait_async(int wait_arg, int async_arg);}
 @end multitable
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_wait_async(arg, async)}
-@item                   @tab @code{integer(acc_handle_kind) arg, async}
+@item @emph{Interface}: @tab @code{subroutine acc_wait_async(wait_arg, async_arg)}
+@item                   @tab @code{integer(acc_handle_kind) wait_arg, async_arg}
 @end multitable
 
 @item @emph{Reference}:
@@ -4614,17 +4614,17 @@ asynchronous operations enqueued on queue @var{arg}.
 @table @asis
 @item @emph{Description}
 This function initializes the runtime for the device type specified in
-@var{devicetype}.
+@var{dev_type}.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_init(acc_device_t devicetype);}
+@item @emph{Prototype}: @tab @code{void acc_init(acc_device_t dev_type);}
 @end multitable
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_init(devicetype)}
-@item                   @tab @code{integer(acc_device_kind) devicetype}
+@item @emph{Interface}: @tab @code{subroutine acc_init(dev_type)}
+@item                   @tab @code{integer(acc_device_kind) dev_type}
 @end multitable
 
 @item @emph{Reference}:
@@ -4639,17 +4639,17 @@ This function initializes the runtime for the device type specified in
 @table @asis
 @item @emph{Description}
 This function shuts down the runtime for the device type specified in
-@var{devicetype}.
+@var{dev_type}.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_shutdown(acc_device_t devicetype);}
+@item @emph{Prototype}: @tab @code{void acc_shutdown(acc_device_t dev_type);}
 @end multitable
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_shutdown(devicetype)}
-@item                   @tab @code{integer(acc_device_kind) devicetype}
+@item @emph{Interface}: @tab @code{subroutine acc_shutdown(dev_type)}
+@item                   @tab @code{integer(acc_device_kind) dev_type}
 @end multitable
 
 @item @emph{Reference}:
@@ -4664,7 +4664,7 @@ This function shuts down the runtime for the device type specified in
 @table @asis
 @item @emph{Description}:
 This function returns whether the program is executing on a particular
-device specified in @var{devicetype}. In C/C++ a non-zero value is
+device specified in @var{dev_type}. In C/C++ a non-zero value is
 returned to indicate the device is executing on the specified device type.
 In Fortran, @code{true} is returned. If the program is not executing
 on the specified device type C/C++ returns zero, while Fortran
@@ -4672,13 +4672,13 @@ returns @code{false}.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_on_device(acc_device_t devicetype);}
+@item @emph{Prototype}: @tab @code{void acc_on_device(acc_device_t dev_type);}
 @end multitable
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{function acc_on_device(devicetype)}
-@item                   @tab @code{integer(acc_device_kind) devicetype}
+@item @emph{Interface}: @tab @code{function acc_on_device(dev_type)}
+@item                   @tab @code{integer(acc_device_kind) dev_type}
 @item                   @tab @code{logical acc_on_device}
 @end multitable
 
@@ -4744,34 +4744,34 @@ Free previously allocated device memory at the device address @code{data_dev}.
 @section @code{acc_copyin} -- Allocate device memory and copy host memory to it.
 @table @asis
 @item @emph{Description}
-In C/C++, this function allocates @var{len} bytes of device memory
-and maps it to the specified host address in @var{a}. The device
+In C/C++, this function allocates @var{bytes} bytes of device memory
+and maps it to the specified host address in @var{data_arg}. The device
 address of the newly allocated device memory is returned.
 
-In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
-a contiguous array section. The second form @var{a} specifies a
-variable or array element and @var{len} specifies the length in bytes.
+In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
+a contiguous array section. The second form @var{data_arg} specifies a
+variable or array element and @var{bytes} specifies the length in bytes.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{void *acc_copyin(h_void *a, size_t len);}
-@item @emph{Prototype}: @tab @code{void *acc_copyin_async(h_void *a, size_t len, int async);}
+@item @emph{Prototype}: @tab @code{void *acc_copyin(h_void *data_arg, size_t bytes);}
+@item @emph{Prototype}: @tab @code{void *acc_copyin_async(h_void *data_arg, size_t bytes, int async_arg);}
 @end multitable
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_copyin(a)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_copyin(a, len)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer len}
-@item @emph{Interface}: @tab @code{subroutine acc_copyin_async(a, async)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer(acc_handle_kind) :: async}
-@item @emph{Interface}: @tab @code{subroutine acc_copyin_async(a, len, async)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer len}
-@item                   @tab @code{integer(acc_handle_kind) :: async}
+@item @emph{Interface}: @tab @code{subroutine acc_copyin(data_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_copyin(data_arg, bytes)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer bytes}
+@item @emph{Interface}: @tab @code{subroutine acc_copyin_async(data_arg, async_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer(acc_handle_kind) :: async_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_copyin_async(data_arg, bytes, async_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer bytes}
+@item                   @tab @code{integer(acc_handle_kind) :: async_arg}
 @end multitable
 
 @item @emph{Reference}:
@@ -4785,36 +4785,36 @@ variable or array element and @var{len} specifies the length in bytes.
 @section @code{acc_present_or_copyin} -- If the data is not present on the device, allocate device memory and copy from host memory.
 @table @asis
 @item @emph{Description}
-This function tests if the host data specified by @var{a} and of length
-@var{len} is present or not. If it is not present, device memory
+This function tests if the host data specified by @var{data_arg} and of length
+@var{bytes} is present or not. If it is not present, device memory
 is allocated and the host memory copied. The device address of
 the newly allocated device memory is returned.
 
-In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
-a contiguous array section. The second form @var{a} specifies a variable or
-array element and @var{len} specifies the length in bytes.
+In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
+a contiguous array section. The second form @var{data_arg} specifies a variable or
+array element and @var{bytes} specifies the length in bytes.
 
 Note that @code{acc_present_or_copyin} and @code{acc_pcopyin} exist for
 backward compatibility with OpenACC 2.0; use @ref{acc_copyin} instead.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{void *acc_present_or_copyin(h_void *a, size_t len);}
-@item @emph{Prototype}: @tab @code{void *acc_pcopyin(h_void *a, size_t len);}
+@item @emph{Prototype}: @tab @code{void *acc_present_or_copyin(h_void *data_arg, size_t bytes);}
+@item @emph{Prototype}: @tab @code{void *acc_pcopyin(h_void *data_arg, size_t bytes);}
 @end multitable
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_present_or_copyin(a)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_present_or_copyin(a, len)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer len}
-@item @emph{Interface}: @tab @code{subroutine acc_pcopyin(a)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_pcopyin(a, len)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer len}
+@item @emph{Interface}: @tab @code{subroutine acc_present_or_copyin(data_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_present_or_copyin(data_arg, bytes)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer bytes}
+@item @emph{Interface}: @tab @code{subroutine acc_pcopyin(data_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_pcopyin(data_arg, bytes)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer bytes}
 @end multitable
 
 @item @emph{Reference}:
@@ -4829,33 +4829,33 @@ backward compatibility with OpenACC 2.0; use @ref{acc_copyin} instead.
 @table @asis
 @item @emph{Description}
 This function allocates device memory and maps it to host memory specified
-by the host address @var{a} with a length of @var{len} bytes. In C/C++,
+by the host address @var{data_arg} with a length of @var{bytes} bytes. In C/C++,
 the function returns the device address of the allocated device memory.
 
-In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
-a contiguous array section. The second form @var{a} specifies a variable or
-array element and @var{len} specifies the length in bytes.
+In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
+a contiguous array section. The second form @var{data_arg} specifies a variable or
+array element and @var{bytes} specifies the length in bytes.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{void *acc_create(h_void *a, size_t len);}
-@item @emph{Prototype}: @tab @code{void *acc_create_async(h_void *a, size_t len, int async);}
+@item @emph{Prototype}: @tab @code{void *acc_create(h_void *data_arg, size_t bytes);}
+@item @emph{Prototype}: @tab @code{void *acc_create_async(h_void *data_arg, size_t bytes, int async_arg);}
 @end multitable
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_create(a)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_create(a, len)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer len}
-@item @emph{Interface}: @tab @code{subroutine acc_create_async(a, async)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer(acc_handle_kind) :: async}
-@item @emph{Interface}: @tab @code{subroutine acc_create_async(a, len, async)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer len}
-@item                   @tab @code{integer(acc_handle_kind) :: async}
+@item @emph{Interface}: @tab @code{subroutine acc_create(data_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_create(data_arg, bytes)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer bytes}
+@item @emph{Interface}: @tab @code{subroutine acc_create_async(data_arg, async_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer(acc_handle_kind) :: async_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_create_async(data_arg, bytes, async_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer bytes}
+@item                   @tab @code{integer(acc_handle_kind) :: async_arg}
 @end multitable
 
 @item @emph{Reference}:
@@ -4869,36 +4869,36 @@ array element and @var{len} specifies the length in bytes.
 @section @code{acc_present_or_create} -- If the data is not present on the device, allocate device memory and map it to host memory.
 @table @asis
 @item @emph{Description}
-This function tests if the host data specified by @var{a} and of length
-@var{len} is present or not. If it is not present, device memory
+This function tests if the host data specified by @var{data_args} and of length
+@var{bytes} is present or not. If it is not present, device memory
 is allocated and mapped to host memory. In C/C++, the device address
 of the newly allocated device memory is returned.
 
-In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
-a contiguous array section. The second form @var{a} specifies a variable or
-array element and @var{len} specifies the length in bytes.
+In Fortran, two (2) forms are supported. In the first form, @var{data_args} specifies
+a contiguous array section. The second form @var{data_args} specifies a variable or
+array element and @var{bytes} specifies the length in bytes.
 
 Note that @code{acc_present_or_create} and @code{acc_pcreate} exist for
 backward compatibility with OpenACC 2.0; use @ref{acc_create} instead.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{void *acc_present_or_create(h_void *a, size_t len)}
-@item @emph{Prototype}: @tab @code{void *acc_pcreate(h_void *a, size_t len)}
+@item @emph{Prototype}: @tab @code{void *acc_present_or_create(h_void *data_args, size_t bytes)}
+@item @emph{Prototype}: @tab @code{void *acc_pcreate(h_void *data_args, size_t bytes)}
 @end multitable
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_present_or_create(a)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_present_or_create(a, len)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer len}
-@item @emph{Interface}: @tab @code{subroutine acc_pcreate(a)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_pcreate(a, len)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer len}
+@item @emph{Interface}: @tab @code{subroutine acc_present_or_create(data_args)}
+@item                   @tab @code{type(*), dimension(..) :: data_args}
+@item @emph{Interface}: @tab @code{subroutine acc_present_or_create(data_args, bytes)}
+@item                   @tab @code{type(*), dimension(..) :: data_args}
+@item                   @tab @code{integer bytes}
+@item @emph{Interface}: @tab @code{subroutine acc_pcreate(data_args)}
+@item                   @tab @code{type(*), dimension(..) :: data_args}
+@item @emph{Interface}: @tab @code{subroutine acc_pcreate(data_args, bytes)}
+@item                   @tab @code{type(*), dimension(..) :: data_args}
+@item                   @tab @code{integer bytes}
 @end multitable
 
 @item @emph{Reference}:
@@ -4913,46 +4913,46 @@ backward compatibility with OpenACC 2.0; use @ref{acc_create} instead.
 @table @asis
 @item @emph{Description}
 This function copies mapped device memory to host memory which is specified
-by host address @var{a} for a length @var{len} bytes in C/C++.
+by host address @var{data_arg} for a length @var{bytes} bytes in C/C++.
 
-In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
-a contiguous array section. The second form @var{a} specifies a variable or
-array element and @var{len} specifies the length in bytes.
+In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
+a contiguous array section. The second form @var{data_arg} specifies a variable or
+array element and @var{bytes} specifies the length in bytes.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_copyout(h_void *a, size_t len);}
-@item @emph{Prototype}: @tab @code{acc_copyout_async(h_void *a, size_t len, int async);}
-@item @emph{Prototype}: @tab @code{acc_copyout_finalize(h_void *a, size_t len);}
-@item @emph{Prototype}: @tab @code{acc_copyout_finalize_async(h_void *a, size_t len, int async);}
+@item @emph{Prototype}: @tab @code{void acc_copyout(h_void *data_arg, size_t bytes);}
+@item @emph{Prototype}: @tab @code{void acc_copyout_async(h_void *data_arg, size_t bytes, int async_arg);}
+@item @emph{Prototype}: @tab @code{void acc_copyout_finalize(h_void *data_arg, size_t bytes);}
+@item @emph{Prototype}: @tab @code{void acc_copyout_finalize_async(h_void *data_arg, size_t bytes, int async_arg);}
 @end multitable
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_copyout(a)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_copyout(a, len)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer len}
-@item @emph{Interface}: @tab @code{subroutine acc_copyout_async(a, async)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer(acc_handle_kind) :: async}
-@item @emph{Interface}: @tab @code{subroutine acc_copyout_async(a, len, async)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer len}
-@item                   @tab @code{integer(acc_handle_kind) :: async}
-@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize(a)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize(a, len)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer len}
-@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize_async(a, async)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer(acc_handle_kind) :: async}
-@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize_async(a, len, async)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer len}
-@item                   @tab @code{integer(acc_handle_kind) :: async}
+@item @emph{Interface}: @tab @code{subroutine acc_copyout(data_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_copyout(data_arg, bytes)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer bytes}
+@item @emph{Interface}: @tab @code{subroutine acc_copyout_async(data_arg, async_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer(acc_handle_kind) :: async_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_copyout_async(data_arg, bytes, async_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer bytes}
+@item                   @tab @code{integer(acc_handle_kind) :: async_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize(data_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize(data_arg, bytes)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer bytes}
+@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize_async(data_arg, async_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer(acc_handle_kind) :: async_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize_async(data_arg, bytes, async_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer bytes}
+@item                   @tab @code{integer(acc_handle_kind) :: async_arg}
 @end multitable
 
 @item @emph{Reference}:
@@ -4967,46 +4967,46 @@ array element and @var{len} specifies the length in bytes.
 @table @asis
 @item @emph{Description}
 This function frees previously allocated device memory specified by
-the device address @var{a} and the length of @var{len} bytes.
+the device address @var{data_arg} and the length of @var{bytes} bytes.
 
-In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
-a contiguous array section. The second form @var{a} specifies a variable or
-array element and @var{len} specifies the length in bytes.
+In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
+a contiguous array section. The second form @var{data_arg} specifies a variable or
+array element and @var{bytes} specifies the length in bytes.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_delete(h_void *a, size_t len);}
-@item @emph{Prototype}: @tab @code{acc_delete_async(h_void *a, size_t len, int async);}
-@item @emph{Prototype}: @tab @code{acc_delete_finalize(h_void *a, size_t len);}
-@item @emph{Prototype}: @tab @code{acc_delete_finalize_async(h_void *a, size_t len, int async);}
+@item @emph{Prototype}: @tab @code{acc_delete(h_void *data_arg, size_t bytes);}
+@item @emph{Prototype}: @tab @code{acc_delete_async(h_void *data_arg, size_t bytes, int async_arg);}
+@item @emph{Prototype}: @tab @code{acc_delete_finalize(h_void *data_arg, size_t bytes);}
+@item @emph{Prototype}: @tab @code{acc_delete_finalize_async(h_void *data_arg, size_t bytes, int async_arg);}
 @end multitable
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_delete(a)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_delete(a, len)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer len}
-@item @emph{Interface}: @tab @code{subroutine acc_delete_async(a, async)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer(acc_handle_kind) :: async}
-@item @emph{Interface}: @tab @code{subroutine acc_delete_async(a, len, async)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer len}
-@item                   @tab @code{integer(acc_handle_kind) :: async}
-@item @emph{Interface}: @tab @code{subroutine acc_delete_finalize(a)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_delete_finalize(a, len)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer len}
-@item @emph{Interface}: @tab @code{subroutine acc_delete_async_finalize(a, async)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer(acc_handle_kind) :: async}
-@item @emph{Interface}: @tab @code{subroutine acc_delete_async_finalize(a, len, async)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer len}
-@item                   @tab @code{integer(acc_handle_kind) :: async}
+@item @emph{Interface}: @tab @code{subroutine acc_delete(data_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_delete(data_arg, bytes)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer bytes}
+@item @emph{Interface}: @tab @code{subroutine acc_delete_async(data_arg, async_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer(acc_handle_kind) :: async_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_delete_async(data_arg, bytes, async_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer bytes}
+@item                   @tab @code{integer(acc_handle_kind) :: async_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_delete_finalize(data_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_delete_finalize(data_arg, bytes)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer bytes}
+@item @emph{Interface}: @tab @code{subroutine acc_delete_async_finalize(data_arg, async_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer(acc_handle_kind) :: async_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_delete_async_finalize(data_arg, bytes, async_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer bytes}
+@item                   @tab @code{integer(acc_handle_kind) :: async_arg}
 @end multitable
 
 @item @emph{Reference}:
@@ -5021,33 +5021,33 @@ array element and @var{len} specifies the length in bytes.
 @table @asis
 @item @emph{Description}
 This function updates the device copy from the previously mapped host memory.
-The host memory is specified with the host address @var{a} and a length of
-@var{len} bytes.
+The host memory is specified with the host address @var{data_arg} and a length of
+@var{bytes} bytes.
 
-In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
-a contiguous array section. The second form @var{a} specifies a variable or
-array element and @var{len} specifies the length in bytes.
+In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
+a contiguous array section. The second form @var{data_arg} specifies a variable or
+array element and @var{bytes} specifies the length in bytes.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_update_device(h_void *a, size_t len);}
-@item @emph{Prototype}: @tab @code{acc_update_device(h_void *a, size_t len, async);}
+@item @emph{Prototype}: @tab @code{void acc_update_device(h_void *data_arg, size_t bytes);}
+@item @emph{Prototype}: @tab @code{void acc_update_device(h_void *data_arg, size_t bytes, async_arg);}
 @end multitable
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_update_device(a)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_update_device(a, len)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer len}
-@item @emph{Interface}: @tab @code{subroutine acc_update_device_async(a, async)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer(acc_handle_kind) :: async}
-@item @emph{Interface}: @tab @code{subroutine acc_update_device_async(a, len, async)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer len}
-@item                   @tab @code{integer(acc_handle_kind) :: async}
+@item @emph{Interface}: @tab @code{subroutine acc_update_device(data_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_update_device(data_arg, bytes)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer bytes}
+@item @emph{Interface}: @tab @code{subroutine acc_update_device_async(data_arg, async_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer(acc_handle_kind) :: async_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_update_device_async(data_arg, bytes, async_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer bytes}
+@item                   @tab @code{integer(acc_handle_kind) :: async_arg}
 @end multitable
 
 @item @emph{Reference}:
@@ -5062,33 +5062,33 @@ array element and @var{len} specifies the length in bytes.
 @table @asis
 @item @emph{Description}
 This function updates the host copy from the previously mapped device memory.
-The host memory is specified with the host address @var{a} and a length of
-@var{len} bytes.
+The host memory is specified with the host address @var{data_arg} and a length of
+@var{bytes} bytes.
 
-In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
-a contiguous array section. The second form @var{a} specifies a variable or
-array element and @var{len} specifies the length in bytes.
+In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
+a contiguous array section. The second form @var{data_arg} specifies a variable or
+array element and @var{bytes} specifies the length in bytes.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_update_self(h_void *a, size_t len);}
-@item @emph{Prototype}: @tab @code{acc_update_self_async(h_void *a, size_t len, int async);}
+@item @emph{Prototype}: @tab @code{acc_update_self(h_void *data_arg, size_t bytes);}
+@item @emph{Prototype}: @tab @code{acc_update_self_async(h_void *data_arg, size_t bytes, int async_arg);}
 @end multitable
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_update_self(a)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_update_self(a, len)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer len}
-@item @emph{Interface}: @tab @code{subroutine acc_update_self_async(a, async)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer(acc_handle_kind) :: async}
-@item @emph{Interface}: @tab @code{subroutine acc_update_self_async(a, len, async)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer len}
-@item                   @tab @code{integer(acc_handle_kind) :: async}
+@item @emph{Interface}: @tab @code{subroutine acc_update_self(data_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_update_self(data_arg, bytes)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer bytes}
+@item @emph{Interface}: @tab @code{subroutine acc_update_self_async(data_arg, async_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer(acc_handle_kind) :: async_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_update_self_async(data_arg, bytes, async_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer bytes}
+@item                   @tab @code{integer(acc_handle_kind) :: async_arg}
 @end multitable
 
 @item @emph{Reference}:
@@ -5209,31 +5209,31 @@ device address specified by @var{data_dev}.
 @section @code{acc_is_present} -- Indicate whether host variable / array is present on device.
 @table @asis
 @item @emph{Description}
-This function indicates whether the specified host address in @var{a} and a
-length of @var{len} bytes is present on the device. In C/C++, a non-zero
+This function indicates whether the specified host address in @var{data_arg} and a
+length of @var{bytes} bytes is present on the device. In C/C++, a non-zero
 value is returned to indicate the presence of the mapped memory on the
 device. A zero is returned to indicate the memory is not mapped on the
 device.
 
-In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
-a contiguous array section. The second form @var{a} specifies a variable or
-array element and @var{len} specifies the length in bytes. If the host
+In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
+a contiguous array section. The second form @var{data_arg} specifies a variable or
+array element and @var{bytes} specifies the length in bytes. If the host
 memory is mapped to device memory, then a @code{true} is returned. Otherwise,
 a @code{false} is return to indicate the mapped memory is not present.
 
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{int acc_is_present(h_void *a, size_t len);}
+@item @emph{Prototype}: @tab @code{int acc_is_present(h_void *data_arg, size_t bytes);}
 @end multitable
 
 @item @emph{Fortran}:
 @multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{function acc_is_present(a)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
+@item @emph{Interface}: @tab @code{function acc_is_present(data_arg)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
 @item                   @tab @code{logical acc_is_present}
-@item @emph{Interface}: @tab @code{function acc_is_present(a, len)}
-@item                   @tab @code{type, dimension(:[,:]...) :: a}
-@item                   @tab @code{integer len}
+@item @emph{Interface}: @tab @code{function acc_is_present(data_arg, bytes)}
+@item                   @tab @code{type(*), dimension(..) :: data_arg}
+@item                   @tab @code{integer bytes}
 @item                   @tab @code{logical acc_is_present}
 @end multitable
 
@@ -5326,7 +5326,7 @@ address to pointing to the corresponding device data.
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
 @item @emph{Prototype}: @tab @code{void acc_attach(h_void **ptr_addr);}
-@item @emph{Prototype}: @tab @code{void acc_attach_async(h_void **ptr_addr, int async);}
+@item @emph{Prototype}: @tab @code{void acc_attach_async(h_void **ptr_addr, int async_arg);}
 @end multitable
 
 @c @item @emph{Fortran}:
@@ -5356,9 +5356,9 @@ address to pointing to the corresponding host data.
 @item @emph{C/C++}:
 @multitable @columnfractions .20 .80
 @item @emph{Prototype}: @tab @code{void acc_detach(h_void **ptr_addr);}
-@item @emph{Prototype}: @tab @code{void acc_detach_async(h_void **ptr_addr, int async);}
+@item @emph{Prototype}: @tab @code{void acc_detach_async(h_void **ptr_addr, int async_arg);}
 @item @emph{Prototype}: @tab @code{void acc_detach_finalize(h_void **ptr_addr);}
-@item @emph{Prototype}: @tab @code{void acc_detach_finalize_async(h_void **ptr_addr, int async);}
+@item @emph{Prototype}: @tab @code{void acc_detach_finalize_async(h_void **ptr_addr, int async_arg);}
 @end multitable
 
 @c @item @emph{Fortran}:
diff --git a/libgomp/openacc.f90 b/libgomp/openacc.f90
index 4e24ee46a97..c5c99b5fa9d 100644
--- a/libgomp/openacc.f90
+++ b/libgomp/openacc.f90
@@ -74,15 +74,15 @@ module openacc_internal
   implicit none
 
   interface
-    function acc_get_num_devices_h (devicetype)
+    function acc_get_num_devices_h (dev_type)
       import
       integer acc_get_num_devices_h
-      integer (acc_device_kind) devicetype
+      integer (acc_device_kind) dev_type
     end function
 
-    subroutine acc_set_device_type_h (devicetype)
+    subroutine acc_set_device_type_h (dev_type)
       import
-      integer (acc_device_kind) devicetype
+      integer (acc_device_kind) dev_type
     end subroutine
 
     function acc_get_device_type_h ()
@@ -90,435 +90,435 @@ module openacc_internal
       integer (acc_device_kind) acc_get_device_type_h
     end function
 
-    subroutine acc_set_device_num_h (devicenum, devicetype)
+    subroutine acc_set_device_num_h (dev_num, dev_type)
       import
-      integer devicenum
-      integer (acc_device_kind) devicetype
+      integer dev_num
+      integer (acc_device_kind) dev_type
     end subroutine
 
-    function acc_get_device_num_h (devicetype)
+    function acc_get_device_num_h (dev_type)
       import
       integer acc_get_device_num_h
-      integer (acc_device_kind) devicetype
+      integer (acc_device_kind) dev_type
     end function
 
-    function acc_get_property_h (devicenum, devicetype, property)
+    function acc_get_property_h (dev_num, dev_type, property)
       use iso_c_binding, only: c_size_t
       import
       implicit none (type, external)
       integer (c_size_t) :: acc_get_property_h
-      integer, value :: devicenum
-      integer (acc_device_kind), value :: devicetype
+      integer, value :: dev_num
+      integer (acc_device_kind), value :: dev_type
       integer (acc_device_property_kind), value :: property
     end function
 
-    subroutine acc_get_property_string_h (devicenum, devicetype, property, string)
+    subroutine acc_get_property_string_h (dev_num, dev_type, property, string)
       import
       implicit none (type, external)
-      integer, value :: devicenum
-      integer (acc_device_kind), value :: devicetype
+      integer, value :: dev_num
+      integer (acc_device_kind), value :: dev_type
       integer (acc_device_property_kind), value :: property
       character (*) :: string
     end subroutine
 
-    function acc_async_test_h (arg)
+    function acc_async_test_h (wait_arg)
       logical acc_async_test_h
-      integer arg
+      integer wait_arg
     end function
 
     function acc_async_test_all_h ()
       logical acc_async_test_all_h
     end function
 
-    subroutine acc_wait_h (arg)
-      integer arg
+    subroutine acc_wait_h (wait_arg)
+      integer wait_arg
     end subroutine
 
-    subroutine acc_wait_async_h (arg, async)
-      integer arg, async
+    subroutine acc_wait_async_h (wait_arg, async_arg)
+      integer wait_arg, async_arg
     end subroutine
 
     subroutine acc_wait_all_h ()
     end subroutine
 
-    subroutine acc_wait_all_async_h (async)
-      integer async
+    subroutine acc_wait_all_async_h (async_arg)
+      integer async_arg
     end subroutine
 
-    subroutine acc_init_h (devicetype)
+    subroutine acc_init_h (dev_type)
       import
-      integer (acc_device_kind) devicetype
+      integer (acc_device_kind) dev_type
     end subroutine
 
-    subroutine acc_shutdown_h (devicetype)
+    subroutine acc_shutdown_h (dev_type)
       import
-      integer (acc_device_kind) devicetype
+      integer (acc_device_kind) dev_type
     end subroutine
 
-    function acc_on_device_h (devicetype)
+    function acc_on_device_h (dev_type)
       import
-      integer (acc_device_kind) devicetype
+      integer (acc_device_kind) dev_type
       logical acc_on_device_h
     end function
 
-    subroutine acc_copyin_32_h (a, len)
+    subroutine acc_copyin_32_h (data_arg, bytes)
       use iso_c_binding, only: c_int32_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int32_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int32_t) bytes
     end subroutine
 
-    subroutine acc_copyin_64_h (a, len)
+    subroutine acc_copyin_64_h (data_arg, bytes)
       use iso_c_binding, only: c_int64_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int64_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int64_t) bytes
     end subroutine
 
-    subroutine acc_copyin_array_h (a)
-      type (*), dimension (..), contiguous :: a
+    subroutine acc_copyin_array_h (data_arg)
+      type (*), dimension (..), contiguous :: data_arg
     end subroutine
 
-    subroutine acc_present_or_copyin_32_h (a, len)
+    subroutine acc_present_or_copyin_32_h (data_arg, bytes)
       use iso_c_binding, only: c_int32_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int32_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int32_t) bytes
     end subroutine
 
-    subroutine acc_present_or_copyin_64_h (a, len)
+    subroutine acc_present_or_copyin_64_h (data_arg, bytes)
       use iso_c_binding, only: c_int64_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int64_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int64_t) bytes
     end subroutine
 
-    subroutine acc_present_or_copyin_array_h (a)
-      type (*), dimension (..), contiguous :: a
+    subroutine acc_present_or_copyin_array_h (data_arg)
+      type (*), dimension (..), contiguous :: data_arg
     end subroutine
 
-    subroutine acc_create_32_h (a, len)
+    subroutine acc_create_32_h (data_arg, bytes)
       use iso_c_binding, only: c_int32_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int32_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int32_t) bytes
     end subroutine
 
-    subroutine acc_create_64_h (a, len)
+    subroutine acc_create_64_h (data_arg, bytes)
       use iso_c_binding, only: c_int64_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int64_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int64_t) bytes
     end subroutine
 
-    subroutine acc_create_array_h (a)
-      type (*), dimension (..), contiguous :: a
+    subroutine acc_create_array_h (data_arg)
+      type (*), dimension (..), contiguous :: data_arg
     end subroutine
 
-    subroutine acc_present_or_create_32_h (a, len)
+    subroutine acc_present_or_create_32_h (data_arg, bytes)
       use iso_c_binding, only: c_int32_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int32_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int32_t) bytes
     end subroutine
 
-    subroutine acc_present_or_create_64_h (a, len)
+    subroutine acc_present_or_create_64_h (data_arg, bytes)
       use iso_c_binding, only: c_int64_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int64_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int64_t) bytes
     end subroutine
 
-    subroutine acc_present_or_create_array_h (a)
-      type (*), dimension (..), contiguous :: a
+    subroutine acc_present_or_create_array_h (data_arg)
+      type (*), dimension (..), contiguous :: data_arg
     end subroutine
 
-    subroutine acc_copyout_32_h (a, len)
+    subroutine acc_copyout_32_h (data_arg, bytes)
       use iso_c_binding, only: c_int32_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int32_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int32_t) bytes
     end subroutine
 
-    subroutine acc_copyout_64_h (a, len)
+    subroutine acc_copyout_64_h (data_arg, bytes)
       use iso_c_binding, only: c_int64_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int64_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int64_t) bytes
     end subroutine
 
-    subroutine acc_copyout_array_h (a)
-      type (*), dimension (..), contiguous :: a
+    subroutine acc_copyout_array_h (data_arg)
+      type (*), dimension (..), contiguous :: data_arg
     end subroutine
 
-    subroutine acc_copyout_finalize_32_h (a, len)
+    subroutine acc_copyout_finalize_32_h (data_arg, bytes)
       use iso_c_binding, only: c_int32_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int32_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int32_t) bytes
     end subroutine
 
-    subroutine acc_copyout_finalize_64_h (a, len)
+    subroutine acc_copyout_finalize_64_h (data_arg, bytes)
       use iso_c_binding, only: c_int64_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int64_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int64_t) bytes
     end subroutine
 
-    subroutine acc_copyout_finalize_array_h (a)
-      type (*), dimension (..), contiguous :: a
+    subroutine acc_copyout_finalize_array_h (data_arg)
+      type (*), dimension (..), contiguous :: data_arg
     end subroutine
 
-    subroutine acc_delete_32_h (a, len)
+    subroutine acc_delete_32_h (data_arg, bytes)
       use iso_c_binding, only: c_int32_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int32_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int32_t) bytes
     end subroutine
 
-    subroutine acc_delete_64_h (a, len)
+    subroutine acc_delete_64_h (data_arg, bytes)
       use iso_c_binding, only: c_int64_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int64_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int64_t) bytes
     end subroutine
 
-    subroutine acc_delete_array_h (a)
-      type (*), dimension (..), contiguous :: a
+    subroutine acc_delete_array_h (data_arg)
+      type (*), dimension (..), contiguous :: data_arg
     end subroutine
 
-    subroutine acc_delete_finalize_32_h (a, len)
+    subroutine acc_delete_finalize_32_h (data_arg, bytes)
       use iso_c_binding, only: c_int32_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int32_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int32_t) bytes
     end subroutine
 
-    subroutine acc_delete_finalize_64_h (a, len)
+    subroutine acc_delete_finalize_64_h (data_arg, bytes)
       use iso_c_binding, only: c_int64_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int64_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int64_t) bytes
     end subroutine
 
-    subroutine acc_delete_finalize_array_h (a)
-      type (*), dimension (..), contiguous :: a
+    subroutine acc_delete_finalize_array_h (data_arg)
+      type (*), dimension (..), contiguous :: data_arg
     end subroutine
 
-    subroutine acc_update_device_32_h (a, len)
+    subroutine acc_update_device_32_h (data_arg, bytes)
       use iso_c_binding, only: c_int32_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int32_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int32_t) bytes
     end subroutine
 
-    subroutine acc_update_device_64_h (a, len)
+    subroutine acc_update_device_64_h (data_arg, bytes)
       use iso_c_binding, only: c_int64_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int64_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int64_t) bytes
     end subroutine
 
-    subroutine acc_update_device_array_h (a)
-      type (*), dimension (..), contiguous :: a
+    subroutine acc_update_device_array_h (data_arg)
+      type (*), dimension (..), contiguous :: data_arg
     end subroutine
 
-    subroutine acc_update_self_32_h (a, len)
+    subroutine acc_update_self_32_h (data_arg, bytes)
       use iso_c_binding, only: c_int32_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int32_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int32_t) bytes
     end subroutine
 
-    subroutine acc_update_self_64_h (a, len)
+    subroutine acc_update_self_64_h (data_arg, bytes)
       use iso_c_binding, only: c_int64_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int64_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int64_t) bytes
     end subroutine
 
-    subroutine acc_update_self_array_h (a)
-      type (*), dimension (..), contiguous :: a
+    subroutine acc_update_self_array_h (data_arg)
+      type (*), dimension (..), contiguous :: data_arg
     end subroutine
 
-    function acc_is_present_32_h (a, len)
+    function acc_is_present_32_h (data_arg, bytes)
       use iso_c_binding, only: c_int32_t
       logical acc_is_present_32_h
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int32_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int32_t) bytes
     end function
 
-    function acc_is_present_64_h (a, len)
+    function acc_is_present_64_h (data_arg, bytes)
       use iso_c_binding, only: c_int64_t
       logical acc_is_present_64_h
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int64_t) len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int64_t) bytes
     end function
 
-    function acc_is_present_array_h (a)
+    function acc_is_present_array_h (data_arg)
       logical acc_is_present_array_h
-      type (*), dimension (..), contiguous :: a
+      type (*), dimension (..), contiguous :: data_arg
     end function
 
-    subroutine acc_copyin_async_32_h (a, len, async)
+    subroutine acc_copyin_async_32_h (data_arg, bytes, async_arg)
       use iso_c_binding, only: c_int32_t
       use openacc_kinds, only: acc_handle_kind
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int32_t) len
-      integer (acc_handle_kind) async
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int32_t) bytes
+      integer (acc_handle_kind) async_arg
     end subroutine
 
-    subroutine acc_copyin_async_64_h (a, len, async)
+    subroutine acc_copyin_async_64_h (data_arg, bytes, async_arg)
       use iso_c_binding, only: c_int64_t
       use openacc_kinds, only: acc_handle_kind
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int64_t) len
-      integer (acc_handle_kind) async
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int64_t) bytes
+      integer (acc_handle_kind) async_arg
     end subroutine
 
-    subroutine acc_copyin_async_array_h (a, async)
+    subroutine acc_copyin_async_array_h (data_arg, async_arg)
       use openacc_kinds, only: acc_handle_kind
-      type (*), dimension (..), contiguous :: a
-      integer (acc_handle_kind) async
+      type (*), dimension (..), contiguous :: data_arg
+      integer (acc_handle_kind) async_arg
     end subroutine
 
-    subroutine acc_create_async_32_h (a, len, async)
+    subroutine acc_create_async_32_h (data_arg, bytes, async_arg)
       use iso_c_binding, only: c_int32_t
       use openacc_kinds, only: acc_handle_kind
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int32_t) len
-      integer (acc_handle_kind) async
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int32_t) bytes
+      integer (acc_handle_kind) async_arg
     end subroutine
 
-    subroutine acc_create_async_64_h (a, len, async)
+    subroutine acc_create_async_64_h (data_arg, bytes, async_arg)
       use iso_c_binding, only: c_int64_t
       use openacc_kinds, only: acc_handle_kind
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int64_t) len
-      integer (acc_handle_kind) async
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int64_t) bytes
+      integer (acc_handle_kind) async_arg
     end subroutine
 
-    subroutine acc_create_async_array_h (a, async)
+    subroutine acc_create_async_array_h (data_arg, async_arg)
       use openacc_kinds, only: acc_handle_kind
-      type (*), dimension (..), contiguous :: a
-      integer (acc_handle_kind) async
+      type (*), dimension (..), contiguous :: data_arg
+      integer (acc_handle_kind) async_arg
     end subroutine
 
-    subroutine acc_copyout_async_32_h (a, len, async)
+    subroutine acc_copyout_async_32_h (data_arg, bytes, async_arg)
       use iso_c_binding, only: c_int32_t
       use openacc_kinds, only: acc_handle_kind
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int32_t) len
-      integer (acc_handle_kind) async
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int32_t) bytes
+      integer (acc_handle_kind) async_arg
     end subroutine
 
-    subroutine acc_copyout_async_64_h (a, len, async)
+    subroutine acc_copyout_async_64_h (data_arg, bytes, async_arg)
       use iso_c_binding, only: c_int64_t
       use openacc_kinds, only: acc_handle_kind
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int64_t) len
-      integer (acc_handle_kind) async
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int64_t) bytes
+      integer (acc_handle_kind) async_arg
     end subroutine
 
-    subroutine acc_copyout_async_array_h (a, async)
+    subroutine acc_copyout_async_array_h (data_arg, async_arg)
       use openacc_kinds, only: acc_handle_kind
-      type (*), dimension (..), contiguous :: a
-      integer (acc_handle_kind) async
+      type (*), dimension (..), contiguous :: data_arg
+      integer (acc_handle_kind) async_arg
     end subroutine
 
-    subroutine acc_delete_async_32_h (a, len, async)
+    subroutine acc_delete_async_32_h (data_arg, bytes, async_arg)
       use iso_c_binding, only: c_int32_t
       use openacc_kinds, only: acc_handle_kind
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int32_t) len
-      integer (acc_handle_kind) async
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int32_t) bytes
+      integer (acc_handle_kind) async_arg
     end subroutine
 
-    subroutine acc_delete_async_64_h (a, len, async)
+    subroutine acc_delete_async_64_h (data_arg, bytes, async_arg)
       use iso_c_binding, only: c_int64_t
       use openacc_kinds, only: acc_handle_kind
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int64_t) len
-      integer (acc_handle_kind) async
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int64_t) bytes
+      integer (acc_handle_kind) async_arg
     end subroutine
 
-    subroutine acc_delete_async_array_h (a, async)
+    subroutine acc_delete_async_array_h (data_arg, async_arg)
       use openacc_kinds, only: acc_handle_kind
-      type (*), dimension (..), contiguous :: a
-      integer (acc_handle_kind) async
+      type (*), dimension (..), contiguous :: data_arg
+      integer (acc_handle_kind) async_arg
     end subroutine
 
-    subroutine acc_update_device_async_32_h (a, len, async)
+    subroutine acc_update_device_async_32_h (data_arg, bytes, async_arg)
       use iso_c_binding, only: c_int32_t
       use openacc_kinds, only: acc_handle_kind
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int32_t) len
-      integer (acc_handle_kind) async
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int32_t) bytes
+      integer (acc_handle_kind) async_arg
     end subroutine
 
-    subroutine acc_update_device_async_64_h (a, len, async)
+    subroutine acc_update_device_async_64_h (data_arg, bytes, async_arg)
       use iso_c_binding, only: c_int64_t
       use openacc_kinds, only: acc_handle_kind
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int64_t) len
-      integer (acc_handle_kind) async
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int64_t) bytes
+      integer (acc_handle_kind) async_arg
     end subroutine
 
-    subroutine acc_update_device_async_array_h (a, async)
+    subroutine acc_update_device_async_array_h (data_arg, async_arg)
       use openacc_kinds, only: acc_handle_kind
-      type (*), dimension (..), contiguous :: a
-      integer (acc_handle_kind) async
+      type (*), dimension (..), contiguous :: data_arg
+      integer (acc_handle_kind) async_arg
     end subroutine
 
-    subroutine acc_update_self_async_32_h (a, len, async)
+    subroutine acc_update_self_async_32_h (data_arg, bytes, async_arg)
       use iso_c_binding, only: c_int32_t
       use openacc_kinds, only: acc_handle_kind
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int32_t) len
-      integer (acc_handle_kind) async
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int32_t) bytes
+      integer (acc_handle_kind) async_arg
     end subroutine
 
-    subroutine acc_update_self_async_64_h (a, len, async)
+    subroutine acc_update_self_async_64_h (data_arg, bytes, async_arg)
       use iso_c_binding, only: c_int64_t
       use openacc_kinds, only: acc_handle_kind
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_int64_t) len
-      integer (acc_handle_kind) async
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_int64_t) bytes
+      integer (acc_handle_kind) async_arg
     end subroutine
 
-    subroutine acc_update_self_async_array_h (a, async)
+    subroutine acc_update_self_async_array_h (data_arg, async_arg)
       use openacc_kinds, only: acc_handle_kind
-      type (*), dimension (..), contiguous :: a
-      integer (acc_handle_kind) async
+      type (*), dimension (..), contiguous :: data_arg
+      integer (acc_handle_kind) async_arg
     end subroutine
   end interface
 
   interface
-    function acc_get_num_devices_l (devicetype) &
+    function acc_get_num_devices_l (dev_type) &
         bind (C, name = "acc_get_num_devices")
       use iso_c_binding, only: c_int
       integer (c_int) :: acc_get_num_devices_l
-      integer (c_int), value :: devicetype
+      integer (c_int), value :: dev_type
     end function
 
-    subroutine acc_set_device_type_l (devicetype) &
+    subroutine acc_set_device_type_l (dev_type) &
         bind (C, name = "acc_set_device_type")
       use iso_c_binding, only: c_int
-      integer (c_int), value :: devicetype
+      integer (c_int), value :: dev_type
     end subroutine
 
     function acc_get_device_type_l () &
@@ -527,44 +527,44 @@ module openacc_internal
       integer (c_int) :: acc_get_device_type_l
     end function
 
-    subroutine acc_set_device_num_l (devicenum, devicetype) &
+    subroutine acc_set_device_num_l (dev_num, dev_type) &
         bind (C, name = "acc_set_device_num")
       use iso_c_binding, only: c_int
-      integer (c_int), value :: devicenum, devicetype
+      integer (c_int), value :: dev_num, dev_type
     end subroutine
 
-    function acc_get_device_num_l (devicetype) &
+    function acc_get_device_num_l (dev_type) &
         bind (C, name = "acc_get_device_num")
       use iso_c_binding, only: c_int
       integer (c_int) :: acc_get_device_num_l
-      integer (c_int), value :: devicetype
+      integer (c_int), value :: dev_type
     end function
 
-    function acc_get_property_l (devicenum, devicetype, property) &
+    function acc_get_property_l (dev_num, dev_type, property) &
         bind (C, name = "acc_get_property")
       use iso_c_binding, only: c_int, c_size_t
       implicit none (type, external)
       integer (c_size_t) :: acc_get_property_l
-      integer (c_int), value :: devicenum
-      integer (c_int), value :: devicetype
+      integer (c_int), value :: dev_num
+      integer (c_int), value :: dev_type
       integer (c_int), value :: property
     end function
 
-    function acc_get_property_string_l (devicenum, devicetype, property) &
+    function acc_get_property_string_l (dev_num, dev_type, property) &
         bind (C, name = "acc_get_property_string")
       use iso_c_binding, only: c_int, c_ptr
       implicit none (type, external)
       type (c_ptr) :: acc_get_property_string_l
-      integer (c_int), value :: devicenum
-      integer (c_int), value :: devicetype
+      integer (c_int), value :: dev_num
+      integer (c_int), value :: dev_type
       integer (c_int), value :: property
     end function
 
-    function acc_async_test_l (a) &
+    function acc_async_test_l (data_arg) &
         bind (C, name = "acc_async_test")
       use iso_c_binding, only: c_int
       integer (c_int) :: acc_async_test_l
-      integer (c_int), value :: a
+      integer (c_int), value :: data_arg
     end function
 
     function acc_async_test_all_l () &
@@ -573,16 +573,16 @@ module openacc_internal
       integer (c_int) :: acc_async_test_all_l
     end function
 
-    subroutine acc_wait_l (a) &
+    subroutine acc_wait_l (data_arg) &
         bind (C, name = "acc_wait")
       use iso_c_binding, only: c_int
-      integer (c_int), value :: a
+      integer (c_int), value :: data_arg
     end subroutine
 
-    subroutine acc_wait_async_l (arg, async) &
+    subroutine acc_wait_async_l (wait_arg, async_arg) &
         bind (C, name = "acc_wait_async")
       use iso_c_binding, only: c_int
-      integer (c_int), value :: arg, async
+      integer (c_int), value :: wait_arg, async_arg
     end subroutine
 
     subroutine acc_wait_all_l () &
@@ -590,172 +590,172 @@ module openacc_internal
       use iso_c_binding, only: c_int
     end subroutine
 
-    subroutine acc_wait_all_async_l (async) &
+    subroutine acc_wait_all_async_l (async_arg) &
         bind (C, name = "acc_wait_all_async")
       use iso_c_binding, only: c_int
-      integer (c_int), value :: async
+      integer (c_int), value :: async_arg
     end subroutine
 
-    subroutine acc_init_l (devicetype) &
+    subroutine acc_init_l (dev_type) &
         bind (C, name = "acc_init")
       use iso_c_binding, only: c_int
-      integer (c_int), value :: devicetype
+      integer (c_int), value :: dev_type
     end subroutine
 
-    subroutine acc_shutdown_l (devicetype) &
+    subroutine acc_shutdown_l (dev_type) &
         bind (C, name = "acc_shutdown")
       use iso_c_binding, only: c_int
-      integer (c_int), value :: devicetype
+      integer (c_int), value :: dev_type
     end subroutine
 
-    function acc_on_device_l (devicetype) &
+    function acc_on_device_l (dev_type) &
         bind (C, name = "acc_on_device")
       use iso_c_binding, only: c_int
       integer (c_int) :: acc_on_device_l
-      integer (c_int), value :: devicetype
+      integer (c_int), value :: dev_type
     end function
 
-    subroutine acc_copyin_l (a, len) &
+    subroutine acc_copyin_l (data_arg, bytes) &
         bind (C, name = "acc_copyin")
       use iso_c_binding, only: c_size_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_size_t), value :: len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_size_t), value :: bytes
     end subroutine
 
-    subroutine acc_present_or_copyin_l (a, len) &
+    subroutine acc_present_or_copyin_l (data_arg, bytes) &
         bind (C, name = "acc_present_or_copyin")
       use iso_c_binding, only: c_size_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_size_t), value :: len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_size_t), value :: bytes
     end subroutine
 
-    subroutine acc_create_l (a, len) &
+    subroutine acc_create_l (data_arg, bytes) &
         bind (C, name = "acc_create")
       use iso_c_binding, only: c_size_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_size_t), value :: len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_size_t), value :: bytes
     end subroutine
 
-    subroutine acc_present_or_create_l (a, len) &
+    subroutine acc_present_or_create_l (data_arg, bytes) &
         bind (C, name = "acc_present_or_create")
       use iso_c_binding, only: c_size_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_size_t), value :: len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_size_t), value :: bytes
     end subroutine
 
-    subroutine acc_copyout_l (a, len) &
+    subroutine acc_copyout_l (data_arg, bytes) &
         bind (C, name = "acc_copyout")
       use iso_c_binding, only: c_size_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_size_t), value :: len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_size_t), value :: bytes
     end subroutine
 
-    subroutine acc_copyout_finalize_l (a, len) &
+    subroutine acc_copyout_finalize_l (data_arg, bytes) &
         bind (C, name = "acc_copyout_finalize")
       use iso_c_binding, only: c_size_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_size_t), value :: len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_size_t), value :: bytes
     end subroutine
 
-    subroutine acc_delete_l (a, len) &
+    subroutine acc_delete_l (data_arg, bytes) &
         bind (C, name = "acc_delete")
       use iso_c_binding, only: c_size_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_size_t), value :: len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_size_t), value :: bytes
     end subroutine
 
-    subroutine acc_delete_finalize_l (a, len) &
+    subroutine acc_delete_finalize_l (data_arg, bytes) &
         bind (C, name = "acc_delete_finalize")
       use iso_c_binding, only: c_size_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_size_t), value :: len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_size_t), value :: bytes
     end subroutine
 
-    subroutine acc_update_device_l (a, len) &
+    subroutine acc_update_device_l (data_arg, bytes) &
         bind (C, name = "acc_update_device")
       use iso_c_binding, only: c_size_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_size_t), value :: len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_size_t), value :: bytes
     end subroutine
 
-    subroutine acc_update_self_l (a, len) &
+    subroutine acc_update_self_l (data_arg, bytes) &
         bind (C, name = "acc_update_self")
       use iso_c_binding, only: c_size_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_size_t), value :: len
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_size_t), value :: bytes
     end subroutine
 
-    function acc_is_present_l (a, len) &
+    function acc_is_present_l (data_arg, bytes) &
         bind (C, name = "acc_is_present")
       use iso_c_binding, only: c_int32_t, c_size_t
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
       integer (c_int32_t) :: acc_is_present_l
-      type (*), dimension (*) :: a
-      integer (c_size_t), value :: len
+      type (*), dimension (*) :: data_arg
+      integer (c_size_t), value :: bytes
     end function
 
-    subroutine acc_copyin_async_l (a, len, async) &
+    subroutine acc_copyin_async_l (data_arg, bytes, async_arg) &
         bind (C, name = "acc_copyin_async")
       use iso_c_binding, only: c_size_t, c_int
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_size_t), value :: len
-      integer (c_int), value :: async
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_size_t), value :: bytes
+      integer (c_int), value :: async_arg
     end subroutine
 
-    subroutine acc_create_async_l (a, len, async) &
+    subroutine acc_create_async_l (data_arg, bytes, async_arg) &
         bind (C, name = "acc_create_async")
       use iso_c_binding, only: c_size_t, c_int
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_size_t), value :: len
-      integer (c_int), value :: async
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_size_t), value :: bytes
+      integer (c_int), value :: async_arg
     end subroutine
 
-    subroutine acc_copyout_async_l (a, len, async) &
+    subroutine acc_copyout_async_l (data_arg, bytes, async_arg) &
         bind (C, name = "acc_copyout_async")
       use iso_c_binding, only: c_size_t, c_int
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_size_t), value :: len
-      integer (c_int), value :: async
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_size_t), value :: bytes
+      integer (c_int), value :: async_arg
     end subroutine
 
-    subroutine acc_delete_async_l (a, len, async) &
+    subroutine acc_delete_async_l (data_arg, bytes, async_arg) &
         bind (C, name = "acc_delete_async")
       use iso_c_binding, only: c_size_t, c_int
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_size_t), value :: len
-      integer (c_int), value :: async
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_size_t), value :: bytes
+      integer (c_int), value :: async_arg
     end subroutine
 
-    subroutine acc_update_device_async_l (a, len, async) &
+    subroutine acc_update_device_async_l (data_arg, bytes, async_arg) &
         bind (C, name = "acc_update_device_async")
       use iso_c_binding, only: c_size_t, c_int
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_size_t), value :: len
-      integer (c_int), value :: async
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_size_t), value :: bytes
+      integer (c_int), value :: async_arg
     end subroutine
 
-    subroutine acc_update_self_async_l (a, len, async) &
+    subroutine acc_update_self_async_l (data_arg, bytes, async_arg) &
         bind (C, name = "acc_update_self_async")
       use iso_c_binding, only: c_size_t, c_int
-      !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-      type (*), dimension (*) :: a
-      integer (c_size_t), value :: len
-      integer (c_int), value :: async
+      !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+      type (*), dimension (*) :: data_arg
+      integer (c_size_t), value :: bytes
+      integer (c_int), value :: async_arg
     end subroutine
   end interface
 end module openacc_internal
@@ -1084,19 +1084,19 @@ module openacc
 
 end module openacc
 
-function acc_get_num_devices_h (devicetype)
+function acc_get_num_devices_h (dev_type)
   use openacc_internal, only: acc_get_num_devices_l
   use openacc_kinds
   integer acc_get_num_devices_h
-  integer (acc_device_kind) devicetype
-  acc_get_num_devices_h = acc_get_num_devices_l (devicetype)
+  integer (acc_device_kind) dev_type
+  acc_get_num_devices_h = acc_get_num_devices_l (dev_type)
 end function
 
-subroutine acc_set_device_type_h (devicetype)
+subroutine acc_set_device_type_h (dev_type)
   use openacc_internal, only: acc_set_device_type_l
   use openacc_kinds
-  integer (acc_device_kind) devicetype
-  call acc_set_device_type_l (devicetype)
+  integer (acc_device_kind) dev_type
+  call acc_set_device_type_l (dev_type)
 end subroutine
 
 function acc_get_device_type_h ()
@@ -1106,41 +1106,41 @@ function acc_get_device_type_h ()
   acc_get_device_type_h = acc_get_device_type_l ()
 end function
 
-subroutine acc_set_device_num_h (devicenum, devicetype)
+subroutine acc_set_device_num_h (dev_num, dev_type)
   use openacc_internal, only: acc_set_device_num_l
   use openacc_kinds
-  integer devicenum
-  integer (acc_device_kind) devicetype
-  call acc_set_device_num_l (devicenum, devicetype)
+  integer dev_num
+  integer (acc_device_kind) dev_type
+  call acc_set_device_num_l (dev_num, dev_type)
 end subroutine
 
-function acc_get_device_num_h (devicetype)
+function acc_get_device_num_h (dev_type)
   use openacc_internal, only: acc_get_device_num_l
   use openacc_kinds
   integer acc_get_device_num_h
-  integer (acc_device_kind) devicetype
-  acc_get_device_num_h = acc_get_device_num_l (devicetype)
+  integer (acc_device_kind) dev_type
+  acc_get_device_num_h = acc_get_device_num_l (dev_type)
 end function
 
-function acc_get_property_h (devicenum, devicetype, property)
+function acc_get_property_h (dev_num, dev_type, property)
   use iso_c_binding, only: c_size_t
   use openacc_internal, only: acc_get_property_l
   use openacc_kinds
   implicit none (type, external)
   integer (c_size_t) :: acc_get_property_h
-  integer, value :: devicenum
-  integer (acc_device_kind), value :: devicetype
+  integer, value :: dev_num
+  integer (acc_device_kind), value :: dev_type
   integer (acc_device_property_kind), value :: property
-  acc_get_property_h = acc_get_property_l (devicenum, devicetype, property)
+  acc_get_property_h = acc_get_property_l (dev_num, dev_type, property)
 end function
 
-subroutine acc_get_property_string_h (devicenum, devicetype, property, string)
+subroutine acc_get_property_string_h (dev_num, dev_type, property, string)
   use iso_c_binding, only: c_char, c_size_t, c_ptr, c_f_pointer, c_associated
   use openacc_internal, only: acc_get_property_string_l
   use openacc_kinds
   implicit none (type, external)
-  integer, value :: devicenum
-  integer (acc_device_kind), value :: devicetype
+  integer, value :: dev_num
+  integer (acc_device_kind), value :: dev_type
   integer (acc_device_property_kind), value :: property
   character (*) :: string
 
@@ -1156,7 +1156,7 @@ subroutine acc_get_property_string_h (devicenum, devicetype, property, string)
      end function strlen
   end interface
 
-  cptr = acc_get_property_string_l (devicenum, devicetype, property)
+  cptr = acc_get_property_string_l (dev_num, dev_type, property)
   string = ""
   if (.not. c_associated (cptr)) then
      return
@@ -1171,11 +1171,11 @@ subroutine acc_get_property_string_h (devicenum, devicetype, property, string)
   end do
 end subroutine
 
-function acc_async_test_h (arg)
+function acc_async_test_h (wait_arg)
   use openacc_internal, only: acc_async_test_l
   logical acc_async_test_h
-  integer arg
-  acc_async_test_h = acc_async_test_l (arg) /= 0
+  integer wait_arg
+  acc_async_test_h = acc_async_test_l (wait_arg) /= 0
 end function
 
 function acc_async_test_all_h ()
@@ -1184,16 +1184,16 @@ function acc_async_test_all_h ()
   acc_async_test_all_h = acc_async_test_all_l () /= 0
 end function
 
-subroutine acc_wait_h (arg)
+subroutine acc_wait_h (wait_arg)
   use openacc_internal, only: acc_wait_l
-  integer arg
-  call acc_wait_l (arg)
+  integer wait_arg
+  call acc_wait_l (wait_arg)
 end subroutine
 
-subroutine acc_wait_async_h (arg, async)
+subroutine acc_wait_async_h (wait_arg, async_arg)
   use openacc_internal, only: acc_wait_async_l
-  integer arg, async
-  call acc_wait_async_l (arg, async)
+  integer wait_arg, async_arg
+  call acc_wait_async_l (wait_arg, async_arg)
 end subroutine
 
 subroutine acc_wait_all_h ()
@@ -1201,483 +1201,483 @@ subroutine acc_wait_all_h ()
   call acc_wait_all_l ()
 end subroutine
 
-subroutine acc_wait_all_async_h (async)
+subroutine acc_wait_all_async_h (async_arg)
   use openacc_internal, only: acc_wait_all_async_l
-  integer async
-  call acc_wait_all_async_l (async)
+  integer async_arg
+  call acc_wait_all_async_l (async_arg)
 end subroutine
 
-subroutine acc_init_h (devicetype)
+subroutine acc_init_h (dev_type)
   use openacc_internal, only: acc_init_l
   use openacc_kinds
-  integer (acc_device_kind) devicetype
-  call acc_init_l (devicetype)
+  integer (acc_device_kind) dev_type
+  call acc_init_l (dev_type)
 end subroutine
 
-subroutine acc_shutdown_h (devicetype)
+subroutine acc_shutdown_h (dev_type)
   use openacc_internal, only: acc_shutdown_l
   use openacc_kinds
-  integer (acc_device_kind) devicetype
-  call acc_shutdown_l (devicetype)
+  integer (acc_device_kind) dev_type
+  call acc_shutdown_l (dev_type)
 end subroutine
 
-function acc_on_device_h (devicetype)
+function acc_on_device_h (dev_type)
   use openacc_internal, only: acc_on_device_l
   use openacc_kinds
-  integer (acc_device_kind) devicetype
+  integer (acc_device_kind) dev_type
   logical acc_on_device_h
-  acc_on_device_h = acc_on_device_l (devicetype) /= 0
+  acc_on_device_h = acc_on_device_l (dev_type) /= 0
 end function
 
-subroutine acc_copyin_32_h (a, len)
+subroutine acc_copyin_32_h (data_arg, bytes)
   use iso_c_binding, only: c_int32_t, c_size_t
   use openacc_internal, only: acc_copyin_l
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int32_t) len
-  call acc_copyin_l (a, int (len, kind = c_size_t))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int32_t) bytes
+  call acc_copyin_l (data_arg, int (bytes, kind = c_size_t))
 end subroutine
 
-subroutine acc_copyin_64_h (a, len)
+subroutine acc_copyin_64_h (data_arg, bytes)
   use iso_c_binding, only: c_int64_t, c_size_t
   use openacc_internal, only: acc_copyin_l
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int64_t) len
-  call acc_copyin_l (a, int (len, kind = c_size_t))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int64_t) bytes
+  call acc_copyin_l (data_arg, int (bytes, kind = c_size_t))
 end subroutine
 
-subroutine acc_copyin_array_h (a)
+subroutine acc_copyin_array_h (data_arg)
   use openacc_internal, only: acc_copyin_l
-  type (*), dimension (..), contiguous :: a
-  call acc_copyin_l (a, sizeof (a))
+  type (*), dimension (..), contiguous :: data_arg
+  call acc_copyin_l (data_arg, sizeof (data_arg))
 end subroutine
 
-subroutine acc_present_or_copyin_32_h (a, len)
+subroutine acc_present_or_copyin_32_h (data_arg, bytes)
   use iso_c_binding, only: c_int32_t, c_size_t
   use openacc_internal, only: acc_present_or_copyin_l
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int32_t) len
-  call acc_present_or_copyin_l (a, int (len, kind = c_size_t))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int32_t) bytes
+  call acc_present_or_copyin_l (data_arg, int (bytes, kind = c_size_t))
 end subroutine
 
-subroutine acc_present_or_copyin_64_h (a, len)
+subroutine acc_present_or_copyin_64_h (data_arg, bytes)
   use iso_c_binding, only: c_int64_t, c_size_t
   use openacc_internal, only: acc_present_or_copyin_l
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int64_t) len
-  call acc_present_or_copyin_l (a, int (len, kind = c_size_t))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int64_t) bytes
+  call acc_present_or_copyin_l (data_arg, int (bytes, kind = c_size_t))
 end subroutine
 
-subroutine acc_present_or_copyin_array_h (a)
+subroutine acc_present_or_copyin_array_h (data_arg)
   use openacc_internal, only: acc_present_or_copyin_l
-  type (*), dimension (..), contiguous :: a
-  call acc_present_or_copyin_l (a, sizeof (a))
+  type (*), dimension (..), contiguous :: data_arg
+  call acc_present_or_copyin_l (data_arg, sizeof (data_arg))
 end subroutine
 
-subroutine acc_create_32_h (a, len)
+subroutine acc_create_32_h (data_arg, bytes)
   use iso_c_binding, only: c_int32_t, c_size_t
   use openacc_internal, only: acc_create_l
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int32_t) len
-  call acc_create_l (a, int (len, kind = c_size_t))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int32_t) bytes
+  call acc_create_l (data_arg, int (bytes, kind = c_size_t))
 end subroutine
 
-subroutine acc_create_64_h (a, len)
+subroutine acc_create_64_h (data_arg, bytes)
   use iso_c_binding, only: c_int64_t, c_size_t
   use openacc_internal, only: acc_create_l
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int64_t) len
-  call acc_create_l (a, int (len, kind = c_size_t))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int64_t) bytes
+  call acc_create_l (data_arg, int (bytes, kind = c_size_t))
 end subroutine
 
-subroutine acc_create_array_h (a)
+subroutine acc_create_array_h (data_arg)
   use openacc_internal, only: acc_create_l
-  type (*), dimension (..), contiguous :: a
-  call acc_create_l (a, sizeof (a))
+  type (*), dimension (..), contiguous :: data_arg
+  call acc_create_l (data_arg, sizeof (data_arg))
 end subroutine
 
-subroutine acc_present_or_create_32_h (a, len)
+subroutine acc_present_or_create_32_h (data_arg, bytes)
   use iso_c_binding, only: c_int32_t, c_size_t
   use openacc_internal, only: acc_present_or_create_l
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int32_t) len
-  call acc_present_or_create_l (a, int (len, kind = c_size_t))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int32_t) bytes
+  call acc_present_or_create_l (data_arg, int (bytes, kind = c_size_t))
 end subroutine
 
-subroutine acc_present_or_create_64_h (a, len)
+subroutine acc_present_or_create_64_h (data_arg, bytes)
   use iso_c_binding, only: c_int64_t, c_size_t
   use openacc_internal, only: acc_present_or_create_l
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int64_t) len
-  call acc_present_or_create_l (a, int (len, kind = c_size_t))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int64_t) bytes
+  call acc_present_or_create_l (data_arg, int (bytes, kind = c_size_t))
 end subroutine
 
-subroutine acc_present_or_create_array_h (a)
+subroutine acc_present_or_create_array_h (data_arg)
   use openacc_internal, only: acc_present_or_create_l
-  type (*), dimension (..), contiguous :: a
-  call acc_present_or_create_l (a, sizeof (a))
+  type (*), dimension (..), contiguous :: data_arg
+  call acc_present_or_create_l (data_arg, sizeof (data_arg))
 end subroutine
 
-subroutine acc_copyout_32_h (a, len)
+subroutine acc_copyout_32_h (data_arg, bytes)
   use iso_c_binding, only: c_int32_t, c_size_t
   use openacc_internal, only: acc_copyout_l
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int32_t) len
-  call acc_copyout_l (a, int (len, kind = c_size_t))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int32_t) bytes
+  call acc_copyout_l (data_arg, int (bytes, kind = c_size_t))
 end subroutine
 
-subroutine acc_copyout_64_h (a, len)
+subroutine acc_copyout_64_h (data_arg, bytes)
   use iso_c_binding, only: c_int64_t, c_size_t
   use openacc_internal, only: acc_copyout_l
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int64_t) len
-  call acc_copyout_l (a, int (len, kind = c_size_t))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int64_t) bytes
+  call acc_copyout_l (data_arg, int (bytes, kind = c_size_t))
 end subroutine
 
-subroutine acc_copyout_array_h (a)
+subroutine acc_copyout_array_h (data_arg)
   use openacc_internal, only: acc_copyout_l
-  type (*), dimension (..), contiguous :: a
-  call acc_copyout_l (a, sizeof (a))
+  type (*), dimension (..), contiguous :: data_arg
+  call acc_copyout_l (data_arg, sizeof (data_arg))
 end subroutine
 
-subroutine acc_copyout_finalize_32_h (a, len)
+subroutine acc_copyout_finalize_32_h (data_arg, bytes)
   use iso_c_binding, only: c_int32_t, c_size_t
   use openacc_internal, only: acc_copyout_finalize_l
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int32_t) len
-  call acc_copyout_finalize_l (a, int (len, kind = c_size_t))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int32_t) bytes
+  call acc_copyout_finalize_l (data_arg, int (bytes, kind = c_size_t))
 end subroutine
 
-subroutine acc_copyout_finalize_64_h (a, len)
+subroutine acc_copyout_finalize_64_h (data_arg, bytes)
   use iso_c_binding, only: c_int64_t, c_size_t
   use openacc_internal, only: acc_copyout_finalize_l
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int64_t) len
-  call acc_copyout_finalize_l (a, int (len, kind = c_size_t))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int64_t) bytes
+  call acc_copyout_finalize_l (data_arg, int (bytes, kind = c_size_t))
 end subroutine
 
-subroutine acc_copyout_finalize_array_h (a)
+subroutine acc_copyout_finalize_array_h (data_arg)
   use openacc_internal, only: acc_copyout_finalize_l
-  type (*), dimension (..), contiguous :: a
-  call acc_copyout_finalize_l (a, sizeof (a))
+  type (*), dimension (..), contiguous :: data_arg
+  call acc_copyout_finalize_l (data_arg, sizeof (data_arg))
 end subroutine
 
-subroutine acc_delete_32_h (a, len)
+subroutine acc_delete_32_h (data_arg, bytes)
   use iso_c_binding, only: c_int32_t, c_size_t
   use openacc_internal, only: acc_delete_l
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int32_t) len
-  call acc_delete_l (a, int (len, kind = c_size_t))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int32_t) bytes
+  call acc_delete_l (data_arg, int (bytes, kind = c_size_t))
 end subroutine
 
-subroutine acc_delete_64_h (a, len)
+subroutine acc_delete_64_h (data_arg, bytes)
   use iso_c_binding, only: c_int64_t, c_size_t
   use openacc_internal, only: acc_delete_l
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int64_t) len
-  call acc_delete_l (a, int (len, kind = c_size_t))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int64_t) bytes
+  call acc_delete_l (data_arg, int (bytes, kind = c_size_t))
 end subroutine
 
-subroutine acc_delete_array_h (a)
+subroutine acc_delete_array_h (data_arg)
   use openacc_internal, only: acc_delete_l
-  type (*), dimension (..), contiguous :: a
-  call acc_delete_l (a, sizeof (a))
+  type (*), dimension (..), contiguous :: data_arg
+  call acc_delete_l (data_arg, sizeof (data_arg))
 end subroutine
 
-subroutine acc_delete_finalize_32_h (a, len)
+subroutine acc_delete_finalize_32_h (data_arg, bytes)
   use iso_c_binding, only: c_int32_t, c_size_t
   use openacc_internal, only: acc_delete_finalize_l
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int32_t) len
-  call acc_delete_finalize_l (a, int (len, kind = c_size_t))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int32_t) bytes
+  call acc_delete_finalize_l (data_arg, int (bytes, kind = c_size_t))
 end subroutine
 
-subroutine acc_delete_finalize_64_h (a, len)
+subroutine acc_delete_finalize_64_h (data_arg, bytes)
   use iso_c_binding, only: c_int64_t, c_size_t
   use openacc_internal, only: acc_delete_finalize_l
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int64_t) len
-  call acc_delete_finalize_l (a, int (len, kind = c_size_t))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int64_t) bytes
+  call acc_delete_finalize_l (data_arg, int (bytes, kind = c_size_t))
 end subroutine
 
-subroutine acc_delete_finalize_array_h (a)
+subroutine acc_delete_finalize_array_h (data_arg)
   use openacc_internal, only: acc_delete_finalize_l
-  type (*), dimension (..), contiguous :: a
-  call acc_delete_finalize_l (a, sizeof (a))
+  type (*), dimension (..), contiguous :: data_arg
+  call acc_delete_finalize_l (data_arg, sizeof (data_arg))
 end subroutine
 
-subroutine acc_update_device_32_h (a, len)
+subroutine acc_update_device_32_h (data_arg, bytes)
   use iso_c_binding, only: c_int32_t, c_size_t
   use openacc_internal, only: acc_update_device_l
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int32_t) len
-  call acc_update_device_l (a, int (len, kind = c_size_t))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int32_t) bytes
+  call acc_update_device_l (data_arg, int (bytes, kind = c_size_t))
 end subroutine
 
-subroutine acc_update_device_64_h (a, len)
+subroutine acc_update_device_64_h (data_arg, bytes)
   use iso_c_binding, only: c_int64_t, c_size_t
   use openacc_internal, only: acc_update_device_l
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int64_t) len
-  call acc_update_device_l (a, int (len, kind = c_size_t))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int64_t) bytes
+  call acc_update_device_l (data_arg, int (bytes, kind = c_size_t))
 end subroutine
 
-subroutine acc_update_device_array_h (a)
+subroutine acc_update_device_array_h (data_arg)
   use openacc_internal, only: acc_update_device_l
-  type (*), dimension (..), contiguous :: a
-  call acc_update_device_l (a, sizeof (a))
+  type (*), dimension (..), contiguous :: data_arg
+  call acc_update_device_l (data_arg, sizeof (data_arg))
 end subroutine
 
-subroutine acc_update_self_32_h (a, len)
+subroutine acc_update_self_32_h (data_arg, bytes)
   use iso_c_binding, only: c_int32_t, c_size_t
   use openacc_internal, only: acc_update_self_l
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int32_t) len
-  call acc_update_self_l (a, int (len, kind = c_size_t))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int32_t) bytes
+  call acc_update_self_l (data_arg, int (bytes, kind = c_size_t))
 end subroutine
 
-subroutine acc_update_self_64_h (a, len)
+subroutine acc_update_self_64_h (data_arg, bytes)
   use iso_c_binding, only: c_int64_t, c_size_t
   use openacc_internal, only: acc_update_self_l
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int64_t) len
-  call acc_update_self_l (a, int (len, kind = c_size_t))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int64_t) bytes
+  call acc_update_self_l (data_arg, int (bytes, kind = c_size_t))
 end subroutine
 
-subroutine acc_update_self_array_h (a)
+subroutine acc_update_self_array_h (data_arg)
   use openacc_internal, only: acc_update_self_l
-  type (*), dimension (..), contiguous :: a
-  call acc_update_self_l (a, sizeof (a))
+  type (*), dimension (..), contiguous :: data_arg
+  call acc_update_self_l (data_arg, sizeof (data_arg))
 end subroutine
 
-function acc_is_present_32_h (a, len)
+function acc_is_present_32_h (data_arg, bytes)
   use iso_c_binding, only: c_int32_t, c_size_t
   use openacc_internal, only: acc_is_present_l
   logical acc_is_present_32_h
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int32_t) len
-  acc_is_present_32_h = acc_is_present_l (a, int (len, kind = c_size_t)) /= 0
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int32_t) bytes
+  acc_is_present_32_h = acc_is_present_l (data_arg, int (bytes, kind = c_size_t)) /= 0
 end function
 
-function acc_is_present_64_h (a, len)
+function acc_is_present_64_h (data_arg, bytes)
   use iso_c_binding, only: c_int64_t, c_size_t
   use openacc_internal, only: acc_is_present_l
   logical acc_is_present_64_h
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int64_t) len
-  acc_is_present_64_h = acc_is_present_l (a, int (len, kind = c_size_t)) /= 0
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int64_t) bytes
+  acc_is_present_64_h = acc_is_present_l (data_arg, int (bytes, kind = c_size_t)) /= 0
 end function
 
-function acc_is_present_array_h (a)
+function acc_is_present_array_h (data_arg)
   use openacc_internal, only: acc_is_present_l
   logical acc_is_present_array_h
-  type (*), dimension (..), contiguous :: a
-  acc_is_present_array_h = acc_is_present_l (a, sizeof (a)) /= 0
+  type (*), dimension (..), contiguous :: data_arg
+  acc_is_present_array_h = acc_is_present_l (data_arg, sizeof (data_arg)) /= 0
 end function
 
-subroutine acc_copyin_async_32_h (a, len, async)
+subroutine acc_copyin_async_32_h (data_arg, bytes, async_arg)
   use iso_c_binding, only: c_int32_t, c_size_t, c_int
   use openacc_internal, only: acc_copyin_async_l
   use openacc_kinds, only: acc_handle_kind
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int32_t) len
-  integer (acc_handle_kind) async
-  call acc_copyin_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int32_t) bytes
+  integer (acc_handle_kind) async_arg
+  call acc_copyin_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
 end subroutine
 
-subroutine acc_copyin_async_64_h (a, len, async)
+subroutine acc_copyin_async_64_h (data_arg, bytes, async_arg)
   use iso_c_binding, only: c_int64_t, c_size_t, c_int
   use openacc_internal, only: acc_copyin_async_l
   use openacc_kinds, only: acc_handle_kind
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int64_t) len
-  integer (acc_handle_kind) async
-  call acc_copyin_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int64_t) bytes
+  integer (acc_handle_kind) async_arg
+  call acc_copyin_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
 end subroutine
 
-subroutine acc_copyin_async_array_h (a, async)
+subroutine acc_copyin_async_array_h (data_arg, async_arg)
   use iso_c_binding, only: c_int
   use openacc_internal, only: acc_copyin_async_l
   use openacc_kinds, only: acc_handle_kind
-  type (*), dimension (..), contiguous :: a
-  integer (acc_handle_kind) async
-  call acc_copyin_async_l (a, sizeof (a), int (async, kind = c_int))
+  type (*), dimension (..), contiguous :: data_arg
+  integer (acc_handle_kind) async_arg
+  call acc_copyin_async_l (data_arg, sizeof (data_arg), int (async_arg, kind = c_int))
 end subroutine
 
-subroutine acc_create_async_32_h (a, len, async)
+subroutine acc_create_async_32_h (data_arg, bytes, async_arg)
   use iso_c_binding, only: c_int32_t, c_size_t, c_int
   use openacc_internal, only: acc_create_async_l
   use openacc_kinds, only: acc_handle_kind
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int32_t) len
-  integer (acc_handle_kind) async
-  call acc_create_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int32_t) bytes
+  integer (acc_handle_kind) async_arg
+  call acc_create_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
 end subroutine
 
-subroutine acc_create_async_64_h (a, len, async)
+subroutine acc_create_async_64_h (data_arg, bytes, async_arg)
   use iso_c_binding, only: c_int64_t, c_size_t, c_int
   use openacc_internal, only: acc_create_async_l
   use openacc_kinds, only: acc_handle_kind
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int64_t) len
-  integer (acc_handle_kind) async
-  call acc_create_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int64_t) bytes
+  integer (acc_handle_kind) async_arg
+  call acc_create_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
 end subroutine
 
-subroutine acc_create_async_array_h (a, async)
+subroutine acc_create_async_array_h (data_arg, async_arg)
   use iso_c_binding, only: c_int
   use openacc_internal, only: acc_create_async_l
   use openacc_kinds, only: acc_handle_kind
-  type (*), dimension (..), contiguous :: a
-  integer (acc_handle_kind) async
-  call acc_create_async_l (a, sizeof (a), int (async, kind = c_int))
+  type (*), dimension (..), contiguous :: data_arg
+  integer (acc_handle_kind) async_arg
+  call acc_create_async_l (data_arg, sizeof (data_arg), int (async_arg, kind = c_int))
 end subroutine
 
-subroutine acc_copyout_async_32_h (a, len, async)
+subroutine acc_copyout_async_32_h (data_arg, bytes, async_arg)
   use iso_c_binding, only: c_int32_t, c_size_t, c_int
   use openacc_internal, only: acc_copyout_async_l
   use openacc_kinds, only: acc_handle_kind
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int32_t) len
-  integer (acc_handle_kind) async
-  call acc_copyout_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int32_t) bytes
+  integer (acc_handle_kind) async_arg
+  call acc_copyout_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
 end subroutine
 
-subroutine acc_copyout_async_64_h (a, len, async)
+subroutine acc_copyout_async_64_h (data_arg, bytes, async_arg)
   use iso_c_binding, only: c_int64_t, c_size_t, c_int
   use openacc_internal, only: acc_copyout_async_l
   use openacc_kinds, only: acc_handle_kind
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int64_t) len
-  integer (acc_handle_kind) async
-  call acc_copyout_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int64_t) bytes
+  integer (acc_handle_kind) async_arg
+  call acc_copyout_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
 end subroutine
 
-subroutine acc_copyout_async_array_h (a, async)
+subroutine acc_copyout_async_array_h (data_arg, async_arg)
   use iso_c_binding, only: c_int
   use openacc_internal, only: acc_copyout_async_l
   use openacc_kinds, only: acc_handle_kind
-  type (*), dimension (..), contiguous :: a
-  integer (acc_handle_kind) async
-  call acc_copyout_async_l (a, sizeof (a), int (async, kind = c_int))
+  type (*), dimension (..), contiguous :: data_arg
+  integer (acc_handle_kind) async_arg
+  call acc_copyout_async_l (data_arg, sizeof (data_arg), int (async_arg, kind = c_int))
 end subroutine
 
-subroutine acc_delete_async_32_h (a, len, async)
+subroutine acc_delete_async_32_h (data_arg, bytes, async_arg)
   use iso_c_binding, only: c_int32_t, c_size_t, c_int
   use openacc_internal, only: acc_delete_async_l
   use openacc_kinds, only: acc_handle_kind
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int32_t) len
-  integer (acc_handle_kind) async
-  call acc_delete_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int32_t) bytes
+  integer (acc_handle_kind) async_arg
+  call acc_delete_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
 end subroutine
 
-subroutine acc_delete_async_64_h (a, len, async)
+subroutine acc_delete_async_64_h (data_arg, bytes, async_arg)
   use iso_c_binding, only: c_int64_t, c_size_t, c_int
   use openacc_internal, only: acc_delete_async_l
   use openacc_kinds, only: acc_handle_kind
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int64_t) len
-  integer (acc_handle_kind) async
-  call acc_delete_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int64_t) bytes
+  integer (acc_handle_kind) async_arg
+  call acc_delete_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
 end subroutine
 
-subroutine acc_delete_async_array_h (a, async)
+subroutine acc_delete_async_array_h (data_arg, async_arg)
   use iso_c_binding, only: c_int
   use openacc_internal, only: acc_delete_async_l
   use openacc_kinds, only: acc_handle_kind
-  type (*), dimension (..), contiguous :: a
-  integer (acc_handle_kind) async
-  call acc_delete_async_l (a, sizeof (a), int (async, kind = c_int))
+  type (*), dimension (..), contiguous :: data_arg
+  integer (acc_handle_kind) async_arg
+  call acc_delete_async_l (data_arg, sizeof (data_arg), int (async_arg, kind = c_int))
 end subroutine
 
-subroutine acc_update_device_async_32_h (a, len, async)
+subroutine acc_update_device_async_32_h (data_arg, bytes, async_arg)
   use iso_c_binding, only: c_int32_t, c_size_t, c_int
   use openacc_internal, only: acc_update_device_async_l
   use openacc_kinds, only: acc_handle_kind
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int32_t) len
-  integer (acc_handle_kind) async
-  call acc_update_device_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int32_t) bytes
+  integer (acc_handle_kind) async_arg
+  call acc_update_device_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
 end subroutine
 
-subroutine acc_update_device_async_64_h (a, len, async)
+subroutine acc_update_device_async_64_h (data_arg, bytes, async_arg)
   use iso_c_binding, only: c_int64_t, c_size_t, c_int
   use openacc_internal, only: acc_update_device_async_l
   use openacc_kinds, only: acc_handle_kind
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int64_t) len
-  integer (acc_handle_kind) async
-  call acc_update_device_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int64_t) bytes
+  integer (acc_handle_kind) async_arg
+  call acc_update_device_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
 end subroutine
 
-subroutine acc_update_device_async_array_h (a, async)
+subroutine acc_update_device_async_array_h (data_arg, async_arg)
   use iso_c_binding, only: c_int
   use openacc_internal, only: acc_update_device_async_l
   use openacc_kinds, only: acc_handle_kind
-  type (*), dimension (..), contiguous :: a
-  integer (acc_handle_kind) async
-  call acc_update_device_async_l (a, sizeof (a), int (async, kind = c_int))
+  type (*), dimension (..), contiguous :: data_arg
+  integer (acc_handle_kind) async_arg
+  call acc_update_device_async_l (data_arg, sizeof (data_arg), int (async_arg, kind = c_int))
 end subroutine
 
-subroutine acc_update_self_async_32_h (a, len, async)
+subroutine acc_update_self_async_32_h (data_arg, bytes, async_arg)
   use iso_c_binding, only: c_int32_t, c_size_t, c_int
   use openacc_internal, only: acc_update_self_async_l
   use openacc_kinds, only: acc_handle_kind
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int32_t) len
-  integer (acc_handle_kind) async
-  call acc_update_self_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int32_t) bytes
+  integer (acc_handle_kind) async_arg
+  call acc_update_self_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
 end subroutine
 
-subroutine acc_update_self_async_64_h (a, len, async)
+subroutine acc_update_self_async_64_h (data_arg, bytes, async_arg)
   use iso_c_binding, only: c_int64_t, c_size_t, c_int
   use openacc_internal, only: acc_update_self_async_l
   use openacc_kinds, only: acc_handle_kind
-  !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-  type (*), dimension (*) :: a
-  integer (c_int64_t) len
-  integer (acc_handle_kind) async
-  call acc_update_self_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+  !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+  type (*), dimension (*) :: data_arg
+  integer (c_int64_t) bytes
+  integer (acc_handle_kind) async_arg
+  call acc_update_self_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
 end subroutine
 
-subroutine acc_update_self_async_array_h (a, async)
+subroutine acc_update_self_async_array_h (data_arg, async_arg)
   use iso_c_binding, only: c_int
   use openacc_internal, only: acc_update_self_async_l
   use openacc_kinds, only: acc_handle_kind
-  type (*), dimension (..), contiguous :: a
-  integer (acc_handle_kind) async
-  call acc_update_self_async_l (a, sizeof (a), int (async, kind = c_int))
+  type (*), dimension (..), contiguous :: data_arg
+  integer (acc_handle_kind) async_arg
+  call acc_update_self_async_l (data_arg, sizeof (data_arg), int (async_arg, kind = c_int))
 end subroutine
diff --git a/libgomp/openacc_lib.h b/libgomp/openacc_lib.h
index 913c3f1aa3d..07f6da1bad2 100644
--- a/libgomp/openacc_lib.h
+++ b/libgomp/openacc_lib.h
@@ -73,17 +73,17 @@
       integer, parameter :: openacc_version = 201711
 
       interface acc_get_num_devices
-        function acc_get_num_devices_h (devicetype)
+        function acc_get_num_devices_h (dev_type)
           import acc_device_kind
           integer acc_get_num_devices_h
-          integer (acc_device_kind) devicetype
+          integer (acc_device_kind) dev_type
         end function
       end interface
 
       interface acc_set_device_type
-        subroutine acc_set_device_type_h (devicetype)
+        subroutine acc_set_device_type_h (dev_type)
           import acc_device_kind
-          integer (acc_device_kind) devicetype
+          integer (acc_device_kind) dev_type
         end subroutine
       end interface
 
@@ -95,50 +95,50 @@
       end interface
 
       interface acc_set_device_num
-        subroutine acc_set_device_num_h (devicenum, devicetype)
+        subroutine acc_set_device_num_h (dev_num, dev_type)
           import acc_device_kind
-          integer devicenum
-          integer (acc_device_kind) devicetype
+          integer dev_num
+          integer (acc_device_kind) dev_type
         end subroutine
       end interface
 
       interface acc_get_device_num
-        function acc_get_device_num_h (devicetype)
+        function acc_get_device_num_h (dev_type)
           import acc_device_kind
           integer acc_get_device_num_h
-          integer (acc_device_kind) devicetype
+          integer (acc_device_kind) dev_type
         end function
       end interface
 
       interface acc_get_property
-        function acc_get_property_h (devicenum, devicetype,             &
+        function acc_get_property_h (dev_num, dev_type,                 &
      &                               property)
           use iso_c_binding, only: c_size_t
           import acc_device_kind, acc_device_property_kind
           implicit none (type, external)
           integer (c_size_t) :: acc_get_property_h
-          integer, value :: devicenum
-          integer (acc_device_kind), value :: devicetype
+          integer, value :: dev_num
+          integer (acc_device_kind), value :: dev_type
           integer (acc_device_property_kind), value :: property
         end function
       end interface
 
       interface acc_get_property_string
-        subroutine acc_get_property_string_h (devicenum, devicetype,    &
+        subroutine acc_get_property_string_h (dev_num, dev_type,        &
      &                                        property, string)
           import acc_device_kind, acc_device_property_kind
           implicit none (type, external)
-          integer, value :: devicenum
-          integer (acc_device_kind), value :: devicetype
+          integer, value :: dev_num
+          integer (acc_device_kind), value :: dev_type
           integer (acc_device_property_kind), value :: property
           character (*) :: string
         end subroutine
       end interface
 
       interface acc_async_test
-        function acc_async_test_h (arg)
+        function acc_async_test_h (wait_arg)
           logical acc_async_test_h
-          integer arg
+          integer wait_arg
         end function
       end interface
 
@@ -149,8 +149,8 @@
       end interface
 
       interface acc_wait
-        subroutine acc_wait_h (arg)
-          integer arg
+        subroutine acc_wait_h (wait_arg)
+          integer wait_arg
         end subroutine
       end interface
 
@@ -160,8 +160,8 @@
       end interface
 
       interface acc_wait_async
-        subroutine acc_wait_async_h (arg, async)
-          integer arg, async
+        subroutine acc_wait_async_h (wait_arg, async_arg)
+          integer wait_arg, async_arg
         end subroutine
       end interface
 
@@ -177,30 +177,30 @@
       end interface
 
       interface acc_wait_all_async
-        subroutine acc_wait_all_async_h (async)
-          integer async
+        subroutine acc_wait_all_async_h (async_arg)
+          integer async_arg
         end subroutine
       end interface
 
       interface acc_init
-        subroutine acc_init_h (devicetype)
+        subroutine acc_init_h (dev_type)
           import acc_device_kind
-          integer (acc_device_kind) devicetype
+          integer (acc_device_kind) dev_type
         end subroutine
       end interface
 
       interface acc_shutdown
-        subroutine acc_shutdown_h (devicetype)
+        subroutine acc_shutdown_h (dev_type)
           import acc_device_kind
-          integer (acc_device_kind) devicetype
+          integer (acc_device_kind) dev_type
         end subroutine
       end interface
 
       interface acc_on_device
-        function acc_on_device_h (devicetype)
+        function acc_on_device_h (dev_type)
           import acc_device_kind
           logical acc_on_device_h
-          integer (acc_device_kind) devicetype
+          integer (acc_device_kind) dev_type
         end function
       end interface
 
@@ -219,42 +219,42 @@
       end interface
 
       interface acc_copyin
-        subroutine acc_copyin_32_h (a, len)
+        subroutine acc_copyin_32_h (data_arg, bytes)
           use iso_c_binding, only: c_int32_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int32_t) bytes
         end subroutine
 
-        subroutine acc_copyin_64_h (a, len)
+        subroutine acc_copyin_64_h (data_arg, bytes)
           use iso_c_binding, only: c_int64_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int64_t) bytes
         end subroutine
 
-        subroutine acc_copyin_array_h (a)
-          type (*), dimension (..), contiguous :: a
+        subroutine acc_copyin_array_h (data_arg)
+          type (*), dimension (..), contiguous :: data_arg
           end subroutine
       end interface
 
       interface acc_present_or_copyin
-        subroutine acc_present_or_copyin_32_h (a, len)
+        subroutine acc_present_or_copyin_32_h (data_arg, bytes)
           use iso_c_binding, only: c_int32_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int32_t) bytes
         end subroutine
 
-        subroutine acc_present_or_copyin_64_h (a, len)
+        subroutine acc_present_or_copyin_64_h (data_arg, bytes)
           use iso_c_binding, only: c_int64_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int64_t) bytes
         end subroutine
 
-        subroutine acc_present_or_copyin_array_h (a)
-          type (*), dimension (..), contiguous :: a
+        subroutine acc_present_or_copyin_array_h (data_arg)
+          type (*), dimension (..), contiguous :: data_arg
           end subroutine
       end interface
 
@@ -265,42 +265,42 @@
       end interface
 
       interface acc_create
-        subroutine acc_create_32_h (a, len)
+        subroutine acc_create_32_h (data_arg, bytes)
           use iso_c_binding, only: c_int32_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int32_t) bytes
         end subroutine
 
-        subroutine acc_create_64_h (a, len)
+        subroutine acc_create_64_h (data_arg, bytes)
           use iso_c_binding, only: c_int64_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int64_t) bytes
         end subroutine
 
-        subroutine acc_create_array_h (a)
-          type (*), dimension (..), contiguous :: a
+        subroutine acc_create_array_h (data_arg)
+          type (*), dimension (..), contiguous :: data_arg
           end subroutine
       end interface
 
       interface acc_present_or_create
-        subroutine acc_present_or_create_32_h (a, len)
+        subroutine acc_present_or_create_32_h (data_arg, bytes)
           use iso_c_binding, only: c_int32_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int32_t) bytes
         end subroutine
 
-        subroutine acc_present_or_create_64_h (a, len)
+        subroutine acc_present_or_create_64_h (data_arg, bytes)
           use iso_c_binding, only: c_int64_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int64_t) bytes
         end subroutine
 
-        subroutine acc_present_or_create_array_h (a)
-          type (*), dimension (..), contiguous :: a
+        subroutine acc_present_or_create_array_h (data_arg)
+          type (*), dimension (..), contiguous :: data_arg
           end subroutine
       end interface
 
@@ -311,122 +311,122 @@
       end interface
 
       interface acc_copyout
-        subroutine acc_copyout_32_h (a, len)
+        subroutine acc_copyout_32_h (data_arg, bytes)
           use iso_c_binding, only: c_int32_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int32_t) bytes
         end subroutine
 
-        subroutine acc_copyout_64_h (a, len)
+        subroutine acc_copyout_64_h (data_arg, bytes)
           use iso_c_binding, only: c_int64_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int64_t) bytes
         end subroutine
 
-        subroutine acc_copyout_array_h (a)
-          type (*), dimension (..), contiguous :: a
+        subroutine acc_copyout_array_h (data_arg)
+          type (*), dimension (..), contiguous :: data_arg
         end subroutine
       end interface
 
       interface acc_copyout_finalize
-        subroutine acc_copyout_finalize_32_h (a, len)
+        subroutine acc_copyout_finalize_32_h (data_arg, bytes)
           use iso_c_binding, only: c_int32_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int32_t) bytes
         end subroutine
 
-        subroutine acc_copyout_finalize_64_h (a, len)
+        subroutine acc_copyout_finalize_64_h (data_arg, bytes)
           use iso_c_binding, only: c_int64_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int64_t) bytes
         end subroutine
 
-        subroutine acc_copyout_finalize_array_h (a)
-          type (*), dimension (..), contiguous :: a
+        subroutine acc_copyout_finalize_array_h (data_arg)
+          type (*), dimension (..), contiguous :: data_arg
         end subroutine
       end interface
 
       interface acc_delete
-        subroutine acc_delete_32_h (a, len)
+        subroutine acc_delete_32_h (data_arg, bytes)
           use iso_c_binding, only: c_int32_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int32_t) bytes
         end subroutine
 
-        subroutine acc_delete_64_h (a, len)
+        subroutine acc_delete_64_h (data_arg, bytes)
           use iso_c_binding, only: c_int64_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int64_t) bytes
         end subroutine
 
-        subroutine acc_delete_array_h (a)
-          type (*), dimension (..), contiguous :: a
+        subroutine acc_delete_array_h (data_arg)
+          type (*), dimension (..), contiguous :: data_arg
         end subroutine
       end interface
 
       interface acc_delete_finalize
-        subroutine acc_delete_finalize_32_h (a, len)
+        subroutine acc_delete_finalize_32_h (data_arg, bytes)
           use iso_c_binding, only: c_int32_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int32_t) bytes
         end subroutine
 
-        subroutine acc_delete_finalize_64_h (a, len)
+        subroutine acc_delete_finalize_64_h (data_arg, bytes)
           use iso_c_binding, only: c_int64_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int64_t) bytes
         end subroutine
 
-        subroutine acc_delete_finalize_array_h (a)
-          type (*), dimension (..), contiguous :: a
+        subroutine acc_delete_finalize_array_h (data_arg)
+          type (*), dimension (..), contiguous :: data_arg
         end subroutine
       end interface
 
       interface acc_update_device
-        subroutine acc_update_device_32_h (a, len)
+        subroutine acc_update_device_32_h (data_arg, bytes)
           use iso_c_binding, only: c_int32_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int32_t) bytes
         end subroutine
 
-        subroutine acc_update_device_64_h (a, len)
+        subroutine acc_update_device_64_h (data_arg, bytes)
           use iso_c_binding, only: c_int64_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int64_t) bytes
         end subroutine
 
-        subroutine acc_update_device_array_h (a)
-          type (*), dimension (..), contiguous :: a
+        subroutine acc_update_device_array_h (data_arg)
+          type (*), dimension (..), contiguous :: data_arg
         end subroutine
       end interface
 
       interface acc_update_self
-        subroutine acc_update_self_32_h (a, len)
+        subroutine acc_update_self_32_h (data_arg, bytes)
           use iso_c_binding, only: c_int32_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int32_t) bytes
         end subroutine
 
-        subroutine acc_update_self_64_h (a, len)
+        subroutine acc_update_self_64_h (data_arg, bytes)
           use iso_c_binding, only: c_int64_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int64_t) bytes
         end subroutine
 
-        subroutine acc_update_self_array_h (a)
-          type (*), dimension (..), contiguous :: a
+        subroutine acc_update_self_array_h (data_arg)
+          type (*), dimension (..), contiguous :: data_arg
         end subroutine
       end interface
 
@@ -460,25 +460,25 @@
       end interface
 
       interface acc_is_present
-        function acc_is_present_32_h (a, len)
+        function acc_is_present_32_h (data_arg, bytes)
           use iso_c_binding, only: c_int32_t
           logical acc_is_present_32_h
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int32_t) bytes
         end function
 
-        function acc_is_present_64_h (a, len)
+        function acc_is_present_64_h (data_arg, bytes)
           use iso_c_binding, only: c_int64_t
           logical acc_is_present_64_h
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int64_t) bytes
         end function
 
-        function acc_is_present_array_h (a)
+        function acc_is_present_array_h (data_arg)
           logical acc_is_present_array_h
-          type (*), dimension (..), contiguous :: a
+          type (*), dimension (..), contiguous :: data_arg
         end function
       end interface
 
@@ -529,157 +529,161 @@
       end interface
 
       interface acc_copyin_async
-        subroutine acc_copyin_async_32_h (a, len, async)
+        subroutine acc_copyin_async_32_h (data_arg, bytes, async_arg)
           use iso_c_binding, only: c_int32_t
           import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int32_t) len
-          integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int32_t) bytes
+          integer (acc_handle_kind) async_arg
         end subroutine
 
-        subroutine acc_copyin_async_64_h (a, len, async)
+        subroutine acc_copyin_async_64_h (data_arg, bytes, async_arg)
           use iso_c_binding, only: c_int64_t
           import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int64_t) len
-          integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int64_t) bytes
+          integer (acc_handle_kind) async_arg
         end subroutine
 
-        subroutine acc_copyin_async_array_h (a, async_)
+        subroutine acc_copyin_async_array_h (data_arg, async_arg)
           import acc_handle_kind
-          type (*), dimension (..), contiguous :: a
-          integer (acc_handle_kind) async_
+          type (*), dimension (..), contiguous :: data_arg
+          integer (acc_handle_kind) async_arg
         end subroutine
       end interface
 
       interface acc_create_async
-        subroutine acc_create_async_32_h (a, len, async)
+        subroutine acc_create_async_32_h (data_arg, bytes, async_arg)
           use iso_c_binding, only: c_int32_t
           import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int32_t) len
-          integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int32_t) bytes
+          integer (acc_handle_kind) async_arg
         end subroutine
 
-        subroutine acc_create_async_64_h (a, len, async)
+        subroutine acc_create_async_64_h (data_arg, bytes, async_arg)
           use iso_c_binding, only: c_int64_t
           import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int64_t) len
-          integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int64_t) bytes
+          integer (acc_handle_kind) async_arg
         end subroutine
 
-        subroutine acc_create_async_array_h (a, async_)
+        subroutine acc_create_async_array_h (data_arg, async_arg)
           import acc_handle_kind
-          type (*), dimension (..), contiguous :: a
-          integer (acc_handle_kind) async_
+          type (*), dimension (..), contiguous :: data_arg
+          integer (acc_handle_kind) async_arg
         end subroutine
       end interface
 
       interface acc_copyout_async
-        subroutine acc_copyout_async_32_h (a, len, async)
+        subroutine acc_copyout_async_32_h (data_arg, bytes, async_arg)
           use iso_c_binding, only: c_int32_t
           import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int32_t) len
-          integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int32_t) bytes
+          integer (acc_handle_kind) async_arg
         end subroutine
 
-        subroutine acc_copyout_async_64_h (a, len, async)
+        subroutine acc_copyout_async_64_h (data_arg, bytes, async_arg)
           use iso_c_binding, only: c_int64_t
           import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int64_t) len
-          integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int64_t) bytes
+          integer (acc_handle_kind) async_arg
         end subroutine
 
-        subroutine acc_copyout_async_array_h (a, async_)
+        subroutine acc_copyout_async_array_h (data_arg, async_arg)
           import acc_handle_kind
-          type (*), dimension (..), contiguous :: a
-          integer (acc_handle_kind) async_
+          type (*), dimension (..), contiguous :: data_arg
+          integer (acc_handle_kind) async_arg
         end subroutine
       end interface
 
       interface acc_delete_async
-        subroutine acc_delete_async_32_h (a, len, async)
+        subroutine acc_delete_async_32_h (data_arg, bytes, async_arg)
           use iso_c_binding, only: c_int32_t
           import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int32_t) len
-          integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int32_t) bytes
+          integer (acc_handle_kind) async_arg
         end subroutine
 
-        subroutine acc_delete_async_64_h (a, len, async)
+        subroutine acc_delete_async_64_h (data_arg, bytes, async_arg)
           use iso_c_binding, only: c_int64_t
           import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int64_t) len
-          integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int64_t) bytes
+          integer (acc_handle_kind) async_arg
         end subroutine
 
-        subroutine acc_delete_async_array_h (a, async_)
+        subroutine acc_delete_async_array_h (data_arg, async_arg)
           import acc_handle_kind
-          type (*), dimension (..), contiguous :: a
-          integer (acc_handle_kind) async_
+          type (*), dimension (..), contiguous :: data_arg
+          integer (acc_handle_kind) async_arg
         end subroutine
       end interface
 
       interface acc_update_device_async
-        subroutine acc_update_device_async_32_h (a, len, async)
+        subroutine acc_update_device_async_32_h (data_arg, bytes,       &
+     &                                           async_arg)
           use iso_c_binding, only: c_int32_t
           import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int32_t) len
-          integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int32_t) bytes
+          integer (acc_handle_kind) async_arg
         end subroutine
 
-        subroutine acc_update_device_async_64_h (a, len, async)
+        subroutine acc_update_device_async_64_h (data_arg, bytes,       &
+     &                                           async_arg)
           use iso_c_binding, only: c_int64_t
           import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int64_t) len
-          integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int64_t) bytes
+          integer (acc_handle_kind) async_arg
         end subroutine
 
-        subroutine acc_update_device_async_array_h (a, async_)
+        subroutine acc_update_device_async_array_h (data_arg, async_arg)
           import acc_handle_kind
-          type (*), dimension (..), contiguous :: a
-          integer (acc_handle_kind) async_
+          type (*), dimension (..), contiguous :: data_arg
+          integer (acc_handle_kind) async_arg
         end subroutine
       end interface
 
       interface acc_update_self_async
-        subroutine acc_update_self_async_32_h (a, len, async)
+        subroutine acc_update_self_async_32_h (data_arg, bytes,         &
+     &                                         async_arg)
           use iso_c_binding, only: c_int32_t
           import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int32_t) len
-          integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int32_t) bytes
+          integer (acc_handle_kind) async_arg
         end subroutine
 
-        subroutine acc_update_self_async_64_h (a, len, async)
+        subroutine acc_update_self_async_64_h (data_arg, bytes,         &
+     &                                         async_arg)
           use iso_c_binding, only: c_int64_t
           import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
-          type (*), dimension (*) :: a
-          integer (c_int64_t) len
-          integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+          type (*), dimension (*) :: data_arg
+          integer (c_int64_t) bytes
+          integer (acc_handle_kind) async_arg
         end subroutine
 
-        subroutine acc_update_self_async_array_h (a, async_)
+        subroutine acc_update_self_async_array_h (data_arg, async_arg)
           import acc_handle_kind
-          type (*), dimension (..), contiguous :: a
-          integer (acc_handle_kind) async_
+          type (*), dimension (..), contiguous :: data_arg
+          integer (acc_handle_kind) async_arg
         end subroutine
       end interface
