[AddressSanitizer] Add AddressSanitizer support for VxWorks OS

[wenbin0301]

Summary

This changeset adds AddressSanitizer support for VxWorks on X86-64/AARCH64/RISCV64. All VxWorks specific code changes are controlled by the macro SANITIZER_VXWORKS and so will not impact other OS and common implementation. There are some differences between VxWorks and other Operating Systems. The most significant one is the VxWorks doesn't support on-demanding page. That means we can't mmap too big memory at one time because of physical memory limitation and hence it also requires the change in VxWorks kernel to support the shadow memory and allocator memory management. All the changes have been proved to work and will be published in VxWorks next release 22.03.

[wenbin0301]

Apply clang-format to some new changes

[vitalybuka]

Are we going to have a buildbot?
Who is going to maintain this code?
I past we had to spent some time reviewing, maintaining on guess, and then finally revering code for abandoned platforms.

If usage is limited, then keeping it downstream fork is a reasonable approach.

[MaskRay]

Same thought. RTEMS and Myriad were previously removed ports. OpenBSD shifted to their downstream port.

[wenbin0301]

Thank you for raising the concern.

The AddressSantizer feature will be officially published to all Windriver Customers worldwild in next VxWorks release and the usage is widespread. The LLVM tool is heavily used in Windriver and has been updated it regularly. We will benifit a lot
if the changeset can be upstreamed.

An internal test platform (something like buildbot) is being setup to reguarly test the AddressSanitizer based on the latest main branch code. In case any something broken, we will be able to quickly fix it. That can prevent the AddressSanitizer on VxWorks from being broken by
new changes. And also, since all VxWorks specific changes are guarded by macro SANITIZER_VXORKS, it will not break others.

I will maintain the AddressSanitizer for VxWorks on behalf of WindRiver.

[wenbin0301]

Hello all reviewers,

May I know your opinion on this review?

Thanks,
Wenbin

[MaskRay]

This is a major target to support. It will add considerable maintenance costs to sanitizer developers.
There are 80 occurrences of SANITIZER_VXWORKS. Consider that when a maintainer refactors some interfaces, if there is a vxworks special case, they may need to stop and think about it, and probably remember to inform the vxworks maintainer(s).

