Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?

by

TL;DR

In C++14 this is explicitly not allowed, although in 2011 it appeared like this case would be explicitly allowed. It is unclear if for C++11 this fell under the as-if rule, I don’t believe it does since it alters observable behavior but that point was not clarified in the issue I reference below.

Details

The answer to this question has shifted with the evolving status of LWG issue 2013 which opens with:

Suppose that a particular function is not tagged as constexpr in the
standard, but that, in some particular implementation, it is possible
to write it within the constexpr constraints. If an implementer tags
such a function as constexpr, is that a violation of the standard or
is it a conforming extension?

In C++11 it was unclear if the as-if rule permitted this but the orignal proposal would have explicitly allowed it once it was accepted and we can see below in the gcc bug report I reference, this was the assumption made by the gcc team.

The consensus to allow this shifted in 2012 and the proposal changed and in C++14 this is a non-conforming extension. This is reflected in the draft C++14 standard section 17.6.5.6 [constexpr.functions] which says:

[…]An implementation shall not declare any standard library function
signature as constexpr except for those where it is explicitly
required.[..]

and although a strict reading of this seems to leave some wiggle room for treating a builtin implicitly as if it were a constexpr we can see from the following quote in the issue that the intention was to prevent divergence in implementations since identical code could produce different behavior when using SFINAE (emphasis mine):

Some concern expressed when presented to full committee for the vote
to WP status that this issue had been resolved without sufficient
thought of the consequences for diverging library implementations, as
users may use SFINAE to observe different behavior from otherwise
identical code.

We can see from the gcc bug report [C++0x] sinh vs asinh vs constexpr that the team relied on the earlier proposed resolution of LWG 2013 which says:

[…]Additionally, an implementation may declare any function to be
constexpr if that function’s definition satisfies the necessary
constraints[…]

when deciding whether this change for the math functions was allowed in strict conformance mode.

As far as I can tell this would become conforming if this we received a warning in strict conformance mode i.e. using -std=c++11 -pedantic or if it was disabled in this mode.

Note, I added a comment to the bug report explaining that the resolution changed since this issue was originally addressed.

Jonathan Wakely pointed out in another question a more recent discussion and it seems likely the gcc bug report will be reopened to address this conformance issue.

What about intrinsics

Compiler intrinsics are not covered by the standard and so as far as I can tell they should be exempt from this rule, so using:

static constexpr double a = __builtin_cos(3.);

should be allowed. This question came up in the bug report and opinion of Daniel Krügler was:

[…]Library functions and other intrinsics can probably be considered as
exceptions, because they are not required to be “explainable” by
normal language rules.

More Related Contents:

  1. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  2. Implementation C++14 make_integer_sequence
  3. C++11 aggregate initialization for classes with non-static member initializers
  4. Are notes and examples in the core language specification of the C++ Standard non-normative?
  5. Classes with both template and non-template conversion operators in the condition of switch statement
  6. Calling an explicit constructor with a braced-init list: ambiguous or not?
  7. Injected class name compiler discrepancy
  8. what is the concept of evaluation of expression z = (y = 30) + (y = 10) + (y = 20); [closed]
  9. Is cout synchronized/thread-safe?
  10. Is the size of std::array defined by standard
  11. constexpr and initialization of a static const void pointer with reinterpret cast, which compiler is right?
  12. Capturing a reference by reference in a C++11 lambda
  13. Can I use C++11 with Xcode?
  14. Deleted default constructor. Objects can still be created… sometimes
  15. Order of evaluation of elements in list-initialization
  16. When is it necessary to use the flag -stdlib=libstdc++?
  17. In C++11, does `i += ++i + 1` exhibit undefined behavior?
  18. Lambda capture as const reference?
  19. Proper way to create unique_ptr that holds an allocated array
  20. Is there an automatic noexcept specifier?
  21. Which headers in the C++ standard library are guaranteed to include another header?
  22. How can an incomplete type be used as a template parameter to vector here?
  23. How to update GCC in MinGW on Windows?
  24. Why was the space character not chosen for C++14 digit separators?
  25. What is the difference between std::quick_exit and std::abort and why was std::quick_exit needed?
  26. Can nullptr be emulated in gcc?
  27. Multiple “could not be resolved” problems using Eclipse with minGW
  28. const auto std::initializer_list difference between Clang and GCC
  29. Undefined reference to process(std::__cxx11::basic_string … ) when compiling affdex linux sample applications
  30. Overload resolution with ref-qualifiers

Leave a Comment