OpenACC / nvc++: will indirect function/procedure calls be supported in the future?

I tried to accelerate the following code using OpenACC (nvc++ compiler version 21.7). It contains an indirect call to a function “func1()”, which is an argument to the integration routine “newton_cotes()”:

#include <iostream>
#include <iomanip>

//  Compile with:
//  nvc++ -acc=gpu -gpu=cc80 -Minfo=accel -o openacc_integ && ./openacc_integ

using namespace std;

//  The function which should be integrated.
double func1(double x)
  return x * x;

//  Closed Newton-Cotes integration on multiple intervals `n´.
#pragma acc routine seq
newton_cotes(double (*func)(double), double a, double b, int n)
  constexpr int ndegree = 6;
  while (n % ndegree != 0) ++n;
  double h = (b - a) / double(n);
  double w[ndegree]     = { 216.0, 27.0, 272.0, 27.0, 216.0,  82.0 };
  double r = 0.5 * w[ndegree-1] * (func(a) + func(b));
  for (int i = 1; i < n; ++i) r += w[(i-1) % ndegree] * func(a + double(i) * h);
  return r * double(ndegree) * h / 840.0;

main(int argc, char* argv[])
  double integ;
#pragma acc serial
  integ = newton_cotes(func1, 0.0, 1.0, 256);
  cout << setprecision(16) << integ << endl;
  return 0;

Unfortunately compilation with nvc++ fails with the following error message:

newton_cotes(double (*)(double), double, double, int):
     30, Accelerator restriction: Indirect function/procedure calls are not supported
     40, Accelerator serial kernel generated
         Generating Tesla code
nvvmCompileProgram error 9: NVVM_ERROR_COMPILATION.

My questions: is there a chance that indirect function calls will be supported in a future release? Is this a limitation of the OpenACC standard or the compiler?

Thanks & Kind Regards!

Correct, indirect calls are not currently supported in device code. We are working on it, and do expect that they will be supported in a future release. It is not really a limitation in the OpenACC standard, but more a compiler limitation, and to a lesser extent, a limitation of the underlying CUDA capabilities, which are continually adding features, and that fortunately will make higher-level constructs like this easier for us to implement in our directive-based models.