PoPS/doxygen/abi__key_8hpp_source.html

#pragma once


#include <pops/runtime/export.hpp>  // POPS_EXPORT (default visibility across the hidden _pops module)


#include <string>


#ifndef POPS_HEADER_SIG

#define POPS_HEADER_SIG "unknown"

#endif


// Indirection to stringify the value of a macro (not its name). Defined BEFORE the tokens that use

// it (expansion happens at use, but keeping it readable does no harm).

#define POPS_ABI_STR_(x) #x

#define POPS_ABI_STR(x) POPS_ABI_STR_(x)


// Kokkos token: evaluated PER UNIT (_pops module on one side, generated .so loader on the other).

#ifdef POPS_HAS_KOKKOS

#define POPS_ABI_KOKKOS "1"

#else

#define POPS_ABI_KOKKOS "0"

#endif


// stdlib token: identity + version of the linked standard library. _LIBCPP_VERSION /

// __GLIBCXX__ are only defined after including a stdlib header (<string> above).

#if defined(_LIBCPP_VERSION)

#define POPS_ABI_STDLIB "libc++_" POPS_ABI_STR(_LIBCPP_VERSION)

#elif defined(__GLIBCXX__)

#define POPS_ABI_STDLIB "libstdc++_" POPS_ABI_STR(__GLIBCXX__)

#else

#define POPS_ABI_STDLIB "unknown"

#endif


// Compiler token: __VERSION__ (GCC/Clang/AppleClang) is already a string LITERAL; MSVC does NOT

// define it -> stringify _MSC_FULL_VER. Keeps the key comparable cross-compiler (native Windows

// port, ADC-99/100). POSIX unchanged (POPS_ABI_COMPILER == __VERSION__).

#if defined(__VERSION__)

#define POPS_ABI_COMPILER __VERSION__

#elif defined(_MSC_FULL_VER)

#define POPS_ABI_COMPILER "MSVC_" POPS_ABI_STR(_MSC_FULL_VER)

#else

#define POPS_ABI_COMPILER "unknown"

#endif


// ABI key of the current TRANSLATION UNIT, as a pure literal concatenated by the preprocessor:

// "compiler=<__VERSION__>;std=<__cplusplus>;headers=<POPS_HEADER_SIG>;kokkos=<0|1>;stdlib=<...>".

// All tokens are string literals (__VERSION__ and POPS_HEADER_SIG already are), so the key is frozen

// in the .rodata of EACH TU at preprocessing -- NO function call.

//

// WHY a literal and not an inline function (real CI bug, ELF/Linux): a .so loader is loaded

// RTLD_GLOBAL and an `inline` function (weak linkage, default visibility) that would build the key

// would be INTERPOSED by the dynamic linker onto the copy in the already-loaded module -- the

// loader would then return the key OF THE MODULE and the guard would compare the module key against

// itself (tautology: ABI never rejected). Whether interposition happened depended on the compiler's

// inlining threshold (the short function was inlined -> correct local key; lengthened by

// kokkos=/stdlib=, gcc -O2 stopped inlining it -> interposition -> guard neutralized, caught by

// test_amr_native_loader). A literal crosses no symbol: no interposition.

// NB: the parsers (dsl._pops_cxx_std_from_module / module_header_signature) scan by token prefix

// ("std=", "headers=") -> insensitive to ADDING tokens at the tail.


#define POPS_ABI_KEY_LITERAL                                                                \

  "compiler=" POPS_ABI_COMPILER ";std=" POPS_ABI_STR(__cplusplus) ";headers=" POPS_HEADER_SIG \

                                                                ";kokkos=" POPS_ABI_KOKKOS  \

                                                                ";stdlib=" POPS_ABI_STDLIB


namespace pops {

namespace detail {


inline std::string abi_key_string() {

  return POPS_ABI_KEY_LITERAL;

}


}  // namespace detail


POPS_EXPORT std::string abi_key();


}  // namespace pops

POPS_ABI_KEY_LITERAL
#define POPS_ABI_KEY_LITERAL
Definition abi_key.hpp:93

export.hpp
POPS_EXPORT: force DEFAULT VISIBILITY on an out-of-line symbol, even when the unit is compiled with -...

POPS_EXPORT
#define POPS_EXPORT
Definition export.hpp:25

pops::detail::abi_key_string
std::string abi_key_string()
ABI key of the current TU (cf.
Definition abi_key.hpp:104

pops
Definition amr_hierarchy.hpp:29

pops::abi_key
POPS_EXPORT std::string abi_key()
ABI key of the module (TU system.cpp).