mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-01-31 03:27:39 +00:00
c9152b6f14
This change switches c++ exception handling from sjlj to standard dwarf. It's needed because clang for aarch64 doesn't support sjlj. It turns out that libunwind had a bare-metal configuration that made this easy to do. This change gets the new experimental cosmocc -mclang flag in a state of working so well that it can now be used to build all of llamafile and it goes 3x faster in terms of build latency, without trading away any perf. The int_fast16_t and int_fast32_t types are now always defined as 32-bit in the interest of having more abi consistency between cosmocc -mgcc and -mclang mode.
475 lines
17 KiB
C++
475 lines
17 KiB
C++
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//
|
|
// Implements unw_* functions from <libunwind.h>
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "third_party/libunwind/include/libunwind.h"
|
|
|
|
#include "third_party/libunwind/config.h"
|
|
#include "third_party/libunwind/libunwind_ext.h"
|
|
|
|
#include "libc/isystem/stdlib.h"
|
|
|
|
// Define the __has_feature extension for compilers that do not support it so
|
|
// that we can later check for the presence of ASan in a compiler-neutral way.
|
|
#if !defined(__has_feature)
|
|
#define __has_feature(feature) 0
|
|
#endif
|
|
|
|
#if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
|
|
//#include <sanitizer/asan_interface.h>
|
|
#endif
|
|
|
|
#if !defined(__USING_SJLJ_EXCEPTIONS__)
|
|
#include "third_party/libunwind/AddressSpace.hpp"
|
|
#include "third_party/libunwind/UnwindCursor.hpp"
|
|
|
|
using namespace libunwind;
|
|
|
|
/// internal object to represent this processes address space
|
|
LocalAddressSpace LocalAddressSpace::sThisAddressSpace;
|
|
|
|
_LIBUNWIND_EXPORT unw_addr_space_t unw_local_addr_space =
|
|
(unw_addr_space_t)&LocalAddressSpace::sThisAddressSpace;
|
|
|
|
/// Create a cursor of a thread in this process given 'context' recorded by
|
|
/// __unw_getcontext().
|
|
_LIBUNWIND_HIDDEN int __unw_init_local(unw_cursor_t *cursor,
|
|
unw_context_t *context) {
|
|
_LIBUNWIND_TRACE_API("__unw_init_local(cursor=%p, context=%p)",
|
|
static_cast<void *>(cursor),
|
|
static_cast<void *>(context));
|
|
#if defined(__i386__)
|
|
# define REGISTER_KIND Registers_x86
|
|
#elif defined(__x86_64__)
|
|
# define REGISTER_KIND Registers_x86_64
|
|
#elif defined(__powerpc64__)
|
|
# define REGISTER_KIND Registers_ppc64
|
|
#elif defined(__powerpc__)
|
|
# define REGISTER_KIND Registers_ppc
|
|
#elif defined(__aarch64__)
|
|
# define REGISTER_KIND Registers_arm64
|
|
#elif defined(__arm__)
|
|
# define REGISTER_KIND Registers_arm
|
|
#elif defined(__or1k__)
|
|
# define REGISTER_KIND Registers_or1k
|
|
#elif defined(__hexagon__)
|
|
# define REGISTER_KIND Registers_hexagon
|
|
#elif defined(__mips__) && defined(_ABIO32) && _MIPS_SIM == _ABIO32
|
|
# define REGISTER_KIND Registers_mips_o32
|
|
#elif defined(__mips64)
|
|
# define REGISTER_KIND Registers_mips_newabi
|
|
#elif defined(__mips__)
|
|
# warning The MIPS architecture is not supported with this ABI and environment!
|
|
#elif defined(__sparc__) && defined(__arch64__)
|
|
#define REGISTER_KIND Registers_sparc64
|
|
#elif defined(__sparc__)
|
|
# define REGISTER_KIND Registers_sparc
|
|
#elif defined(__riscv)
|
|
# define REGISTER_KIND Registers_riscv
|
|
#elif defined(__ve__)
|
|
# define REGISTER_KIND Registers_ve
|
|
#elif defined(__s390x__)
|
|
# define REGISTER_KIND Registers_s390x
|
|
#elif defined(__loongarch__) && __loongarch_grlen == 64
|
|
#define REGISTER_KIND Registers_loongarch
|
|
#else
|
|
# error Architecture not supported
|
|
#endif
|
|
// Use "placement new" to allocate UnwindCursor in the cursor buffer.
|
|
new (reinterpret_cast<UnwindCursor<LocalAddressSpace, REGISTER_KIND> *>(cursor))
|
|
UnwindCursor<LocalAddressSpace, REGISTER_KIND>(
|
|
context, LocalAddressSpace::sThisAddressSpace);
|
|
#undef REGISTER_KIND
|
|
AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
|
|
co->setInfoBasedOnIPRegister();
|
|
|
|
return UNW_ESUCCESS;
|
|
}
|
|
_LIBUNWIND_WEAK_ALIAS(__unw_init_local, unw_init_local)
|
|
|
|
/// Get value of specified register at cursor position in stack frame.
|
|
_LIBUNWIND_HIDDEN int __unw_get_reg(unw_cursor_t *cursor, unw_regnum_t regNum,
|
|
unw_word_t *value) {
|
|
_LIBUNWIND_TRACE_API("__unw_get_reg(cursor=%p, regNum=%d, &value=%p)",
|
|
static_cast<void *>(cursor), regNum,
|
|
static_cast<void *>(value));
|
|
AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
|
|
if (co->validReg(regNum)) {
|
|
*value = co->getReg(regNum);
|
|
return UNW_ESUCCESS;
|
|
}
|
|
return UNW_EBADREG;
|
|
}
|
|
_LIBUNWIND_WEAK_ALIAS(__unw_get_reg, unw_get_reg)
|
|
|
|
/// Set value of specified register at cursor position in stack frame.
|
|
_LIBUNWIND_HIDDEN int __unw_set_reg(unw_cursor_t *cursor, unw_regnum_t regNum,
|
|
unw_word_t value) {
|
|
_LIBUNWIND_TRACE_API("__unw_set_reg(cursor=%p, regNum=%d, value=0x%" PRIxPTR
|
|
")",
|
|
static_cast<void *>(cursor), regNum, value);
|
|
typedef LocalAddressSpace::pint_t pint_t;
|
|
AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
|
|
if (co->validReg(regNum)) {
|
|
co->setReg(regNum, (pint_t)value);
|
|
// special case altering IP to re-find info (being called by personality
|
|
// function)
|
|
if (regNum == UNW_REG_IP) {
|
|
unw_proc_info_t info;
|
|
// First, get the FDE for the old location and then update it.
|
|
co->getInfo(&info);
|
|
co->setInfoBasedOnIPRegister(false);
|
|
// If the original call expects stack adjustment, perform this now.
|
|
// Normal frame unwinding would have included the offset already in the
|
|
// CFA computation.
|
|
// Note: for PA-RISC and other platforms where the stack grows up,
|
|
// this should actually be - info.gp. LLVM doesn't currently support
|
|
// any such platforms and Clang doesn't export a macro for them.
|
|
if (info.gp)
|
|
co->setReg(UNW_REG_SP, co->getReg(UNW_REG_SP) + info.gp);
|
|
}
|
|
return UNW_ESUCCESS;
|
|
}
|
|
return UNW_EBADREG;
|
|
}
|
|
_LIBUNWIND_WEAK_ALIAS(__unw_set_reg, unw_set_reg)
|
|
|
|
/// Get value of specified float register at cursor position in stack frame.
|
|
_LIBUNWIND_HIDDEN int __unw_get_fpreg(unw_cursor_t *cursor, unw_regnum_t regNum,
|
|
unw_fpreg_t *value) {
|
|
_LIBUNWIND_TRACE_API("__unw_get_fpreg(cursor=%p, regNum=%d, &value=%p)",
|
|
static_cast<void *>(cursor), regNum,
|
|
static_cast<void *>(value));
|
|
AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
|
|
if (co->validFloatReg(regNum)) {
|
|
*value = co->getFloatReg(regNum);
|
|
return UNW_ESUCCESS;
|
|
}
|
|
return UNW_EBADREG;
|
|
}
|
|
_LIBUNWIND_WEAK_ALIAS(__unw_get_fpreg, unw_get_fpreg)
|
|
|
|
/// Set value of specified float register at cursor position in stack frame.
|
|
_LIBUNWIND_HIDDEN int __unw_set_fpreg(unw_cursor_t *cursor, unw_regnum_t regNum,
|
|
unw_fpreg_t value) {
|
|
#if defined(_LIBUNWIND_ARM_EHABI)
|
|
_LIBUNWIND_TRACE_API("__unw_set_fpreg(cursor=%p, regNum=%d, value=%llX)",
|
|
static_cast<void *>(cursor), regNum, value);
|
|
#else
|
|
_LIBUNWIND_TRACE_API("__unw_set_fpreg(cursor=%p, regNum=%d, value=%g)",
|
|
static_cast<void *>(cursor), regNum, value);
|
|
#endif
|
|
AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
|
|
if (co->validFloatReg(regNum)) {
|
|
co->setFloatReg(regNum, value);
|
|
return UNW_ESUCCESS;
|
|
}
|
|
return UNW_EBADREG;
|
|
}
|
|
_LIBUNWIND_WEAK_ALIAS(__unw_set_fpreg, unw_set_fpreg)
|
|
|
|
/// Move cursor to next frame.
|
|
_LIBUNWIND_HIDDEN int __unw_step(unw_cursor_t *cursor) {
|
|
_LIBUNWIND_TRACE_API("__unw_step(cursor=%p)", static_cast<void *>(cursor));
|
|
AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
|
|
return co->step();
|
|
}
|
|
_LIBUNWIND_WEAK_ALIAS(__unw_step, unw_step)
|
|
|
|
// Move cursor to next frame and for stage2 of unwinding.
|
|
// This resets MTE tags of tagged frames to zero.
|
|
extern "C" _LIBUNWIND_HIDDEN int __unw_step_stage2(unw_cursor_t *cursor) {
|
|
_LIBUNWIND_TRACE_API("__unw_step_stage2(cursor=%p)",
|
|
static_cast<void *>(cursor));
|
|
AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
|
|
return co->step(true);
|
|
}
|
|
|
|
/// Get unwind info at cursor position in stack frame.
|
|
_LIBUNWIND_HIDDEN int __unw_get_proc_info(unw_cursor_t *cursor,
|
|
unw_proc_info_t *info) {
|
|
_LIBUNWIND_TRACE_API("__unw_get_proc_info(cursor=%p, &info=%p)",
|
|
static_cast<void *>(cursor), static_cast<void *>(info));
|
|
AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
|
|
co->getInfo(info);
|
|
if (info->end_ip == 0)
|
|
return UNW_ENOINFO;
|
|
return UNW_ESUCCESS;
|
|
}
|
|
_LIBUNWIND_WEAK_ALIAS(__unw_get_proc_info, unw_get_proc_info)
|
|
|
|
/// Resume execution at cursor position (aka longjump).
|
|
_LIBUNWIND_HIDDEN int __unw_resume(unw_cursor_t *cursor) {
|
|
_LIBUNWIND_TRACE_API("__unw_resume(cursor=%p)", static_cast<void *>(cursor));
|
|
#if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
|
|
// Inform the ASan runtime that now might be a good time to clean stuff up.
|
|
__asan_handle_no_return();
|
|
#endif
|
|
AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
|
|
co->jumpto();
|
|
return UNW_EUNSPEC;
|
|
}
|
|
_LIBUNWIND_WEAK_ALIAS(__unw_resume, unw_resume)
|
|
|
|
/// Get name of function at cursor position in stack frame.
|
|
_LIBUNWIND_HIDDEN int __unw_get_proc_name(unw_cursor_t *cursor, char *buf,
|
|
size_t bufLen, unw_word_t *offset) {
|
|
_LIBUNWIND_TRACE_API("__unw_get_proc_name(cursor=%p, &buf=%p, bufLen=%lu)",
|
|
static_cast<void *>(cursor), static_cast<void *>(buf),
|
|
static_cast<unsigned long>(bufLen));
|
|
AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
|
|
if (co->getFunctionName(buf, bufLen, offset))
|
|
return UNW_ESUCCESS;
|
|
return UNW_EUNSPEC;
|
|
}
|
|
_LIBUNWIND_WEAK_ALIAS(__unw_get_proc_name, unw_get_proc_name)
|
|
|
|
/// Checks if a register is a floating-point register.
|
|
_LIBUNWIND_HIDDEN int __unw_is_fpreg(unw_cursor_t *cursor,
|
|
unw_regnum_t regNum) {
|
|
_LIBUNWIND_TRACE_API("__unw_is_fpreg(cursor=%p, regNum=%d)",
|
|
static_cast<void *>(cursor), regNum);
|
|
AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
|
|
return co->validFloatReg(regNum);
|
|
}
|
|
_LIBUNWIND_WEAK_ALIAS(__unw_is_fpreg, unw_is_fpreg)
|
|
|
|
/// Checks if a register is a floating-point register.
|
|
_LIBUNWIND_HIDDEN const char *__unw_regname(unw_cursor_t *cursor,
|
|
unw_regnum_t regNum) {
|
|
_LIBUNWIND_TRACE_API("__unw_regname(cursor=%p, regNum=%d)",
|
|
static_cast<void *>(cursor), regNum);
|
|
AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
|
|
return co->getRegisterName(regNum);
|
|
}
|
|
_LIBUNWIND_WEAK_ALIAS(__unw_regname, unw_regname)
|
|
|
|
/// Checks if current frame is signal trampoline.
|
|
_LIBUNWIND_HIDDEN int __unw_is_signal_frame(unw_cursor_t *cursor) {
|
|
_LIBUNWIND_TRACE_API("__unw_is_signal_frame(cursor=%p)",
|
|
static_cast<void *>(cursor));
|
|
AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
|
|
return co->isSignalFrame();
|
|
}
|
|
_LIBUNWIND_WEAK_ALIAS(__unw_is_signal_frame, unw_is_signal_frame)
|
|
|
|
#ifdef _AIX
|
|
_LIBUNWIND_EXPORT uintptr_t __unw_get_data_rel_base(unw_cursor_t *cursor) {
|
|
_LIBUNWIND_TRACE_API("unw_get_data_rel_base(cursor=%p)",
|
|
static_cast<void *>(cursor));
|
|
AbstractUnwindCursor *co = reinterpret_cast<AbstractUnwindCursor *>(cursor);
|
|
return co->getDataRelBase();
|
|
}
|
|
_LIBUNWIND_WEAK_ALIAS(__unw_get_data_rel_base, unw_get_data_rel_base)
|
|
#endif
|
|
|
|
#ifdef __arm__
|
|
// Save VFP registers d0-d15 using FSTMIADX instead of FSTMIADD
|
|
_LIBUNWIND_HIDDEN void __unw_save_vfp_as_X(unw_cursor_t *cursor) {
|
|
_LIBUNWIND_TRACE_API("__unw_get_fpreg_save_vfp_as_X(cursor=%p)",
|
|
static_cast<void *>(cursor));
|
|
AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
|
|
return co->saveVFPAsX();
|
|
}
|
|
_LIBUNWIND_WEAK_ALIAS(__unw_save_vfp_as_X, unw_save_vfp_as_X)
|
|
#endif
|
|
|
|
|
|
#if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
|
|
/// SPI: walks cached DWARF entries
|
|
_LIBUNWIND_HIDDEN void __unw_iterate_dwarf_unwind_cache(void (*func)(
|
|
unw_word_t ip_start, unw_word_t ip_end, unw_word_t fde, unw_word_t mh)) {
|
|
_LIBUNWIND_TRACE_API("__unw_iterate_dwarf_unwind_cache(func=%p)",
|
|
reinterpret_cast<void *>(func));
|
|
DwarfFDECache<LocalAddressSpace>::iterateCacheEntries(func);
|
|
}
|
|
_LIBUNWIND_WEAK_ALIAS(__unw_iterate_dwarf_unwind_cache,
|
|
unw_iterate_dwarf_unwind_cache)
|
|
|
|
/// IPI: for __register_frame()
|
|
void __unw_add_dynamic_fde(unw_word_t fde) {
|
|
CFI_Parser<LocalAddressSpace>::FDE_Info fdeInfo;
|
|
CFI_Parser<LocalAddressSpace>::CIE_Info cieInfo;
|
|
const char *message = CFI_Parser<LocalAddressSpace>::decodeFDE(
|
|
LocalAddressSpace::sThisAddressSpace,
|
|
(LocalAddressSpace::pint_t) fde, &fdeInfo, &cieInfo);
|
|
if (message == NULL) {
|
|
// dynamically registered FDEs don't have a mach_header group they are in.
|
|
// Use fde as mh_group
|
|
unw_word_t mh_group = fdeInfo.fdeStart;
|
|
DwarfFDECache<LocalAddressSpace>::add((LocalAddressSpace::pint_t)mh_group,
|
|
fdeInfo.pcStart, fdeInfo.pcEnd,
|
|
fdeInfo.fdeStart);
|
|
} else {
|
|
_LIBUNWIND_DEBUG_LOG("__unw_add_dynamic_fde: bad fde: %s", message);
|
|
}
|
|
}
|
|
|
|
/// IPI: for __deregister_frame()
|
|
void __unw_remove_dynamic_fde(unw_word_t fde) {
|
|
// fde is own mh_group
|
|
DwarfFDECache<LocalAddressSpace>::removeAllIn((LocalAddressSpace::pint_t)fde);
|
|
}
|
|
|
|
void __unw_add_dynamic_eh_frame_section(unw_word_t eh_frame_start) {
|
|
// The eh_frame section start serves as the mh_group
|
|
unw_word_t mh_group = eh_frame_start;
|
|
CFI_Parser<LocalAddressSpace>::CIE_Info cieInfo = {};
|
|
CFI_Parser<LocalAddressSpace>::FDE_Info fdeInfo;
|
|
auto p = (LocalAddressSpace::pint_t)eh_frame_start;
|
|
while (true) {
|
|
if (CFI_Parser<LocalAddressSpace>::decodeFDE(
|
|
LocalAddressSpace::sThisAddressSpace, p, &fdeInfo, &cieInfo,
|
|
true) == NULL) {
|
|
DwarfFDECache<LocalAddressSpace>::add((LocalAddressSpace::pint_t)mh_group,
|
|
fdeInfo.pcStart, fdeInfo.pcEnd,
|
|
fdeInfo.fdeStart);
|
|
p += fdeInfo.fdeLength;
|
|
} else if (CFI_Parser<LocalAddressSpace>::parseCIE(
|
|
LocalAddressSpace::sThisAddressSpace, p, &cieInfo) == NULL) {
|
|
p += cieInfo.cieLength;
|
|
} else
|
|
return;
|
|
}
|
|
}
|
|
|
|
void __unw_remove_dynamic_eh_frame_section(unw_word_t eh_frame_start) {
|
|
// The eh_frame section start serves as the mh_group
|
|
DwarfFDECache<LocalAddressSpace>::removeAllIn(
|
|
(LocalAddressSpace::pint_t)eh_frame_start);
|
|
}
|
|
|
|
#endif // defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
|
|
#endif // !defined(__USING_SJLJ_EXCEPTIONS__)
|
|
|
|
#ifdef __APPLE__
|
|
|
|
namespace libunwind {
|
|
|
|
static constexpr size_t MAX_DYNAMIC_UNWIND_SECTIONS_FINDERS = 8;
|
|
|
|
static RWMutex findDynamicUnwindSectionsLock;
|
|
static size_t numDynamicUnwindSectionsFinders = 0;
|
|
static unw_find_dynamic_unwind_sections
|
|
dynamicUnwindSectionsFinders[MAX_DYNAMIC_UNWIND_SECTIONS_FINDERS] = {0};
|
|
|
|
bool findDynamicUnwindSections(void *addr, unw_dynamic_unwind_sections *info) {
|
|
bool found = false;
|
|
findDynamicUnwindSectionsLock.lock_shared();
|
|
for (size_t i = 0; i != numDynamicUnwindSectionsFinders; ++i) {
|
|
if (dynamicUnwindSectionsFinders[i]((unw_word_t)addr, info)) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
findDynamicUnwindSectionsLock.unlock_shared();
|
|
return found;
|
|
}
|
|
|
|
} // namespace libunwind
|
|
|
|
int __unw_add_find_dynamic_unwind_sections(
|
|
unw_find_dynamic_unwind_sections find_dynamic_unwind_sections) {
|
|
findDynamicUnwindSectionsLock.lock();
|
|
|
|
// Check that we have enough space...
|
|
if (numDynamicUnwindSectionsFinders == MAX_DYNAMIC_UNWIND_SECTIONS_FINDERS) {
|
|
findDynamicUnwindSectionsLock.unlock();
|
|
return UNW_ENOMEM;
|
|
}
|
|
|
|
// Check for value already present...
|
|
for (size_t i = 0; i != numDynamicUnwindSectionsFinders; ++i) {
|
|
if (dynamicUnwindSectionsFinders[i] == find_dynamic_unwind_sections) {
|
|
findDynamicUnwindSectionsLock.unlock();
|
|
return UNW_EINVAL;
|
|
}
|
|
}
|
|
|
|
// Success -- add callback entry.
|
|
dynamicUnwindSectionsFinders[numDynamicUnwindSectionsFinders++] =
|
|
find_dynamic_unwind_sections;
|
|
findDynamicUnwindSectionsLock.unlock();
|
|
|
|
return UNW_ESUCCESS;
|
|
}
|
|
|
|
int __unw_remove_find_dynamic_unwind_sections(
|
|
unw_find_dynamic_unwind_sections find_dynamic_unwind_sections) {
|
|
findDynamicUnwindSectionsLock.lock();
|
|
|
|
// Find index to remove.
|
|
size_t finderIdx = numDynamicUnwindSectionsFinders;
|
|
for (size_t i = 0; i != numDynamicUnwindSectionsFinders; ++i) {
|
|
if (dynamicUnwindSectionsFinders[i] == find_dynamic_unwind_sections) {
|
|
finderIdx = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If no such registration is present then error out.
|
|
if (finderIdx == numDynamicUnwindSectionsFinders) {
|
|
findDynamicUnwindSectionsLock.unlock();
|
|
return UNW_EINVAL;
|
|
}
|
|
|
|
// Remove entry.
|
|
for (size_t i = finderIdx; i != numDynamicUnwindSectionsFinders - 1; ++i)
|
|
dynamicUnwindSectionsFinders[i] = dynamicUnwindSectionsFinders[i + 1];
|
|
dynamicUnwindSectionsFinders[--numDynamicUnwindSectionsFinders] = nullptr;
|
|
|
|
findDynamicUnwindSectionsLock.unlock();
|
|
return UNW_ESUCCESS;
|
|
}
|
|
|
|
#endif // __APPLE__
|
|
|
|
// Add logging hooks in Debug builds only
|
|
#ifndef NDEBUG
|
|
#include "libc/isystem/stdlib.h"
|
|
|
|
_LIBUNWIND_HIDDEN
|
|
bool logAPIs() {
|
|
// do manual lock to avoid use of _cxa_guard_acquire or initializers
|
|
static bool checked = false;
|
|
static bool log = false;
|
|
if (!checked) {
|
|
log = (getenv("LIBUNWIND_PRINT_APIS") != NULL);
|
|
checked = true;
|
|
}
|
|
return log;
|
|
}
|
|
|
|
_LIBUNWIND_HIDDEN
|
|
bool logUnwinding() {
|
|
// do manual lock to avoid use of _cxa_guard_acquire or initializers
|
|
static bool checked = false;
|
|
static bool log = false;
|
|
if (!checked) {
|
|
log = (getenv("LIBUNWIND_PRINT_UNWINDING") != NULL);
|
|
checked = true;
|
|
}
|
|
return log;
|
|
}
|
|
|
|
_LIBUNWIND_HIDDEN
|
|
bool logDWARF() {
|
|
// do manual lock to avoid use of _cxa_guard_acquire or initializers
|
|
static bool checked = false;
|
|
static bool log = false;
|
|
if (!checked) {
|
|
log = (getenv("LIBUNWIND_PRINT_DWARF") != NULL);
|
|
checked = true;
|
|
}
|
|
return log;
|
|
}
|
|
|
|
#endif // NDEBUG
|
|
|