[libunwind] unw_* alias fixes for ELF and Mach-O

[rprichard]

Summary

Rename the CMake option, LIBUNWIND_HERMETIC_STATIC_LIBRARY, to
LIBUNWIND_HIDE_SYMBOLS. Rename the C macro define,
_LIBUNWIND_DISABLE_VISIBILITY_ANNOTATIONS, to _LIBUNWIND_HIDE_SYMBOLS,
because now the macro adds a .hidden directive rather than merely
suppress visibility annotations.

For ELF, when LIBUNWIND_HIDE_SYMBOLS is enabled, mark unw_getcontext as
hidden. This symbol is the only one defined using src/assembly.h's
WEAK_ALIAS macro. Other unw_* weak aliases are defined in C++ and are
already hidden.

Mach-O doesn't support weak aliases, so remove .weak_reference and
weak_import. When LIBUNWIND_HIDE_SYMBOLS is enabled, output
.private_extern for the unw_* aliases.

In assembly.h, add missing SYMBOL_NAME macro invocations, which are
used to prefix symbol names with '_' on some targets.

Fixes PR46709.

[rprichard]

Fix LIBUNWIND_HERMETIC_STATIC_LIBRARY on macOS.

[rprichard]

I assume the LIBUNWIND_HERMETIC_STATIC_LIBRARY setting isn't used on Darwin -- it leaves unw_* symbols as Extern and not PrivateExtern. Maybe the CMake file could reject that flag on Darwin instead of trying to make it work.

AFAICT, the existing unw_* aliases aren't weak on macOS. For aliases to C++ functions, the __attribute__((weak_import)) didn't seem to do anything when I tested it. I think the declared unw_* functions aren't referenced in the TU that declares them, so the compiler doesn't do anything with the declaration. When I experimented, if I *did* reference the function, then the compiler outputted a .weak_reference directive. However, AFAIK, the assembler ignores the .weak_reference directive and uses the weakdef/weakref flags from the target of the alias instead (i.e. the __unw_* function).

For unw_getcontext specifically, assembly.h's WEAK_SYMBOL(aliasname) SEPARATOR omitted the SYMBOL_NAME macro on Darwin, so I think the .weak_reference would have referred to the wrong symbol. For arm64 iphoneos, I saw this preprocessed output:

.globl _unw_getcontext %% .weak_reference unw_getcontext %% _unw_getcontext = ___unw_getcontext

Adding SYMBOL_NAME doesn't make unw_getcontext weak.

I'm not sure if the aliases can actually be marked weak on Darwin, so instead, I removed the code making them weak. Windows already leaves the symbols non-weak. I'm not very familiar with Mach-O, though, so maybe I'm wrong here. In particular, maybe there's some configuration where it works (e.g. where the assembler behaves differently).

libunwind/CMakeLists.txt

324

This code block effectively duplicates the LIBUNWIND_HERMETIC_STATIC_LIBRARY block in libunwind/src/CMakeLists.txt, assuming that the -fvisibility flags are ignored for Windows. It's on by default, though, whereas the LIBUNWIND_HERMETIC_STATIC_LIBRARY option is off by default. Maybe this code block should be removed, but I suppose that would break current users, quietly.

libunwind/src/CMakeLists.txt

163

e.g. Maybe this could be: if(LIBUNWIND_HERMETIC_STATIC_LIBRARY OR WIN32)

Or maybe we can default LIBUNWIND_HERMETIC_STATIC_LIBRARY to ON for WIN32? I'm not sure what's possible with CMake.

165

I think this -fvisibility-global-new-delete-hidden flag has no effect, but if it did have an effect, it could break the NDK's libc++_shared.so when it's linked with libunwind.a.

i.e. AFAIK, libunwind doesn't define or use the global new/delete operators. (D57251 switched to placement new.) If libunwind merely referenced new/delete, then this flag would make the undefined symbol reference hidden, and then linking libunwind.a into the NDK's libc++_shared.so could make the new/delete definitions hidden (because undef-hidden + def-default ==> def-hidden).

It was added with D57107.

[compnerd]

libunwind/CMakeLists.txt

323

