From 3408c53a62c3afb17d31adac47200ed5cfcc0fc4 Mon Sep 17 00:00:00 2001 From: PulkoMandy Date: Tue, 4 Feb 2025 16:16:01 +0100 Subject: [PATCH] gcc: enable libasan and libubsan This allows to use GCC address and undefined behavior sanitizers. ASLR must be disabled for the address sanitizer to work (otherwise there is an mmap failure during initialization). The implementation is based on the existing ones for other POSIX-ish operating systems (mainly Linux, FreeBSD, NetBSD, as seemed appropriate). The main difficulty is that the sanitizer intercepts various C library calls but also needs the original functions. This is implemented either by direct syscalls (when simple enough), or with dlopen to locate the original symbol in libroot. Only lightly tested, but it already allowed me to find a bug in one of my projects. --- sys-devel/gcc/gcc-13.3.0_2023_08_10.recipe | 54 +- .../patches/gcc-13.3.0_2023_08_10.patchset | 1374 ++++++++++++++++- 2 files changed, 1409 insertions(+), 19 deletions(-) diff --git a/sys-devel/gcc/gcc-13.3.0_2023_08_10.recipe b/sys-devel/gcc/gcc-13.3.0_2023_08_10.recipe index e429ff9ab..37c045355 100644 --- a/sys-devel/gcc/gcc-13.3.0_2023_08_10.recipe +++ b/sys-devel/gcc/gcc-13.3.0_2023_08_10.recipe @@ -5,7 +5,7 @@ HOMEPAGE="https://gcc.gnu.org/" COPYRIGHT="1988-2023 Free Software Foundation, Inc." LICENSE="GNU GPL v3 GNU LGPL v3" -REVISION="3" +REVISION="4" gccVersion="${portVersion%%_*}" SOURCE_URI="https://ftpmirror.gnu.org/gcc/gcc-$gccVersion/gcc-$gccVersion.tar.xz https://ftp.gnu.org/gnu/gcc/gcc-$gccVersion/gcc-$gccVersion.tar.xz" @@ -17,6 +17,9 @@ PATCHES="gcc-$portVersion.patchset ARCHITECTURES="all !x86_gcc2" SECONDARY_ARCHITECTURES="x86" +libasanSoVersion="8" +libasanLibVersion="8.0.0" + libatomicSoVersion="1" libatomicLibVersion="1.2.0" @@ -41,6 +44,9 @@ libsspLibVersion="0.0.0" libstdcxxSoVersion="6" libstdcxxLibVersion="6.0.32" +libubsanSoVersion="1" +libubsanLibVersion="1.0.0" + PROVIDES=" gcc$secondaryArchSuffix = $portVersion compat >= 7 cmd:c++$secondaryArchSuffix = $portVersion compat >= 7 @@ -115,6 +121,7 @@ distribution. This package contains the shared libraries for the runtime \ loader, so it is required for executing most c/c++ programs." PROVIDES_syslibs=" gcc${secondaryArchSuffix}_syslibs = $portVersion compat >= 7 + lib:libasan$secondaryArchSuffix = $libasanLibVersion compat >= $libasanSoVersion lib:libatomic$secondaryArchSuffix = $libatomicLibVersion compat >= $libatomicSoVersion lib:libgcc_s$secondaryArchSuffix = $libgccLibVersion compat >= $libgccSoVersion lib:libgfortran$secondaryArchSuffix = $libgfortranLibVersion compat >= $libgfortranSoVersion @@ -123,6 +130,7 @@ PROVIDES_syslibs=" lib:libssp$secondaryArchSuffix = $libsspLibVersion compat >= $libsspSoVersion lib:libstdc++$secondaryArchSuffix = $libstdcxxLibVersion compat >= $libstdcxxSoVersion lib:libsupc++$secondaryArchSuffix = $portVersion compat >= 7 + lib:libubsan$secondaryArchSuffix = $libubsanLibVersion compat >= $libubsanSoVersion " REQUIRES_syslibs=" haiku$secondaryArchSuffix @@ -135,6 +143,7 @@ contains the set of gcc's C/C++-runtime libraries and headers that is \ required by Haiku's build system when building Haiku." PROVIDES_syslibs_devel=" gcc${secondaryArchSuffix}_syslibs_devel = $portVersion compat >= 7 + devel:libasan$secondaryArchSuffix = $libasanLibVersion compat >= $libasanSoVersion devel:libatomic$secondaryArchSuffix = $libatomicLibVersion compat >= $libatomicSoVersion devel:libgcc$secondaryArchSuffix = $libgccLibVersion compat >= $libgccSoVersion devel:libgcc_boot$secondaryArchSuffix = $libgccLibVersion compat >= $libgccSoVersion @@ -153,6 +162,7 @@ PROVIDES_syslibs_devel=" devel:libsupc++$secondaryArchSuffix = $portVersion compat >= 7 devel:libsupc++_boot$secondaryArchSuffix = $portVersion compat >= 7 devel:libsupc++_kernel$secondaryArchSuffix = $portVersion compat >= 7 + devel:libubsan$secondaryArchSuffix = $libubsanLibVersion compat >= $libubsanSoVersion " REQUIRES_syslibs_devel=" gcc${secondaryArchSuffix}_syslibs == $portVersion base @@ -206,13 +216,15 @@ defineDebugInfoPackage gcc$secondaryArchSuffix \ "$(getPackagePrefix fortran)/$relativeInstallDir"/bin/gfortran \ "$(getPackagePrefix fortran)/$relativeInstallDir/$gccLibDir"/f951 \ "$(getPackagePrefix jit)/$relativeLibDir"/libgccjit.so.$libgccjitLibVersion \ + "$(getPackagePrefix syslibs)/$relativeLibDir"/libasan.so.$libasanLibVersion \ "$(getPackagePrefix syslibs)/$relativeLibDir"/libatomic.so.$libatomicLibVersion \ "$(getPackagePrefix syslibs)/$relativeLibDir"/libgcc_s.so.$libgccSoVersion \ "$(getPackagePrefix syslibs)/$relativeLibDir"/libgfortran.so.$libgfortranLibVersion \ "$(getPackagePrefix syslibs)/$relativeLibDir"/libgomp.so.$libgompLibVersion \ "$(getPackagePrefix syslibs)/$relativeLibDir"/libquadmath.so.$libquadmathLibVersion \ "$(getPackagePrefix syslibs)/$relativeLibDir"/libssp.so.$libsspLibVersion \ - "$(getPackagePrefix syslibs)/$relativeLibDir"/libstdc++.so.$libstdcxxLibVersion + "$(getPackagePrefix syslibs)/$relativeLibDir"/libstdc++.so.$libstdcxxLibVersion \ + "$(getPackagePrefix syslibs)/$relativeLibDir"/libubsan.so.$libubsanLibVersion BUILD() { @@ -236,8 +248,8 @@ BUILD() kernelCcFlags="$kernelCcFlags -mno-red-zone" fi - "$sourceDir/configure" \ - --build=$effectiveTargetMachineTriple \ + "$sourceDir/configure" \ + --build=$effectiveTargetMachineTriple \ --prefix=$installDir --libexecdir=$installDir/lib --mandir=$manDir \ --docdir=$docDir --enable-threads=posix \ --disable-nls --enable-shared --with-gnu-ld --with-gnu-as \ @@ -248,7 +260,7 @@ BUILD() --enable-__cxa-atexit --with-system-zlib --enable-checking=release \ --with-bug-url=http://dev.haiku-os.org/ \ --with-default-libstdcxx-abi=gcc4-compatible \ - --enable-libssp --enable-host-shared \ + --enable-libssp --enable-libsanitizer --enable-host-shared \ $additionalConfigureFlags make $jobArgs @@ -370,6 +382,17 @@ INSTALL() mkdir -p $developLibDir cd $installDir + # libasan + mv $gccLibDir/libasan.so \ + $gccLibDir/libasan.so.$libasanSoVersion \ + $gccLibDir/libasan.so.$libasanLibVersion \ + $libDir/ + ln -s $libDir/libasan.so \ + $libDir/libasan.so.$libasanSoVersion \ + $libDir/libasan.so.$libasanLibVersion \ + $gccLibDir + rm $gccLibDir/libasan.a + # libatomic mv $gccLibDir/libatomic.so \ $gccLibDir/libatomic.so.$libatomicSoVersion \ @@ -453,6 +476,17 @@ INSTALL() ln -s $libDir/libstdc++.so $libDir/libsupc++.so mv $gccLibDir/libsupc++*.a $developLibDir/ + # libubsan + mv $gccLibDir/libubsan.so \ + $gccLibDir/libubsan.so.$libubsanSoVersion \ + $gccLibDir/libubsan.so.$libubsanLibVersion \ + $libDir/ + ln -s $libDir/libubsan.so \ + $libDir/libubsan.so.$libubsanSoVersion \ + $libDir/libubsan.so.$libubsanLibVersion \ + $gccLibDir + rm $gccLibDir/libubsan.a + # libgcc cp $objectsDir/$effectiveTargetMachineTriple/libgcc/libgcc-kernel.a \ $objectsDir/$effectiveTargetMachineTriple/libgcc/libgcc_eh-kernel.a \ @@ -529,7 +563,7 @@ INSTALL() # symlink all libraries from libDir -> developLibDir mkdir -p $developLibDir - for l in libatomic libgccjit libgomp libquadmath libssp libgcc_s libstdc++ \ + for l in libasan libatomic libgccjit libgcc_s libgomp libquadmath libssp libubsan libstdc++ \ libsupc++; do for f in $libDir/$l*; do symlinkRelative -sfn $f $developLibDir/ @@ -570,6 +604,9 @@ INSTALL() $relativeIncludeDir/libgccjit++.h packageEntries "syslibs" \ + $relativeLibDir/libasan.so \ + $relativeLibDir/libasan.so.$libasanSoVersion \ + $relativeLibDir/libasan.so.$libasanLibVersion \ $relativeLibDir/libatomic.so \ $relativeLibDir/libatomic.so.$libatomicSoVersion \ $relativeLibDir/libatomic.so.$libatomicLibVersion \ @@ -590,7 +627,10 @@ INSTALL() $relativeLibDir/libstdc++.so \ $relativeLibDir/libstdc++.so.$libstdcxxSoVersion \ $relativeLibDir/libstdc++.so.$libstdcxxLibVersion \ - $relativeLibDir/libsupc++.so + $relativeLibDir/libsupc++.so \ + $relativeLibDir/libubsan.so \ + $relativeLibDir/libubsan.so.$libubsanSoVersion \ + $relativeLibDir/libubsan.so.$libubsanLibVersion packageEntries "syslibs_devel" \ $developLibDir/*.so* \ diff --git a/sys-devel/gcc/patches/gcc-13.3.0_2023_08_10.patchset b/sys-devel/gcc/patches/gcc-13.3.0_2023_08_10.patchset index 36c97850b..848e3e3de 100644 --- a/sys-devel/gcc/patches/gcc-13.3.0_2023_08_10.patchset +++ b/sys-devel/gcc/patches/gcc-13.3.0_2023_08_10.patchset @@ -1,4 +1,4 @@ -From 3f0d11d2185da906d21ee2f6ca8cbc379062719f Mon Sep 17 00:00:00 2001 +From 18b974306411da4abcd08a94fc778cae18bfa4c1 Mon Sep 17 00:00:00 2001 From: Niels Sascha Reedijk Date: Tue, 15 Aug 2023 06:19:59 +0100 Subject: Modifications for GCC 13.2.0 for Haiku (from buildtools repository) @@ -8222,10 +8222,10 @@ index b92e284..6a180a5 100644 hpux*) -- -2.37.3 +2.45.2 -From b3d8f39d12da09930ff28c37212612781eb2460a Mon Sep 17 00:00:00 2001 +From 6bbc307436eef13811173fc37072786972741f91 Mon Sep 17 00:00:00 2001 From: Yn0ga Date: Thu, 5 Oct 2023 19:58:27 +0000 Subject: Update PPC toolchain, should fix #18474 @@ -8318,10 +8318,10 @@ index 2c78454..8dd05b6 100644 powerpc-*-netbsd*) tmake_file="$tmake_file rs6000/t-netbsd rs6000/t-crtstuff" -- -2.37.3 +2.45.2 -From 37ffec1f0e98a71888729067283a84e48e5eb262 Mon Sep 17 00:00:00 2001 +From d42622c32987c0c42c0e7418332cd1a678733405 Mon Sep 17 00:00:00 2001 From: Adrien Destugues Date: Wed, 13 Dec 2023 13:54:29 +0100 Subject: gcc: remove obsolete macro definitions @@ -8401,10 +8401,10 @@ index 1b56931..3781045 100644 /* Output assembler code to FILE to call the profiler. */ #define NO_PROFILE_COUNTERS 1 -- -2.37.3 +2.45.2 -From 0b08f1412c04dc04d946c3fabcf068f14fac7bbe Mon Sep 17 00:00:00 2001 +From 8f901f7ea21b2056fa8955b7cfd0006c8118a2fb Mon Sep 17 00:00:00 2001 From: David Karoly Date: Thu, 28 Mar 2024 17:19:03 +0100 Subject: gcc/config/rs6000: fix typo @@ -8425,10 +8425,10 @@ index 59be0b8..f1f1317 100644 + } \ while (0) -- -2.37.3 +2.45.2 -From b70e8909fec9f29601ffb2afeebadd228a12f19c Mon Sep 17 00:00:00 2001 +From e576c232e8c97f538ace4710b55ab597325ed293 Mon Sep 17 00:00:00 2001 From: Jerome Duval Date: Mon, 10 Jun 2024 16:41:43 +0200 Subject: gcc/config/i386: apply change from 13.x to haiku @@ -8469,10 +8469,10 @@ index 3781045..d9d99c3 100644 #define TARGET_OS_CPP_BUILTINS() \ do \ -- -2.37.3 +2.45.2 -From 12bd93b7b7bdfac702c1ccf80e159c5fd56d8f94 Mon Sep 17 00:00:00 2001 +From 42cdebf93c1df48e299a3ff2c7031dbeeb9c3b0e Mon Sep 17 00:00:00 2001 From: Jerome Duval Date: Mon, 10 Jun 2024 16:45:13 +0200 Subject: libstdc++: fix posix_memalign signature @@ -8492,5 +8492,1355 @@ index 29767c1..3c06b5c 100644 void *aligned_alloc(size_t alignment, size_t size); # elif _GLIBCXX_HAVE__ALIGNED_MALLOC -- -2.37.3 +2.45.2 + + +From d9ad7647fe6d7edd2092fe9ceecbe02f8d0a1b9e Mon Sep 17 00:00:00 2001 +From: PulkoMandy +Date: Mon, 27 Jan 2025 22:06:02 +0100 +Subject: Fix build of libasan and libubsan for Haiku + + +diff --git a/libsanitizer/asan/asan_linux.cpp b/libsanitizer/asan/asan_linux.cpp +index 89450fc..6aa4659 100644 +--- a/libsanitizer/asan/asan_linux.cpp ++++ b/libsanitizer/asan/asan_linux.cpp +@@ -13,7 +13,7 @@ + + #include "sanitizer_common/sanitizer_platform.h" + #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \ +- SANITIZER_SOLARIS ++ SANITIZER_SOLARIS || SANITIZER_HAIKU + + #include "asan_interceptors.h" + #include "asan_internal.h" +@@ -27,7 +27,9 @@ + #include + #include + #include ++#if !SANITIZER_HAIKU + #include ++#endif + #include + #include + #include +@@ -37,7 +39,7 @@ + #include + #include + +-#if SANITIZER_FREEBSD ++#if SANITIZER_FREEBSD || SANITIZER_HAIKU + #include + #endif + +@@ -45,8 +47,10 @@ + #include + #endif + +-#if SANITIZER_ANDROID || SANITIZER_FREEBSD || SANITIZER_SOLARIS ++#if SANITIZER_ANDROID || SANITIZER_FREEBSD || SANITIZER_SOLARIS || SANITIZER_HAIKU ++#if !SANITIZER_HAIKU + #include ++#endif + extern "C" void* _DYNAMIC; + #elif SANITIZER_NETBSD + #include +@@ -139,6 +143,12 @@ static int FindFirstDSOCallback(struct dl_phdr_info *info, size_t size, + return 0; + } + ++#if SANITIZER_HAIKU ++ if (!info->dlpi_name[0] || ++ internal_strncmp(info->dlpi_name, "/boot/system/runtime_loader", sizeof("/boot/system/runtime_loader") - 1) == 0) ++ return 0; ++#endif ++ + # if SANITIZER_LINUX + // Ignore vDSO. glibc versions earlier than 2.15 (and some patched + // by distributors) return an empty name for the vDSO entry, so +@@ -172,7 +182,7 @@ void AsanCheckDynamicRTPrereqs() { + if (first_dso_name && first_dso_name[0] && !IsDynamicRTName(first_dso_name)) { + Report("ASan runtime does not come first in initial library list; " + "you should either link runtime to your application or " +- "manually preload it with LD_PRELOAD.\n"); ++ "manually preload it with LD_PRELOAD (%s).\n", first_dso_name); + Die(); + } + } +diff --git a/libsanitizer/asan/asan_malloc_linux.cpp b/libsanitizer/asan/asan_malloc_linux.cpp +index bab80b9..1821f9e 100644 +--- a/libsanitizer/asan/asan_malloc_linux.cpp ++++ b/libsanitizer/asan/asan_malloc_linux.cpp +@@ -15,7 +15,7 @@ + + #include "sanitizer_common/sanitizer_platform.h" + #if SANITIZER_FREEBSD || SANITIZER_FUCHSIA || SANITIZER_LINUX || \ +- SANITIZER_NETBSD || SANITIZER_SOLARIS ++ SANITIZER_NETBSD || SANITIZER_SOLARIS || SANITIZER_HAIKU + + # include "asan_allocator.h" + # include "asan_interceptors.h" +diff --git a/libsanitizer/configure.tgt b/libsanitizer/configure.tgt +index d24566a..f7e6d85 100644 +--- a/libsanitizer/configure.tgt ++++ b/libsanitizer/configure.tgt +@@ -24,6 +24,8 @@ SANITIZER_COMMON_TARGET_DEPENDENT_OBJECTS= + case "${target}" in + x86_64-*-freebsd* | i?86-*-freebsd*) + ;; ++ x86_64-*-haiku*) ++ ;; + x86_64-*-linux* | i?86-*-linux*) + if test x$ac_cv_sizeof_void_p = x8; then + TSAN_SUPPORTED=yes +diff --git a/libsanitizer/interception/interception.h b/libsanitizer/interception/interception.h +index d97974e..ec10fa0 100644 +--- a/libsanitizer/interception/interception.h ++++ b/libsanitizer/interception/interception.h +@@ -18,7 +18,7 @@ + + #if !SANITIZER_LINUX && !SANITIZER_FREEBSD && !SANITIZER_APPLE && \ + !SANITIZER_NETBSD && !SANITIZER_WINDOWS && !SANITIZER_FUCHSIA && \ +- !SANITIZER_SOLARIS ++ !SANITIZER_SOLARIS && !SANITIZER_HAIKU + # error "Interception doesn't work on this operating system." + #endif + +@@ -272,7 +272,7 @@ typedef unsigned long uptr; + #define INCLUDED_FROM_INTERCEPTION_LIB + + #if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD || \ +- SANITIZER_SOLARIS ++ SANITIZER_SOLARIS || SANITIZER_HAIKU + + # include "interception_linux.h" + # define INTERCEPT_FUNCTION(func) INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func) +diff --git a/libsanitizer/interception/interception_linux.cpp b/libsanitizer/interception/interception_linux.cpp +index 5111a87..e851bec 100644 +--- a/libsanitizer/interception/interception_linux.cpp ++++ b/libsanitizer/interception/interception_linux.cpp +@@ -14,7 +14,7 @@ + #include "interception.h" + + #if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD || \ +- SANITIZER_SOLARIS ++ SANITIZER_SOLARIS || SANITIZER_HAIKU + + #include // for dlsym() and dlvsym() + +diff --git a/libsanitizer/interception/interception_linux.h b/libsanitizer/interception/interception_linux.h +index a08f8cb..36ed75d 100644 +--- a/libsanitizer/interception/interception_linux.h ++++ b/libsanitizer/interception/interception_linux.h +@@ -12,7 +12,7 @@ + //===----------------------------------------------------------------------===// + + #if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD || \ +- SANITIZER_SOLARIS ++ SANITIZER_SOLARIS || SANITIZER_HAIKU + + #if !defined(INCLUDED_FROM_INTERCEPTION_LIB) + # error "interception_linux.h should be included from interception library only" +diff --git a/libsanitizer/sanitizer_common/Makefile.am b/libsanitizer/sanitizer_common/Makefile.am +index cd8a9bf..9b9c65d 100644 +--- a/libsanitizer/sanitizer_common/Makefile.am ++++ b/libsanitizer/sanitizer_common/Makefile.am +@@ -7,7 +7,7 @@ DEFS = -D_GNU_SOURCE -D_DEBUG -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D + AM_CXXFLAGS = -Wall -W -Wno-unused-parameter -Wwrite-strings -pedantic -Wno-long-long -fPIC -fno-builtin -fno-exceptions -fno-rtti -fomit-frame-pointer -funwind-tables -fvisibility=hidden -Wno-variadic-macros + AM_CXXFLAGS += $(LIBSTDCXX_RAW_CXX_CXXFLAGS) + AM_CXXFLAGS += -std=gnu++14 +-AM_CXXFLAGS += $(EXTRA_CXXFLAGS) ++AM_CXXFLAGS += $(EXTRA_CXXFLAGS) -I /system/develop/headers/private -I /system/develop/headers/private/system/arch/x86_64 -I /system/develop/headers/private/system \ + if LIBBACKTRACE_SUPPORTED + AM_CXXFLAGS += -DSANITIZER_LIBBACKTRACE -DSANITIZER_CP_DEMANGLE \ + -I $(top_srcdir)/../libbacktrace \ +@@ -54,6 +54,7 @@ sanitizer_common_files = \ + sanitizer_printf.cpp \ + sanitizer_procmaps_bsd.cpp \ + sanitizer_procmaps_common.cpp \ ++ sanitizer_procmaps_haiku.cpp \ + sanitizer_procmaps_linux.cpp \ + sanitizer_procmaps_mac.cpp \ + sanitizer_procmaps_solaris.cpp \ +diff --git a/libsanitizer/sanitizer_common/Makefile.in b/libsanitizer/sanitizer_common/Makefile.in +index 6499036..de7b62d 100644 +--- a/libsanitizer/sanitizer_common/Makefile.in ++++ b/libsanitizer/sanitizer_common/Makefile.in +@@ -137,7 +137,7 @@ am__objects_1 = sancov_flags.lo sanitizer_allocator.lo \ + sanitizer_platform_limits_solaris.lo sanitizer_posix.lo \ + sanitizer_posix_libcdep.lo sanitizer_printf.lo \ + sanitizer_procmaps_bsd.lo sanitizer_procmaps_common.lo \ +- sanitizer_procmaps_linux.lo sanitizer_procmaps_mac.lo \ ++ sanitizer_procmaps_haiku.lo sanitizer_procmaps_linux.lo sanitizer_procmaps_mac.lo \ + sanitizer_procmaps_solaris.lo sanitizer_solaris.lo \ + sanitizer_stack_store.lo sanitizer_stackdepot.lo \ + sanitizer_stacktrace.lo sanitizer_stacktrace_libcdep.lo \ +@@ -376,7 +376,7 @@ AM_CXXFLAGS = -Wall -W -Wno-unused-parameter -Wwrite-strings -pedantic \ + -Wno-long-long -fPIC -fno-builtin -fno-exceptions -fno-rtti \ + -fomit-frame-pointer -funwind-tables -fvisibility=hidden \ + -Wno-variadic-macros $(LIBSTDCXX_RAW_CXX_CXXFLAGS) \ +- -std=gnu++14 $(EXTRA_CXXFLAGS) $(am__append_1) ++ -std=gnu++14 $(EXTRA_CXXFLAGS) -I /system/develop/headers/private -I /system/develop/headers/private/system/arch/x86_64 -I /system/develop/headers/private/system $(am__append_1) + AM_CCASFLAGS = $(EXTRA_ASFLAGS) + ACLOCAL_AMFLAGS = -I m4 + noinst_LTLIBRARIES = libsanitizer_common.la +@@ -413,6 +413,7 @@ sanitizer_common_files = \ + sanitizer_printf.cpp \ + sanitizer_procmaps_bsd.cpp \ + sanitizer_procmaps_common.cpp \ ++ sanitizer_procmaps_haiku.cpp \ + sanitizer_procmaps_linux.cpp \ + sanitizer_procmaps_mac.cpp \ + sanitizer_procmaps_solaris.cpp \ +@@ -569,6 +570,7 @@ distclean-compile: + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sanitizer_printf.Plo@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sanitizer_procmaps_bsd.Plo@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sanitizer_procmaps_common.Plo@am__quote@ ++@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sanitizer_procmaps_haiku.Plo@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sanitizer_procmaps_linux.Plo@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sanitizer_procmaps_mac.Plo@am__quote@ + @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sanitizer_procmaps_solaris.Plo@am__quote@ +diff --git a/libsanitizer/sanitizer_common/sanitizer_common_interceptors_ioctl.inc b/libsanitizer/sanitizer_common/sanitizer_common_interceptors_ioctl.inc +index 49ec409..f88f914 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_common_interceptors_ioctl.inc ++++ b/libsanitizer/sanitizer_common/sanitizer_common_interceptors_ioctl.inc +@@ -48,35 +48,39 @@ static void ioctl_table_fill() { + ++ioctl_table_size; \ + } + ++ _(FIONBIO, READ, sizeof(int)); ++#if !SANITIZER_HAIKU + _(FIOASYNC, READ, sizeof(int)); + _(FIOCLEX, NONE, 0); + _(FIOGETOWN, WRITE, sizeof(int)); +- _(FIONBIO, READ, sizeof(int)); + _(FIONCLEX, NONE, 0); + _(FIOSETOWN, READ, sizeof(int)); ++#endif + _(SIOCATMARK, WRITE, sizeof(int)); + _(SIOCGIFCONF, CUSTOM, 0); + _(SIOCGPGRP, WRITE, sizeof(int)); + _(SIOCSPGRP, READ, sizeof(int)); +-#if !SANITIZER_SOLARIS ++#if !SANITIZER_SOLARIS && !SANITIZER_HAIKU + _(TIOCCONS, NONE, 0); + #endif +- _(TIOCEXCL, NONE, 0); ++#if !SANITIZER_HAIKU + _(TIOCGETD, WRITE, sizeof(int)); ++ _(TIOCNOTTY, NONE, 0); ++ _(TIOCPKT, READ, sizeof(int)); ++ _(TIOCSETD, READ, sizeof(int)); ++ _(TIOCSTI, READ, sizeof(char)); ++#endif ++ _(TIOCEXCL, NONE, 0); + _(TIOCGPGRP, WRITE, pid_t_sz); + _(TIOCGWINSZ, WRITE, struct_winsize_sz); + _(TIOCMBIC, READ, sizeof(int)); + _(TIOCMBIS, READ, sizeof(int)); + _(TIOCMGET, WRITE, sizeof(int)); + _(TIOCMSET, READ, sizeof(int)); +- _(TIOCNOTTY, NONE, 0); + _(TIOCNXCL, NONE, 0); + _(TIOCOUTQ, WRITE, sizeof(int)); +- _(TIOCPKT, READ, sizeof(int)); + _(TIOCSCTTY, NONE, 0); +- _(TIOCSETD, READ, sizeof(int)); + _(TIOCSPGRP, READ, pid_t_sz); +- _(TIOCSTI, READ, sizeof(char)); + _(TIOCSWINSZ, READ, struct_winsize_sz); + + #if !SANITIZER_IOS +diff --git a/libsanitizer/sanitizer_common/sanitizer_errno.h b/libsanitizer/sanitizer_common/sanitizer_errno.h +index 46c8536..76919da 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_errno.h ++++ b/libsanitizer/sanitizer_common/sanitizer_errno.h +@@ -29,6 +29,8 @@ + # define __errno_location ___errno + #elif SANITIZER_WINDOWS + # define __errno_location _errno ++#elif SANITIZER_HAIKU ++# define __errno_location _errnop + #endif + + extern "C" int *__errno_location(); +diff --git a/libsanitizer/sanitizer_common/sanitizer_errno_codes.h b/libsanitizer/sanitizer_common/sanitizer_errno_codes.h +index 192e939..959290d 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_errno_codes.h ++++ b/libsanitizer/sanitizer_common/sanitizer_errno_codes.h +@@ -21,10 +21,17 @@ + + namespace __sanitizer { + ++#ifdef __HAIKU__ ++#define errno_ENOMEM (0x80000000) ++#define errno_EBUSY (0x80000000 + 14) ++#define errno_EINVAL (0x80000000 + 5) ++#define errno_ENAMETOOLONG (0x80000000 + 0x6004) ++#else + #define errno_ENOMEM 12 + #define errno_EBUSY 16 + #define errno_EINVAL 22 + #define errno_ENAMETOOLONG 36 ++#endif + + // Those might not present or their value differ on different platforms. + extern const int errno_EOWNERDEAD; +diff --git a/libsanitizer/sanitizer_common/sanitizer_linux.cpp b/libsanitizer/sanitizer_common/sanitizer_linux.cpp +index f23ea9d..3a42559 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_linux.cpp ++++ b/libsanitizer/sanitizer_common/sanitizer_linux.cpp +@@ -14,7 +14,7 @@ + #include "sanitizer_platform.h" + + #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \ +- SANITIZER_SOLARIS ++ SANITIZER_SOLARIS || SANITIZER_HAIKU + + #include "sanitizer_common.h" + #include "sanitizer_flags.h" +@@ -59,15 +59,17 @@ + #include + #include + #include +-#if !SANITIZER_SOLARIS ++#if !SANITIZER_SOLARIS && !SANITIZER_HAIKU + #include + #endif + #include + #include ++#if !SANITIZER_HAIKU + #include ++#include ++#endif + #include + #include +-#include + #include + + #if SANITIZER_LINUX +@@ -108,6 +110,10 @@ extern struct ps_strings *__ps_strings; + #define environ _environ + #endif + ++#if SANITIZER_HAIKU ++#include ++#endif ++ + extern char **environ; + + #if SANITIZER_LINUX +@@ -199,7 +205,7 @@ ScopedBlockSignals::~ScopedBlockSignals() { SetSigProcMask(&saved_, nullptr); } + # endif + + // --------------- sanitizer_libc.h +-#if !SANITIZER_SOLARIS && !SANITIZER_NETBSD ++#if !SANITIZER_SOLARIS && !SANITIZER_NETBSD && !SANITIZER_HAIKU + #if !SANITIZER_S390 + uptr internal_mmap(void *addr, uptr length, int prot, int flags, int fd, + u64 offset) { +@@ -521,7 +527,7 @@ uptr internal_execve(const char *filename, char *const argv[], + } + #endif // !SANITIZER_SOLARIS && !SANITIZER_NETBSD + +-#if !SANITIZER_NETBSD ++#if !SANITIZER_NETBSD && !SANITIZER_HAIKU + void internal__exit(int exitcode) { + #if SANITIZER_FREEBSD || SANITIZER_SOLARIS + internal_syscall(SYSCALL(exit), exitcode); +@@ -558,6 +564,8 @@ tid_t GetTid() { + return Tid; + #elif SANITIZER_SOLARIS + return thr_self(); ++#elif SANITIZER_HAIKU ++ return find_thread(NULL); + #else + return internal_syscall(SYSCALL(gettid)); + #endif +@@ -571,6 +579,8 @@ int TgKill(pid_t pid, tid_t tid, int sig) { + #elif SANITIZER_SOLARIS + (void)pid; + return thr_kill(tid, sig); ++#elif SANITIZER_HAIKU ++ return kill_thread(tid); + #endif + } + #endif +@@ -598,7 +608,7 @@ u64 NanoTime() { + // 'environ' array (on some others) and does not use libc. This function + // should be called first inside __asan_init. + const char *GetEnv(const char *name) { +-#if SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_SOLARIS ++#if SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_SOLARIS || SANITIZER_HAIKU + if (::environ != 0) { + uptr NameLen = internal_strlen(name); + for (char **Env = ::environ; *Env != 0; Env++) { +@@ -722,7 +732,7 @@ char **GetEnviron() { + void FutexWait(atomic_uint32_t *p, u32 cmp) { + # if SANITIZER_FREEBSD + _umtx_op(p, UMTX_OP_WAIT_UINT, cmp, 0, 0); +-# elif SANITIZER_NETBSD ++# elif SANITIZER_NETBSD || SANITIZER_HAIKU + sched_yield(); /* No userspace futex-like synchronization */ + # else + internal_syscall(SYSCALL(futex), (uptr)p, FUTEX_WAIT_PRIVATE, cmp, 0, 0, 0); +@@ -732,7 +742,7 @@ void FutexWait(atomic_uint32_t *p, u32 cmp) { + void FutexWake(atomic_uint32_t *p, u32 count) { + # if SANITIZER_FREEBSD + _umtx_op(p, UMTX_OP_WAKE, count, 0, 0); +-# elif SANITIZER_NETBSD ++# elif SANITIZER_NETBSD || SANITIZER_HAIKU + /* No userspace futex-like synchronization */ + # else + internal_syscall(SYSCALL(futex), (uptr)p, FUTEX_WAKE_PRIVATE, count, 0, 0, 0); +@@ -764,7 +774,7 @@ struct linux_dirent { + }; + #endif + +-#if !SANITIZER_SOLARIS && !SANITIZER_NETBSD ++#if !SANITIZER_SOLARIS && !SANITIZER_NETBSD && !SANITIZER_HAIKU + // Syscall wrappers. + uptr internal_ptrace(int request, int pid, void *addr, void *data) { + return internal_syscall(SYSCALL(ptrace), request, pid, (uptr)addr, +@@ -976,7 +986,7 @@ bool internal_sigismember(__sanitizer_sigset_t *set, int signum) { + #endif + #endif // !SANITIZER_SOLARIS + +-#if !SANITIZER_NETBSD ++#if !SANITIZER_NETBSD && !SANITIZER_HAIKU + // ThreadLister implementation. + ThreadLister::ThreadLister(pid_t pid) : pid_(pid), buffer_(4096) { + char task_directory_path[80]; +@@ -1230,11 +1240,11 @@ bool LibraryNameIs(const char *full_name, const char *base_name) { + return (name[base_name_length] == '-' || name[base_name_length] == '.'); + } + +-#if !SANITIZER_ANDROID ++#if !SANITIZER_ANDROID && !SANITIZER_HAIKU + // Call cb for each region mapped by map. + void ForEachMappedRegion(link_map *map, void (*cb)(const void *, uptr)) { + CHECK_NE(map, nullptr); +-#if !SANITIZER_FREEBSD ++#if !SANITIZER_FREEBSD && !SANITIZER_HAIKU + typedef ElfW(Phdr) Elf_Phdr; + typedef ElfW(Ehdr) Elf_Ehdr; + #endif // !SANITIZER_FREEBSD +@@ -1886,11 +1896,15 @@ using Context = ucontext_t; + SignalContext::WriteFlag SignalContext::GetWriteFlag() const { + Context *ucontext = (Context *)context; + #if defined(__x86_64__) || defined(__i386__) ++#if !SANITIZER_HAIKU + static const uptr PF_WRITE = 1U << 1; ++#endif + #if SANITIZER_FREEBSD + uptr err = ucontext->uc_mcontext.mc_err; + #elif SANITIZER_NETBSD + uptr err = ucontext->uc_mcontext.__gregs[_REG_ERR]; ++#elif SANITIZER_HAIKU ++ uptr err = ucontext->uc_mcontext.r13; + #elif SANITIZER_SOLARIS && defined(__i386__) + const int Err = 13; + uptr err = ucontext->uc_mcontext.gregs[Err]; +@@ -2134,6 +2148,11 @@ static void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp) { + *pc = ucontext->uc_mcontext.mc_rip; + *bp = ucontext->uc_mcontext.mc_rbp; + *sp = ucontext->uc_mcontext.mc_rsp; ++# elif SANITIZER_HAIKU ++ ucontext_t *ucontext = (ucontext_t*)context; ++ *pc = ucontext->uc_mcontext.rip; ++ *bp = ucontext->uc_mcontext.rbp; ++ *sp = ucontext->uc_mcontext.rsp; + # else + ucontext_t *ucontext = (ucontext_t*)context; + *pc = ucontext->uc_mcontext.gregs[REG_RIP]; +diff --git a/libsanitizer/sanitizer_common/sanitizer_linux.h b/libsanitizer/sanitizer_common/sanitizer_linux.h +index 761c57d..6110b24 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_linux.h ++++ b/libsanitizer/sanitizer_common/sanitizer_linux.h +@@ -14,7 +14,7 @@ + + #include "sanitizer_platform.h" + #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \ +- SANITIZER_SOLARIS ++ SANITIZER_SOLARIS || SANITIZER_HAIKU + #include "sanitizer_common.h" + #include "sanitizer_internal_defs.h" + #include "sanitizer_platform_limits_freebsd.h" +diff --git a/libsanitizer/sanitizer_common/sanitizer_linux_libcdep.cpp b/libsanitizer/sanitizer_common/sanitizer_linux_libcdep.cpp +index 56d2316..1d9ede9 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_linux_libcdep.cpp ++++ b/libsanitizer/sanitizer_common/sanitizer_linux_libcdep.cpp +@@ -14,7 +14,7 @@ + #include "sanitizer_platform.h" + + #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \ +- SANITIZER_SOLARIS ++ SANITIZER_SOLARIS || SANITIZER_HAIKU + + #include "sanitizer_allocator_internal.h" + #include "sanitizer_atomic.h" +@@ -68,6 +68,10 @@ + #include + #endif + ++#if SANITIZER_HAIKU ++#include ++#endif ++ + #if SANITIZER_ANDROID + #include + #if !defined(CPU_COUNT) && !defined(__aarch64__) +@@ -634,8 +638,13 @@ static int AddModuleSegments(const char *module_name, dl_phdr_info *info, + if (phdr->p_type == PT_LOAD) { + uptr cur_beg = info->dlpi_addr + phdr->p_vaddr; + uptr cur_end = cur_beg + phdr->p_memsz; ++#if SANITIZER_HAIKU ++ bool executable = phdr->p_flags & PF_EXECUTE; ++ bool writable = phdr->p_flags & PF_WRITE; ++#else + bool executable = phdr->p_flags & PF_X; + bool writable = phdr->p_flags & PF_W; ++#endif + cur_module.addAddressRange(cur_beg, cur_end, executable, + writable); + } else if (phdr->p_type == PT_NOTE) { +@@ -783,6 +792,10 @@ u32 GetNumberOfCPUs() { + req[1] = HW_NCPU; + CHECK_EQ(internal_sysctl(req, 2, &ncpu, &len, NULL, 0), 0); + return ncpu; ++#elif SANITIZER_HAIKU ++ system_info info; ++ get_system_info(&info); ++ return info.cpu_count; + #elif SANITIZER_ANDROID && !defined(CPU_COUNT) && !defined(__aarch64__) + // Fall back to /sys/devices/system/cpu on Android when cpu_set_t doesn't + // exist in sched.h. That is the case for toolchains generated with older +diff --git a/libsanitizer/sanitizer_common/sanitizer_netbsd.cpp b/libsanitizer/sanitizer_common/sanitizer_netbsd.cpp +index 5e601bd..940a2fc 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_netbsd.cpp ++++ b/libsanitizer/sanitizer_common/sanitizer_netbsd.cpp +@@ -12,7 +12,7 @@ + + #include "sanitizer_platform.h" + +-#if SANITIZER_NETBSD ++#if SANITIZER_NETBSD || SANITIZER_HAIKU + + #include "sanitizer_common.h" + #include "sanitizer_flags.h" +@@ -27,27 +27,35 @@ + #include + #include + ++#if !SANITIZER_HAIKU + #include +-#include + #include +-#include +-#include + #include + #include ++#endif ++#include ++#include ++#include + #include + ++#if !SANITIZER_HAIKU ++#include ++#include ++#endif + #include + #include + #include + #include + #include +-#include + #include + #include + #include +-#include + #include + ++#if SANITIZER_HAIKU ++#include ++#include ++#else + extern "C" void *__mmap(void *, size_t, int, int, int, int, + off_t) SANITIZER_WEAK_ATTRIBUTE; + extern "C" int __sysctl(const int *, unsigned int, void *, size_t *, +@@ -71,6 +79,7 @@ extern "C" int _sys___sigprocmask14(int, const void *, + void *) SANITIZER_WEAK_ATTRIBUTE; + extern "C" int _sys___wait450(int wpid, int *, int, + void *) SANITIZER_WEAK_ATTRIBUTE; ++#endif + + namespace __sanitizer { + +@@ -96,8 +105,44 @@ static void *GetRealLibcAddress(const char *symbol) { + // --------------- sanitizer_libc.h + uptr internal_mmap(void *addr, uptr length, int prot, int flags, int fd, + u64 offset) { ++#if SANITIZER_HAIKU ++ if ((flags & MAP_ANONYMOUS) != 0) { ++ fd = -1; ++ } ++ ++ int mapping = (flags & MAP_SHARED) != 0 ++ ? REGION_NO_PRIVATE_MAP : REGION_PRIVATE_MAP; ++ ++ uint32 addressSpec; ++ if ((flags & MAP_FIXED) != 0) ++ addressSpec = B_EXACT_ADDRESS; ++ else if (addr != NULL) ++ addressSpec = B_BASE_ADDRESS; ++ else ++ addressSpec = B_RANDOMIZED_ANY_ADDRESS; ++ ++ uint32 areaProtection = 0; ++ if ((prot & PROT_READ) != 0) ++ areaProtection |= B_READ_AREA; ++ if ((prot & PROT_WRITE) != 0) ++ areaProtection |= B_WRITE_AREA; ++ if ((prot & PROT_EXEC) != 0) ++ areaProtection |= B_EXECUTE_AREA; ++ ++ if ((flags & MAP_NORESERVE) != 0) ++ areaProtection |= B_OVERCOMMITTING_AREA; ++ ++ area_id area = _kern_map_file("sanitizer mmap", &addr, addressSpec, length, ++ areaProtection, mapping, true, fd, offset); ++ if (area < 0) { ++ errno = area; ++ return (uptr)MAP_FAILED; ++ } ++ return (uptr)addr; ++#else + CHECK(&__mmap); +- return (uptr)__mmap(addr, length, prot, flags, fd, 0, offset); ++ return (uptr)__mmap(addr, length, prot, mapping, fd, 0, offset); ++#endif + } + + uptr internal_munmap(void *addr, uptr length) { +@@ -122,38 +167,68 @@ int internal_madvise(uptr addr, uptr length, int advice) { + } + + uptr internal_close(fd_t fd) { ++#if SANITIZER_HAIKU ++ CHECK(&_kern_close); ++ return _kern_close(fd); ++#else + CHECK(&_sys_close); + return _sys_close(fd); ++#endif + } + + uptr internal_open(const char *filename, int flags) { ++#if SANITIZER_HAIKU ++ CHECK(&_kern_open); ++ return _kern_open(-1, filename, flags, 0); ++#else + CHECK(&_sys_open); + return _sys_open(filename, flags); ++#endif + } + + uptr internal_open(const char *filename, int flags, u32 mode) { ++#if SANITIZER_HAIKU ++ CHECK(&_kern_open); ++ return _kern_open(-1, filename, flags, mode); ++#else + CHECK(&_sys_open); + return _sys_open(filename, flags, mode); ++#endif + } + + uptr internal_read(fd_t fd, void *buf, uptr count) { + sptr res; ++#if SANITIZER_HAIKU ++ CHECK(&_kern_read); ++ HANDLE_EINTR(res, (sptr)_kern_read(fd, -1, buf, (size_t)count)); ++#else + CHECK(&_sys_read); + HANDLE_EINTR(res, (sptr)_sys_read(fd, buf, (size_t)count)); ++#endif + return res; + } + + uptr internal_write(fd_t fd, const void *buf, uptr count) { + sptr res; ++#if SANITIZER_HAIKU ++ CHECK(&_kern_write); ++ HANDLE_EINTR(res, (sptr)_kern_write(fd, -1, buf, count)); ++#else + CHECK(&_sys_write); + HANDLE_EINTR(res, (sptr)_sys_write(fd, buf, count)); ++#endif + return res; + } + + uptr internal_ftruncate(fd_t fd, uptr size) { + sptr res; ++#if SANITIZER_HAIKU ++ DEFINE__REAL(int, ftruncate, int, off_t); ++ return _REAL(ftruncate, fd, size); ++#else + CHECK(&__ftruncate); + HANDLE_EINTR(res, __ftruncate(fd, 0, (s64)size)); ++#endif + return res; + } + +@@ -190,8 +265,13 @@ uptr internal_dup2(int oldfd, int newfd) { + } + + uptr internal_readlink(const char *path, char *buf, uptr bufsize) { ++#if SANITIZER_HAIKU ++ CHECK(&_kern_read_link); ++ return (uptr)_kern_read_link(-1, path, buf, &bufsize); ++#else + CHECK(&_sys_readlink); + return (uptr)_sys_readlink(path, buf, bufsize); ++#endif + } + + uptr internal_unlink(const char *path) { +@@ -205,8 +285,14 @@ uptr internal_rename(const char *oldpath, const char *newpath) { + } + + uptr internal_sched_yield() { ++#if SANITIZER_HAIKU ++ CHECK(&_kern_thread_yield); ++ _kern_thread_yield(); ++ return 0; ++#else + CHECK(&_sys_sched_yield); + return _sys_sched_yield(); ++#endif + } + + void internal__exit(int exitcode) { +@@ -216,19 +302,29 @@ void internal__exit(int exitcode) { + } + + void internal_usleep(u64 useconds) { ++#if SANITIZER_HAIKU ++ _kern_snooze_etc(useconds, B_SYSTEM_TIMEBASE, B_RELATIVE_TIMEOUT, NULL); ++#else + struct timespec ts; + ts.tv_sec = useconds / 1000000; + ts.tv_nsec = (useconds % 1000000) * 1000; + CHECK(&_sys___nanosleep50); + _sys___nanosleep50(&ts, &ts); ++#endif + } + + uptr internal_execve(const char *filename, char *const argv[], + char *const envp[]) { ++#if SANITIZER_HAIKU ++ DEFINE__REAL(int, execve, const char*, char*const[], char*const[]); ++ return _REAL(execve, filename, argv, envp); ++#else + CHECK(&_sys_execve); + return _sys_execve(filename, argv, envp); ++#endif + } + ++#if !SANITIZER_HAIKU + tid_t GetTid() { + DEFINE__REAL(int, _lwp_self); + return _REAL(_lwp_self); +@@ -247,6 +343,7 @@ u64 NanoTime() { + _REAL(__gettimeofday50, &tv, 0); + return (u64)tv.tv_sec * 1000 * 1000 * 1000 + tv.tv_usec * 1000; + } ++#endif + + uptr internal_clock_gettime(__sanitizer_clockid_t clk_id, void *tp) { + DEFINE__REAL(int, __clock_gettime50, __sanitizer_clockid_t a, void *b); +@@ -259,13 +356,23 @@ uptr internal_ptrace(int request, int pid, void *addr, int data) { + } + + uptr internal_waitpid(int pid, int *status, int options) { ++#if SANITIZER_HAIKU ++ CHECK(&_kern_wait_for_team); ++ return _kern_wait_for_team(pid, status); ++#else + CHECK(&_sys___wait450); + return _sys___wait450(pid, status, options, 0 /* rusage */); ++#endif + } + + uptr internal_getpid() { ++#if SANITIZER_HAIKU ++ CHECK(&_kern_get_current_team); ++ return _kern_get_current_team(); ++#else + DEFINE__REAL(int, getpid); + return _REAL(getpid); ++#endif + } + + uptr internal_getppid() { +@@ -284,8 +391,13 @@ uptr internal_getdents(fd_t fd, void *dirp, unsigned int count) { + } + + uptr internal_lseek(fd_t fd, OFF_T offset, int whence) { ++#if SANITIZER_HAIKU ++ CHECK(&_kern_seek); ++ return _kern_seek(fd, offset, whence); ++#else + CHECK(&__lseek); + return __lseek(fd, 0, offset, whence); ++#endif + } + + uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5) { +@@ -300,15 +412,22 @@ uptr internal_sigaltstack(const void *ss, void *oss) { + } + + int internal_fork() { ++#if SANITIZER_HAIKU ++ CHECK(&_kern_fork); ++ return _kern_fork(); ++#else + CHECK(&__fork); + return __fork(); ++#endif + } + ++#if !SANITIZER_HAIKU + int internal_sysctl(const int *name, unsigned int namelen, void *oldp, + uptr *oldlenp, const void *newp, uptr newlen) { + CHECK(&__sysctl); + return __sysctl(name, namelen, oldp, (size_t *)oldlenp, newp, (size_t)newlen); + } ++#endif + + int internal_sysctlbyname(const char *sname, void *oldp, uptr *oldlenp, + const void *newp, uptr newlen) { +@@ -320,8 +439,13 @@ int internal_sysctlbyname(const char *sname, void *oldp, uptr *oldlenp, + + uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set, + __sanitizer_sigset_t *oldset) { ++#if SANITIZER_HAIKU ++ CHECK(&_kern_set_signal_mask); ++ return _kern_set_signal_mask(how, set, oldset); ++#else + CHECK(&_sys___sigprocmask14); + return _sys___sigprocmask14(how, set, oldset); ++#endif + } + + void internal_sigfillset(__sanitizer_sigset_t *set) { +diff --git a/libsanitizer/sanitizer_common/sanitizer_platform.h b/libsanitizer/sanitizer_common/sanitizer_platform.h +index 7ecc465..1c10f93 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_platform.h ++++ b/libsanitizer/sanitizer_common/sanitizer_platform.h +@@ -14,7 +14,7 @@ + + #if !defined(__linux__) && !defined(__FreeBSD__) && !defined(__NetBSD__) && \ + !defined(__APPLE__) && !defined(_WIN32) && !defined(__Fuchsia__) && \ +- !(defined(__sun__) && defined(__svr4__)) ++ !(defined(__sun__) && defined(__svr4__)) && !defined(__HAIKU__) + # error "This operating system is not supported" + #endif + +@@ -43,6 +43,12 @@ + # define SANITIZER_FREEBSD 0 + #endif + ++#if defined(__HAIKU__) ++# define SANITIZER_HAIKU 1 ++#else ++# define SANITIZER_HAIKU 0 ++#endif ++ + #if defined(__NetBSD__) + # define SANITIZER_NETBSD 1 + #else +@@ -138,7 +144,7 @@ + + #define SANITIZER_POSIX \ + (SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_APPLE || \ +- SANITIZER_NETBSD || SANITIZER_SOLARIS) ++ SANITIZER_NETBSD || SANITIZER_SOLARIS || SANITIZER_HAIKU) + + #if __LP64__ || defined(_WIN64) + # define SANITIZER_WORDSIZE 64 +@@ -391,7 +397,7 @@ + # define SANITIZER_SUPPRESS_LEAK_ON_PTHREAD_EXIT 0 + #endif + +-#if SANITIZER_FREEBSD || SANITIZER_APPLE || SANITIZER_NETBSD || SANITIZER_SOLARIS ++#if SANITIZER_FREEBSD || SANITIZER_APPLE || SANITIZER_NETBSD || SANITIZER_SOLARIS || SANITIZER_HAIKU + # define SANITIZER_MADVISE_DONTNEED MADV_FREE + #else + # define SANITIZER_MADVISE_DONTNEED MADV_DONTNEED +diff --git a/libsanitizer/sanitizer_common/sanitizer_platform_limits_posix.cpp b/libsanitizer/sanitizer_common/sanitizer_platform_limits_posix.cpp +index c85cf16..d7864d1 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_platform_limits_posix.cpp ++++ b/libsanitizer/sanitizer_common/sanitizer_platform_limits_posix.cpp +@@ -23,7 +23,7 @@ + // Must go after undef _FILE_OFFSET_BITS. + #include "sanitizer_platform.h" + +-#if SANITIZER_LINUX || SANITIZER_APPLE ++#if SANITIZER_LINUX || SANITIZER_APPLE || SANITIZER_HAIKU + // Must go after undef _FILE_OFFSET_BITS. + #include "sanitizer_glibc_version.h" + +@@ -51,7 +51,7 @@ + #include + #include + #include +-#if !SANITIZER_APPLE ++#if !SANITIZER_APPLE && !SANITIZER_HAIKU + #include + #endif + +@@ -60,7 +60,9 @@ + #endif + + #if !SANITIZER_ANDROID ++#if !SANITIZER_HAIKU + #include ++#endif + #include + #include + #endif +@@ -109,9 +111,11 @@ typedef struct user_fpregs elf_fpregset_t; + + #if !SANITIZER_ANDROID + #include ++#if !SANITIZER_HAIKU + #include + #include + #endif ++#endif + + #if SANITIZER_LINUX + #if SANITIZER_GLIBC +@@ -161,7 +165,9 @@ typedef struct user_fpregs elf_fpregset_t; + #include + #include + #else ++#if !SANITIZER_HAIKU + #include ++#endif + #endif // SANITIZER_LINUX + + #if SANITIZER_APPLE +@@ -170,6 +176,11 @@ typedef struct user_fpregs elf_fpregset_t; + #include + #endif + ++#if SANITIZER_HAIKU ++#include ++#include ++#endif ++ + // Include these after system headers to avoid name clashes and ambiguities. + # include "sanitizer_common.h" + # include "sanitizer_internal_defs.h" +@@ -218,7 +229,7 @@ namespace __sanitizer { + unsigned struct_fstab_sz = sizeof(struct fstab); + #endif // SANITIZER_GLIBC || SANITIZER_FREEBSD || SANITIZER_NETBSD || + // SANITIZER_APPLE +-#if !SANITIZER_ANDROID ++#if !SANITIZER_ANDROID && !SANITIZER_HAIKU + unsigned struct_statfs_sz = sizeof(struct statfs); + unsigned struct_sockaddr_sz = sizeof(struct sockaddr); + +@@ -313,7 +324,7 @@ namespace __sanitizer { + int shmctl_shm_stat = (int)SHM_STAT; + #endif + +-#if !SANITIZER_APPLE && !SANITIZER_FREEBSD ++#if !SANITIZER_APPLE && !SANITIZER_FREEBSD && !SANITIZER_HAIKU + unsigned struct_utmp_sz = sizeof(struct utmp); + #endif + #if !SANITIZER_ANDROID +@@ -345,7 +356,7 @@ unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr); + int glob_altdirfunc = GLOB_ALTDIRFUNC; + #endif + +-# if !SANITIZER_ANDROID ++# if !SANITIZER_ANDROID && !SANITIZER_HAIKU + const int wordexp_wrde_dooffs = WRDE_DOOFFS; + # endif // !SANITIZER_ANDROID + +@@ -521,7 +532,7 @@ unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr); + unsigned struct_ppp_stats_sz = sizeof(struct ppp_stats); + #endif // SANITIZER_GLIBC + +-#if !SANITIZER_ANDROID && !SANITIZER_APPLE ++#if !SANITIZER_ANDROID && !SANITIZER_APPLE && !SANITIZER_HAIKU + unsigned struct_sioc_sg_req_sz = sizeof(struct sioc_sg_req); + unsigned struct_sioc_vif_req_sz = sizeof(struct sioc_vif_req); + #endif +@@ -530,12 +541,14 @@ unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr); + + const unsigned IOCTL_NOT_PRESENT = 0; + ++ unsigned IOCTL_FIONBIO = FIONBIO; ++#if !SANITIZER_HAIKU + unsigned IOCTL_FIOASYNC = FIOASYNC; + unsigned IOCTL_FIOCLEX = FIOCLEX; + unsigned IOCTL_FIOGETOWN = FIOGETOWN; +- unsigned IOCTL_FIONBIO = FIONBIO; + unsigned IOCTL_FIONCLEX = FIONCLEX; + unsigned IOCTL_FIOSETOWN = FIOSETOWN; ++#endif + unsigned IOCTL_SIOCADDMULTI = SIOCADDMULTI; + unsigned IOCTL_SIOCATMARK = SIOCATMARK; + unsigned IOCTL_SIOCDELMULTI = SIOCDELMULTI; +@@ -556,23 +569,27 @@ unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr); + unsigned IOCTL_SIOCSIFMTU = SIOCSIFMTU; + unsigned IOCTL_SIOCSIFNETMASK = SIOCSIFNETMASK; + unsigned IOCTL_SIOCSPGRP = SIOCSPGRP; ++ ++#if !SANITIZER_HAIKU + unsigned IOCTL_TIOCCONS = TIOCCONS; +- unsigned IOCTL_TIOCEXCL = TIOCEXCL; + unsigned IOCTL_TIOCGETD = TIOCGETD; ++ unsigned IOCTL_TIOCNOTTY = TIOCNOTTY; ++ unsigned IOCTL_TIOCPKT = TIOCPKT; ++ unsigned IOCTL_TIOCSETD = TIOCSETD; ++ unsigned IOCTL_TIOCSTI = TIOCSTI; ++#endif ++ ++ unsigned IOCTL_TIOCEXCL = TIOCEXCL; + unsigned IOCTL_TIOCGPGRP = TIOCGPGRP; + unsigned IOCTL_TIOCGWINSZ = TIOCGWINSZ; + unsigned IOCTL_TIOCMBIC = TIOCMBIC; + unsigned IOCTL_TIOCMBIS = TIOCMBIS; + unsigned IOCTL_TIOCMGET = TIOCMGET; + unsigned IOCTL_TIOCMSET = TIOCMSET; +- unsigned IOCTL_TIOCNOTTY = TIOCNOTTY; + unsigned IOCTL_TIOCNXCL = TIOCNXCL; + unsigned IOCTL_TIOCOUTQ = TIOCOUTQ; +- unsigned IOCTL_TIOCPKT = TIOCPKT; + unsigned IOCTL_TIOCSCTTY = TIOCSCTTY; +- unsigned IOCTL_TIOCSETD = TIOCSETD; + unsigned IOCTL_TIOCSPGRP = TIOCSPGRP; +- unsigned IOCTL_TIOCSTI = TIOCSTI; + unsigned IOCTL_TIOCSWINSZ = TIOCSWINSZ; + #if SANITIZER_LINUX && !SANITIZER_ANDROID + unsigned IOCTL_SIOCGETSGCNT = SIOCGETSGCNT; +@@ -1082,7 +1099,7 @@ COMPILER_CHECK(sizeof(__sanitizer_dirent) <= sizeof(dirent)); + CHECK_SIZE_AND_OFFSET(dirent, d_ino); + #if SANITIZER_APPLE + CHECK_SIZE_AND_OFFSET(dirent, d_seekoff); +-#elif SANITIZER_FREEBSD ++#elif SANITIZER_FREEBSD || SANITIZER_HAIKU + // There is no 'd_off' field on FreeBSD. + #else + CHECK_SIZE_AND_OFFSET(dirent, d_off); +@@ -1098,7 +1115,9 @@ CHECK_SIZE_AND_OFFSET(dirent64, d_reclen); + + CHECK_TYPE_SIZE(ifconf); + CHECK_SIZE_AND_OFFSET(ifconf, ifc_len); ++#if !SANITIZER_HAIKU + CHECK_SIZE_AND_OFFSET(ifconf, ifc_ifcu); ++#endif + + CHECK_TYPE_SIZE(pollfd); + CHECK_SIZE_AND_OFFSET(pollfd, fd); +@@ -1144,7 +1163,7 @@ CHECK_TYPE_SIZE(__kernel_loff_t); + CHECK_TYPE_SIZE(__kernel_fd_set); + #endif + +-#if !SANITIZER_ANDROID ++#if !SANITIZER_ANDROID && !SANITIZER_HAIKU + CHECK_TYPE_SIZE(wordexp_t); + CHECK_SIZE_AND_OFFSET(wordexp_t, we_wordc); + CHECK_SIZE_AND_OFFSET(wordexp_t, we_wordv); +@@ -1174,7 +1193,9 @@ CHECK_SIZE_AND_OFFSET(mntent, mnt_freq); + CHECK_SIZE_AND_OFFSET(mntent, mnt_passno); + #endif + ++#if !SANITIZER_HAIKU + CHECK_TYPE_SIZE(ether_addr); ++#endif + + #if SANITIZER_GLIBC || SANITIZER_FREEBSD + CHECK_TYPE_SIZE(ipc_perm); +diff --git a/libsanitizer/sanitizer_common/sanitizer_platform_limits_posix.h b/libsanitizer/sanitizer_common/sanitizer_platform_limits_posix.h +index 44dd3d9..28cf80a 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_platform_limits_posix.h ++++ b/libsanitizer/sanitizer_common/sanitizer_platform_limits_posix.h +@@ -14,7 +14,7 @@ + #ifndef SANITIZER_PLATFORM_LIMITS_POSIX_H + #define SANITIZER_PLATFORM_LIMITS_POSIX_H + +-#if SANITIZER_LINUX || SANITIZER_APPLE ++#if SANITIZER_LINUX || SANITIZER_APPLE || SANITIZER_HAIKU + + #include "sanitizer_internal_defs.h" + #include "sanitizer_platform.h" +@@ -29,10 +29,12 @@ + #define SANITIZER_HAS_STATFS64 0 + #endif + #else ++#if !SANITIZER_HAIKU + // Must be SANITIZER_LINUX then + #define SANITIZER_HAS_STAT64 1 + #define SANITIZER_HAS_STATFS64 1 + #endif ++#endif + + #if defined(__sparc__) + // FIXME: This can't be included from tsan which does not support sparc yet. +@@ -374,7 +376,7 @@ struct __sanitizer_passwd { + long pw_change; + char *pw_class; + #endif +-#if !(SANITIZER_ANDROID && (SANITIZER_WORDSIZE == 32)) ++#if !(SANITIZER_ANDROID && (SANITIZER_WORDSIZE == 32)) && !SANITIZER_HAIKU + char *pw_gecos; + #endif + char *pw_dir; +@@ -382,6 +384,9 @@ struct __sanitizer_passwd { + #if SANITIZER_APPLE + long pw_expire; + #endif ++#if SANITIZER_HAIKU ++ char *pw_gecos; ++#endif + }; + + struct __sanitizer_group { +@@ -431,7 +436,11 @@ struct __sanitizer_tm { + int tm_wday; + int tm_yday; + int tm_isdst; ++#if SANITIZER_HAIKU ++ int tm_gmtoff; ++#else + long int tm_gmtoff; ++#endif + const char *tm_zone; + }; + +@@ -452,7 +461,7 @@ struct __sanitizer_file_handle { + }; + #endif + +-#if SANITIZER_APPLE ++#if SANITIZER_APPLE || SANITIZER_HAIKU + struct __sanitizer_msghdr { + void *msg_name; + unsigned msg_namelen; +@@ -500,6 +509,15 @@ struct __sanitizer_dirent { + unsigned short d_reclen; + // more fields that we don't care about + }; ++#elif SANITIZER_HAIKU ++struct __sanitizer_dirent { ++ int d_dev; ++ int d_pdev; ++ unsigned long long d_ino; ++ unsigned long long d_pino; ++ unsigned short d_reclen; ++ // more fields that we don't care about ++}; + # elif (SANITIZER_LINUX && !SANITIZER_GLIBC) || defined(__x86_64__) || \ + defined(__hexagon__) + struct __sanitizer_dirent { +@@ -526,13 +544,15 @@ struct __sanitizer_dirent64 { + }; + #endif + +-#if defined(__x86_64__) && !defined(_LP64) ++#if SANITIZER_HAIKU ++typedef int __sanitizer_clock_t; ++#elif defined(__x86_64__) && !defined(_LP64) + typedef long long __sanitizer_clock_t; + #else + typedef long __sanitizer_clock_t; + #endif + +-#if SANITIZER_LINUX ++#if SANITIZER_LINUX || SANITIZER_HAIKU + typedef int __sanitizer_clockid_t; + #endif + +@@ -580,6 +600,8 @@ typedef unsigned long __sanitizer_sigset_t; + # endif + #elif SANITIZER_APPLE + typedef unsigned __sanitizer_sigset_t; ++#elif SANITIZER_HAIKU ++typedef unsigned long __sanitizer_sigset_t; + #elif SANITIZER_LINUX + struct __sanitizer_sigset_t { + // The size is determined by looking at sizeof of real sigset_t on linux. +@@ -663,7 +685,7 @@ struct __sanitizer_sigaction { + #endif + #endif + #endif +-#if SANITIZER_LINUX ++#if SANITIZER_LINUX || SANITIZER_HAIKU + void (*sa_restorer)(); + #endif + #if defined(__mips__) && (SANITIZER_WORDSIZE == 32) +@@ -750,7 +772,7 @@ struct __sanitizer_addrinfo { + int ai_family; + int ai_socktype; + int ai_protocol; +-#if SANITIZER_ANDROID || SANITIZER_APPLE ++#if SANITIZER_ANDROID || SANITIZER_APPLE || SANITIZER_HAIKU + unsigned ai_addrlen; + char *ai_canonname; + void *ai_addr; +@@ -1081,23 +1103,25 @@ extern unsigned IOCTL_SIOCSIFMETRIC; + extern unsigned IOCTL_SIOCSIFMTU; + extern unsigned IOCTL_SIOCSIFNETMASK; + extern unsigned IOCTL_SIOCSPGRP; ++#if !SANITIZER_HAIKU + extern unsigned IOCTL_TIOCCONS; +-extern unsigned IOCTL_TIOCEXCL; + extern unsigned IOCTL_TIOCGETD; ++extern unsigned IOCTL_TIOCNOTTY; ++extern unsigned IOCTL_TIOCPKT; ++extern unsigned IOCTL_TIOCSETD; ++extern unsigned IOCTL_TIOCSTI; ++#endif ++extern unsigned IOCTL_TIOCEXCL; + extern unsigned IOCTL_TIOCGPGRP; + extern unsigned IOCTL_TIOCGWINSZ; + extern unsigned IOCTL_TIOCMBIC; + extern unsigned IOCTL_TIOCMBIS; + extern unsigned IOCTL_TIOCMGET; + extern unsigned IOCTL_TIOCMSET; +-extern unsigned IOCTL_TIOCNOTTY; + extern unsigned IOCTL_TIOCNXCL; + extern unsigned IOCTL_TIOCOUTQ; +-extern unsigned IOCTL_TIOCPKT; + extern unsigned IOCTL_TIOCSCTTY; +-extern unsigned IOCTL_TIOCSETD; + extern unsigned IOCTL_TIOCSPGRP; +-extern unsigned IOCTL_TIOCSTI; + extern unsigned IOCTL_TIOCSWINSZ; + #if SANITIZER_LINUX && !SANITIZER_ANDROID + extern unsigned IOCTL_SIOCGETSGCNT; +diff --git a/libsanitizer/sanitizer_common/sanitizer_procmaps.h b/libsanitizer/sanitizer_common/sanitizer_procmaps.h +index 19bad15..13a68c6 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_procmaps.h ++++ b/libsanitizer/sanitizer_common/sanitizer_procmaps.h +@@ -16,7 +16,7 @@ + #include "sanitizer_platform.h" + + #if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD || \ +- SANITIZER_APPLE || SANITIZER_SOLARIS || \ ++ SANITIZER_APPLE || SANITIZER_SOLARIS || SANITIZER_HAIKU || \ + SANITIZER_FUCHSIA + + #include "sanitizer_common.h" +diff --git a/libsanitizer/sanitizer_common/sanitizer_procmaps_common.cpp b/libsanitizer/sanitizer_common/sanitizer_procmaps_common.cpp +index eb351b0..4925667 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_procmaps_common.cpp ++++ b/libsanitizer/sanitizer_common/sanitizer_procmaps_common.cpp +@@ -12,7 +12,7 @@ + #include "sanitizer_platform.h" + + #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \ +- SANITIZER_SOLARIS ++ SANITIZER_SOLARIS || SANITIZER_HAIKU + + #include "sanitizer_common.h" + #include "sanitizer_placement_new.h" +diff --git a/libsanitizer/sanitizer_common/sanitizer_procmaps_haiku.cpp b/libsanitizer/sanitizer_common/sanitizer_procmaps_haiku.cpp +new file mode 100644 +index 0000000..2974e9c +--- /dev/null ++++ b/libsanitizer/sanitizer_common/sanitizer_procmaps_haiku.cpp +@@ -0,0 +1,51 @@ ++//===-- sanitizer_procmaps_bsd.cpp ----------------------------------------===// ++// ++// 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 ++// ++//===----------------------------------------------------------------------===// ++// ++// Information about the process mappings ++// (Haiku-specific parts). ++//===----------------------------------------------------------------------===// ++ ++#include "sanitizer_platform.h" ++ ++#if SANITIZER_HAIKU ++#include "sanitizer_common.h" ++#include "sanitizer_procmaps.h" ++ ++#include ++ ++namespace __sanitizer { ++ ++void ReadProcMaps(ProcSelfMapsBuff *proc_maps) { ++ // Nothing to do because get_next_area_info is self-initializing. ++ proc_maps->data = nullptr; ++ proc_maps->mmaped_size = 0; ++ proc_maps->len = 0; ++} ++ ++bool MemoryMappingLayout::Next(MemoryMappedSegment *segment) { ++ area_info info; ++ if (get_next_area_info(B_CURRENT_TEAM, (ssize_t*)&data_.current, &info) != B_OK) ++ return false; ++ ++ segment->start = (uptr)info.address; ++ segment->end = (uptr)info.address + info.size; ++ segment->offset = 0; ++ segment->protection = 0; ++ if (info.protection & B_READ_AREA) ++ segment->protection |= kProtectionRead; ++ if (info.protection & B_WRITE_AREA) ++ segment->protection |= kProtectionWrite; ++ if (info.protection & B_EXECUTE_AREA) ++ segment->protection |= kProtectionExecute; ++ ++ return true; ++} ++ ++} // namespace __sanitizer ++ ++#endif +diff --git a/libsanitizer/sanitizer_common/sanitizer_stoptheworld_netbsd_libcdep.cpp b/libsanitizer/sanitizer_common/sanitizer_stoptheworld_netbsd_libcdep.cpp +index 701db72..4779064 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_stoptheworld_netbsd_libcdep.cpp ++++ b/libsanitizer/sanitizer_common/sanitizer_stoptheworld_netbsd_libcdep.cpp +@@ -16,7 +16,7 @@ + + #include "sanitizer_platform.h" + +-#if SANITIZER_NETBSD ++#if SANITIZER_NETBSD || SANITIZER_HAIKU + + #include "sanitizer_stoptheworld.h" + +diff --git a/libsanitizer/sanitizer_common/sanitizer_unwind_linux_libcdep.cpp b/libsanitizer/sanitizer_common/sanitizer_unwind_linux_libcdep.cpp +index 6a8e82e..3f6901a 100644 +--- a/libsanitizer/sanitizer_common/sanitizer_unwind_linux_libcdep.cpp ++++ b/libsanitizer/sanitizer_common/sanitizer_unwind_linux_libcdep.cpp +@@ -12,7 +12,7 @@ + + #include "sanitizer_platform.h" + #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \ +- SANITIZER_SOLARIS ++ SANITIZER_SOLARIS || SANITIZER_HAIKU + #include "sanitizer_common.h" + #include "sanitizer_stacktrace.h" + +@@ -171,4 +171,4 @@ void BufferedStackTrace::UnwindSlow(uptr pc, void *context, u32 max_depth) { + } // namespace __sanitizer + + #endif // SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || +- // SANITIZER_SOLARIS ++ // SANITIZER_SOLARIS || SANITIZER_HAIKU +-- +2.45.2 +