issue compiling code with large constexpr arrays of function pointers

[wheatman]

I am trying to make some large constexpr arrays of functions pointers, but when they get to a certain size they just seem to break and starts giving error messages about parts of the code which doesn't change with the size.

The code can be found at

working with a size of 1<<15
https://godbolt.org/z/15badTccs

broken with a size of 1<<16
https://godbolt.org/z/KMPGYbKcx

the timeouts from g++ are just from godbolt, when I compile the same code on my own machine it does finish without errors with g++

The code has been simplified down to

#include <array>
#include <type_traits>



  template <int enabled_blocks>
  static void foo() {
    return;
  }


  using fn_type = void();

  template <std::size_t... I>
  constexpr auto static make_helper(std::index_sequence<I...>) {
    return std::array<fn_type *, sizeof...(I)>{foo<I>...};
  }
  template <std::size_t MAX> static constexpr auto get_foos() {
    return make_helper(std::make_index_sequence<MAX>{});
  }

  static constexpr int num = 1UL << 15;  // it no longer compiles if this is changed to 16

  static constexpr std::array<fn_type *, num> foos =
      get_foos<num>();




int main(int argc, char *argv[]) {

  foos[argc]();
  return 0;
}

The error with the code that has 16 instead of 15 is

<source>:17:48: error: initializer for aggregate with no elements requires explicit braces
   17 |     return std::array<fn_type *, sizeof...(I)>{foo<I>...};
      |                                                ^
<source>:20:12: note: in instantiation of function template specialization 'make_helper<0UL, 1UL, 2UL, 3UL, 4UL, 
...
...
65530UL, 65531UL, 65532UL, 65533UL, 65534UL, 65535UL>' requested here
   20 |     return make_helper(std::make_index_sequence<MAX>{});
      |            ^
<source>:26:7: note: in instantiation of function template specialization 'get_foos<65536UL>' requested here
   26 |       get_foos<num>();
      |       ^
1 error generated.
Compiler returned: 1

I first guessed the issue had to do with one of the limits here https://clang.llvm.org/docs/UsersManual.html#controlling-implementation-limits

However, all but constexpr-steps seem to small to be related and I tried increasing it with -fconstexpr-steps=134217728 and it had no effect

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: None (wheatman)

I am trying to make some large constexpr arrays of functions pointers, but when they get to a certain size they just seem to break and starts giving error messages about parts of the code which doesn't change with the size.

The code can be found at

working with a size of 1<<15
https://godbolt.org/z/15badTccs

broken with a size of 1<<16
https://godbolt.org/z/KMPGYbKcx

the timeouts from g++ are just from godbolt, when I compile the same code on my own machine it does finish without errors with g++

The code has been simplified down to

#include <array>
#include <type_traits>



  template <int enabled_blocks>
  static void foo() {
    return;
  }


  using fn_type = void();

  template <std::size_t... I>
  constexpr auto static make_helper(std::index_sequence<I...>) {
    return std::array<fn_type *, sizeof...(I)>{foo<I>...};
  }
  template <std::size_t MAX> static constexpr auto get_foos() {
    return make_helper(std::make_index_sequence<MAX>{});
  }

  static constexpr int num = 1UL << 15;  // it no longer compiles if this is changed to 16

  static constexpr std::array<fn_type *, num> foos =
      get_foos<num>();




int main(int argc, char *argv[]) {

  foos[argc]();
  return 0;
}

The error with the code that has 16 instead of 15 is

<source>:17:48: error: initializer for aggregate with no elements requires explicit braces
   17 |     return std::array<fn_type *, sizeof...(I)>{foo<I>...};
      |                                                ^
<source>:20:12: note: in instantiation of function template specialization 'make_helper<0UL, 1UL, 2UL, 3UL, 4UL, 
...
...
65530UL, 65531UL, 65532UL, 65533UL, 65534UL, 65535UL>' requested here
   20 |     return make_helper(std::make_index_sequence<MAX>{});
      |            ^
<source>:26:7: note: in instantiation of function template specialization 'get_foos<65536UL>' requested here
   26 |       get_foos<num>();
      |       ^
1 error generated.
Compiler returned: 1

I first guessed the issue had to do with one of the limits here https://clang.llvm.org/docs/UsersManual.html#controlling-implementation-limits

However, all but constexpr-steps seem to small to be related and I tried increasing it with -fconstexpr-steps=134217728 and it had no effect

[tbaederr]

Tracked this down to SubstNonTypeTemplateParmPackExpr simply just having 16 bits for the number of arguments:

llvm-project/clang/include/clang/AST/ExprCXX.h

Line 4446 in 5c36f43

unsigned NumArguments : 16;

Which we never check for before creating the expression.

[wheatman]

It looks like the 32 bit to 16 bit conversion happens here

llvm-project/clang/lib/AST/ExprCXX.cpp

Line 1682 in 5c36f43

NumArguments(ArgPack.pack_size()), Index(Index), NameLoc(NameLoc) {

I feel like there should at least be some sort of error raised here instead of just silently cutting off the high bits.
Also, I can't find anything in the standard about the max size of a pack, seems to just say zero or more, so it would be nice if instead NumArguments could be made 32 bits

[wheatman]

I added a patch to add the assert when the conversion happens as a temporary fix, this may also lead to some discovery if this case is common enough that large packs should be supported, I imagine they may be some time and space overhead of supporting larger packs

#74220