Similar to the argument for the naming for the compiler-rt builtins, would you mind renaming this to _LIBUNWIND_HIDE_SYMBOLS please?

324

IIRC, -fvisibility= is not ignored and is an error. Either way, -fvisibility= is meaningless on Windows - you *must* control the behaviour via macros and __declspec(dllexport) for the DLL build, and nothing for the static build (which makes it internal).

libunwind/src/CMakeLists.txt

163

-fvisibility= should not be set for Win32. This is correct as is.

libunwind/src/assembly.h

81

Does this not change the behaviour on MachO? This symbol is now private_extern rather than a weak_reference. A weak reference will be set to 0 by the loader if it is not found, and a private_extern is a strong internal reference.

103

I don't understand how this works. This is making the symbol a forward declaration, which is not a weak symbol definition.

[rprichard]

libunwind/CMakeLists.txt

323

Should I also rename the CMake variable? And if so, do I need to continue recognizing the old name for backwards compatibility?

If we change the CMake variable name, at least ./clang/cmake/caches/Fuchsia-stage2.cmake will need to be updated.

libunwind/src/assembly.h

81

Is .weak_reference the right directive to use here, instead of .weak_definition? We're defining a symbol (aliasname) and setting its value to that of another symbol (name).

I think marking unw_* weak is intended to let some other strong definition override it. Its value won't ever be set to 0.

Currently on Mach-O, the hide-symbols flag hides almost everything (including _Unwind_*) but leaves all of the unw_* alias symbols as extern (and not private-extern) and not weak. With my change, they're still not weak, but they're private-extern.

libunwind's current assembly.h behavior for a weak alias:

.globl aliasname
.weak_reference aliasname
aliasname = name

The LLVM Mach-O assembler ignores the .weak_reference directive. If I change it to .weak_definition, it is still ignored. AFAICT, the LLVM assembler uses the WeakDef/WeakRef attributes from the name symbol.

e.g.

$ cat test.S    
    .text
    .space 0x42

    // Define foo.
    .globl foo
foo:
    ret

    // Define a weak alias, bar.
    .globl bar
    .weak_reference bar
    bar = foo

$ ~/clang11/bin/clang test.S -c && ~/clang11/bin/llvm-readobj --syms test.o

File: test.o
Format: Mach-O 64-bit x86-64
Arch: x86_64
AddressSize: 64bit
Symbols [
  Symbol {
    Name: bar (1)
    Extern
    Type: Section (0xE)
    Section: __text (0x1)
    RefType: UndefinedNonLazy (0x0)
    Flags [ (0x0)
    ]
    Value: 0x42
  }
  Symbol {
    Name: foo (5)
    Extern
    Type: Section (0xE)
    Section: __text (0x1)
    RefType: UndefinedNonLazy (0x0)
    Flags [ (0x0)
    ]
    Value: 0x42
  }
]

The Flags are empty.

OTOH, if I flip things around:

    .text
    .space 0x42

    // Define a weak function, foo.
    .globl foo
    .weak_reference foo
foo:
    ret

    // Define an alias, bar.
    .globl bar
    bar = foo

Now both symbols are WeakRef:

File: test.o
Format: Mach-O 64-bit x86-64
Arch: x86_64
AddressSize: 64bit
Symbols [
  Symbol {
    Name: bar (1)
    Extern
    Type: Section (0xE)
    Section: __text (0x1)
    RefType: UndefinedNonLazy (0x0)
    Flags [ (0x40)
      WeakRef (0x40)
    ]
    Value: 0x42
  }
  Symbol {
    Name: foo (5)
    Extern
    Type: Section (0xE)
    Section: __text (0x1)
    RefType: UndefinedNonLazy (0x0)
    Flags [ (0x40)
      WeakRef (0x40)
    ]
    Value: 0x42
  }
]

