pure/const function attributes in different compilers

pure is a function attribute which says that a function does not modify any global memory.

const is a function attribute which says that a function does not read/modify any global memory.

Given that information, the compiler can do some additional optimisations.

Example for GCC:

float sigmoid(float x) __attribute__ ((const));

float calculate(float x, unsigned int C) {
    float sum = 0;
    for(unsigned int i = 0; i < C; ++i)
        sum += sigmoid(x);
    return sum;
}

float sigmoid(float x) { return 1.0f / (开发者_开发问答1.0f - exp(-x)); }

In that example, the compiler could optimise the function calculate to:

float calculate(float x, unsigned int C) {
    float sum = 0;
    float temp = C ? sigmoid(x) : 0.0f;
    for(unsigned int i = 0; i < C; ++i)
        sum += temp;
    return sum;
}

Or if your compiler is clever enough (and not so strict about floats):

float calculate(float x, unsigned int C) { return C ? sigmoid(x) * C : 0.0f; }

How can I mark a function in such way for the different compilers, i.e. GCC, Clang, ICC, MSVC or others?

---

• GCC: pure/const function attributes
• llvm-gcc: supports the GCC pure/const attributes
• Clang: seems to support it (I tried on a simple example with the GCC style attributes and it worked.)
• ICC: seems to adopt the GCC attributes (Sorry, only a forum post.)
• MSVC: Seems not to support it. (discussion)

In general, it seems that almost all compilers support the GCC attributes. MSVC is so far the only compiler which does not support them (and which also doesn't have any alternative).

---

First, it's useful to note that "const" is a more strict version of "pure", so "pure" can be used as a fallback if a compiler doesn't implement "const".

As others have mentioned, MSVC doesn't really have anything similar, but a lot of compilers have adopted the GCC syntax, including many which don't define __GNUC__ (and some which sometimes do and sometimes don't, depending on flags).

• GCC supports pure since 2.96+, and const since 2.5.0, in case you feel like checking the version.
• Clang supports both; you can use __has_attribute(pure) and __has_attribute(const) to detect them, but it's probably fine to just rely on clang setting __GNUC__. This also includes compilers based on clang like emscripten and XL C/C++ 13+.
• Intel C/C++ Compiler supports both, but their documentation is terrible so I have no idea when they were added. 16.0+ is certainly safe.
• Oracle Developer Studio 12.2+ supports both.
• ARM C/C++ Compiler 4.1+ (and possibly older) supports both pure and const
• IBM XL C/C++ since at least 10.1.
• TI 8.0+
• TI 7.3+ with --gcc (detected with __TI_GNU_ATTRIBUTE_SUPPORT__) supports both.
• PGI doesn't document it (AFAICT), but both attributes work (or are at least silently ignored). 17.10+ is safe, though they've probably been acceptable for much longer.

Of these, clang always defines __GNUC__ and friends (currently to 4.2, IIRC). Intel defines __GNUC__ by default (though it can be suppressed with -no-gcc) as does PGI in C++ mode (but not in C mode). The others you'll have to check for manually.

Oracle Developer Studio has also supported pragmas since it was known as Forte Developer 6. They're used a bit differently since they require you to specify the function name:

/* pure: */
#pragma does_not_write_global_data (funcname)
/* const; SPARC-only until 12.2 */
#pragma no_side_effect (funcname)

TI 6.0+ (at least) supports a #pragma FUNC_IS_PURE; pragma in C++ mode only. In C mode, it's #pragma FUNC_IS_PURE(funcname);.

Most of this can be hidden behind a macro, which is what I've done in Hedley:

#if \
  HEDLEY_GNUC_HAS_ATTRIBUTE(pure,2,96,0) || \
  HEDLEY_INTEL_VERSION_CHECK(16,0,0) || \
  HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
  HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
  HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
  HEDLEY_TI_VERSION_CHECK(8,0,0) || \
  (HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
  HEDLEY_PGI_VERSION_CHECK(17,10,0)
#  define HEDLEY_PURE __attribute__((__pure__))
#elif HEDLEY_TI_VERSION_CHECK(6,0,0) && defined(__cplusplus)
#  define HEDLEY_NO_RETURN _Pragma("FUNC_IS_PURE;")
#else
#  define HEDLEY_PURE
#endif

#if HEDLEY_GNUC_HAS_ATTRIBUTE(const, 2, 5, 0) || \
  HEDLEY_INTEL_VERSION_CHECK(16,0,0) || \
  HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
  HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
  HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
  HEDLEY_TI_VERSION_CHECK(8,0,0) || \
  (HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
  HEDLEY_PGI_VERSION_CHECK(17,10,0)
#  define HEDLEY_CONST __attribute__((__const__))
#else
#  define HEDLEY_CONST HEDLEY_PURE
#endif

This doesn't include the variants which would require the function names as an argument, but it still covers the vast majority of users, and it's safe to use everywhere.

If you don't want to use Hedley (it's a single public domain / CC0 header) it shouldn't be too difficult to replace the internal version macros. If you choose to do that, you should probably base your port on the Hedley repo instead of this answer as I'm much more likely to keep it up to date.

---

As an update for anyone reading this after all these years, starting with C++11 (and with continuous improvements with C++14, C++17 and C++20), the constexpr keyword was added to the language, letting you mark functions, methods, statements, templates, variables (pretty much everything) as absolutely and completely constant, allowing for nice optimization from the compiler.

constevel and constinit were also added in C++20 to further expand the compile-time capabilities of the language.