Historically such a major addition needs an RFC on the llvm-dev mailing list.
Now that it has been migrated to discourse (https://discourse.llvm.org/t/post-discourse-migration-information/59719), I'd suggest that you start a post on https://discourse.llvm.org/c/runtimes/sanitizers/12 and tag eugenis, kcc, vitalybuka in the post.

The main consideration for accepting a target is (in asb's words) "benefits to end users, the cost of having the functionality upstream, and if there are people willing to support it"
These bullet points https://clang.llvm.org/get_involved.html#criteria may be useful as a start point.

[MaskRay]

compiler-rt/lib/interception/interception.h

277–279

Just stick with the local formatting that uses one-column for indentation. Ignore clang-format lints. This applies to other places in this patch.

compiler-rt/lib/interception/interception_linux.h

22–23

Ignore clang-format lints. Use the local convention.

[MaskRay]

compiler-rt/lib/sanitizer_common/sanitizer_common.h

953

I believe this is not needed after D118783

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cpp

54–56

use local convention. don't add indentation

compiler-rt/lib/sanitizer_common/sanitizer_posix.cpp

30

Is the comment stale?

compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cpp

54

This seems surprising to me. Why isn't pthread_self available?

126

Prefer #if XXX #else #endif to #if !XXX xxx #else #endif if XXX has 0/1 value

Why is SANITIZER_VXWORKS special?

[wenbin0301]

compiler-rt/lib/interception/interception.h

277–279

The pre-merge check always failed if not follow the clang-format result. Does that matter?

compiler-rt/lib/sanitizer_common/sanitizer_common.h

953

That is right. Thank you for your info.

compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cpp

54

It is actually available on VxWorks. We are using a vxWorks native method to implement GetThreadSelf. The reason is we want to avoid linking PTHREAD library only due to the reference to pthread_self on vxWorks if application code doesn't use other pthread_* functions.

I can delete this change if it is not appropriate from upstream point of view.

126

VxWorks doesn't support RLIMIT_AS and RLIMIT_CORE in kernel. I can delete these changes and keep them in private patch if it is not appropriate for upstreaming.

[wenbin0301]

compiler-rt/lib/sanitizer_common/sanitizer_posix.cpp

30

MAP_NORESERVE is not supported on VxWorks either. Yeah, this information could be added in the comments.

[wenbin0301]

@MaskRay , great thanks for your suggestion. I posted one RFC for this at https://discourse.llvm.org/t/rfc-add-addresssanitizer-support-for-vxworks-os/61023.

compiler-rt/cmake/config-ix.cmake

 message(STATUS "Compiler-RT supported architectures: ${COMPILER_RT_SUPPORTED_ARCH}")
 
 set(ALL_SANITIZERS asan;dfsan;msan;hwasan;tsan;safestack;cfi;scudo;ubsan_minimal;gwp_asan)
 set(COMPILER_RT_SANITIZERS_TO_BUILD all CACHE STRING
     "sanitizers to build if supported on the target (all;${ALL_SANITIZERS})")
 list_replace(COMPILER_RT_SANITIZERS_TO_BUILD all "${ALL_SANITIZERS}")
 
 if (SANITIZER_COMMON_SUPPORTED_ARCH AND NOT LLVM_USE_SANITIZER AND
-    (OS_NAME MATCHES "Android|Darwin|Linux|FreeBSD|NetBSD|Fuchsia|SunOS" OR
+    (OS_NAME MATCHES "Android|Darwin|Linux|FreeBSD|NetBSD|Fuchsia|SunOS|VxWorks" OR
     (OS_NAME MATCHES "Windows" AND NOT CYGWIN AND
         (NOT MINGW OR CMAKE_CXX_COMPILER_ID MATCHES "Clang"))))
   set(COMPILER_RT_HAS_SANITIZER_COMMON TRUE)
 else()
   set(COMPILER_RT_HAS_SANITIZER_COMMON FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON)

compiler-rt/lib/asan/CMakeLists.txt

set(ASAN_SOURCES
   asan_flags.cpp
   asan_fuchsia.cpp
   asan_globals.cpp
   asan_globals_win.cpp
   asan_interceptors.cpp
   asan_interceptors_memintrinsics.cpp
   asan_linux.cpp
   asan_mac.cpp
+  asan_vxworks.cpp
   asan_malloc_linux.cpp
   asan_malloc_mac.cpp
   asan_malloc_win.cpp
   asan_memory_profile.cpp
   asan_poisoning.cpp
   asan_posix.cpp
   asan_premap_shadow.cpp
   asan_report.cpp
SET(ASAN_HEADERS
   asan_init_version.h
   asan_interceptors.h
   asan_interceptors_memintrinsics.h
   asan_interface.inc
   asan_interface_internal.h
   asan_internal.h
   asan_lock.h
   asan_mapping.h
+  asan_mapping_vxworks.h
   asan_poisoning.h
   asan_premap_shadow.h
   asan_report.h
   asan_scariness_score.h
   asan_stack.h
   asan_stats.h
   asan_suppressions.h
   asan_thread.h

compiler-rt/lib/asan/asan_allocator.h

struct AsanMapUnmapCallback {
   void OnUnmap(uptr p, uptr size) const;
 };
 
 #if SANITIZER_CAN_USE_ALLOCATOR64
 # if SANITIZER_FUCHSIA
 const uptr kAllocatorSpace = ~(uptr)0;
 const uptr kAllocatorSize  =  0x40000000000ULL;  // 4T.
 typedef DefaultSizeClassMap SizeClassMap;
-# elif defined(__powerpc64__)
+#  elif SANITIZER_VXWORKS
+const uptr kAllocatorSpace = 0x7DC00000000ULL;
+const uptr kAllocatorSize = 0x2000000000ULL;  // 128G.
+typedef VeryCompactSizeClassMap SizeClassMap;
+#  elif defined(__powerpc64__)
 const uptr kAllocatorSpace = ~(uptr)0;
 const uptr kAllocatorSize  =  0x20000000000ULL;  // 2T.
 typedef DefaultSizeClassMap SizeClassMap;
-# elif defined(__aarch64__) && SANITIZER_ANDROID
+#  elif defined(__aarch64__) && SANITIZER_ANDROID
 // Android needs to support 39, 42 and 48 bit VMA.
 const uptr kAllocatorSpace =  ~(uptr)0;
 const uptr kAllocatorSize  =  0x2000000000ULL;  // 128G.
 typedef VeryCompactSizeClassMap SizeClassMap;
-#elif SANITIZER_RISCV64
+#  elif SANITIZER_RISCV64
 const uptr kAllocatorSpace = ~(uptr)0;
 const uptr kAllocatorSize = 0x2000000000ULL;  // 128G.
 typedef VeryDenseSizeClassMap SizeClassMap;
-# elif defined(__aarch64__)
+#  elif defined(__aarch64__)
 // AArch64/SANITIZER_CAN_USE_ALLOCATOR64 is only for 42-bit VMA
 // so no need to different values for different VMA.
 const uptr kAllocatorSpace =  0x10000000000ULL;
 const uptr kAllocatorSize  =  0x10000000000ULL;  // 3T.
 typedef DefaultSizeClassMap SizeClassMap;
-#elif defined(__sparc__)
+#  elif defined(__sparc__)
 const uptr kAllocatorSpace = ~(uptr)0;
 const uptr kAllocatorSize = 0x20000000000ULL;  // 2T.
 typedef DefaultSizeClassMap SizeClassMap;
-# elif SANITIZER_WINDOWS
+#  elif SANITIZER_WINDOWS
 const uptr kAllocatorSpace = ~(uptr)0;
 const uptr kAllocatorSize  =  0x8000000000ULL;  // 500G
 typedef DefaultSizeClassMap SizeClassMap;
-# else
+#  else
 const uptr kAllocatorSpace = 0x600000000000ULL;
 const uptr kAllocatorSize  =  0x40000000000ULL;  // 4T.
 typedef DefaultSizeClassMap SizeClassMap;
-# endif
+#  endif
 template <typename AddressSpaceViewTy>
 struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
   static const uptr kSpaceBeg = kAllocatorSpace;
   static const uptr kSpaceSize = kAllocatorSize;
   static const uptr kMetadataSize = 0;
   typedef __asan::SizeClassMap SizeClassMap;
   typedef AsanMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;

compiler-rt/lib/asan/asan_malloc_linux.cpp

 //
 // Linux-specific malloc interception.
 // We simply define functions like malloc, free, realloc, etc.
 // They will replace the corresponding libc functions automagically.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common/sanitizer_platform.h"
 #if SANITIZER_FREEBSD || SANITIZER_FUCHSIA || SANITIZER_LINUX || \
-    SANITIZER_NETBSD || SANITIZER_SOLARIS
+    SANITIZER_NETBSD || SANITIZER_SOLARIS || SANITIZER_VXWORKS
 
 #  include "asan_allocator.h"
 #  include "asan_interceptors.h"
 #  include "asan_internal.h"
 #  include "asan_stack.h"
 #  include "lsan/lsan_common.h"
 #  include "sanitizer_common/sanitizer_allocator_checks.h"
 #  include "sanitizer_common/sanitizer_allocator_dlsym.h"

compiler-rt/lib/asan/asan_mapping.h

 // (the exact location of HighShadow/HighMem may vary depending
 //  on WoW64, /LARGEADDRESSAWARE, etc).
 // || `[0x50000000, 0xffffffff]` || HighMem    ||
 // || `[0x3a000000, 0x4fffffff]` || HighShadow ||
 // || `[0x36000000, 0x39ffffff]` || ShadowGap  ||
 // || `[0x30000000, 0x35ffffff]` || LowShadow  ||
 // || `[0x00000000, 0x2fffffff]` || LowMem     ||
 
+// Shadow mapping on VxWorks/x86_64 with SHADOW_OFFSET == 0x80000000000:
+// || `[0x0000780000000000, 0x00007fffffffffff]` || HighMem    ||
+// || `[0x0000170000000000, 0x000017ffffffffff]` || HighShadow ||
+// || `[                                      ]` || ShadowGap  ||
+// || `[0x0000080000040000, 0x000008ffffffffff]` || LowShadow  ||
+// || `[0x0000000000200000, 0x000007ffffffffff]` || LowMem     ||
+
 #define ASAN_SHADOW_SCALE 3
 
 #if SANITIZER_FUCHSIA
 #  define ASAN_SHADOW_OFFSET_CONST (0)
 #elif SANITIZER_WORDSIZE == 32
 #  if SANITIZER_ANDROID
 #    define ASAN_SHADOW_OFFSET_DYNAMIC
 #  elif defined(__mips__)

 #  else
 #    define ASAN_SHADOW_OFFSET_CONST 0x20000000
 #  endif
 #else
 #  if SANITIZER_IOS
 #    define ASAN_SHADOW_OFFSET_DYNAMIC
 #  elif SANITIZER_MAC && defined(__aarch64__)
 #    define ASAN_SHADOW_OFFSET_DYNAMIC
+#  elif SANITIZER_VXWORKS
+#    define ASAN_SHADOW_OFFSET_DYNAMIC
 #  elif SANITIZER_RISCV64
 #    define ASAN_SHADOW_OFFSET_CONST 0x0000000d55550000
 #  elif defined(__aarch64__)
 #    define ASAN_SHADOW_OFFSET_CONST 0x0000001000000000
 #  elif defined(__powerpc64__)
 #    define ASAN_SHADOW_OFFSET_CONST 0x0000100000000000
 #  elif defined(__s390x__)
 #    define ASAN_SHADOW_OFFSET_CONST 0x0010000000000000

 #  else
 extern uptr kHighMemEnd, kMidMemBeg, kMidMemEnd;  // Initialized in __asan_init.
 #  endif
 
 }  // namespace __asan
 
 #  if defined(__sparc__) && SANITIZER_WORDSIZE == 64
 #    include "asan_mapping_sparc64.h"
+#  elif SANITIZER_VXWORKS
+#    include "asan_mapping_vxworks.h"
 #  else
 #    define MEM_TO_SHADOW(mem) \
       (((mem) >> ASAN_SHADOW_SCALE) + (ASAN_SHADOW_OFFSET))
 
 #    define kLowMemBeg 0
 #    define kLowMemEnd (ASAN_SHADOW_OFFSET ? ASAN_SHADOW_OFFSET - 1 : 0)
 
 #    define kLowShadowBeg ASAN_SHADOW_OFFSET

compiler-rt/lib/asan/asan_mapping_vxworks.h

+//===-- asan_mapping_vxworks.h -----------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// VxWorks-specific definitions for ASan memory mapping.
+//===----------------------------------------------------------------------===//
+#ifndef ASAN_MAPPING_VXWORKS_H
+#define ASAN_MAPPING_VXWORKS_H
+
+#define MEM_TO_SHADOW(mem) (((mem) >> ASAN_SHADOW_SCALE) + (ASAN_SHADOW_OFFSET))
+
+#if defined(__riscv) && !defined(_WRS_CONFIG_SATP_MODE_SV48)
+#  define kLowMemBeg 0x0000000000200000UL
+#  define kLowMemEnd (kLowMemBeg + 0x00000007ffe00000 - 1)
+#  define kHighMemBeg 0x0000003800000000UL
+#else
+#  define kLowMemBeg 0x0000000000200000UL
+#  define kLowMemEnd (kLowMemBeg + 0x000007ffffe00000 - 1)
+#  define kHighMemBeg 0x0000780000000000UL
+#endif
+
+#define kLowShadowBeg MEM_TO_SHADOW(kLowMemBeg)
+#define kLowShadowEnd MEM_TO_SHADOW(kLowMemEnd)
+
+#define kHighShadowBeg MEM_TO_SHADOW(kHighMemBeg)
+#define kHighShadowEnd MEM_TO_SHADOW(kHighMemEnd)
+
+#define kMidShadowBeg 0
+#define kMidShadowEnd 0
+
+#define kShadowGapBeg 0
+#define kShadowGapEnd 0
+
+#define kShadowGap2Beg 0
+#define kShadowGap2End 0
+
+#define kShadowGap3Beg 0
+#define kShadowGap3End 0
+
+namespace __asan {
+
+static inline bool AddrIsInLowMem(uptr a) {
+  PROFILE_ASAN_MAPPING();
+  return a >= kLowMemBeg && a <= kLowMemEnd;
+}
+
+static inline bool AddrIsInLowShadow(uptr a) {
+  PROFILE_ASAN_MAPPING();
+  return a >= kLowShadowBeg && a <= kLowShadowEnd;
+}
+
+static inline bool AddrIsInMidMem(uptr a) {
+  PROFILE_ASAN_MAPPING();
+  return false;
+}
+
+static inline bool AddrIsInMidShadow(uptr a) {
+  PROFILE_ASAN_MAPPING();
+  return false;
+}
+
+static inline bool AddrIsInHighMem(uptr a) {
+  PROFILE_ASAN_MAPPING();
+  return a >= kHighMemBeg && a <= kHighMemEnd;
+}
+
+static inline bool AddrIsInHighShadow(uptr a) {
+  PROFILE_ASAN_MAPPING();
+  return a >= kHighShadowBeg && a <= kHighShadowEnd;
+}
+
+static inline bool AddrIsInShadowGap(uptr a) {
+  PROFILE_ASAN_MAPPING();
+  return a >= kShadowGapBeg && a <= kShadowGapEnd;
+}
+
+}  // namespace __asan
+
+#endif  // ASAN_MAPPING_VXWORKS_H

compiler-rt/lib/asan/asan_posix.cpp

 
 #include <pthread.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <unistd.h>
 
+#  if SANITIZER_VXWORKS
+#    include <private/semLibP.h>
+#    include <semLib.h>
+#    include <taskLib.h>
+#  endif
+
 namespace __asan {
 
 void AsanOnDeadlySignal(int signo, void *siginfo, void *context) {
   StartReportDeadlySignal();
   SignalContext sig(siginfo, context);
   ReportDeadlySignal(sig);
 }
 

 void PlatformTSDDtor(void *tsd) {
   CHECK(tsd_destructor);
   CHECK_EQ(key.key, tsd);
   key.key = nullptr;
   // Make sure that signal handler can not see a stale current thread pointer.
   atomic_signal_fence(memory_order_seq_cst);
   AsanThread::TSDDtor(tsd);
 }
-#else
+#  elif SANITIZER_VXWORKS
+// The intercepted malloc may use TSD before __createTLSArea_GD and the
+// intercepted free may use TSD even after _FreeModuleTLSArea. It is
+// impossible to use the standard thread local storage "_thread". So we define
+// a simple two dimensional array here to simulate the thread local storage
+// model.
+
+static void (*tsd_destructor)(void *tsd) = nullptr;
+
+struct TSD_KEY {
+  TASK_ID taskId;
+  void *key;
+};
+
+#    define TSD_KEY_COUNT 32
+SEMAPHORE tsdKeySem;
+static struct TSD_KEY tsdKey[TSD_KEY_COUNT] = {};
+
+static STATUS resetTSDHook(TASK_ID taskId) {
+  for (int i = 0; i < TSD_KEY_COUNT; i++)
+    if (tsdKey[i].taskId == taskId) {
+      tsdKey[i].taskId = TASK_ID_NULL;
+      tsdKey[i].key = nullptr;
+    }
+
+  return OK;
+}
+
+void AsanTSDInit(void (*destructor)(void *tsd)) {
+  CHECK(!tsd_destructor);
+  tsd_destructor = destructor;
+  (void)semMInit(&tsdKeySem, SEM_Q_PRIORITY);
+  (void)taskDeleteHookAdd(resetTSDHook);
+}
+
+void *AsanTSDGet() {
+  CHECK(tsd_destructor);
+
+  TASK_ID curTask = taskIdSelf();
+
+  (void)semTake(&tsdKeySem, WAIT_FOREVER);
+  for (int i = 0; i < TSD_KEY_COUNT; i++)
+    if (tsdKey[i].taskId == curTask) {
+      (void)semGive(&tsdKeySem);
+      return tsdKey[i].key;
+    }
+  (void)semGive(&tsdKeySem);
+
+  return nullptr;
+}
+
+void AsanTSDSet(void *tsd) {
+  TASK_ID curTask = taskIdSelf();
+
+  (void)semTake(&tsdKeySem, WAIT_FOREVER);
+  for (int i = 0; i < TSD_KEY_COUNT; i++)
+    if (tsdKey[i].taskId == TASK_ID_NULL) {
+      tsdKey[i].taskId = curTask;
+      tsdKey[i].key = tsd;
+      (void)semGive(&tsdKeySem);
+      return;
+    }
+  (void)semGive(&tsdKeySem);
+}
+
+void PlatformTSDDtor(void *tsd) {
+  CHECK(tsd_destructor);
+  CHECK_EQ(AsanTSDGet(), tsd);
+  AsanTSDSet(nullptr);
+  // Make sure that signal handler can not see a stale current thread pointer.
+  atomic_signal_fence(memory_order_seq_cst);
+  AsanThread::TSDDtor(tsd);
+}
+
+#  else
 static pthread_key_t tsd_key;
 static bool tsd_key_inited = false;
 void AsanTSDInit(void (*destructor)(void *tsd)) {
   CHECK(!tsd_key_inited);
   tsd_key_inited = true;
   CHECK_EQ(0, pthread_key_create(&tsd_key, destructor));
 }
 
void PlatformTSDDtor(void *tsd) {
   AsanThreadContext *context = (AsanThreadContext*)tsd;
   if (context->destructor_iterations > 1) {
     context->destructor_iterations--;
     CHECK_EQ(0, pthread_setspecific(tsd_key, tsd));
     return;
   }
   AsanThread::TSDDtor(tsd);
 }
-#endif
+#  endif
 }  // namespace __asan
 
 #endif  // SANITIZER_POSIX

compiler-rt/lib/asan/asan_shadow_setup.cpp

 //===-- asan_shadow_setup.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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of AddressSanitizer, an address sanity checker.
 //
 // Set up the shadow memory.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common/sanitizer_platform.h"
 
 // asan_fuchsia.cpp has their own InitializeShadowMemory implementation.
-#if !SANITIZER_FUCHSIA
+#if !SANITIZER_FUCHSIA && !SANITIZER_VXWORKS
 
 #  include "asan_internal.h"
 #  include "asan_mapping.h"
 
 namespace __asan {
 
 static void ProtectGap(uptr addr, uptr size) {
   if (!flags()->protect_shadow_gap) {

compiler-rt/lib/asan/asan_vxworks.cpp

+//===-- asan_VxWorks.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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// VxWorks-specific details.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+
+#if SANITIZER_VXWORKS
+#  include <dlfcn.h>
+#  include <fcntl.h>
+#  include <pthread.h>
+#  include <stdlib.h>  // for free()
+#  include <sys/mman.h>
+#  include <sys/resource.h>
+#  include <sys/sysctl.h>
+#  include <taskLib.h>
+#  include <ucontext.h>
+#  include <unistd.h>
+
+#  include "asan_interceptors.h"
+#  include "asan_internal.h"
+#  include "asan_mapping.h"
+#  include "asan_stack.h"
+#  include "asan_thread.h"
+#  include "sanitizer_common/sanitizer_atomic.h"
+#  include "sanitizer_common/sanitizer_libc.h"
+
+namespace __asan {
+
+void InitializeShadowMemory() {
+#  if defined(__riscv) && !defined(_WRS_CONFIG_SATP_MODE_SV48)
+  __asan_shadow_memory_dynamic_address = 0x800000000;
+#  else
+  __asan_shadow_memory_dynamic_address = 0x80000000000;
+#  endif
+
+  // vxWorks system will handle all shadow memory allocation automatically, but
+  // we need a way to tell vxworks that current process is configured with asan.
+  // The way is to mmap a memory starting at kLowShadowBeg no matter whatever
+  // the size is.
+
+  ReserveShadowMemoryRange(kLowShadowBeg, kLowShadowBeg + 0x1000 - 1,
+                           "low shadow");
+  ReserveShadowMemoryRange(kHighShadowBeg, kHighShadowBeg + 0x1000 - 1,
+                           "high shadow");
+}
+
+void InitializePlatformExceptionHandlers() {}
+bool IsSystemHeapAddress(uptr addr) { return false; }
+
+// No-op. VxWorks does not support static linkage anyway.
+void *AsanDoesNotSupportStaticLinkage() { return 0; }
+
+// No-op. VxWorks does not support static linkage anyway.
+void AsanCheckDynamicRTPrereqs() {}
+
+// No-op. VxWorks does not support static linkage anyway.
+void AsanCheckIncompatibleRT() {}
+
+void AsanApplyToGlobals(globals_op_fptr op, const void *needle) {
+  UNIMPLEMENTED();
+}
+
+void FlushUnneededASanShadowMemory(uptr p, uptr size) {
+  // Since asan's mapping is compacting, the shadow chunk may be
+  // not page-aligned, so we only flush the page-aligned portion.
+  ReleaseMemoryPagesToOS(MemToShadow(p), MemToShadow(p + size));
+}
+
+void ReadContextStack(void *context, uptr *stack, uptr *ssize) {
+  UNIMPLEMENTED();
+}
+
+struct task_spawn_arg {
+  FUNCPTR entryPt;
+  _Vx_usr_arg_t arg1;
+  _Vx_usr_arg_t arg2;
+  _Vx_usr_arg_t arg3;
+  _Vx_usr_arg_t arg4;
+  _Vx_usr_arg_t arg5;
+  _Vx_usr_arg_t arg6;
+  _Vx_usr_arg_t arg7;
+  _Vx_usr_arg_t arg8;
+  _Vx_usr_arg_t arg9;
+  _Vx_usr_arg_t arg10;
+};
+
+static thread_return_t asan_entry_wrap(void *arg) {
+  struct task_spawn_arg *wrap_arg = (task_spawn_arg *)arg;
+  (wrap_arg->entryPt)(wrap_arg->arg1, wrap_arg->arg2, wrap_arg->arg3,
+                      wrap_arg->arg4, wrap_arg->arg5, wrap_arg->arg6,
+                      wrap_arg->arg7, wrap_arg->arg8, wrap_arg->arg9,
+                      wrap_arg->arg10);
+  free(wrap_arg);
+  return 0;
+}
+
+static void init_asan_entry_wrap(struct task_spawn_arg *arg, FUNCPTR entryPt,
+                                 _Vx_usr_arg_t arg1, _Vx_usr_arg_t arg2,
+                                 _Vx_usr_arg_t arg3, _Vx_usr_arg_t arg4,
+                                 _Vx_usr_arg_t arg5, _Vx_usr_arg_t arg6,
+                                 _Vx_usr_arg_t arg7, _Vx_usr_arg_t arg8,
+                                 _Vx_usr_arg_t arg9, _Vx_usr_arg_t arg10) {
+  arg->entryPt = entryPt;
+  arg->arg1 = arg1;
+  arg->arg2 = arg2;
+  arg->arg3 = arg3;
+  arg->arg4 = arg4;
+  arg->arg5 = arg4;
+  arg->arg6 = arg6;
+  arg->arg7 = arg7;
+  arg->arg8 = arg8;
+  arg->arg9 = arg9;
+  arg->arg10 = arg10;
+}
+
+static int asan_thread_start(_Vx_usr_arg_t arg) {
+  AsanThread *t = (AsanThread *)arg;
+  SetCurrentThread(t);
+  t->ThreadStart(GetTid());
+  return 0;
+}
+
+INTERCEPTOR(TASK_ID, taskCreate, char *name, int priority, int options,
+            size_t stackSize, FUNCPTR entryPt, _Vx_usr_arg_t arg1,
+            _Vx_usr_arg_t arg2, _Vx_usr_arg_t arg3, _Vx_usr_arg_t arg4,
+            _Vx_usr_arg_t arg5, _Vx_usr_arg_t arg6, _Vx_usr_arg_t arg7,
+            _Vx_usr_arg_t arg8, _Vx_usr_arg_t arg9, _Vx_usr_arg_t arg10) {
+  TASK_ID tid;
+
+  // Strict init-order checking is thread-hostile.
+  if (flags()->strict_init_order)
+    StopInitOrderChecking();
+  GET_STACK_TRACE_THREAD;
+  bool detached = false;  // FIXME: how can we determine it on VxWorks?
+  u32 current_tid = GetCurrentTidOrInvalid();
+  struct task_spawn_arg *wrap_arg;
+
+  wrap_arg = (struct task_spawn_arg *)malloc(sizeof(struct task_spawn_arg));
+  init_asan_entry_wrap(wrap_arg, entryPt, arg1, arg2, arg3, arg4, arg5, arg6,
+                       arg7, arg8, arg9, arg10);
+
+  AsanThread *t = AsanThread::Create(asan_entry_wrap, wrap_arg, current_tid,
+                                     &stack, detached);
+
+  if (t)
+    asanThreadRegistry().SetThreadName(t->tid(), name);
+
+  tid = REAL(taskCreate)(name, priority, options, stackSize,
+                         (FUNCPTR)asan_thread_start, (_Vx_usr_arg_t)t, 0, 0, 0,
+                         0, 0, 0, 0, 0, 0);
+
+  if (tid == TASK_ID_NULL) {
+    t->Destroy();
+  }
+
+  return tid;
+}
+
+INTERCEPTOR(TASK_ID, taskOpen, const char *name, int priority, int options,
+            int mode, char *pStackBase, size_t stackSize, void *context,
+            FUNCPTR entryPt, _Vx_usr_arg_t arg1, _Vx_usr_arg_t arg2,
+            _Vx_usr_arg_t arg3, _Vx_usr_arg_t arg4, _Vx_usr_arg_t arg5,
+            _Vx_usr_arg_t arg6, _Vx_usr_arg_t arg7, _Vx_usr_arg_t arg8,
+            _Vx_usr_arg_t arg9, _Vx_usr_arg_t arg10) {
+  TASK_ID tid;
+
+  // Strict init-order checking is thread-hostile.
+  if (flags()->strict_init_order)
+    StopInitOrderChecking();
+  GET_STACK_TRACE_THREAD;
+  bool detached = false;  // FIXME: how can we determine it on VxWorks?
+  u32 current_tid = GetCurrentTidOrInvalid();
+  struct task_spawn_arg *wrap_arg;
+
+  wrap_arg = (struct task_spawn_arg *)malloc(sizeof(struct task_spawn_arg));
+  init_asan_entry_wrap(wrap_arg, entryPt, arg1, arg2, arg3, arg4, arg5, arg6,
+                       arg7, arg8, arg9, arg10);
+
+  AsanThread *t = AsanThread::Create(asan_entry_wrap, wrap_arg, current_tid,
+                                     &stack, detached);
+
+  if (t)
+    asanThreadRegistry().SetThreadName(t->tid(), name);
+
+  tid = REAL(taskOpen)(name, priority, options, mode, pStackBase, stackSize,
+                       context, (FUNCPTR)asan_thread_start, (_Vx_usr_arg_t)t, 0,
+                       0, 0, 0, 0, 0, 0, 0, 0);
+
+  if (tid == TASK_ID_NULL) {
+    t->Destroy();
+  }
+
+  return tid;
+}
+
+INTERCEPTOR(STATUS, taskActivate, TASK_ID tid) {
+  return REAL(taskActivate)(tid);
+}
+
+void InitializePlatformInterceptors() {
+  // Inteception to taskSpawn is not needed because it will call
+  // taskCreate/taskActivate internallly
+  ASAN_INTERCEPT_FUNC(taskCreate);
+  ASAN_INTERCEPT_FUNC(taskActivate);
+  ASAN_INTERCEPT_FUNC(taskOpen);
+}
+}  // namespace __asan
+#endif  // SANITIZER_VXWORKS

compiler-rt/lib/interception/interception.h

 
 #ifndef INTERCEPTION_H
 #define INTERCEPTION_H
 
 #include "sanitizer_common/sanitizer_internal_defs.h"
 
 #if !SANITIZER_LINUX && !SANITIZER_FREEBSD && !SANITIZER_MAC &&      \
     !SANITIZER_NETBSD && !SANITIZER_WINDOWS && !SANITIZER_FUCHSIA && \
-    !SANITIZER_SOLARIS
+    !SANITIZER_SOLARIS && !SANITIZER_VXWORKS
 #  error "Interception doesn't work on this operating system."
 #endif
 
 // These typedefs should be used only in the interceptor definitions to replace
 // the standard system types (e.g. SSIZE_T instead of ssize_t)
 typedef __sanitizer::uptr    SIZE_T;
 typedef __sanitizer::sptr    SSIZE_T;
 typedef __sanitizer::sptr    PTRDIFF_T;

 #else
 typedef unsigned long uptr;
 #endif  // _WIN64
 }  // namespace __interception
 
 #define INCLUDED_FROM_INTERCEPTION_LIB
 
 #if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD || \
-    SANITIZER_SOLARIS
+    SANITIZER_SOLARIS || SANITIZER_VXWORKS
 
-# include "interception_linux.h"
-# define INTERCEPT_FUNCTION(func) INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func)
-# define INTERCEPT_FUNCTION_VER(func, symver) \
+#  include "interception_linux.h"
+#  define INTERCEPT_FUNCTION(func) INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func)
+#  define INTERCEPT_FUNCTION_VER(func, symver) \
     INTERCEPT_FUNCTION_VER_LINUX_OR_FREEBSD(func, symver)
 #elif SANITIZER_MAC
 # include "interception_mac.h"
 # define INTERCEPT_FUNCTION(func) INTERCEPT_FUNCTION_MAC(func)
 # define INTERCEPT_FUNCTION_VER(func, symver) \
     INTERCEPT_FUNCTION_VER_MAC(func, symver)
 #elif SANITIZER_WINDOWS
 # include "interception_win.h"
 # define INTERCEPT_FUNCTION(func) INTERCEPT_FUNCTION_WIN(func)
 # define INTERCEPT_FUNCTION_VER(func, symver) \
     INTERCEPT_FUNCTION_VER_WIN(func, symver)
 #endif
 
 #undef INCLUDED_FROM_INTERCEPTION_LIB
 
 #endif  // INTERCEPTION_H

compiler-rt/lib/interception/interception_linux.h

 //===-- interception_linux.h ------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of AddressSanitizer, an address sanity checker.
 //
 // Linux-specific interception methods.
 //===----------------------------------------------------------------------===//
 
 #if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD || \
-    SANITIZER_SOLARIS
+    SANITIZER_SOLARIS || SANITIZER_VXWORKS
 
-#if !defined(INCLUDED_FROM_INTERCEPTION_LIB)
-# error "interception_linux.h should be included from interception library only"
-#endif
+#  if !defined(INCLUDED_FROM_INTERCEPTION_LIB)
+#    error \
+        "interception_linux.h should be included from interception library only"
+#  endif
 
-#ifndef INTERCEPTION_LINUX_H
-#define INTERCEPTION_LINUX_H
+#  ifndef INTERCEPTION_LINUX_H
+#    define INTERCEPTION_LINUX_H
 
 namespace __interception {
 bool InterceptFunction(const char *name, uptr *ptr_to_real, uptr func,
                        uptr wrapper);
 bool InterceptFunction(const char *name, const char *ver, uptr *ptr_to_real,
                        uptr func, uptr wrapper);
 }  // namespace __interception
 

compiler-rt/lib/interception/interception_linux.cpp

 //===-- interception_linux.cpp ----------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of AddressSanitizer, an address sanity checker.
 //
 // Linux-specific interception methods.
 //===----------------------------------------------------------------------===//
 
 #include "interception.h"
 
 #if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD || \
-    SANITIZER_SOLARIS
+    SANITIZER_SOLARIS || SANITIZER_VXWORKS
 
-#include <dlfcn.h>   // for dlsym() and dlvsym()
+#  include <dlfcn.h>  // for dlsym() and dlvsym()
 
 namespace __interception {
 
 #if SANITIZER_NETBSD
 static int StrCmp(const char *s1, const char *s2) {
   while (true) {
     if (*s1 != *s2)
       return false;

compiler-rt/lib/sanitizer_common/CMakeLists.txt

set(SANITIZER_SOURCES_NOTERMINATION
   sanitizer_flags.cpp
   sanitizer_flag_parser.cpp
   sanitizer_fuchsia.cpp
   sanitizer_libc.cpp
   sanitizer_libignore.cpp
   sanitizer_linux.cpp
   sanitizer_linux_s390.cpp
   sanitizer_mac.cpp
+  sanitizer_vxworks.cpp
   sanitizer_mutex.cpp
   sanitizer_netbsd.cpp
   sanitizer_platform_limits_freebsd.cpp
   sanitizer_platform_limits_linux.cpp
   sanitizer_platform_limits_netbsd.cpp
   sanitizer_platform_limits_posix.cpp
   sanitizer_platform_limits_solaris.cpp
   sanitizer_posix.cpp
   sanitizer_printf.cpp
   sanitizer_procmaps_common.cpp
   sanitizer_procmaps_bsd.cpp
   sanitizer_procmaps_fuchsia.cpp
   sanitizer_procmaps_linux.cpp
   sanitizer_procmaps_mac.cpp
   sanitizer_procmaps_solaris.cpp
+  sanitizer_procmaps_vxworks.cpp
   sanitizer_solaris.cpp
   sanitizer_stoptheworld_fuchsia.cpp
   sanitizer_stoptheworld_mac.cpp
   sanitizer_stoptheworld_win.cpp
   sanitizer_suppressions.cpp
   sanitizer_tls_get_addr.cpp
   sanitizer_thread_registry.cpp
   sanitizer_type_traits.cpp
set(SANITIZER_SYMBOLIZER_SOURCES
   sanitizer_stacktrace.cpp
   sanitizer_stacktrace_libcdep.cpp
   sanitizer_stacktrace_printer.cpp
   sanitizer_stacktrace_sparc.cpp
   sanitizer_symbolizer.cpp
   sanitizer_symbolizer_libbacktrace.cpp
   sanitizer_symbolizer_libcdep.cpp
   sanitizer_symbolizer_mac.cpp
+  sanitizer_symbolizer_vxworks.cpp
   sanitizer_symbolizer_markup.cpp
   sanitizer_symbolizer_posix_libcdep.cpp
   sanitizer_symbolizer_report.cpp
   sanitizer_symbolizer_win.cpp
   sanitizer_unwind_linux_libcdep.cpp
   sanitizer_unwind_win.cpp
   )
 

compiler-rt/lib/sanitizer_common/sanitizer_common.h

 static inline void SanitizerBreakOptimization(void *arg) {
 #if defined(_MSC_VER) && !defined(__clang__)
   _ReadWriteBarrier();
 #else
   __asm__ __volatile__("" : : "r" (arg) : "memory");
 #endif
 }
 
+#if SANITIZER_VXWORKS
+#  undef READ
+#  undef WRITE
+#endif
+
 struct SignalContext {
   void *siginfo;
   void *context;
   uptr addr;
   uptr pc;
   uptr sp;
   uptr bp;
   bool is_memory_access;

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_ioctl.inc

if (IOCTL_##rq != IOCTL_NOT_PRESENT) {                 \
     ioctl_table[ioctl_table_size].req = IOCTL_##rq;      \
     ioctl_table[ioctl_table_size].type = ioctl_desc::tp; \
     ioctl_table[ioctl_table_size].size = sz;             \
     ioctl_table[ioctl_table_size].name = #rq;            \
     ++ioctl_table_size;                                  \
   }
 
   _(FIOASYNC, READ, sizeof(int));
+  #if !SANITIZER_VXWORKS
   _(FIOCLEX, NONE, 0);
   _(FIOGETOWN, WRITE, sizeof(int));
+  #endif
   _(FIONBIO, READ, sizeof(int));
+  #if !SANITIZER_VXWORKS
   _(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
   _(TIOCCONS, NONE, 0);
 #endif
   _(TIOCEXCL, NONE, 0);

compiler-rt/lib/sanitizer_common/sanitizer_errno.h

 #ifndef SANITIZER_ERRNO_H
 #define SANITIZER_ERRNO_H
 
 #include "sanitizer_errno_codes.h"
 #include "sanitizer_platform.h"
 
 #if SANITIZER_FREEBSD || SANITIZER_MAC
 #  define __errno_location __error
-#elif SANITIZER_ANDROID || SANITIZER_NETBSD
+#elif SANITIZER_ANDROID || SANITIZER_NETBSD || SANITIZER_VXWORKS
 #  define __errno_location __errno
 #elif SANITIZER_SOLARIS
 #  define __errno_location ___errno
 #elif SANITIZER_WINDOWS
 #  define __errno_location _errno
 #endif
 
 extern "C" int *__errno_location();
 
 #define errno (*__errno_location())
 
 #endif  // SANITIZER_ERRNO_H

compiler-rt/lib/sanitizer_common/sanitizer_linux.h

 //===-- sanitizer_linux.h ---------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Linux-specific syscall wrappers and classes.
 //
 //===----------------------------------------------------------------------===//
 #ifndef SANITIZER_LINUX_H
 #define SANITIZER_LINUX_H
 
 #include "sanitizer_platform.h"
-#if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD ||                \
-    SANITIZER_SOLARIS
-#include "sanitizer_common.h"
-#include "sanitizer_internal_defs.h"
-#include "sanitizer_platform_limits_freebsd.h"
-#include "sanitizer_platform_limits_netbsd.h"
-#include "sanitizer_platform_limits_posix.h"
-#include "sanitizer_platform_limits_solaris.h"
-#include "sanitizer_posix.h"
+#if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
+    SANITIZER_SOLARIS || SANITIZER_VXWORKS
+#  include "sanitizer_common.h"
+#  include "sanitizer_internal_defs.h"
+#  include "sanitizer_platform_limits_freebsd.h"
+#  include "sanitizer_platform_limits_netbsd.h"
+#  include "sanitizer_platform_limits_posix.h"
+#  include "sanitizer_platform_limits_solaris.h"
+#  include "sanitizer_posix.h"
 
 struct link_map;  // Opaque type returned by dlopen().
 struct utsname;
 
 namespace __sanitizer {
 // Dirent structure for getdents(). Note that this structure is different from
 // the one in <dirent.h>, which is used by readdir().
 struct linux_dirent;

compiler-rt/lib/sanitizer_common/sanitizer_mutex.h

enum {
   MutexMulti = -3,
 };
 
 // Go linker does not support THREADLOCAL variables,
 // so we can't use per-thread state.
 // Disable checked locks on Darwin. Although Darwin platforms support
 // THREADLOCAL variables they are not usable early on during process init when
 // `__sanitizer::Mutex` is used.
-#define SANITIZER_CHECK_DEADLOCKS \
-  (SANITIZER_DEBUG && !SANITIZER_GO && SANITIZER_SUPPORTS_THREADLOCAL && !SANITIZER_MAC)
+#define SANITIZER_CHECK_DEADLOCKS                                        \
+  (SANITIZER_DEBUG && !SANITIZER_GO && SANITIZER_SUPPORTS_THREADLOCAL && \
+   !SANITIZER_MAC && !SANITIZER_VXWORKS)
 
 #if SANITIZER_CHECK_DEADLOCKS
 struct MutexMeta {
   MutexType type;
   const char *name;
   // The table fixes what mutexes can be locked under what mutexes.
   // If the entry for MutexTypeFoo contains MutexTypeBar,
   // then Bar mutex can be locked while under Foo mutex.

compiler-rt/lib/sanitizer_common/sanitizer_platform.h

 //===-- sanitizer_platform.h ------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Common platform macros.
 //===----------------------------------------------------------------------===//
 
 #ifndef SANITIZER_PLATFORM_H
 #define SANITIZER_PLATFORM_H
 
 #if !defined(__linux__) && !defined(__FreeBSD__) && !defined(__NetBSD__) && \
     !defined(__APPLE__) && !defined(_WIN32) && !defined(__Fuchsia__) &&     \
-    !(defined(__sun__) && defined(__svr4__))
+    !(defined(__sun__) && defined(__svr4__)) && !defined(__vxworks)
 #  error "This operating system is not supported"
 #endif
 
 // Get __GLIBC__ on a glibc platform. Exclude Android: features.h includes C
 // function declarations into a .S file which doesn't compile.
 // https://crbug.com/1162741
 #if __has_include(<features.h>) && !defined(__ANDROID__)
 #  include <features.h>
 #endif
 
+#if defined(__vxworks)
+#  define SANITIZER_VXWORKS 1
+#  include <vsbConfig.h>
+#else
+#  define SANITIZER_VXWORKS 0
+#endif
+
 #if defined(__linux__)
 #  define SANITIZER_LINUX 1
 #else
 #  define SANITIZER_LINUX 0
 #endif
 
 #if defined(__GLIBC__)
 #  define SANITIZER_GLIBC 1

 #if defined(__Fuchsia__)
 #  define SANITIZER_FUCHSIA 1
 #else
 #  define SANITIZER_FUCHSIA 0
 #endif
 
 #define SANITIZER_POSIX                                     \
   (SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_MAC || \
-   SANITIZER_NETBSD || SANITIZER_SOLARIS)
+   SANITIZER_NETBSD || SANITIZER_SOLARIS || SANITIZER_VXWORKS)
 
 #if __LP64__ || defined(_WIN64)
 #  define SANITIZER_WORDSIZE 64
 #else
 #  define SANITIZER_WORDSIZE 32
 #endif
 
 #if SANITIZER_WORDSIZE == 64

 // does not work well and we need to fallback to SizeClassAllocator32.
 // For such platforms build this code with -DSANITIZER_CAN_USE_ALLOCATOR64=0 or
 // change the definition of SANITIZER_CAN_USE_ALLOCATOR64 here.
 #ifndef SANITIZER_CAN_USE_ALLOCATOR64
 #  if (SANITIZER_ANDROID && defined(__aarch64__)) || SANITIZER_FUCHSIA
 #    define SANITIZER_CAN_USE_ALLOCATOR64 1
 #  elif defined(__mips64) || defined(__aarch64__)
 #    define SANITIZER_CAN_USE_ALLOCATOR64 0
+#  elif SANITIZER_VXWORKS && defined(__riscv) && !_WRS_CONFIG_SATP_MODE_SV48
+#    define SANITIZER_CAN_USE_ALLOCATOR64 0
 #  else
 #    define SANITIZER_CAN_USE_ALLOCATOR64 (SANITIZER_WORDSIZE == 64)
 #  endif
 #endif
 
 // The range of addresses which can be returned my mmap.
 // FIXME: this value should be different on different platforms.  Larger values
 // will still work but will consume more memory for TwoLevelByteMap.

 #if SANITIZER_PPC || defined(__thumb__)
 #  define SANITIZER_SUPPRESS_LEAK_ON_PTHREAD_EXIT 1
 #else
 #  define SANITIZER_SUPPRESS_LEAK_ON_PTHREAD_EXIT 0
 #endif
 
 #if SANITIZER_FREEBSD || SANITIZER_MAC || SANITIZER_NETBSD || SANITIZER_SOLARIS
 #  define SANITIZER_MADVISE_DONTNEED MADV_FREE
+#elif SANITIZER_VXWORKS
+#  define SANITIZER_MADVISE_DONTNEED 0
 #else
 #  define SANITIZER_MADVISE_DONTNEED MADV_DONTNEED
 #endif
 
 // Older gcc have issues aligning to a constexpr, and require an integer.
 // See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56859 among others.
 #if defined(__powerpc__) || defined(__powerpc64__)
 #  define SANITIZER_CACHE_LINE_SIZE 128

compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h

 #endif
 
 #if SANITIZER_SOLARIS32
 #define SI_SOLARIS32 1
 #else
 #define SI_SOLARIS32 0
 #endif
 
+#if SANITIZER_VXWORKS
+#  define SI_VXWORKS 1
+#else
+#  define SI_VXWORKS 0
+#endif
+
 #if SANITIZER_POSIX && !SANITIZER_MAC
 #define SI_POSIX_NOT_MAC 1
 #else
 #define SI_POSIX_NOT_MAC 0
 #endif
 
 #if SANITIZER_LINUX && !SANITIZER_FREEBSD
 #define SI_LINUX_NOT_FREEBSD 1

 #define SANITIZER_INTERCEPT_PTSNAME SI_LINUX
 #define SANITIZER_INTERCEPT_PTSNAME_R SI_LINUX
 #define SANITIZER_INTERCEPT_TTYNAME SI_POSIX
 #define SANITIZER_INTERCEPT_TTYNAME_R SI_POSIX
 #define SANITIZER_INTERCEPT_TEMPNAM SI_POSIX
 #define SANITIZER_INTERCEPT_SINCOS SI_LINUX || SI_SOLARIS
 #define SANITIZER_INTERCEPT_REMQUO SI_POSIX
 #define SANITIZER_INTERCEPT_REMQUOL (SI_POSIX && !SI_NETBSD)
-#define SANITIZER_INTERCEPT_LGAMMA SI_POSIX
-#define SANITIZER_INTERCEPT_LGAMMAL (SI_POSIX && !SI_NETBSD)
+#define SANITIZER_INTERCEPT_LGAMMA (SI_POSIX && !SI_VXWORKS)
+#define SANITIZER_INTERCEPT_LGAMMAL (SI_POSIX && !SI_NETBSD && !SI_VXWORKS)
 #define SANITIZER_INTERCEPT_LGAMMA_R (SI_FREEBSD || SI_LINUX || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_LGAMMAL_R SI_LINUX_NOT_ANDROID || SI_SOLARIS
 #define SANITIZER_INTERCEPT_DRAND48_R SI_GLIBC
 #define SANITIZER_INTERCEPT_RAND_R \
   (SI_FREEBSD || SI_NETBSD || SI_MAC || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_ICONV \
   (SI_FREEBSD || SI_NETBSD || SI_LINUX_NOT_ANDROID || SI_SOLARIS)
 #define SANITIZER_INTERCEPT_TIMES SI_POSIX

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.h

 //===-- sanitizer_platform_limits_posix.h ---------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of Sanitizer common code.
 //
 // Sizes and layouts of platform-specific POSIX data structures.
 //===----------------------------------------------------------------------===//
 
 #ifndef SANITIZER_PLATFORM_LIMITS_POSIX_H
 #define SANITIZER_PLATFORM_LIMITS_POSIX_H
 
-#if SANITIZER_LINUX || SANITIZER_MAC
+#if SANITIZER_LINUX || SANITIZER_MAC || SANITIZER_VXWORKS
 
-#include "sanitizer_internal_defs.h"
-#include "sanitizer_platform.h"
+#  include "sanitizer_internal_defs.h"
+#  include "sanitizer_platform.h"
 
-#if defined(__sparc__)
+#  if defined(__sparc__)
 // FIXME: This can't be included from tsan which does not support sparc yet.
 #include "sanitizer_glibc_version.h"
 #endif
 
 # define GET_LINK_MAP_BY_DLOPEN_HANDLE(handle) ((link_map*)(handle))
 
 namespace __sanitizer {
 extern unsigned struct_utsname_sz;

 # ifdef ifa_dstaddr
 # undef ifa_dstaddr
 # endif
   void *ifa_dstaddr;  // (struct sockaddr *)
   void *ifa_data;
 };
 #endif  // !SANITIZER_ANDROID
 
-#if SANITIZER_MAC
+#  if SANITIZER_MAC || SANITIZER_VXWORKS
 typedef unsigned long __sanitizer_pthread_key_t;
 #else
 typedef unsigned __sanitizer_pthread_key_t;
 #endif
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
 
 struct __sanitizer_XDR {

 
 struct __sanitizer_file_handle {
   unsigned int handle_bytes;
   int handle_type;
   unsigned char f_handle[1];  // variable sized
 };
 #endif
 
-#if SANITIZER_MAC
+#  if SANITIZER_MAC || SANITIZER_VXWORKS
 struct __sanitizer_msghdr {
   void *msg_name;
   unsigned msg_namelen;
   struct __sanitizer_iovec *msg_iov;
   unsigned msg_iovlen;
   void *msg_control;
   unsigned msg_controllen;
   int msg_flags;

 #endif
 
 #if 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_VXWORKS
 typedef int __sanitizer_clockid_t;
 #endif
 
 #if SANITIZER_LINUX
 #    if defined(_LP64) || defined(__x86_64__) || defined(__powerpc__) || \
         defined(__mips__) || defined(__hexagon__)
 typedef unsigned __sanitizer___kernel_uid_t;
 typedef unsigned __sanitizer___kernel_gid_t;

 # endif
 #elif SANITIZER_MAC
 typedef unsigned __sanitizer_sigset_t;
 #elif SANITIZER_LINUX
 struct __sanitizer_sigset_t {
   // The size is determined by looking at sizeof of real sigset_t on linux.
   uptr val[128 / sizeof(uptr)];
 };
-#endif
+#  elif SANITIZER_VXWORKS
+typedef unsigned long long __sanitizer_sigset_t;
+#  endif
 
 struct __sanitizer_siginfo {
   // The size is determined by looking at sizeof of real siginfo_t on linux.
   u64 opaque[128 / sizeof(u64)];
 };
 
 using __sanitizer_sighandler_ptr = void (*)(int sig);
 using __sanitizer_sigactionhandler_ptr = void (*)(int sig,

 };
 
 struct __sanitizer_pollfd {
   int fd;
   short events;
   short revents;
 };
 
-#if SANITIZER_ANDROID || SANITIZER_MAC
+#  if SANITIZER_ANDROID || SANITIZER_MAC || SANITIZER_VXWORKS
 typedef unsigned __sanitizer_nfds_t;
 #else
 typedef unsigned long __sanitizer_nfds_t;
 #endif
 
 #if !SANITIZER_ANDROID
 # if SANITIZER_LINUX
 struct __sanitizer_glob_t {

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cpp

 // depends on _FILE_OFFSET_BITS setting.
 // To get this "true" dirent definition, we undefine _FILE_OFFSET_BITS below.
 #undef _FILE_OFFSET_BITS
 #endif
 
 // Must go after undef _FILE_OFFSET_BITS.
 #include "sanitizer_platform.h"
 
-#if SANITIZER_LINUX || SANITIZER_MAC
+#if SANITIZER_LINUX || SANITIZER_MAC || SANITIZER_VXWORKS
 // Must go after undef _FILE_OFFSET_BITS.
 #include "sanitizer_glibc_version.h"
 
 #include <arpa/inet.h>
 #include <dirent.h>
 #include <grp.h>
 #include <limits.h>
 #include <net/if.h>

 #include <sys/time.h>
 #include <sys/times.h>
 #include <sys/types.h>
 #include <sys/utsname.h>
 #include <termios.h>
 #include <time.h>
 #include <wchar.h>
 #include <regex.h>
-#if !SANITIZER_MAC
-#include <utmp.h>
-#endif
+#  if !SANITIZER_MAC && !SANITIZER_VXWORKS
+#    include <utmp.h>
+#  endif
 
-#if !SANITIZER_IOS
-#include <net/route.h>
-#endif
+#  if !SANITIZER_IOS
+#    include <net/route.h>
+#  endif
 
-#if !SANITIZER_ANDROID
-#include <sys/mount.h>
-#include <sys/timeb.h>
-#include <utmpx.h>
-#endif
+#  if !SANITIZER_ANDROID && !SANITIZER_VXWORKS
+#    include <sys/mount.h>
+#    include <sys/timeb.h>
+#    include <utmpx.h>
+#  endif
 
-#if SANITIZER_LINUX
-#include <malloc.h>
-#include <mntent.h>
-#include <netinet/ether.h>
-#include <sys/sysinfo.h>
-#include <sys/vt.h>
-#include <linux/cdrom.h>
-#include <linux/fd.h>
-#include <linux/fs.h>
-#include <linux/hdreg.h>
-#include <linux/input.h>
-#include <linux/ioctl.h>
-#include <linux/soundcard.h>
-#include <linux/sysctl.h>
-#include <linux/utsname.h>
-#include <linux/posix_types.h>
-#include <net/if_arp.h>
-#endif
+#  if SANITIZER_LINUX
+#    include <malloc.h>
+#    include <mntent.h>
+#    include <netinet/ether.h>
+#    include <sys/sysinfo.h>
+#    include <sys/vt.h>
+#    include <linux/cdrom.h>
+#    include <linux/fd.h>
+#    include <linux/fs.h>
+#    include <linux/hdreg.h>
+#    include <linux/input.h>
+#    include <linux/ioctl.h>
+#    include <linux/soundcard.h>
+#    include <linux/sysctl.h>
+#    include <linux/utsname.h>
+#    include <linux/posix_types.h>
+#    include <net/if_arp.h>
+#  endif
 
-#if SANITIZER_IOS
-#undef IOC_DIRMASK
-#endif
+#  if SANITIZER_IOS
+#    undef IOC_DIRMASK
+#  endif
 
-#if SANITIZER_LINUX
-# include <utime.h>
-# include <sys/ptrace.h>
+#  if SANITIZER_LINUX
+#    include <utime.h>
+#    include <sys/ptrace.h>
 #    if defined(__mips64) || defined(__aarch64__) || defined(__arm__) || \
         defined(__hexagon__) || SANITIZER_RISCV64
 #      include <asm/ptrace.h>
 #      ifdef __arm__
 typedef struct user_fpregs elf_fpregset_t;
 #   define ARM_VFPREGS_SIZE_ASAN (32 * 8 /*fpregs*/ + 4 /*fpscr*/)
 #   if !defined(ARM_VFPREGS_SIZE)
 #     define ARM_VFPREGS_SIZE ARM_VFPREGS_SIZE_ASAN
 #   endif
 #  endif
 # endif
 # include <semaphore.h>
 #endif
 
-#if !SANITIZER_ANDROID
-#include <ifaddrs.h>
-#include <sys/ucontext.h>
-#include <wordexp.h>
-#endif
+#  if !SANITIZER_ANDROID && !SANITIZER_VXWORKS
+#    include <ifaddrs.h>
+#    include <sys/ucontext.h>
+#    include <wordexp.h>
+#  endif
 
-#if SANITIZER_LINUX
-#if SANITIZER_GLIBC
-#include <fstab.h>
-#include <net/if_ppp.h>
-#include <netax25/ax25.h>
-#include <netipx/ipx.h>
-#include <netrom/netrom.h>
-#include <obstack.h>
-#if HAVE_RPC_XDR_H
-# include <rpc/xdr.h>
-#endif
-#include <scsi/scsi.h>
-#else
-#include <linux/if_ppp.h>
-#include <linux/kd.h>
-#include <linux/ppp_defs.h>
-#endif  // SANITIZER_GLIBC
+#  if SANITIZER_LINUX
+#    if SANITIZER_GLIBC
+#      include <fstab.h>
+#      include <net/if_ppp.h>
+#      include <netax25/ax25.h>
+#      include <netipx/ipx.h>
+#      include <netrom/netrom.h>
+#      include <obstack.h>
+#      if HAVE_RPC_XDR_H
+#        include <rpc/xdr.h>
+#      endif
+#      include <scsi/scsi.h>
+#    else
+#      include <linux/if_ppp.h>
+#      include <linux/kd.h>
+#      include <linux/ppp_defs.h>
+#    endif  // SANITIZER_GLIBC
 
-#if SANITIZER_ANDROID
-#include <linux/mtio.h>
-#else
-#include <glob.h>
-#include <mqueue.h>
-#include <sys/kd.h>
-#include <sys/mtio.h>
-#include <sys/shm.h>
-#include <sys/statvfs.h>
-#include <sys/timex.h>
-#if defined(__mips64)
-# include <sys/procfs.h>
-#endif
-#include <sys/user.h>
-#include <linux/if_eql.h>
-#include <linux/if_plip.h>
-#include <linux/lp.h>
-#include <linux/mroute.h>
-#include <linux/mroute6.h>
-#include <linux/scc.h>
-#include <linux/serial.h>
-#include <sys/msg.h>
-#include <sys/ipc.h>
-#include <crypt.h>
-#endif  // SANITIZER_ANDROID
+#    if SANITIZER_ANDROID
+#      include <linux/mtio.h>
+#    else
+#      include <glob.h>
+#      include <mqueue.h>
+#      include <sys/kd.h>
+#      include <sys/mtio.h>
+#      include <sys/shm.h>
+#      include <sys/statvfs.h>
+#      include <sys/timex.h>
+#      if defined(__mips64)
+#        include <sys/procfs.h>
+#      endif
+#      include <sys/user.h>
+#      include <linux/if_eql.h>
+#      include <linux/if_plip.h>
+#      include <linux/lp.h>
+#      include <linux/mroute.h>
+#      include <linux/mroute6.h>
+#      include <linux/scc.h>
+#      include <linux/serial.h>
+#      include <sys/msg.h>
+#      include <sys/ipc.h>
+#      include <crypt.h>
+#    endif  // SANITIZER_ANDROID
 
-#include <link.h>
-#include <sys/vfs.h>
-#include <sys/epoll.h>
-#include <linux/capability.h>
-#else
-#include <fstab.h>
-#endif // SANITIZER_LINUX
+#    include <link.h>
+#    include <sys/vfs.h>
+#    include <sys/epoll.h>
+#    include <linux/capability.h>
+#  else
+#    if !SANITIZER_VXWORKS
+#      include <fstab.h>
+#    endif
+#  endif  // SANITIZER_LINUX
 
-#if SANITIZER_MAC
-#include <net/ethernet.h>
-#include <sys/filio.h>
-#include <sys/sockio.h>
-#endif
+#  if SANITIZER_MAC
+#    include <net/ethernet.h>
+#    include <sys/filio.h>
+#    include <sys/sockio.h>
+#  endif
 
+#  if SANITIZER_VXWORKS
+#    include <ifaddrs.h>
+#    include <net/ethernet.h>
+#    include <sys/mount.h>
+#    include <sys/poll.h>
+#    include <ucontext.h>
+#  endif
+
 // Include these after system headers to avoid name clashes and ambiguities.
 #  include "sanitizer_common.h"
 #  include "sanitizer_internal_defs.h"
 #  include "sanitizer_platform_limits_posix.h"
 
 namespace __sanitizer {
   unsigned struct_utsname_sz = sizeof(struct utsname);
   unsigned struct_stat_sz = sizeof(struct stat);
-#if !SANITIZER_IOS && !(SANITIZER_MAC && TARGET_CPU_ARM64)
+#  if !SANITIZER_IOS && !(SANITIZER_MAC && TARGET_CPU_ARM64) && \
+      !SANITIZER_VXWORKS
   unsigned struct_stat64_sz = sizeof(struct stat64);
 #endif // !SANITIZER_IOS && !(SANITIZER_MAC && TARGET_CPU_ARM64)
   unsigned struct_rusage_sz = sizeof(struct rusage);
   unsigned struct_tm_sz = sizeof(struct tm);
+#  if !SANITIZER_VXWORKS
   unsigned struct_passwd_sz = sizeof(struct passwd);
+#  endif
   unsigned struct_group_sz = sizeof(struct group);
   unsigned siginfo_t_sz = sizeof(siginfo_t);
   unsigned struct_sigaction_sz = sizeof(struct sigaction);
   unsigned struct_stack_t_sz = sizeof(stack_t);
   unsigned struct_itimerval_sz = sizeof(struct itimerval);
   unsigned pthread_t_sz = sizeof(pthread_t);
   unsigned pthread_mutex_t_sz = sizeof(pthread_mutex_t);
   unsigned pthread_cond_t_sz = sizeof(pthread_cond_t);
   unsigned pid_t_sz = sizeof(pid_t);
   unsigned timeval_sz = sizeof(timeval);
   unsigned uid_t_sz = sizeof(uid_t);
   unsigned gid_t_sz = sizeof(gid_t);
   unsigned mbstate_t_sz = sizeof(mbstate_t);
   unsigned sigset_t_sz = sizeof(sigset_t);
+#  if !SANITIZER_VXWORKS
   unsigned struct_timezone_sz = sizeof(struct timezone);
+#  endif
   unsigned struct_tms_sz = sizeof(struct tms);
   unsigned struct_sigevent_sz = sizeof(struct sigevent);
   unsigned struct_sched_param_sz = sizeof(struct sched_param);
   unsigned struct_regex_sz = sizeof(regex_t);
   unsigned struct_regmatch_sz = sizeof(regmatch_t);
 
 #if (SANITIZER_MAC && !TARGET_CPU_ARM64) && !SANITIZER_IOS
   unsigned struct_statfs64_sz = sizeof(struct statfs64);
#if SANITIZER_LINUX && !SANITIZER_ANDROID
   unsigned struct_shminfo_sz = sizeof(struct shminfo);
   unsigned struct_shm_info_sz = sizeof(struct shm_info);
   int shmctl_ipc_stat = (int)IPC_STAT;
   int shmctl_ipc_info = (int)IPC_INFO;
   int shmctl_shm_info = (int)SHM_INFO;
   int shmctl_shm_stat = (int)SHM_STAT;
 #endif
 
-#if !SANITIZER_MAC && !SANITIZER_FREEBSD
+#  if !SANITIZER_MAC && !SANITIZER_FREEBSD && !SANITIZER_VXWORKS
   unsigned struct_utmp_sz = sizeof(struct utmp);
 #endif
-#if !SANITIZER_ANDROID
+#  if !SANITIZER_ANDROID && !SANITIZER_VXWORKS
   unsigned struct_utmpx_sz = sizeof(struct utmpx);
 #endif
 
   int map_fixed = MAP_FIXED;
 
   int af_inet = (int)AF_INET;
   int af_inet6 = (int)AF_INET6;
 

 unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr);
 #endif
 
 #if SANITIZER_GLIBC
   int glob_nomatch = GLOB_NOMATCH;
   int glob_altdirfunc = GLOB_ALTDIRFUNC;
 #endif
 
-#  if !SANITIZER_ANDROID
+#  if !SANITIZER_ANDROID && !SANITIZER_VXWORKS
   const int wordexp_wrde_dooffs = WRDE_DOOFFS;
 #  endif  // !SANITIZER_ANDROID
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID &&                               \
     (defined(__i386) || defined(__x86_64) || defined(__mips64) ||          \
      defined(__powerpc64__) || defined(__aarch64__) || defined(__arm__) || \
      defined(__s390__) || SANITIZER_RISCV64)
 #if defined(__mips64) || defined(__powerpc64__) || defined(__arm__)
#endif
   unsigned struct_sockaddr_ax25_sz = sizeof(struct sockaddr_ax25);
   unsigned struct_unimapdesc_sz = sizeof(struct unimapdesc);
   unsigned struct_unimapinit_sz = sizeof(struct unimapinit);
 
   unsigned struct_audio_buf_info_sz = sizeof(struct audio_buf_info);
   unsigned struct_ppp_stats_sz = sizeof(struct ppp_stats);
 #endif  // SANITIZER_GLIBC
 
-#if !SANITIZER_ANDROID && !SANITIZER_MAC
+#  if !SANITIZER_ANDROID && !SANITIZER_MAC && !SANITIZER_VXWORKS
   unsigned struct_sioc_sg_req_sz = sizeof(struct sioc_sg_req);
   unsigned struct_sioc_vif_req_sz = sizeof(struct sioc_vif_req);
 #endif
 
   const unsigned long __sanitizer_bufsiz = BUFSIZ;
 
   const unsigned IOCTL_NOT_PRESENT = 0;
 
   unsigned IOCTL_FIOASYNC = FIOASYNC;
+#  if !SANITIZER_VXWORKS
   unsigned IOCTL_FIOCLEX = FIOCLEX;
   unsigned IOCTL_FIOGETOWN = FIOGETOWN;
+#  endif
   unsigned IOCTL_FIONBIO = FIONBIO;
+#  if !SANITIZER_VXWORKS
   unsigned IOCTL_FIONCLEX = FIONCLEX;
   unsigned IOCTL_FIOSETOWN = FIOSETOWN;
+#  endif
   unsigned IOCTL_SIOCADDMULTI = SIOCADDMULTI;
   unsigned IOCTL_SIOCATMARK = SIOCATMARK;
   unsigned IOCTL_SIOCDELMULTI = SIOCDELMULTI;
   unsigned IOCTL_SIOCGIFADDR = SIOCGIFADDR;
   unsigned IOCTL_SIOCGIFBRDADDR = SIOCGIFBRDADDR;
   unsigned IOCTL_SIOCGIFCONF = SIOCGIFCONF;
   unsigned IOCTL_SIOCGIFDSTADDR = SIOCGIFDSTADDR;
   unsigned IOCTL_SIOCGIFFLAGS = SIOCGIFFLAGS;

 #endif  // SANITIZER_GLIBC || SANITIZER_FREEBSD
 
 CHECK_TYPE_SIZE(addrinfo);
 CHECK_SIZE_AND_OFFSET(addrinfo, ai_flags);
 CHECK_SIZE_AND_OFFSET(addrinfo, ai_family);
 CHECK_SIZE_AND_OFFSET(addrinfo, ai_socktype);
 CHECK_SIZE_AND_OFFSET(addrinfo, ai_protocol);
 CHECK_SIZE_AND_OFFSET(addrinfo, ai_protocol);
+#  if !SANITIZER_VXWORKS
 CHECK_SIZE_AND_OFFSET(addrinfo, ai_addrlen);
 CHECK_SIZE_AND_OFFSET(addrinfo, ai_canonname);
 CHECK_SIZE_AND_OFFSET(addrinfo, ai_addr);
+#  endif
 
 CHECK_TYPE_SIZE(hostent);
 CHECK_SIZE_AND_OFFSET(hostent, h_name);
 CHECK_SIZE_AND_OFFSET(hostent, h_aliases);
 CHECK_SIZE_AND_OFFSET(hostent, h_addrtype);
 CHECK_SIZE_AND_OFFSET(hostent, h_length);
 CHECK_SIZE_AND_OFFSET(hostent, h_addr_list);
 

 CHECK_SIZE_AND_OFFSET(mmsghdr, msg_hdr);
 CHECK_SIZE_AND_OFFSET(mmsghdr, msg_len);
 #endif
 
 COMPILER_CHECK(sizeof(__sanitizer_dirent) <= sizeof(dirent));
 CHECK_SIZE_AND_OFFSET(dirent, d_ino);
 #if SANITIZER_MAC
 CHECK_SIZE_AND_OFFSET(dirent, d_seekoff);
-#elif SANITIZER_FREEBSD
+#  elif SANITIZER_FREEBSD || SANITIZER_VXWORKS
 // There is no 'd_off' field on FreeBSD.
-#else
+#  else
 CHECK_SIZE_AND_OFFSET(dirent, d_off);
-#endif
+#  endif
+#  if !SANITIZER_VXWORKS
 CHECK_SIZE_AND_OFFSET(dirent, d_reclen);
+#  endif
 
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
+#  if SANITIZER_LINUX && !SANITIZER_ANDROID
 COMPILER_CHECK(sizeof(__sanitizer_dirent64) <= sizeof(dirent64));
 CHECK_SIZE_AND_OFFSET(dirent64, d_ino);
 CHECK_SIZE_AND_OFFSET(dirent64, d_off);
 CHECK_SIZE_AND_OFFSET(dirent64, d_reclen);
 #endif
 
 CHECK_TYPE_SIZE(ifconf);
 CHECK_SIZE_AND_OFFSET(ifconf, ifc_len);

 CHECK_TYPE_SIZE(__kernel_old_gid_t);
 #endif
 
 CHECK_TYPE_SIZE(__kernel_off_t);
 CHECK_TYPE_SIZE(__kernel_loff_t);
 CHECK_TYPE_SIZE(__kernel_fd_set);
 #endif
 
-#if !SANITIZER_ANDROID
+#  if !SANITIZER_ANDROID && !SANITIZER_VXWORKS
 CHECK_TYPE_SIZE(wordexp_t);
 CHECK_SIZE_AND_OFFSET(wordexp_t, we_wordc);
 CHECK_SIZE_AND_OFFSET(wordexp_t, we_wordv);
 CHECK_SIZE_AND_OFFSET(wordexp_t, we_offs);
 #endif
 
+#  if !SANITIZER_VXWORKS
 CHECK_TYPE_SIZE(tm);
 CHECK_SIZE_AND_OFFSET(tm, tm_sec);
 CHECK_SIZE_AND_OFFSET(tm, tm_min);
 CHECK_SIZE_AND_OFFSET(tm, tm_hour);
 CHECK_SIZE_AND_OFFSET(tm, tm_mday);
 CHECK_SIZE_AND_OFFSET(tm, tm_mon);
 CHECK_SIZE_AND_OFFSET(tm, tm_year);
 CHECK_SIZE_AND_OFFSET(tm, tm_wday);
 CHECK_SIZE_AND_OFFSET(tm, tm_yday);
 CHECK_SIZE_AND_OFFSET(tm, tm_isdst);
 CHECK_SIZE_AND_OFFSET(tm, tm_gmtoff);
 CHECK_SIZE_AND_OFFSET(tm, tm_zone);
+#  endif
 
-#if SANITIZER_LINUX
+#  if SANITIZER_LINUX
 CHECK_TYPE_SIZE(mntent);
 CHECK_SIZE_AND_OFFSET(mntent, mnt_fsname);
 CHECK_SIZE_AND_OFFSET(mntent, mnt_dir);
 CHECK_SIZE_AND_OFFSET(mntent, mnt_type);
 CHECK_SIZE_AND_OFFSET(mntent, mnt_opts);
 CHECK_SIZE_AND_OFFSET(mntent, mnt_freq);
 CHECK_SIZE_AND_OFFSET(mntent, mnt_passno);
 #endif

 #endif
 
 CHECK_TYPE_SIZE(clock_t);
 
 #if SANITIZER_LINUX
 CHECK_TYPE_SIZE(clockid_t);
 #endif
 
-#if !SANITIZER_ANDROID
+#  if !SANITIZER_ANDROID && !SANITIZER_VXWORKS
 CHECK_TYPE_SIZE(ifaddrs);
 CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_next);
 CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_name);
 CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_addr);
 CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_netmask);
 #if SANITIZER_LINUX || SANITIZER_FREEBSD
 // Compare against the union, because we can't reach into the union in a
 // compliant way.

 #endif // SANITIZER_LINUX
 CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_data);
 #endif
 
 #if SANITIZER_GLIBC || SANITIZER_ANDROID
 COMPILER_CHECK(sizeof(__sanitizer_struct_mallinfo) == sizeof(struct mallinfo));
 #endif
 
-#if !SANITIZER_ANDROID
+#  if !SANITIZER_ANDROID && !SANITIZER_VXWORKS
 CHECK_TYPE_SIZE(timeb);
 CHECK_SIZE_AND_OFFSET(timeb, time);
 CHECK_SIZE_AND_OFFSET(timeb, millitm);
 CHECK_SIZE_AND_OFFSET(timeb, timezone);
 CHECK_SIZE_AND_OFFSET(timeb, dstflag);
 #endif
 
+#  if !SANITIZER_VXWORKS
 CHECK_TYPE_SIZE(passwd);
 CHECK_SIZE_AND_OFFSET(passwd, pw_name);
 CHECK_SIZE_AND_OFFSET(passwd, pw_passwd);
 CHECK_SIZE_AND_OFFSET(passwd, pw_uid);
 CHECK_SIZE_AND_OFFSET(passwd, pw_gid);
 CHECK_SIZE_AND_OFFSET(passwd, pw_dir);
 CHECK_SIZE_AND_OFFSET(passwd, pw_shell);
 
 #if !SANITIZER_ANDROID
 CHECK_SIZE_AND_OFFSET(passwd, pw_gecos);
 #endif
 
 #if SANITIZER_MAC
 CHECK_SIZE_AND_OFFSET(passwd, pw_change);
 CHECK_SIZE_AND_OFFSET(passwd, pw_expire);
 CHECK_SIZE_AND_OFFSET(passwd, pw_class);
 #endif
-
+#  endif
 
 CHECK_TYPE_SIZE(group);
 CHECK_SIZE_AND_OFFSET(group, gr_name);
 CHECK_SIZE_AND_OFFSET(group, gr_passwd);
 CHECK_SIZE_AND_OFFSET(group, gr_gid);
 CHECK_SIZE_AND_OFFSET(group, gr_mem);
 
 #if HAVE_RPC_XDR_H

compiler-rt/lib/sanitizer_common/sanitizer_posix.cpp

 #include "sanitizer_posix.h"
 #include "sanitizer_procmaps.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <sys/mman.h>
 
-#if SANITIZER_FREEBSD
+#  if SANITIZER_FREEBSD || SANITIZER_VXWORKS
 // The MAP_NORESERVE define has been removed in FreeBSD 11.x, and even before
 // that, it was never implemented.  So just define it to zero.
 #undef  MAP_NORESERVE
 #define MAP_NORESERVE 0
 #endif
 
 namespace __sanitizer {
 
while (proc_maps.Next(&segment)) {
     CHECK_NE(0, segment.end);
     if (!IntervalsAreSeparate(segment.start, segment.end - 1, range_start,
                               range_end))
       return false;
   }
   return true;
 }
 
-#if !SANITIZER_MAC
+#  if !SANITIZER_MAC && !SANITIZER_VXWORKS
 void DumpProcessMap() {
   MemoryMappingLayout proc_maps(/*cache_enabled*/true);
   const sptr kBufSize = 4095;
   char *filename = (char*)MmapOrDie(kBufSize, __func__);
   MemoryMappedSegment segment(filename, kBufSize);
   Report("Process memory map follows:\n");
   while (proc_maps.Next(&segment)) {
     Printf("\t%p-%p\t%s\n", (void *)segment.start, (void *)segment.end,

compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cpp

 #include <sys/mman.h>
 #include <sys/resource.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
-#if SANITIZER_FREEBSD
+#  if SANITIZER_FREEBSD || SANITIZER_VXWORKS
 // The MAP_NORESERVE define has been removed in FreeBSD 11.x, and even before
 // that, it was never implemented.  So just define it to zero.
 #undef MAP_NORESERVE
 #define MAP_NORESERVE 0
 #endif
 
 typedef void (*sa_sigaction_t)(int, siginfo_t *, void *);
 
 namespace __sanitizer {
 
 u32 GetUid() {
   return getuid();
 }
 
+#  if !SANITIZER_VXWORKS
 uptr GetThreadSelf() {
   return (uptr)pthread_self();
 }
+#  endif
 
 void ReleaseMemoryPagesToOS(uptr beg, uptr end) {
   uptr page_size = GetPageSizeCached();
   uptr beg_aligned = RoundUpTo(beg, page_size);
   uptr end_aligned = RoundDownTo(end, page_size);
   if (beg_aligned < end_aligned)
     internal_madvise(beg_aligned, end_aligned - beg_aligned,
                      SANITIZER_MADVISE_DONTNEED);
static void setlim(int res, rlim_t lim) {
   rlim.rlim_cur = lim;
   if (setrlimit(res, const_cast<struct rlimit *>(&rlim))) {
     Report("ERROR: %s setrlimit() failed %d\n", SanitizerToolName, errno);
     Die();
   }
 }
 
 void DisableCoreDumperIfNecessary() {
+#  if !SANITIZER_VXWORKS /* getprlimitSc doesn't support RLIMIT_CORE */
   if (common_flags()->disable_coredump) {
     setlim(RLIMIT_CORE, 0);
   }
+#  endif
 }
 
 bool StackSizeIsUnlimited() {
   rlim_t stack_size = getlim(RLIMIT_STACK);
   return (stack_size == RLIM_INFINITY);
 }
 
 void SetStackSizeLimitInBytes(uptr limit) {
   setlim(RLIMIT_STACK, (rlim_t)limit);
   CHECK(!StackSizeIsUnlimited());
 }
 
 bool AddressSpaceIsUnlimited() {
+#  if !SANITIZER_VXWORKS /* getprlimitSc doesn't support RLIMIT_AS */
   rlim_t as_size = getlim(RLIMIT_AS);
   return (as_size == RLIM_INFINITY);
+#  else
+  return false;
+#  endif
 }
 
 void SetAddressSpaceUnlimited() {
+#  if !SANITIZER_VXWORKS /* getprlimitSc doesn't support RLIMIT_AS */
   setlim(RLIMIT_AS, RLIM_INFINITY);
   CHECK(AddressSpaceIsUnlimited());
+#  endif
 }
 
 void Abort() {
 #if !SANITIZER_GO
   // If we are handling SIGABRT, unhandle it first.
   // TODO(vitalybuka): Check if handler belongs to sanitizer.
   if (GetHandleSignalMode(SIGABRT) != kHandleSignalNo) {
     struct sigaction sigact;

compiler-rt/lib/sanitizer_common/sanitizer_procmaps.h

 // Information about the process mappings.
 //===----------------------------------------------------------------------===//
 #ifndef SANITIZER_PROCMAPS_H
 #define SANITIZER_PROCMAPS_H
 
 #include "sanitizer_platform.h"
 
 #if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD || \
-    SANITIZER_MAC || SANITIZER_SOLARIS ||  \
-    SANITIZER_FUCHSIA
+    SANITIZER_MAC || SANITIZER_SOLARIS || SANITIZER_FUCHSIA ||  \
+    SANITIZER_VXWORKS
 
-#include "sanitizer_common.h"
-#include "sanitizer_internal_defs.h"
-#include "sanitizer_fuchsia.h"
-#include "sanitizer_linux.h"
-#include "sanitizer_mac.h"
-#include "sanitizer_mutex.h"
+#  include "sanitizer_common.h"
+#  include "sanitizer_fuchsia.h"
+#  include "sanitizer_internal_defs.h"
+#  include "sanitizer_linux.h"
+#  include "sanitizer_mac.h"
+#  include "sanitizer_mutex.h"
 
 namespace __sanitizer {
 
 // Memory protection masks.
 static const uptr kProtectionRead = 1;
 static const uptr kProtectionWrite = 2;
 static const uptr kProtectionExecute = 4;
 static const uptr kProtectionShared = 8;

compiler-rt/lib/sanitizer_common/sanitizer_procmaps_common.cpp

 //===-- sanitizer_procmaps_common.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 (common parts).
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
 
-#if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD ||                \
-    SANITIZER_SOLARIS
+#if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
+    SANITIZER_SOLARIS || SANITIZER_VXWORKS
 
-#include "sanitizer_common.h"
-#include "sanitizer_placement_new.h"
-#include "sanitizer_procmaps.h"
+#  include "sanitizer_common.h"
+#  include "sanitizer_placement_new.h"
+#  include "sanitizer_procmaps.h"
 
 namespace __sanitizer {
 
 static ProcSelfMapsBuff cached_proc_self_maps;
 static StaticSpinMutex cache_lock;
 
 static int TranslateDigit(char c) {
   if (c >= '0' && c <= '9')

compiler-rt/lib/sanitizer_common/sanitizer_procmaps_vxworks.cpp

+//===-- sanitizer_procmaps_vxworks.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 (VxWorks-specific parts).
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+#if SANITIZER_VXWORKS
+#  include "sanitizer_common.h"
+#  include "sanitizer_procmaps.h"
+
+namespace __sanitizer {
+
+void ReadProcMaps(ProcSelfMapsBuff *proc_maps) { return; }
+
+bool MemoryMappingLayout::Next(MemoryMappedSegment *segment) { return false; }
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_VXWORKS

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.h

 # define SANITIZER_CAN_FAST_UNWIND 0
 #else
 # define SANITIZER_CAN_FAST_UNWIND 1
 #endif
 
 // Fast unwind is the only option on Mac for now; we will need to
 // revisit this macro when slow unwind works on Mac, see
 // https://github.com/google/sanitizers/issues/137
-#if SANITIZER_MAC
+#if SANITIZER_MAC || SANITIZER_VXWORKS
 #  define SANITIZER_CAN_SLOW_UNWIND 0
 #else
 # define SANITIZER_CAN_SLOW_UNWIND 1
 #endif
 
 struct StackTrace {
   const uptr *trace;
   u32 size;

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_posix_libcdep.cpp

 //===-- sanitizer_symbolizer_posix_libcdep.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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between AddressSanitizer and ThreadSanitizer
 // run-time libraries.
 // POSIX-specific implementation of symbolizer parts.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
 #if SANITIZER_POSIX
-#include "sanitizer_allocator_internal.h"
-#include "sanitizer_common.h"
-#include "sanitizer_file.h"
-#include "sanitizer_flags.h"
-#include "sanitizer_internal_defs.h"
-#include "sanitizer_linux.h"
-#include "sanitizer_placement_new.h"
-#include "sanitizer_posix.h"
-#include "sanitizer_procmaps.h"
-#include "sanitizer_symbolizer_internal.h"
-#include "sanitizer_symbolizer_libbacktrace.h"
-#include "sanitizer_symbolizer_mac.h"
-
-#include <dlfcn.h>   // for dlsym()
-#include <errno.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <sys/wait.h>
-#include <unistd.h>
+#  include <dlfcn.h>  // for dlsym()
+#  include <errno.h>
+#  include <stdint.h>
+#  include <stdlib.h>
+#  include <sys/wait.h>
+#  include <unistd.h>
+
+#  include "sanitizer_allocator_internal.h"
+#  include "sanitizer_common.h"
+#  include "sanitizer_file.h"
+#  include "sanitizer_flags.h"
+#  include "sanitizer_internal_defs.h"
+#  include "sanitizer_linux.h"
+#  include "sanitizer_placement_new.h"
+#  include "sanitizer_posix.h"
+#  include "sanitizer_procmaps.h"
+#  include "sanitizer_symbolizer_internal.h"
+#  include "sanitizer_symbolizer_libbacktrace.h"
+#  include "sanitizer_symbolizer_mac.h"
+#  include "sanitizer_symbolizer_vxworks.h"
 
 // C++ demangling function, as required by Itanium C++ ABI. This is weak,
 // because we do not require a C++ ABI library to be linked to a program
 // using sanitizers; if it's not present, we'll just use the mangled name.
 namespace __cxxabiv1 {
   extern "C" SANITIZER_WEAK_ATTRIBUTE
   char *__cxa_demangle(const char *mangled, char *buffer,
                                   size_t *length, int *status);
if (SymbolizerTool *tool = LibbacktraceSymbolizer::get(allocator)) {
     list->push_back(tool);
     return;
   }
 
   if (SymbolizerTool *tool = ChooseExternalSymbolizer(allocator)) {
     list->push_back(tool);
   }
 
-#if SANITIZER_MAC
+#  if SANITIZER_MAC || SANITIZER_VXWORKS
   VReport(2, "Using dladdr symbolizer.\n");
   list->push_back(new(*allocator) DlAddrSymbolizer());
 #endif  // SANITIZER_MAC
 }
 
 Symbolizer *Symbolizer::PlatformInit() {
   IntrusiveList<SymbolizerTool> list;
   list.clear();

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_vxworks.h

+//===-- sanitizer_symbolizer_vxworks.h ------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between various sanitizers' runtime libraries.
+//
+// Header for VxWorks-specific symbolizer.
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_SYMBOLIZER_VXWORKS_H
+#define SANITIZER_SYMBOLIZER_VXWORKS_H
+
+#include "sanitizer_platform.h"
+#if SANITIZER_VXWORKS
+
+#  include "sanitizer_symbolizer_internal.h"
+
+namespace __sanitizer {
+
+class DlAddrSymbolizer final : public SymbolizerTool {
+ public:
+  explicit DlAddrSymbolizer(){};
+
+  bool SymbolizePC(uptr addr, SymbolizedStack *stack) override;
+  bool SymbolizeData(uptr addr, DataInfo *info) override;
+};
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_VXWORKS
+
+#endif  // SANITIZER_SYMBOLIZER_VXWORKS_H

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_vxworks.cpp

+//===-- sanitizer_symbolizer_vxworks.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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between various sanitizers' runtime libraries.
+//
+// Implementation of VxWorks-specific symbolizer.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+#if SANITIZER_VXWORKS
+
+#  include <dlfcn.h>
+#  include <stdlib.h>
+#  include <unistd.h>
+
+#  include "sanitizer_allocator_internal.h"
+#  include "sanitizer_symbolizer_vxworks.h"
+
+namespace __sanitizer {
+
+bool DlAddrSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) {
+  Dl_info info;
+  int result = dladdr((void *)addr, &info);
+  if (!result)
+    return false;
+
+  uptr sym_addr = reinterpret_cast<uptr>(info.dli_saddr);
+  if (addr >= sym_addr) {
+    stack->info.function_offset = addr - sym_addr;
+  }
+
+  const char *demangled = DemangleSwiftAndCXX(info.dli_sname);
+  if (!demangled)
+    return false;
+  stack->info.function = internal_strdup(demangled);
+  return true;
+}
+
+bool DlAddrSymbolizer::SymbolizeData(uptr addr, DataInfo *datainfo) {
+  return true;
+}
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_VXWORKS

compiler-rt/lib/sanitizer_common/sanitizer_thread_registry.cpp

ThreadContextBase *ThreadRegistry::FindThreadContextByOsIDLocked(tid_t os_id) {
   return FindThreadContextLocked(FindThreadContextByOsIdCallback,
                                  (void *)os_id);
 }
 
 void ThreadRegistry::SetThreadName(u32 tid, const char *name) {
   ThreadRegistryLock l(this);
   ThreadContextBase *tctx = threads_[tid];
   CHECK_NE(tctx, 0);
-  CHECK_EQ(SANITIZER_FUCHSIA ? ThreadStatusCreated : ThreadStatusRunning,
+  CHECK_EQ(SANITIZER_FUCHSIA || SANITIZER_VXWORKS ? ThreadStatusCreated
+                                                  : ThreadStatusRunning,
            tctx->status);
   tctx->SetName(name);
 }
 
 void ThreadRegistry::SetThreadNameByUserId(uptr user_id, const char *name) {
   ThreadRegistryLock l(this);
   if (const auto *tid = live_.find(user_id))
     threads_[tid->second]->SetName(name);

compiler-rt/lib/sanitizer_common/sanitizer_vxworks.cpp

+//===-- sanitizer_VxWorks.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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between various sanitizers' runtime libraries and
+// implements VxWorks-specific functions.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+#if SANITIZER_VXWORKS
+#  include <stdio.h>
+
+#  include "interception/interception.h"
+#  include "sanitizer_common.h"
+#  include "sanitizer_file.h"
+#  include "sanitizer_flags.h"
+#  include "sanitizer_internal_defs.h"
+#  include "sanitizer_libc.h"
+#  include "sanitizer_platform_limits_posix.h"
+#  include "sanitizer_procmaps.h"
+#  include "sanitizer_ptrauth.h"
+
+#  if defined(__has_include) && __has_include(<os/trace.h>)
+#    define SANITIZER_OS_TRACE 1
+#    include <os/trace.h>
+#  else
+#    define SANITIZER_OS_TRACE 0
+#  endif
+
+#  include <dlfcn.h>
+#  include <dlfcn.h>  // for dladdr()
+#  include <errno.h>
+#  include <fcntl.h>
+#  include <private/semLibP.h>
+#  include <pthread.h>
+#  include <sched.h>
+#  include <semLib.h>
+#  include <signal.h>
+#  include <spawn.h>
+#  include <stdlib.h>
+#  include <sys/ioctl.h>
+#  include <sys/mman.h>
+#  include <sys/resource.h>
+#  include <sys/stat.h>
+#  include <sys/sysctl.h>
+#  include <sys/types.h>
+#  include <sys/wait.h>
+#  include <taskLib.h>
+#  include <ucontext.h>
+#  include <unistd.h>
+
+/* for VxWorks */
+#  include <dlfcn.h>
+#  include <elf.h>
+#  include <link.h>
+#  include <sys/mman.h>
+#  include <taskLib.h>
+
+#  include "../asan/asan_mapping.h"
+
+#  ifndef _WRS_CONFIG_LP64
+#    define Elf_Phdr Elf32_Phdr
+#  else
+#    define Elf_Phdr Elf64_Phdr
+#  endif
+
+int usleep(useconds_t usecs) {
+  struct timespec tp;
+  tp.tv_sec = 0;
+  tp.tv_nsec = usecs * 1000;
+  return nanosleep(&tp, NULL);
+}
+
+namespace __sanitizer {
+
+#  include "sanitizer_syscall_generic.inc"
+
+// On VxWorks, many system call functions are included in the libc directly
+// which is very suitable for implementing the internal_* functions used by
+// ASAN.
+static void *GetRealLibcAddress(const char *symbol) {
+  void *real = dlsym(RTLD_NEXT, symbol);
+  if (!real) {
+    Printf("GetRealLibcAddress failed for symbol=%s", symbol);
+    Die();
+  }
+  return real;
+}
+
+#  define _REAL(func, ...) real##_##func(__VA_ARGS__)
+#  define DEFINE__REAL(ret_type, func, ...)                              \
+    static ret_type (*real_##func)(__VA_ARGS__) = NULL;                  \
+    if (!real_##func) {                                                  \
+      real_##func = (ret_type(*)(__VA_ARGS__))GetRealLibcAddress(#func); \
+    }                                                                    \
+    CHECK(real_##func);
+
+uptr internal_mmap(void *addr, size_t length, int prot, int flags, int fd,
+                   u64 offset) {
+  DEFINE__REAL(uptr, mmap, void *a, size_t b, int c, int d, int e, u64 f);
+  return _REAL(mmap, addr, length, prot, flags, fd, offset);
+}
+
+uptr internal_munmap(void *addr, uptr length) {
+  DEFINE__REAL(int, munmap, void *a, uptr b);
+  return _REAL(munmap, addr, length);
+}
+
+int internal_mprotect(void *addr, uptr length, int prot) {
+  DEFINE__REAL(int, mprotect, void *a, uptr b, int c);
+  return _REAL(mprotect, addr, length, prot);
+}
+
+int internal_madvise(uptr addr, uptr length, int advice) {
+  // FIXME: VxWorks doesn't support madvise
+  // shadow memory allocate/deallocate is managed by VxWorks OS
+  return 0;
+}
+
+uptr internal_close(fd_t fd) {
+  DEFINE__REAL(int, close, fd_t a);
+  return _REAL(close, fd);
+}
+
+uptr internal_open(const char *filename, int flags) {
+  DEFINE__REAL(int, open, const char *a, int b);
+  return _REAL(open, filename, flags);
+}
+
+uptr internal_open(const char *filename, int flags, u32 mode) {
+  DEFINE__REAL(int, open, const char *filename, int flags, u32 mode);
+  return _REAL(open, filename, flags, mode);
+}
+
+uptr internal_read(fd_t fd, void *buf, uptr count) {
+  DEFINE__REAL(uptr, read, fd_t a, void *b, uptr c);
+  return _REAL(read, fd, buf, count);
+}
+
+uptr internal_write(fd_t fd, const void *buf, uptr count) {
+  DEFINE__REAL(uptr, write, fd_t a, const void *b, uptr c);
+  return _REAL(write, fd, buf, count);
+}
+
+uptr internal_stat(const char *path, void *buf) {
+  DEFINE__REAL(int, stat, const char *a, void *b);
+  return _REAL(stat, path, buf);
+}
+
+uptr internal_lstat(const char *path, void *buf) {
+  DEFINE__REAL(int, lstat, const char *a, void *b);
+  return _REAL(lstat, path, buf);
+}
+
+uptr internal_fstat(fd_t fd, void *buf) {
+  DEFINE__REAL(int, fstat, int a, void *b);
+  return _REAL(fstat, fd, buf);
+}
+
+uptr internal_filesize(fd_t fd) {
+  struct stat st;
+  if (internal_fstat(fd, &st))
+    return -1;
+  return (uptr)st.st_size;
+}
+
+uptr internal_dup(int oldfd) {
+  DEFINE__REAL(int, dup, int a);
+  return _REAL(dup, oldfd);
+}
+
+uptr internal_dup2(int oldfd, int newfd) {
+  DEFINE__REAL(int, dup2, int a, int b);
+  return _REAL(dup2, oldfd, newfd);
+}
+
+uptr internal_readlink(const char *path, char *buf, uptr bufsize) {
+  DEFINE__REAL(uptr, readlink, const char *a, char *b, uptr c);
+  return _REAL(readlink, path, buf, bufsize);
+}
+
+uptr internal_unlink(const char *path) {
+  DEFINE__REAL(uptr, unlink, const char *a);
+  return _REAL(unlink, path);
+}
+
+uptr internal_sched_yield() {
+  DEFINE__REAL(uptr, sched_yield);
+  return _REAL(sched_yield);
+}
+
+uptr internal_clock_gettime(__sanitizer_clockid_t clk_id, void *tp) {
+  DEFINE__REAL(int, clock_gettime, __sanitizer_clockid_t a, void *b);
+  return _REAL(clock_gettime, clk_id, tp);
+}
+
+void internal__exit(int exitcode) {
+  DEFINE__REAL(void, _exit, int a);
+  _REAL(_exit, exitcode);
+  Die();  // Unreachable.
+}
+
+void internal_usleep(u64 useconds) { usleep(useconds); }
+
+uptr internal_getpid() {
+  DEFINE__REAL(int, getpid);
+  return _REAL(getpid);
+}
+
+int internal_dlinfo(void *handle, int request, void *p) { UNIMPLEMENTED(); }
+
+int internal_sigaction(int signum, const void *act, void *oldact) {
+  return sigaction(signum, (const struct sigaction *)act,
+                   (struct sigaction *)oldact);
+}
+
+void internal_sigfillset(__sanitizer_sigset_t *set) { sigfillset(set); }
+
+uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set,
+                          __sanitizer_sigset_t *oldset) {
+  // Don't use sigprocmask here, because it affects all threads.
+  return pthread_sigmask(how, set, oldset);
+}
+
+int internal_fork() {
+  // VxWorks doesn't support fork
+  return -1;
+}
+
+uptr internal_execve(const char *filename, char *const argv[],
+                     char *const envp[]) {
+  // VxWorks doesn't support execve
+  return -1;
+}
+
+uptr internal_rename(const char *oldpath, const char *newpath) {
+  DEFINE__REAL(int, rename, const char *a, const char *b);
+  return _REAL(rename, oldpath, newpath);
+}
+
+uptr internal_ftruncate(fd_t fd, uptr size) { return ftruncate(fd, size); }
+
+uptr internal_waitpid(int pid, int *status, int options) {
+  DEFINE__REAL(uptr, waitpid, int a, int *b, int c);
+  return _REAL(waitpid, pid, status, options);
+}
+
+// ----------------- sanitizer_common.h
+bool FileExists(const char *filename) {
+  struct stat st;
+  if (stat(filename, &st))
+    return false;
+  // Sanity check: filename is a regular file.
+  return S_ISREG(st.st_mode);
+}
+
+tid_t GetTid() { return taskIdSelf(); }
+
+uptr GetThreadSelf() { return GetTid(); }
+
+void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
+                                uptr *stack_bottom) {
+  TASK_DESC taskDesc;
+
+  taskInfoGet(TASK_ID_NULL, &taskDesc);
+  *stack_top = (uptr)taskDesc.td_pStackBase;
+  *stack_bottom = (uptr)taskDesc.td_pStackEnd;
+}
+
+char **GetArgv() { return nullptr; }
+
+char **GetEnviron() { return nullptr; }
+
+const char *GetEnv(const char *name) { return getenv(name); }
+
+uptr ReadBinaryName(/*out*/ char *buf, uptr buf_len) {
+  // FIXME: Actually implement this function.
+  buf[0] = 0;
+  return 0;
+}
+
+uptr ReadLongProcessName(/*out*/ char *buf, uptr buf_len) {
+  return ReadBinaryName(buf, buf_len);
+}
+
+void ReExec() { UNIMPLEMENTED(); }
+
+void CheckASLR() {
+  // Do nothing
+}
+
+void CheckMPROTECT() {
+  // Do nothing
+}
+
+uptr GetPageSize() { return sysconf(_SC_PAGESIZE); }
+
+void FutexWait(atomic_uint32_t *p, u32 cmp) { sched_yield(); }
+
+void FutexWake(atomic_uint32_t *p, u32 count) {}
+
+u64 NanoTime() {
+  timeval tv;
+  internal_memset(&tv, 0, sizeof(tv));
+  gettimeofday(&tv, 0);
+  return (u64)tv.tv_sec * 1000 * 1000 * 1000 + tv.tv_usec * 1000;
+}
+
+u64 MonotonicNanoTime() {
+  timespec ts;
+  internal_clock_gettime(CLOCK_MONOTONIC, &ts);
+  return (u64)ts.tv_sec * (1000ULL * 1000 * 1000) + ts.tv_nsec;
+}
+
+uptr GetTlsBaseAddr() { return 0; }
+
+uptr GetTlsSize() { return 0; }
+
+void InitTlsSize() {}
+
+void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size,
+                          uptr *tls_addr, uptr *tls_size) {
+  uptr stack_top, stack_bottom;
+  GetThreadStackTopAndBottom(main, &stack_top, &stack_bottom);
+  *stk_addr = stack_bottom;
+  *stk_size = stack_top - stack_bottom;
+  *tls_addr = GetTlsBaseAddr();
+  *tls_size = GetTlsSize();
+}
+
+struct DlIteratePhdrData {
+  InternalMmapVectorNoCtor<LoadedModule> *modules;
+  bool first;
+};
+
+static int dl_iterate_phdr_cb(dl_phdr_info *info, size_t size, void *arg) {
+  DlIteratePhdrData *data = (DlIteratePhdrData *)arg;
+  InternalScopedString module_name;
+  if (data->first) {
+    data->first = false;
+    // First module is the binary itself.
+    /*ReadBinaryNameCached(module_name.data(), module_name.size());*/
+    module_name.append("%s", info->dlpi_name);
+  } else if (info->dlpi_name) {
+    module_name.append("%s", info->dlpi_name);
+  }
+
+  LoadedModule cur_module;
+  cur_module.set(module_name.data(), info->dlpi_addr);
+  for (int i = 0; i < (int)info->dlpi_phnum; i++) {
+    const Elf_Phdr *phdr = &info->dlpi_phdr[i];
+    if (phdr->p_type == PT_LOAD) {
+      uptr cur_beg = info->dlpi_addr + phdr->p_vaddr;
+      uptr cur_end = cur_beg + phdr->p_memsz;
+      bool executable = phdr->p_flags & PF_X;
+      bool writable = phdr->p_flags & PF_W;
+      cur_module.addAddressRange(cur_beg, cur_end, executable, writable);
+    }
+  }
+  data->modules->push_back(cur_module);
+  return 0;
+}
+
+void ListOfModules::init() {
+  clearOrInit();
+  DlIteratePhdrData data = {&modules_, true};
+  dl_iterate_phdr(dl_iterate_phdr_cb, &data);
+}
+
+void ListOfModules::fallbackInit() { clear(); }
+
+static HandleSignalMode GetHandleSignalModeImpl(int signum) {
+  switch (signum) {
+    case SIGABRT:
+      return common_flags()->handle_abort;
+    case SIGILL:
+      return common_flags()->handle_sigill;
+    case SIGTRAP:
+      return common_flags()->handle_sigtrap;
+    case SIGFPE:
+      return common_flags()->handle_sigfpe;
+    case SIGSEGV:
+      return common_flags()->handle_segv;
+    case SIGBUS:
+      return common_flags()->handle_sigbus;
+  }
+  return kHandleSignalNo;
+}
+
+HandleSignalMode GetHandleSignalMode(int signum) {
+  HandleSignalMode result = GetHandleSignalModeImpl(signum);
+
+  if (result == kHandleSignalYes && !common_flags()->allow_user_segv_handler)
+    return kHandleSignalExclusive;
+
+  return result;
+}
+
+uptr GetRSS() { return 0; }
+
+void *internal_start_thread(void *(*func)(void *arg), void *arg) { return 0; }
+
+void internal_join_thread(void *th) {}
+
+SignalContext::WriteFlag SignalContext::GetWriteFlag() const { return UNKNOWN; }
+
+bool SignalContext::IsTrueFaultingAddress() const {
+  auto si = static_cast<const siginfo_t *>(siginfo);
+  // "Real" SIGSEGV codes (e.g., SEGV_MAPERR, SEGV_MAPERR) are non-zero.
+  return si->si_signo == SIGSEGV && si->si_code != 0;
+}
+
+#  if defined(__aarch64__) && defined(arm_thread_state64_get_sp)
+#    define AARCH64_GET_REG(r) \
+      (uptr) ptrauth_strip(    \
+          (void *)arm_thread_state64_get_##r(ucontext->uc_mcontext->__ss), 0)
+#  else
+#    define AARCH64_GET_REG(r) ucontext->uc_mcontext->__ss.__##r
+#  endif
+
+static void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp) {
+  ucontext_t *ucontext = (ucontext_t *)context;
+#  if defined(__aarch64__)
+  *pc = (uptr)ucontext->uc_mcontext.regs.pc;
+  *bp = ucontext->uc_mcontext.regs.r[29];
+  *sp = ucontext->uc_mcontext.regs.sp;
+#  elif defined(__x86_64__)
+  *pc = (uptr)ucontext->uc_mcontext.regs.pc;
+  *bp = ucontext->uc_mcontext.regs.rbp;
+  *sp = ucontext->uc_mcontext.regs.rsp;
+#  elif defined(__riscv)
+  *pc = (uptr)ucontext->uc_mcontext.regs.pc;
+  *bp = ucontext->uc_mcontext.regs.gpr[8];
+  *sp = ucontext->uc_mcontext.regs.gpr[2];
+#  else
+#    error "Unknown architecture"
+#  endif
+}
+
+void SignalContext::InitPcSpBp() {
+  addr = (uptr)ptrauth_strip((void *)addr, 0);
+  GetPcSpBp(context, &pc, &sp, &bp);
+}
+
+void InitializePlatformEarly() {
+  // does nothing
+}
+
+bool ReexecDisabled() { return false; }
+
+void MaybeReexec() {}
+
+uptr GetMaxUserVirtualAddress() {
+#  if SANITIZER_WORDSIZE == 64
+  return (1ULL << 47) - 1;  // 0x00007fffffffffffUL;
+#  else                     // SANITIZER_WORDSIZE == 32
+  static_assert(SANITIZER_WORDSIZE == 32, "Wrong wordsize");
+  return (1ULL << 32) - 1;  // 0xffffffff;
+#  endif
+}
+
+uptr GetMaxVirtualAddress() { return GetMaxUserVirtualAddress(); }
+
+void SignalContext::DumpAllRegisters(void *context) { UNIMPLEMENTED(); }
+
+void DumpProcessMap() {
+  Printf("Process module map:\n");
+  ListOfModules modules;
+  modules.init();
+  for (uptr i = 0; i < modules.size(); ++i) {
+    for (const LoadedModule::AddressRange &r : modules[i].ranges()) {
+      Printf("\t%p-%p\tr%c%c\t%s\n", r.beg, r.end, r.writable ? 'w' : '-',
+             r.executable ? 'x' : '-', modules[i].full_name());
+    }
+  }
+  Printf("End of module map.\n");
+}
+
+void CheckNoDeepBind(const char *filename, int flag) { UNIMPLEMENTED(); }
+
+bool GetRandom(void *buffer, uptr length, bool blocking) { UNIMPLEMENTED(); }
+
+u32 GetNumberOfCPUs() { UNIMPLEMENTED(); }
+
+void InitializePlatformCommonFlags(CommonFlags *cf) {}
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_VXWORKS