I'm wondering if this LLVM behavior is actually correct, but I'm also unfamiliar with Mach-O. (i.e. We want to copy the symbol's address, but should we be copying the WeakRef/WeakDef flags?) It looks like the behavior is controlled in MachObjectWriter::writeNlist. writeNlist finds the aliased symbol and uses its flags:

// The Mach-O streamer uses the lowest 16-bits of the flags for the 'desc'
// value.
bool EncodeAsAltEntry =
  IsAlias && cast<MCSymbolMachO>(OrigSymbol).isAltEntry();
W.write<uint16_t>(cast<MCSymbolMachO>(Symbol)->getEncodedFlags(EncodeAsAltEntry));

The PrivateExtern attribute, on the other hand, isn't part of these encoded flags:

if (Data.isPrivateExtern())
  Type |= MachO::N_PEXT;

Data continues to refer to the alias symbol rather than the aliased symbol. However, apparently the author isn't completely sure about things?

// FIXME: Should this update Data as well?

In libunwind, there is one usage of assembly.h's WEAK_ALIAS. UnwindRegistersSave.S defines a hidden non-weak __unw_getcontext function, and also a weak alias unw_getcontext. My patch's goal is to make unw_getcontext hidden or not-hidden depending on a CMake config variable.

Currently, on Mach-O and on Windows, WEAK_ALIAS doesn't actually make the alias weak. I'm just making it a bit more explicit on Mach-O.

Alternatively:

• Instead of a weak alias, we could output a weak thunk -- a weak function with a branch to the internal hidden symbol. That's more of a functional change, though.
• Or, on Mach-O, both the unw_* and __unw_* functions could be WeakDef.
• Maybe the hide-symbols flag should only affect ELF?

103

Currently, there's only one use of WEAK_ALIAS, at the end of UnwindRegistersSave.S, which defines unw_getcontext to have the same value as __unw_getcontext, which was defined earlier in the file. It's generating one of:

.hidden unw_getcontext
.weak unw_getcontext
unw_getcontext = __unw_getcontext

or:

.weak unw_getcontext
unw_getcontext = __unw_getcontext

[rprichard]

Just fix ELF and leave Mach-O as-is.

[rprichard]

After renaming the CMake option, CMake prints a warning if I set the old option:

CMake Warning:
  Manually-specified variables were not used by the project:

    LIBUNWIND_HERMETIC_STATIC_LIBRARY

[steven_wu]

libunwind/src/assembly.h

81

I guess the symbol is never really weak for Darwin. The weak_import attribute will turn all the reference to the symbol to weak_reference but since the alias is declared in .cpp file and never referenced, it will not create any weak linkage to the symbol. I am also not sure if a weak alias is possible on Darwin :) I think making everything .private_extern for Darwin should be fine?

@ldionne The change was added: https://reviews.llvm.org/D59921. I am not sure why the alias need to be weak?

[rprichard]

libunwind/src/assembly.h

81

I guess the symbol is never really weak for Darwin. The weak_import attribute will turn all the reference to the symbol to weak_reference but since the alias is declared in .cpp file and never referenced, it will not create any weak linkage to the symbol. I am also not sure if a weak alias is possible on Darwin :) I think making everything .private_extern for Darwin should be fine?

@ldionne The change was added: https://reviews.llvm.org/D59921. I am not sure why the alias need to be weak?

I'm guessing the unw_* symbols are marked weak because they're not "reserved for the implementation" the way the underscore-uppercase symbols are (_Unwind_*), so if a program wants to define its own unw_* symbols, it should be able to without breaking unwinding. This situation could cause a multiply-defined symbol error at link-time, at least when libunwind is linked statically.

[rprichard]

Restore Mach-O alias fixes.

[rprichard]

libunwind/src/assembly.h

81

Ok, I've restored the Mach-O part of this change. Please take a look.

I did confirm that weak aliases don't work on Mach-O: when a weak function has been overridden with a strong function, the linker can delete the weak function, leaving the aliases pointing at the deleted area (i.e. whatever function happens to come next). https://gist.github.com/rprichard/8775d7844228577e40d2fd0776397f47

I also removed the WEAK_SYMBOL() macro for the Apple case, because it's not used, Windows also doesn't have the macro, and it's not clear whether .weak_definition or .weak_reference would be wanted.

[rprichard]

