Export std hash template specializations from dylibs (#7618)

Use explicit visibility to force std::hash template specializations to
be
exported from libbinaryen dynamic library. 

Currently
we are just using the default flags, causing most of our symbols to have
"default" visibility, meaning they can all be used from the tool
sources.
However a recent libc++ change caused functions declared in namespace
std
(e.g. hash template specializations) to have hidden visibility,
inherited.
from the namespece (see
llvm/llvm-project#131156).
So this macro forces them to be exported. Currently it is only applied
to
the hash specializations that are defined in libbinaryen and used in the
tool code. In the future if we want to compile libbinaryen with
-fvisibility-hidden or use a DLL on Windows, we'll need
to explicitly annotate everything we want to export. But that's probably
only useful if we want external users to link against libbinaryen.so
(currently we don't; it's only used to reduce our install size).

Author: dschuff

CMakeLists.txt

@@ -462,6 +462,10 @@ if(BUILD_STATIC_LIB)
 else()
   message(STATUS "Building libbinaryen as shared library.")
   add_library(binaryen SHARED)
+  if(LINUX)
+    # Disable interposition and resolve Binaryen symbols locally.
+    add_link_flag("-Bsymbolic")
+  endif()
 endif()
 target_link_libraries(binaryen Threads::Threads)
 if(BUILD_LLVM_DWARF)

src/compiler-support.h

@@ -31,4 +31,23 @@
 #define WASM_BUILTIN_UNREACHABLE __assume(false)
 #endif
 
+// Forces symbols to be exported from libbinaryen dynamic library. Currently
+// we are just using the default flags, causing most of our symbols to have
+// "default" visibility, meaning they can all be used from the tool sources.
+// However a recent libc++ change caused functions declared in namespace std
+// (e.g. hash template specializations) to have hidden visibility, inherited.
+// from the namespece (see https://github.com/llvm/llvm-project/pull/131156).
+// So this macro forces them to be exported. Currently it is only applied to
+// the hash specializations that are defined in libbinaryen and used in the
+// tool code. In the future if we want to compile libbinaryen with
+// -fvisibility-hidden or use a DLL on Windows, we'll need
+// to explicitly annotate everything we want to export. But that's probably
+// only useful if we want external users to link against libbinaryen.so
+// (currently we don't; it's only used to reduce our install size).
+#if defined(__ELF__) || defined(__MACH__)
+#define DLLEXPORT [[gnu::visibility("default")]]
+#else
+#define DLLEXPORT
+#endif
+
 #endif // wasm_compiler_support_h

src/wasm-type-shape.h

@@ -20,6 +20,7 @@
 #include <functional>
 #include <vector>
 
+#include "compiler-support.h"
 #include "wasm-features.h"
 #include "wasm-type.h"
 
@@ -74,7 +75,7 @@ namespace std {
 
 template<> class hash<wasm::RecGroupShape> {
 public:
-  size_t operator()(const wasm::RecGroupShape& shape) const;
+  DLLEXPORT size_t operator()(const wasm::RecGroupShape& shape) const;
 };
 
 } // namespace std

src/wasm-type.h

@@ -25,6 +25,7 @@
 #include <variant>
 #include <vector>
 
+#include "compiler-support.h"
 #include "support/index.h"
 #include "support/name.h"
 #include "support/parent_index_iterator.h"
@@ -1005,35 +1006,35 @@ namespace std {
 
 template<> class hash<wasm::Type> {
 public:
-  size_t operator()(const wasm::Type&) const;
+  DLLEXPORT size_t operator()(const wasm::Type&) const;
 };
 template<> class hash<wasm::Signature> {
 public:
-  size_t operator()(const wasm::Signature&) const;
+  DLLEXPORT size_t operator()(const wasm::Signature&) const;
 };
 template<> class hash<wasm::Continuation> {
 public:
-  size_t operator()(const wasm::Continuation&) const;
+  DLLEXPORT size_t operator()(const wasm::Continuation&) const;
 };
 template<> class hash<wasm::Field> {
 public:
-  size_t operator()(const wasm::Field&) const;
+  DLLEXPORT size_t operator()(const wasm::Field&) const;
 };
 template<> class hash<wasm::Struct> {
 public:
-  size_t operator()(const wasm::Struct&) const;
+  DLLEXPORT size_t operator()(const wasm::Struct&) const;
 };
 template<> class hash<wasm::Array> {
 public:
-  size_t operator()(const wasm::Array&) const;
+  DLLEXPORT size_t operator()(const wasm::Array&) const;
 };
 template<> class hash<wasm::HeapType> {
 public:
-  size_t operator()(const wasm::HeapType&) const;
+  DLLEXPORT size_t operator()(const wasm::HeapType&) const;
 };
 template<> class hash<wasm::RecGroup> {
 public:
-  size_t operator()(const wasm::RecGroup&) const;
+  DLLEXPORT size_t operator()(const wasm::RecGroup&) const;
 };
 
 } // namespace std