emaste: Just a heads up in case FreeBSD is affected. FWIW, I noticed that libgcc_eh.a on FreeBSD 12.1 doesn't hide the _Unwind_* or unw_* symbols. The build system is defining VISIBILITY_HIDDEN but libunwind doesn't respond to that name. FreeBSD libgcc_eh.a also defines hidden symbols named logAPIs, logUnwinding, and logDWARF. libunwind defines these internal names if NDEBUG isn't defined. They can break statically-linked programs on FreeBSD (e.g. duplicate symbol linker errors).

[rprichard]

Update libunwind/src/BUILD.gn for macro name change.

[rprichard]

Rebase and fix merge conflict in gn file.

[rprichard]

Maybe this is blocked on someone from Apple reviewing the Mach-O parts?

[steven_wu]

In D93003#2566906, @rprichard wrote:

Maybe this is blocked on someone from Apple reviewing the Mach-O parts?

This is fine with me for how Apple builds libunwind. I am not sure if the open source libunwind build for MachO do expect different behavior but I don't think there are other reasonable behaviors.

I can give my LGTM if @ldionne has no problem with that.

[ldionne]

In D93003#2567088, @steven_wu wrote:

In D93003#2566906, @rprichard wrote:

Maybe this is blocked on someone from Apple reviewing the Mach-O parts?

This is fine with me for how Apple builds libunwind. I am not sure if the open source libunwind build for MachO do expect different behavior but I don't think there are other reasonable behaviors.

I can give my LGTM if @ldionne has no problem with that.

Oh, I had missed that. I'm not a libunwind owner, but if Steven says it's good for Apple, then it is. I trust him a lot more than I trust myself in this area.

[danalbert]

It sounds like everyone is happy here but the tools. Could we get a libunwind reviewer (preferably @compnerd, since his review is the red one) to LGTM this?

[steven_wu]

My main concern is just that weak alias for libc++abi that never worked for Darwin :)

LGTM.

[phosek]

LGTM

I'd also suggest renaming LIBCXXABI_HERMETIC_STATIC_LIBRARY and LIBCXX_HERMETIC_STATIC_LIBRARY to LIBCXXABI_HIDE_SYMBOLS and LIBCXX_HIDE_SYMBOLS respectively in a follow up change to maintain consistency.

[rprichard]

The coff-dwarf.test buildbot failures were fixed by https://github.com/llvm/llvm-project/commit/0fd7c31a098efdfaa5a57dbac6e9c0921b00a999 (on Feb 11).

clang/cmake/caches/Fuchsia-stage2.cmake

foreach(target x86_64;aarch64)
     set(RUNTIMES_${target}-unknown-fuchsia_CMAKE_C_FLAGS ${FUCHSIA_${target}_COMPILER_FLAGS} CACHE STRING "")
     set(RUNTIMES_${target}-unknown-fuchsia_CMAKE_CXX_FLAGS ${FUCHSIA_${target}_COMPILER_FLAGS} CACHE STRING "")
     set(RUNTIMES_${target}-unknown-fuchsia_CMAKE_SHARED_LINKER_FLAGS ${FUCHSIA_${target}_LINKER_FLAGS} CACHE STRING "")
     set(RUNTIMES_${target}-unknown-fuchsia_CMAKE_MODULE_LINKER_FLAGS ${FUCHSIA_${target}_LINKER_FLAGS} CACHE STRING "")
     set(RUNTIMES_${target}-unknown-fuchsia_CMAKE_EXE_LINKER_FLAGS ${FUCHSIA_${target}_LINKER_FLAGS} CACHE STRING "")
     set(RUNTIMES_${target}-unknown-fuchsia_CMAKE_SYSROOT ${FUCHSIA_${target}_SYSROOT} CACHE PATH "")
     set(RUNTIMES_${target}-unknown-fuchsia_COMPILER_RT_USE_BUILTINS_LIBRARY ON CACHE BOOL "")
     set(RUNTIMES_${target}-unknown-fuchsia_LIBUNWIND_USE_COMPILER_RT ON CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia_LIBUNWIND_HERMETIC_STATIC_LIBRARY ON CACHE BOOL "")
+    set(RUNTIMES_${target}-unknown-fuchsia_LIBUNWIND_HIDE_SYMBOLS ON CACHE BOOL "")
     set(RUNTIMES_${target}-unknown-fuchsia_LIBUNWIND_INSTALL_STATIC_LIBRARY OFF CACHE BOOL "")
     set(RUNTIMES_${target}-unknown-fuchsia_LIBCXXABI_USE_COMPILER_RT ON CACHE BOOL "")
     set(RUNTIMES_${target}-unknown-fuchsia_LIBCXXABI_USE_LLVM_UNWINDER ON CACHE BOOL "")
     set(RUNTIMES_${target}-unknown-fuchsia_LIBCXXABI_ENABLE_STATIC_UNWINDER ON CACHE BOOL "")
     set(RUNTIMES_${target}-unknown-fuchsia_LIBCXXABI_HERMETIC_STATIC_LIBRARY ON CACHE BOOL "")
     set(RUNTIMES_${target}-unknown-fuchsia_LIBCXXABI_INSTALL_STATIC_LIBRARY OFF CACHE BOOL "")
     set(RUNTIMES_${target}-unknown-fuchsia_LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY OFF CACHE BOOL "")
     set(RUNTIMES_${target}-unknown-fuchsia_LIBCXX_USE_COMPILER_RT ON CACHE BOOL "")

libunwind/CMakeLists.txt

 if (CMAKE_SIZEOF_VOID_P EQUAL 8 AND NOT WIN32)
   if (LIBUNWIND_BUILD_32_BITS AND NOT LLVM_BUILD_32_BITS) # Don't duplicate the output from LLVM
     message(STATUS "Building 32 bits executables and libraries.")
   endif()
 elseif(LIBUNWIND_BUILD_32_BITS)
   message(FATAL_ERROR "LIBUNWIND_BUILD_32_BITS=ON is not supported on this platform.")
 endif()
 
-option(LIBUNWIND_HERMETIC_STATIC_LIBRARY
+option(LIBUNWIND_HIDE_SYMBOLS
   "Do not export any symbols from the static library." OFF)
 
 #===============================================================================
 # Configure System
 #===============================================================================
 
 # Add path for custom modules
 set(CMAKE_MODULE_PATH

 
 # This is the _ONLY_ place where add_definitions is called.
 if (MSVC)
   add_definitions(-D_CRT_SECURE_NO_WARNINGS)
 endif()
 
 # Disable DLL annotations on Windows for static builds.
 if (WIN32 AND LIBUNWIND_ENABLE_STATIC AND NOT LIBUNWIND_ENABLE_SHARED)
-  add_definitions(-D_LIBUNWIND_DISABLE_VISIBILITY_ANNOTATIONS)
+  add_definitions(-D_LIBUNWIND_HIDE_SYMBOLS)
 endif()
 
 if (LIBUNWIND_HAS_COMMENT_LIB_PRAGMA)
   if (LIBUNWIND_HAS_DL_LIB)
     add_definitions(-D_LIBUNWIND_LINK_DL_LIB)
   endif()
   if (LIBUNWIND_HAS_PTHREAD_LIB)
     add_definitions(-D_LIBUNWIND_LINK_PTHREAD_LIB)
   endif()

libunwind/src/CMakeLists.txt

set_target_properties(unwind_static PROPERTIES
     CXX_EXTENSIONS OFF
     CXX_STANDARD 11
     CXX_STANDARD_REQUIRED ON
     COMPILE_FLAGS "${LIBUNWIND_COMPILE_FLAGS}"
     LINK_FLAGS "${LIBUNWIND_LINK_FLAGS}"
     LINKER_LANGUAGE C
     OUTPUT_NAME "unwind")
 
-  if(LIBUNWIND_HERMETIC_STATIC_LIBRARY)
+  if(LIBUNWIND_HIDE_SYMBOLS)
     append_flags_if_supported(UNWIND_STATIC_LIBRARY_FLAGS -fvisibility=hidden)
     append_flags_if_supported(UNWIND_STATIC_LIBRARY_FLAGS -fvisibility-global-new-delete-hidden)
     target_compile_options(unwind_static PRIVATE ${UNWIND_STATIC_LIBRARY_FLAGS})
-    target_compile_definitions(unwind_static PRIVATE _LIBUNWIND_DISABLE_VISIBILITY_ANNOTATIONS)
+    target_compile_definitions(unwind_static PRIVATE _LIBUNWIND_HIDE_SYMBOLS)
   endif()
 
   list(APPEND LIBUNWIND_BUILD_TARGETS "unwind_static")
   if (LIBUNWIND_INSTALL_STATIC_LIBRARY)
     list(APPEND LIBUNWIND_INSTALL_TARGETS "unwind_static")
   endif()
 endif()
 

libunwind/src/assembly.h

 
 #define GLUE2(a, b) a ## b
 #define GLUE(a, b) GLUE2(a, b)
 #define SYMBOL_NAME(name) GLUE(__USER_LABEL_PREFIX__, name)
 
 #if defined(__APPLE__)
 
 #define SYMBOL_IS_FUNC(name)
-#define EXPORT_SYMBOL(name)
 #define HIDDEN_SYMBOL(name) .private_extern name
-#define WEAK_SYMBOL(name) .weak_reference name
+#if defined(_LIBUNWIND_HIDE_SYMBOLS)
+#define EXPORT_SYMBOL(name) HIDDEN_SYMBOL(name)
+#else
+#define EXPORT_SYMBOL(name)
+#endif
 #define WEAK_ALIAS(name, aliasname)                                            \
   .globl SYMBOL_NAME(aliasname) SEPARATOR                                      \
-  WEAK_SYMBOL(aliasname) SEPARATOR                                             \
+  EXPORT_SYMBOL(SYMBOL_NAME(aliasname)) SEPARATOR                              \
   SYMBOL_NAME(aliasname) = SYMBOL_NAME(name)
 
 #define NO_EXEC_STACK_DIRECTIVE
 
 #elif defined(__ELF__)
 
 #if defined(__arm__)
 #define SYMBOL_IS_FUNC(name) .type name,%function
 #else
 #define SYMBOL_IS_FUNC(name) .type name,@function
 #endif
-#define EXPORT_SYMBOL(name)
 #define HIDDEN_SYMBOL(name) .hidden name
+#if defined(_LIBUNWIND_HIDE_SYMBOLS)
+#define EXPORT_SYMBOL(name) HIDDEN_SYMBOL(name)
+#else
+#define EXPORT_SYMBOL(name)
+#endif
 #define WEAK_SYMBOL(name) .weak name
 
 #if defined(__hexagon__)
-#define WEAK_ALIAS(name, aliasname) \
-  WEAK_SYMBOL(aliasname) SEPARATOR                                             \
+#define WEAK_ALIAS(name, aliasname)                                            \
+  EXPORT_SYMBOL(SYMBOL_NAME(aliasname)) SEPARATOR                              \
+  WEAK_SYMBOL(SYMBOL_NAME(aliasname)) SEPARATOR                                \
   .equiv SYMBOL_NAME(aliasname), SYMBOL_NAME(name)
 #else
 #define WEAK_ALIAS(name, aliasname)                                            \
-  WEAK_SYMBOL(aliasname) SEPARATOR                                             \
+  EXPORT_SYMBOL(SYMBOL_NAME(aliasname)) SEPARATOR                              \
+  WEAK_SYMBOL(SYMBOL_NAME(aliasname)) SEPARATOR                                \
   SYMBOL_NAME(aliasname) = SYMBOL_NAME(name)
 #endif
 
 #if defined(__GNU__) || defined(__FreeBSD__) || defined(__Fuchsia__) || \
     defined(__linux__)
 #define NO_EXEC_STACK_DIRECTIVE .section .note.GNU-stack,"",%progbits
 #else
 #define NO_EXEC_STACK_DIRECTIVE
 #endif
 
 #elif defined(_WIN32)
 
 #define SYMBOL_IS_FUNC(name)                                                   \
   .def name SEPARATOR                                                          \
     .scl 2 SEPARATOR                                                           \
     .type 32 SEPARATOR                                                         \
   .endef
 #define EXPORT_SYMBOL2(name)                                                   \
   .section .drectve,"yn" SEPARATOR                                             \
   .ascii "-export:", #name, "\0" SEPARATOR                                     \
   .text
-#if defined(_LIBUNWIND_DISABLE_VISIBILITY_ANNOTATIONS)
+#if defined(_LIBUNWIND_HIDE_SYMBOLS)
 #define EXPORT_SYMBOL(name)
 #else
 #define EXPORT_SYMBOL(name) EXPORT_SYMBOL2(name)
 #endif
 #define HIDDEN_SYMBOL(name)
 
 #if defined(__MINGW32__)
 #define WEAK_ALIAS(name, aliasname)                                            \

libunwind/src/config.h

#else
   // Assume an ELF system with a dl_iterate_phdr function.
   #define _LIBUNWIND_USE_DL_ITERATE_PHDR 1
   #if !defined(_LIBUNWIND_ARM_EHABI)
     #define _LIBUNWIND_SUPPORT_DWARF_UNWIND 1
     #define _LIBUNWIND_SUPPORT_DWARF_INDEX 1
   #endif
 #endif
 
-#if defined(_LIBUNWIND_DISABLE_VISIBILITY_ANNOTATIONS)
+#if defined(_LIBUNWIND_HIDE_SYMBOLS)
+  // The CMake file passes -fvisibility=hidden to control ELF/Mach-O visibility.
   #define _LIBUNWIND_EXPORT
   #define _LIBUNWIND_HIDDEN
 #else
   #if !defined(__ELF__) && !defined(__MACH__)
     #define _LIBUNWIND_EXPORT __declspec(dllexport)
     #define _LIBUNWIND_HIDDEN
   #else
     #define _LIBUNWIND_EXPORT __attribute__((visibility("default")))
     #define _LIBUNWIND_HIDDEN __attribute__((visibility("hidden")))
   #endif
 #endif
 
 #define STR(a) #a
 #define XSTR(a) STR(a)
 #define SYMBOL_NAME(name) XSTR(__USER_LABEL_PREFIX__) #name
 
 #if defined(__APPLE__)
+#if defined(_LIBUNWIND_HIDE_SYMBOLS)
+#define _LIBUNWIND_ALIAS_VISIBILITY(name) __asm__(".private_extern " name)
+#else
+#define _LIBUNWIND_ALIAS_VISIBILITY(name)
+#endif
 #define _LIBUNWIND_WEAK_ALIAS(name, aliasname)                                 \
   __asm__(".globl " SYMBOL_NAME(aliasname));                                   \
   __asm__(SYMBOL_NAME(aliasname) " = " SYMBOL_NAME(name));                     \
-  extern "C" _LIBUNWIND_EXPORT __typeof(name) aliasname                        \
-      __attribute__((weak_import));
+  _LIBUNWIND_ALIAS_VISIBILITY(SYMBOL_NAME(aliasname));
 #elif defined(__ELF__)
 #define _LIBUNWIND_WEAK_ALIAS(name, aliasname)                                 \
   extern "C" _LIBUNWIND_EXPORT __typeof(name) aliasname                        \
       __attribute__((weak, alias(#name)));
 #elif defined(_WIN32)
 #if defined(__MINGW32__)
 #define _LIBUNWIND_WEAK_ALIAS(name, aliasname)                                 \
   extern "C" _LIBUNWIND_EXPORT __typeof(name) aliasname                        \

llvm/utils/gn/secondary/libunwind/src/BUILD.gn

static_library("unwind_static") {
     output_name = "unwind"
     complete_static_lib = true
     configs -= [ "//llvm/utils/gn/build:thin_archive" ]
     sources = unwind_sources
     public = unwind_headers
     if (libunwind_hermetic_static_library) {
       cflags = [ "-fvisibility=hidden" ]
       cflags_cc = [ "-fvisibility-global-new-delete-hidden" ]
-      defines = [ "_LIBUNWIND_DISABLE_VISIBILITY_ANNOTATIONS" ]
+      defines = [ "_LIBUNWIND_HIDE_SYMBOLS" ]
     }
     deps = [ "//compiler-rt/lib/builtins" ]
     configs += [ ":unwind_config" ]
     configs -= [
       "//llvm/utils/gn/build:no_exceptions",
       "//llvm/utils/gn/build:no_rtti",
     ]
   }