[WebAssembly] Add Emscripten support for UBSan, LSan and ASan

[quantum]

Summary

This diff contains the sum of changes of UBSan, LSan and ASan in the
Emscripten repository.

[sbc100]

compiler-rt/lib/lsan/lsan_common.cpp

173

Why not combine this block with the block below that looks like the only user of cache_begin, cache_end?

Also the comment looks incorrectly indented.

compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.cpp

21

Perhaps worth putting these emscripten_builtin_ functions in the header file and then #include <emscripten/foo.h> here and elsewhere rather than forward declaring them?

21

Same with emscripten_get_module_name.. they could maybe go in <emscripten/internal.h> for want of a better name? Or maybe <emscripoten/jsapi.h>`?

[tlively]

compiler-rt/lib/asan/asan_flags.cpp

28

It might be worth tucking these conditional imports away in a more isolated location. Where do other platforms put this kind of stuff?

compiler-rt/lib/asan/asan_emscripten.cpp

+#include "asan_interceptors.h"
+#include "asan_internal.h"
+#include "asan_mapping.h"
+#include "asan_poisoning.h"
+#include "asan_stack.h"
+#include "asan_thread.h"
+
+#if SANITIZER_EMSCRIPTEN
+#include <emscripten.h>
+
+#include <cstddef>
+
+namespace __asan {
+
+void InitializeShadowMemory() {
+  // Poison the shadow memory of the shadow area at the start of the address
+  // space. This helps catching null pointer dereference.
+  FastPoisonShadow(kLowShadowBeg, kLowShadowEnd - kLowShadowBeg, 0xff);
+}
+
+void AsanCheckDynamicRTPrereqs() {}
+void AsanCheckIncompatibleRT() {}
+void InitializePlatformInterceptors() {}
+void InitializePlatformExceptionHandlers() {}
+bool IsSystemHeapAddress(uptr addr) { return false; }
+
+void *AsanDoesNotSupportStaticLinkage() {
+  // On Linux, this is some magic that fails linking with -static.
+  // On Emscripten, we have to do static linking, so we stub this out.
+  return nullptr;
+}
+
+void InitializeAsanInterceptors() {}
+
+// We can use a plain thread_local variable for TSD.
+static thread_local void *per_thread;
+
+void *AsanTSDGet() { return per_thread; }
+
+void AsanTSDSet(void *tsd) { per_thread = tsd; }
+
+// There's no initialization needed, and the passed-in destructor
+// will never be called.  Instead, our own thread destruction hook
+// (below) will call AsanThread::TSDDtor directly.
+void AsanTSDInit(void (*destructor)(void *tsd)) {
+  DCHECK(destructor == &PlatformTSDDtor);
+}
+
+void PlatformTSDDtor(void *tsd) { UNREACHABLE(__func__); }
+
+extern "C" {
+void *emscripten_builtin_malloc(size_t size);
+void emscripten_builtin_free(void *memory);
+int emscripten_builtin_pthread_create(void *thread, void *attr,
+                                      void *(*callback)(void *), void *arg);
+int pthread_attr_getdetachstate(void *attr, int *detachstate);
+}
+
+static thread_return_t THREAD_CALLING_CONV asan_thread_start(void *arg) {
+  atomic_uintptr_t *param = reinterpret_cast<atomic_uintptr_t *>(arg);
+  AsanThread *t = nullptr;
+  while ((t = reinterpret_cast<AsanThread *>(
+              atomic_load(param, memory_order_acquire))) == nullptr)
+    internal_sched_yield();
+  emscripten_builtin_free(param);
+  SetCurrentThread(t);
+  return t->ThreadStart(GetTid(), nullptr);
+}
+
+INTERCEPTOR(int, pthread_create, void *thread, void *attr,
+            void *(*start_routine)(void *), void *arg) {
+  EnsureMainThreadIDIsCorrect();
+  // Strict init-order checking is thread-hostile.
+  if (flags()->strict_init_order)
+    StopInitOrderChecking();
+  GET_STACK_TRACE_THREAD;
+  int detached = 0;
+  if (attr)
+    pthread_attr_getdetachstate(attr, &detached);
+  atomic_uintptr_t *param =
+      (atomic_uintptr_t *)emscripten_builtin_malloc(sizeof(atomic_uintptr_t));
+  atomic_store(param, 0, memory_order_relaxed);
+  int result;
+  {
+    // Ignore all allocations made by pthread_create: thread stack/TLS may be
+    // stored by pthread for future reuse even after thread destruction, and
+    // the linked list it's stored in doesn't even hold valid pointers to the
+    // objects, the latter are calculated by obscure pointer arithmetic.
+#if CAN_SANITIZE_LEAKS
+    __lsan::ScopedInterceptorDisabler disabler;
+#endif
+    result = REAL(pthread_create)(thread, attr, asan_thread_start, param);
+  }
+  if (result == 0) {
+    u32 current_tid = GetCurrentTidOrInvalid();
+    AsanThread *t =
+        AsanThread::Create(start_routine, arg, current_tid, &stack, detached);
+    atomic_store(param, reinterpret_cast<uptr>(t), memory_order_release);
+  }
+  return result;
+}
+
+}  // namespace __asan
+
+namespace __lsan {
+
+#ifndef USE_THREADS
+// XXX HACK: Emscripten treats thread_local variables the same as globals in
+// non-threaded builds, so a hack was introduced where we skip the allocator
+// cache in the common module. Now we have to define this symbol to keep that
+// hack working when using LSan as part of ASan without threads.
+void GetAllocatorCacheRange(uptr *begin, uptr *end) { *begin = *end = 0; }
+#endif
+
+u32 GetCurrentThread() { return __asan::GetCurrentThread()->tid(); }
+
+}  // namespace __lsan
+
+#endif  // SANITIZER_EMSCRIPTEN

compiler-rt/lib/asan/asan_errors.cpp

if (AddrIsInMem(addr)) {
           bug_descr = "dynamic-stack-buffer-overflow";
           bug_type_score = 25;
           far_from_bounds = AdjacentShadowValuesAreFullyPoisoned(shadow_addr);
           break;
       }
       scariness.Scare(bug_type_score + read_after_free_bonus, bug_descr);
       if (far_from_bounds) scariness.Scare(10, "far-from-bounds");
     }
+#if SANITIZER_EMSCRIPTEN
+    // If address is in the first page (64 KB), then it is likely that the
+    // access is a result of a null pointer dereference.
+    else if (addr < 65536) {
+      bug_descr = "null-pointer-dereference";
+      scariness.Scare(25, bug_descr);
+    } else if (AddrIsInShadow(addr)) {
+      bug_descr = "shadow-access";
+      scariness.Scare(25, bug_descr);
+    }
+#endif
   }
 }
 
 static void PrintContainerOverflowHint() {
   Printf("HINT: if you don't care about these errors you may set "
          "ASAN_OPTIONS=detect_container_overflow=0.\n"
          "If you suspect a false positive see also: "
          "https://github.com/google/sanitizers/wiki/"

compiler-rt/lib/asan/asan_flags.cpp

 #include "asan_stack.h"
 #include "lsan/lsan_common.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_flags.h"
 #include "sanitizer_common/sanitizer_flag_parser.h"
 #include "ubsan/ubsan_flags.h"
 #include "ubsan/ubsan_platform.h"
 
+#if SANITIZER_EMSCRIPTEN
+extern "C" void emscripten_builtin_free(void *);
+#include <emscripten/em_asm.h>
+#endif
+
 namespace __asan {
 
 Flags asan_flags_dont_use_directly;  // use via flags().
 
 static const char *MaybeCallAsanDefaultOptions() {
   return (&__asan_default_options) ? __asan_default_options() : "";
 }
 

 
 void InitializeFlags() {
   // Set the default values and prepare for parsing ASan and common flags.
   SetCommonFlagsDefaults();
   {
     CommonFlags cf;
     cf.CopyFrom(*common_flags());
     cf.detect_leaks = cf.detect_leaks && CAN_SANITIZE_LEAKS;
+#if !SANITIZER_EMSCRIPTEN
+    // getenv on emscripten uses malloc, which we can't when using LSan.
+    // You can't run external symbolizer executables anyway.
     cf.external_symbolizer_path = GetEnv("ASAN_SYMBOLIZER_PATH");
+#endif
     cf.malloc_context_size = kDefaultMallocContextSize;
     cf.intercept_tls_get_addr = true;
     cf.exitcode = 1;
     OverrideCommonFlags(cf);
   }
   Flags *f = flags();
   f->SetDefaults();
 
#if CAN_SANITIZE_UB
   const char *ubsan_default_options = __ubsan::MaybeCallUbsanDefaultOptions();
   ubsan_parser.ParseString(ubsan_default_options);
 #endif
 #if CAN_SANITIZE_LEAKS
   const char *lsan_default_options = __lsan::MaybeCallLsanDefaultOptions();
   lsan_parser.ParseString(lsan_default_options);
 #endif
 
+#if SANITIZER_EMSCRIPTEN
+  char *options;
+  // Override from Emscripten Module.
+#define MAKE_OPTION_LOAD(parser, name)                           \
+  options = (char *)EM_ASM_INT({                                 \
+    return _emscripten_with_builtin_malloc(                      \
+        function() { return allocateUTF8(Module[name] || 0); }); \
+  });                                                            \
+  parser.ParseString(options);                                   \
+  emscripten_builtin_free(options);
+
+  MAKE_OPTION_LOAD(asan_parser, 'ASAN_OPTIONS');
+#if CAN_SANITIZE_LEAKS
+  MAKE_OPTION_LOAD(lsan_parser, 'LSAN_OPTIONS');
+#endif
+#if CAN_SANITIZE_UB
+  MAKE_OPTION_LOAD(ubsan_parser, 'UBSAN_OPTIONS');
+#endif
+#else
   // Override from command line.
   asan_parser.ParseStringFromEnv("ASAN_OPTIONS");
 #if CAN_SANITIZE_LEAKS
   lsan_parser.ParseStringFromEnv("LSAN_OPTIONS");
 #endif
 #if CAN_SANITIZE_UB
   ubsan_parser.ParseStringFromEnv("UBSAN_OPTIONS");
 #endif
+#endif  // SANITIZER_EMSCRIPTEN
 
   InitializeCommonFlags();
 
   // TODO(eugenis): dump all flags at verbosity>=2?
   if (Verbosity()) ReportUnrecognizedFlags();
 
   if (common_flags()->help) {
     // TODO(samsonov): print all of the flags (ASan, LSan, common).

compiler-rt/lib/asan/asan_interceptors.cpp

 #include "asan_poisoning.h"
 #include "asan_report.h"
 #include "asan_stack.h"
 #include "asan_stats.h"
 #include "asan_suppressions.h"
 #include "lsan/lsan_common.h"
 #include "sanitizer_common/sanitizer_libc.h"
 
-// There is no general interception at all on Fuchsia and RTEMS.
+// There is no general interception at all on Fuchsia, RTEMS and Emscripten.
 // Only the functions in asan_interceptors_memintrinsics.cpp are
 // really defined to replace libc functions.
-#if !SANITIZER_FUCHSIA && !SANITIZER_RTEMS
+#if !SANITIZER_FUCHSIA && !SANITIZER_RTEMS && !SANITIZER_EMSCRIPTEN
 
 #if SANITIZER_POSIX
 #include "sanitizer_common/sanitizer_posix.h"
 #endif
 
 #if ASAN_INTERCEPT__UNWIND_RAISEEXCEPTION || \
     ASAN_INTERCEPT__SJLJ_UNWIND_RAISEEXCEPTION
 #include <unwind.h>

compiler-rt/lib/asan/asan_interceptors_memintrinsics.cpp

 void *__asan_memset(void *block, int c, uptr size) {
   ASAN_MEMSET_IMPL(nullptr, block, c, size);
 }
 
 void *__asan_memmove(void *to, const void *from, uptr size) {
   ASAN_MEMMOVE_IMPL(nullptr, to, from, size);
 }
 
-#if SANITIZER_FUCHSIA || SANITIZER_RTEMS
+#if SANITIZER_FUCHSIA || SANITIZER_RTEMS || SANITIZER_EMSCRIPTEN
 
 // Fuchsia and RTEMS don't use sanitizer_common_interceptors.inc, but
 // the only things there it wants are these three.  Just define them
 // as aliases here rather than repeating the contents.
 
 extern "C" decltype(__asan_memcpy) memcpy[[gnu::alias("__asan_memcpy")]];
 extern "C" decltype(__asan_memmove) memmove[[gnu::alias("__asan_memmove")]];
 extern "C" decltype(__asan_memset) memset[[gnu::alias("__asan_memset")]];
 
 #endif  // SANITIZER_FUCHSIA || SANITIZER_RTEMS

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_RTEMS || SANITIZER_SOLARIS
+    SANITIZER_NETBSD || SANITIZER_RTEMS || SANITIZER_SOLARIS ||  \
+    SANITIZER_EMSCRIPTEN
 
 #include "sanitizer_common/sanitizer_allocator_checks.h"
 #include "sanitizer_common/sanitizer_errno.h"
 #include "sanitizer_common/sanitizer_tls_get_addr.h"
 #include "asan_allocator.h"
 #include "asan_interceptors.h"
 #include "asan_internal.h"
 #include "asan_malloc_local.h"

compiler-rt/lib/asan/asan_mapping.h

 #else
 extern uptr kHighMemEnd, kMidMemBeg, kMidMemEnd;  // Initialized in __asan_init.
 #endif
 
 }  // namespace __asan
 
 #if SANITIZER_MYRIAD2
 #include "asan_mapping_myriad.h"
+#elif SANITIZER_EMSCRIPTEN
+#include "asan_mapping_emscripten.h"
 #elif defined(__sparc__) && SANITIZER_WORDSIZE == 64
 #include "asan_mapping_sparc64.h"
 #else
 #define MEM_TO_SHADOW(mem) (((mem) >> SHADOW_SCALE) + (SHADOW_OFFSET))
 
 #define kLowMemBeg      0
 #define kLowMemEnd      (SHADOW_OFFSET ? SHADOW_OFFSET - 1 : 0)
 

compiler-rt/lib/asan/asan_mapping_emscripten.h

+//===-- asan_mapping_emscripten.h -------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Emscripten-specific definitions for ASan memory mapping.
+//===----------------------------------------------------------------------===//
+#ifndef ASAN_MAPPING_EMSCRIPTEN_H
+#define ASAN_MAPPING_EMSCRIPTEN_H
+
+extern char __global_base;
+
+#define kLowMemBeg ((uptr)&__global_base)
+#define kLowMemEnd ((kLowShadowBeg << SHADOW_SCALE) - 1)
+
+#define kLowShadowBeg 0
+#define kLowShadowEnd ((uptr)&__global_base - 1)
+
+#define kHighMemBeg 0
+
+#define kHighShadowBeg 0
+#define kHighShadowEnd 0
+
+#define kMidShadowBeg 0
+#define kMidShadowEnd 0
+
+#define kShadowGapBeg (kLowMemEnd + 1)
+#define kShadowGapEnd 0xFFFFFFFF
+
+#define kShadowGap2Beg 0
+#define kShadowGap2End 0
+
+#define kShadowGap3Beg 0
+#define kShadowGap3End 0
+
+// The first 1/8 of the shadow memory space is shadowing itself.
+// This allows attempted accesses into the shadow memory, as well as null
+// pointer dereferences, to be detected properly.
+// The shadow memory of the shadow memory is poisoned.
+#define MEM_TO_SHADOW(mem) ((mem) >> SHADOW_SCALE)
+
+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 false;
+}
+
+static inline bool AddrIsInHighShadow(uptr a) {
+  PROFILE_ASAN_MAPPING();
+  return false;
+}
+
+static inline bool AddrIsInShadowGap(uptr a) {
+  PROFILE_ASAN_MAPPING();
+  return a >= kShadowGapBeg;
+}
+
+}  // namespace __asan
+
+#endif  // ASAN_MAPPING_EMSCRIPTEN_H

compiler-rt/lib/asan/asan_poisoning.h

#else
   // FIXME: Page states are different on Windows, so using the same interface
   // for mapping shadow and zeroing out pages doesn't "just work", so we should
   // probably provide higher-level interface for these operations.
   // For now, just memset on Windows.
   if (value || SANITIZER_WINDOWS == 1 ||
       // RTEMS doesn't have have pages, let alone a fast way to zero
       // them, so default to memset.
       SANITIZER_RTEMS == 1 ||
+      // Emscripten doesn't have a nice way to zero whole pages.
+      // The bulk memory proposal will allow memset to be optimized, but
+      // even then, we still must use memset.
+      SANITIZER_EMSCRIPTEN == 1 ||
       shadow_end - shadow_beg < common_flags()->clear_shadow_mmap_threshold) {
     REAL(memset)((void*)shadow_beg, value, shadow_end - shadow_beg);
   } else {
     uptr page_size = GetPageSizeCached();
     uptr page_beg = RoundUpTo(shadow_beg, page_size);
     uptr page_end = RoundDownTo(shadow_end, page_size);
 
     if (page_beg >= page_end) {

compiler-rt/lib/asan/asan_poisoning.cpp

explicit ShadowSegmentEndpoint(uptr address) {
     offset = address & (SHADOW_GRANULARITY - 1);
     value = *chunk;
   }
 };
 
 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.
+#if !SANITIZER_EMSCRIPTEN
   ReleaseMemoryPagesToOS(MemToShadow(p), MemToShadow(p + size));
+#endif
 }
 
 void AsanPoisonOrUnpoisonIntraObjectRedzone(uptr ptr, uptr size, bool poison) {
   uptr end = ptr + size;
   if (Verbosity()) {
     Printf("__asan_%spoison_intra_object_redzone [%p,%p) %zd\n",
            poison ? "" : "un", ptr, end, size);
     if (Verbosity() >= 2)
uptr __asan_region_is_poisoned(uptr beg, uptr size) {
   if (!size) return 0;
   uptr end = beg + size;
   if (SANITIZER_MYRIAD2) {
     // On Myriad, address not in DRAM range need to be treated as
     // unpoisoned.
     if (!AddrIsInMem(beg) && !AddrIsInShadow(beg)) return 0;
     if (!AddrIsInMem(end) && !AddrIsInShadow(end)) return 0;
   } else {
+#if SANITIZER_EMSCRIPTEN
+    // XXX Emscripten hack XXX
+    // Null pointer handling, since Emscripten does not crash on null pointer,
+    // ASan must catch null pointer dereference by itself.
+    // Unfortunately, this function returns 0 to mean the region is not
+    // poisoned, so we must return 1 instead if we receive a region
+    // starting at 0.
+    if (!beg)
+      return 1;
+#endif
     if (!AddrIsInMem(beg)) return beg;
     if (!AddrIsInMem(end)) return end;
   }
   CHECK_LT(beg, end);
   uptr aligned_b = RoundUpTo(beg, SHADOW_GRANULARITY);
   uptr aligned_e = RoundDownTo(end, SHADOW_GRANULARITY);
   uptr shadow_beg = MemToShadow(aligned_b);
   uptr shadow_end = MemToShadow(aligned_e);

compiler-rt/lib/asan/asan_posix.cpp

 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_EMSCRIPTEN
 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));
 }
 

compiler-rt/lib/asan/asan_rtl.cpp

if (atomic_fetch_add(&num_calls, 1, memory_order_relaxed) != 0) {
     // Don't die twice - run a busy loop.
     while (1) { }
   }
   if (common_flags()->print_module_map >= 1) PrintModuleMap();
   if (flags()->sleep_before_dying) {
     Report("Sleeping for %d second(s)\n", flags()->sleep_before_dying);
     SleepForSeconds(flags()->sleep_before_dying);
   }
+#if !SANITIZER_EMSCRIPTEN
   if (flags()->unmap_shadow_on_exit) {
     if (kMidMemBeg) {
       UnmapOrDie((void*)kLowShadowBeg, kMidMemBeg - kLowShadowBeg);
       UnmapOrDie((void*)kMidMemEnd, kHighShadowEnd - kMidMemEnd);
     } else {
       if (kHighShadowEnd)
         UnmapOrDie((void*)kLowShadowBeg, kHighShadowEnd - kLowShadowBeg);
     }
   }
+#endif
 }
 
 static void AsanCheckFailed(const char *file, int line, const char *cond,
                             u64 v1, u64 v2) {
   Report("AddressSanitizer CHECK failed: %s:%d \"%s\" (0x%zx, 0x%zx)\n", file,
          line, cond, (uptr)v1, (uptr)v2);
 
   // Print a stack trace the first time we come here. Otherwise, we probably
static void asan_atexit() {
   // Print AsanMappingProfile.
   for (uptr i = 0; i < kAsanMappingProfileSize; i++) {
     if (AsanMappingProfile[i] == 0) continue;
     Printf("asan_mapping.h:%zd -- %zd\n", i, AsanMappingProfile[i]);
   }
 }
 
 static void InitializeHighMemEnd() {
-#if !SANITIZER_MYRIAD2
+#if !SANITIZER_MYRIAD2 && !SANITIZER_EMSCRIPTEN
 #if !ASAN_FIXED_MAPPING
   kHighMemEnd = GetMaxUserVirtualAddress();
   // Increase kHighMemEnd to make sure it's properly
   // aligned together with kHighMemBeg:
   kHighMemEnd |= SHADOW_GRANULARITY * GetMmapGranularity() - 1;
 #endif  // !ASAN_FIXED_MAPPING
   CHECK_EQ((kHighMemBeg % GetMmapGranularity()), 0);
 #endif  // !SANITIZER_MYRIAD2
static void AsanInitInternal() {
 
   ReplaceSystemMalloc();
 
   DisableCoreDumperIfNecessary();
 
   InitializeShadowMemory();
 
   AsanTSDInit(PlatformTSDDtor);
+#if !SANITIZER_EMSCRIPTEN
   InstallDeadlySignalHandlers(AsanOnDeadlySignal);
+#endif
 
   AllocatorOptions allocator_options;
   allocator_options.SetFrom(flags(), common_flags());
   InitializeAllocator(allocator_options);
 
 #ifdef START_BACKGROUND_THREAD_IN_ASAN_INTERNAL
   MaybeStartBackgroudThread();
   SetSoftRssLimitExceededCallback(AsanSoftRssLimitExceededCallback);

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 and asan_rtems.cpp have their own
+// asan_fuchsia.cpp, asan_rtems.cpp and asan_emscripten.cpp have their own
 // InitializeShadowMemory implementation.
-#if !SANITIZER_FUCHSIA && !SANITIZER_RTEMS
+#if !SANITIZER_FUCHSIA && !SANITIZER_RTEMS && !SANITIZER_EMSCRIPTEN
 
 #include "asan_internal.h"
 #include "asan_mapping.h"
 
 namespace __asan {
 
 // ---------------------- mmap -------------------- {{{1
 // Reserve memory range [beg, end].

compiler-rt/lib/asan/asan_thread.h

 
 namespace __sanitizer {
 struct DTLS;
 }  // namespace __sanitizer
 
 namespace __asan {
 
 const u32 kInvalidTid = 0xffffff;  // Must fit into 24 bits.
+#if SANITIZER_EMSCRIPTEN && !defined(USE_THREADS)
+const u32 kMaxNumberOfThreads = 1;
+#elif SANITIZER_EMSCRIPTEN
+const u32 kMaxNumberOfThreads = 128;
+#else
 const u32 kMaxNumberOfThreads = (1 << 22);  // 4M
+#endif
 
 class AsanThread;
 
 // These objects are created for every thread and are never deleted,
 // so we can find them by tid even if the thread is long dead.
 class AsanThreadContext : public ThreadContextBase {
  public:
   explicit AsanThreadContext(int tid)

compiler-rt/lib/asan/asan_thread.cpp

if (context->thread)
     context->thread->Destroy();
 }
 
 void AsanThread::Destroy() {
   int tid = this->tid();
   VReport(1, "T%d exited\n", tid);
 
   malloc_storage().CommitBack();
+#if !SANITIZER_EMSCRIPTEN
   if (common_flags()->use_sigaltstack) UnsetAlternateSignalStack();
+#endif
   asanThreadRegistry().FinishThread(tid);
   FlushToDeadThreadStats(&stats_);
   // We also clear the shadow on thread destruction because
   // some code may still be executing in later TSD destructors
   // and we don't want it to have any poisoned stack.
   ClearShadowForThreadStackAndTLS();
   DeleteFakeStack(tid);
   uptr size = RoundUpTo(sizeof(AsanThread), GetPageSizeCached());

 
 thread_return_t AsanThread::ThreadStart(
     tid_t os_id, atomic_uintptr_t *signal_thread_is_registered) {
   Init();
   asanThreadRegistry().StartThread(tid(), os_id, ThreadType::Regular, nullptr);
   if (signal_thread_is_registered)
     atomic_store(signal_thread_is_registered, 1, memory_order_release);
 
+#if !SANITIZER_EMSCRIPTEN
   if (common_flags()->use_sigaltstack) SetAlternateSignalStack();
+#endif
 
   if (!start_routine_) {
     // start_routine_ == 0 if we're on the main thread or on one of the
     // OS X libdispatch worker threads. But nobody is supposed to call
     // ThreadStart() for the worker threads.
     CHECK_EQ(tid(), 0);
     return 0;
   }

compiler-rt/lib/interception/interception.h

 // Machinery for providing replacements/wrappers for system functions.
 //===----------------------------------------------------------------------===//
 
 #ifndef INTERCEPTION_H
 #define INTERCEPTION_H
 
 #include "sanitizer_common/sanitizer_internal_defs.h"
 
-#if !SANITIZER_LINUX && !SANITIZER_FREEBSD && !SANITIZER_MAC && \
+#if !SANITIZER_LINUX && !SANITIZER_FREEBSD && !SANITIZER_MAC &&      \
     !SANITIZER_NETBSD && !SANITIZER_OPENBSD && !SANITIZER_WINDOWS && \
-    !SANITIZER_FUCHSIA && !SANITIZER_RTEMS && !SANITIZER_SOLARIS
+    !SANITIZER_FUCHSIA && !SANITIZER_RTEMS && !SANITIZER_SOLARIS &&  \
+    !SANITIZER_EMSCRIPTEN
 # 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;

 #elif SANITIZER_WINDOWS
 # define WRAP(x) __asan_wrap_##x
 # define WRAPPER_NAME(x) "__asan_wrap_"#x
 # define INTERCEPTOR_ATTRIBUTE __declspec(dllexport)
 # define DECLARE_WRAPPER(ret_type, func, ...) \
     extern "C" ret_type func(__VA_ARGS__);
 # define DECLARE_WRAPPER_WINAPI(ret_type, func, ...) \
     extern "C" __declspec(dllimport) ret_type __stdcall func(__VA_ARGS__);
-#elif SANITIZER_RTEMS
+#elif SANITIZER_RTEMS || SANITIZER_EMSCRIPTEN
 # define WRAP(x) x
 # define WRAPPER_NAME(x) #x
 # define INTERCEPTOR_ATTRIBUTE
 # define DECLARE_WRAPPER(ret_type, func, ...)
 #elif SANITIZER_FREEBSD || SANITIZER_NETBSD
 # define WRAP(x) __interceptor_ ## x
 # define WRAPPER_NAME(x) "__interceptor_" #x
 # define INTERCEPTOR_ATTRIBUTE __attribute__((visibility("default")))

 #if SANITIZER_FUCHSIA
 // There is no general interception at all on Fuchsia.
 // Sanitizer runtimes just define functions directly to preempt them,
 // and have bespoke ways to access the underlying libc functions.
 # include <zircon/sanitizer.h>
 # define INTERCEPTOR_ATTRIBUTE __attribute__((visibility("default")))
 # define REAL(x) __unsanitized_##x
 # define DECLARE_REAL(ret_type, func, ...)
+#elif SANITIZER_EMSCRIPTEN
+// Sanitizer runtimes on Emscripten just define functions directly to override
+// the libc functions. If the real version is really needed, they can be defined
+// with the emscripten_builtin_ prefix.
+#define REAL(x) emscripten_builtin_##x
+#define DECLARE_REAL(ret_type, func, ...) \
+  extern "C" ret_type REAL(func)(__VA_ARGS__);
 #elif SANITIZER_RTEMS
 # define REAL(x) __real_ ## x
 # define DECLARE_REAL(ret_type, func, ...) \
     extern "C" ret_type REAL(func)(__VA_ARGS__);
 #elif !SANITIZER_MAC
 # define PTR_TO_REAL(x) real_##x
 # define REAL(x) __interception::PTR_TO_REAL(x)
 # define FUNC_TYPE(x) x##_type

 # define DECLARE_REAL_AND_INTERCEPTOR(ret_type, func, ...)
 # define DECLARE_EXTERN_INTERCEPTOR_AND_WRAPPER(ret_type, func, ...)
 #endif
 
 // Generally, you don't need to use DEFINE_REAL by itself, as INTERCEPTOR
 // macros does its job. In exceptional cases you may need to call REAL(foo)
 // without defining INTERCEPTOR(..., foo, ...). For example, if you override
 // foo with an interceptor for other function.
-#if !SANITIZER_MAC && !SANITIZER_FUCHSIA && !SANITIZER_RTEMS
+#if !SANITIZER_MAC && !SANITIZER_FUCHSIA && !SANITIZER_RTEMS && \
+    !SANITIZER_EMSCRIPTEN
 # define DEFINE_REAL(ret_type, func, ...) \
     typedef ret_type (*FUNC_TYPE(func))(__VA_ARGS__); \
     namespace __interception { \
       FUNC_TYPE(func) PTR_TO_REAL(func); \
     }
 #else
 # define DEFINE_REAL(ret_type, func, ...)
 #endif

 #else
 typedef unsigned long uptr;  // NOLINT
 #endif  // _WIN64
 }  // namespace __interception
 
 #define INCLUDED_FROM_INTERCEPTION_LIB
 
 #if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD || \
-    SANITIZER_OPENBSD || SANITIZER_SOLARIS
+    SANITIZER_OPENBSD || SANITIZER_SOLARIS || SANITIZER_EMSCRIPTEN
 
 # 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)

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_OPENBSD || SANITIZER_SOLARIS
+    SANITIZER_OPENBSD || SANITIZER_SOLARIS || SANITIZER_EMSCRIPTEN
 
 #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
 
 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
 
 #define INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func) \
   ::__interception::InterceptFunction(            \
       #func,                                      \
       (::__interception::uptr *) & REAL(func),    \
       (::__interception::uptr) & (func),          \
       (::__interception::uptr) & WRAP(func))
 
-// Android,  Solaris and OpenBSD do not have dlvsym
-#if !SANITIZER_ANDROID && !SANITIZER_SOLARIS && !SANITIZER_OPENBSD
+// Android,  Solaris, OpenBSD and emscripten do not have dlvsym
+#if !SANITIZER_ANDROID && !SANITIZER_SOLARIS && !SANITIZER_OPENBSD && \
+    !SANITIZER_EMSCRIPTEN
 #define INTERCEPT_FUNCTION_VER_LINUX_OR_FREEBSD(func, symver) \
   ::__interception::InterceptFunction(                        \
       #func, symver,                                          \
       (::__interception::uptr *) & REAL(func),                \
       (::__interception::uptr) & (func),                      \
       (::__interception::uptr) & WRAP(func))
 #else
 #define INTERCEPT_FUNCTION_VER_LINUX_OR_FREEBSD(func, symver) \
   INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func)
 #endif  // !SANITIZER_ANDROID && !SANITIZER_SOLARIS
 
 #endif  // INTERCEPTION_LINUX_H
 #endif  // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD ||
         // SANITIZER_OPENBSD || SANITIZER_SOLARIS

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_OPENBSD || SANITIZER_SOLARIS
+    SANITIZER_OPENBSD || SANITIZER_SOLARIS || SANITIZER_EMSCRIPTEN
 
 #include <dlfcn.h>   // for dlsym() and dlvsym()
 
 namespace __interception {
 
 #if SANITIZER_NETBSD
 static int StrCmp(const char *s1, const char *s2) {
   while (true) {

 bool InterceptFunction(const char *name, uptr *ptr_to_real, uptr func,
                        uptr wrapper) {
   void *addr = GetFuncAddr(name, wrapper);
   *ptr_to_real = (uptr)addr;
   return addr && (func == wrapper);
 }
 
 // Android and Solaris do not have dlvsym
-#if !SANITIZER_ANDROID && !SANITIZER_SOLARIS && !SANITIZER_OPENBSD
+#if !SANITIZER_ANDROID && !SANITIZER_SOLARIS && !SANITIZER_OPENBSD && \
+    !SANITIZER_EMSCRIPTEN
 static void *GetFuncAddr(const char *name, const char *ver) {
   return dlvsym(RTLD_NEXT, name, ver);
 }
 
 bool InterceptFunction(const char *name, const char *ver, uptr *ptr_to_real,
                        uptr func, uptr wrapper) {
   void *addr = GetFuncAddr(name, ver);
   *ptr_to_real = (uptr)addr;
   return addr && (func == wrapper);
 }
 #endif  // !SANITIZER_ANDROID
 
 }  // namespace __interception
 
 #endif  // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD ||
         // SANITIZER_OPENBSD || SANITIZER_SOLARIS

compiler-rt/lib/lsan/lsan.cpp

 using namespace __lsan;  // NOLINT
 
 static void InitializeFlags() {
   // Set all the default values.
   SetCommonFlagsDefaults();
   {
     CommonFlags cf;
     cf.CopyFrom(*common_flags());
+#if !SANITIZER_EMSCRIPTEN
+    // getenv on emscripten uses malloc, which we can't when using LSan.
+    // You can't run external symbolizers anyway.
     cf.external_symbolizer_path = GetEnv("LSAN_SYMBOLIZER_PATH");
+#endif
     cf.malloc_context_size = 30;
     cf.intercept_tls_get_addr = true;
     cf.detect_leaks = true;
     cf.exitcode = 23;
     OverrideCommonFlags(cf);
   }
 
   Flags *f = flags();
extern "C" void __lsan_init() {
   AvoidCVE_2016_2143();
   InitializeFlags();
   InitCommonLsan();
   InitializeAllocator();
   ReplaceSystemMalloc();
   InitTlsSize();
   InitializeInterceptors();
   InitializeThreadRegistry();
+#if !SANITIZER_EMSCRIPTEN
+  // Emscripten does not have signals
   InstallDeadlySignalHandlers(LsanOnDeadlySignal);
+#endif
   u32 tid = ThreadCreate(0, 0, true);
   CHECK_EQ(tid, 0);
   ThreadStart(tid, GetTid());
   SetCurrentThread(tid);
 
   if (common_flags()->detect_leaks && common_flags()->leak_check_at_exit)
     Atexit(DoLeakCheck);
 

compiler-rt/lib/lsan/lsan_allocator.h

 #else
   uptr requested_size : 32;
   uptr padding : 22;
 #endif
   u32 stack_trace_id;
 };
 
 #if defined(__mips64) || defined(__aarch64__) || defined(__i386__) || \
-    defined(__arm__)
+    defined(__arm__) || defined(__wasm32__)
 template <typename AddressSpaceViewTy>
 struct AP32 {
   static const uptr kSpaceBeg = 0;
   static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE;
   static const uptr kMetadataSize = sizeof(ChunkMetadata);
   typedef __sanitizer::CompactSizeClassMap SizeClassMap;
   static const uptr kRegionSizeLog = 20;
   using AddressSpaceView = AddressSpaceViewTy;

compiler-rt/lib/lsan/lsan_allocator.cpp

 #include "sanitizer_common/sanitizer_internal_defs.h"
 #include "sanitizer_common/sanitizer_stackdepot.h"
 #include "sanitizer_common/sanitizer_stacktrace.h"
 #include "lsan_common.h"
 
 extern "C" void *memset(void *ptr, int value, uptr num);
 
 namespace __lsan {
-#if defined(__i386__) || defined(__arm__)
+#if defined(__i386__) || defined(__arm__) || defined(__wasm32__)
 static const uptr kMaxAllowedMallocSize = 1UL << 30;
 #elif defined(__mips64) || defined(__aarch64__)
 static const uptr kMaxAllowedMallocSize = 4UL << 30;
 #else
 static const uptr kMaxAllowedMallocSize = 8UL << 30;
 #endif
 
 static Allocator allocator;

compiler-rt/lib/lsan/lsan_common.h

 #elif defined(__i386__) && \
     (SANITIZER_LINUX && !SANITIZER_ANDROID || SANITIZER_MAC)
 #define CAN_SANITIZE_LEAKS 1
 #elif defined(__arm__) && \
     SANITIZER_LINUX && !SANITIZER_ANDROID
 #define CAN_SANITIZE_LEAKS 1
 #elif SANITIZER_NETBSD
 #define CAN_SANITIZE_LEAKS 1
+#elif SANITIZER_EMSCRIPTEN
+#define CAN_SANITIZE_LEAKS 1
 #else
 #define CAN_SANITIZE_LEAKS 0
 #endif
 
 namespace __sanitizer {
 class FlagParser;
 class ThreadRegistry;
 struct DTLS;

 void LockThreadRegistry();
 void UnlockThreadRegistry();
 ThreadRegistry *GetThreadRegistryLocked();
 bool GetThreadRangesLocked(tid_t os_id, uptr *stack_begin, uptr *stack_end,
                            uptr *tls_begin, uptr *tls_end, uptr *cache_begin,
                            uptr *cache_end, DTLS **dtls);
 void ForEachExtraStackRange(tid_t os_id, RangeIteratorCallback callback,
                             void *arg);
+// Scans thread data (stacks and TLS) for heap pointers.
+void ProcessThreads(SuspendedThreadsList const &suspended_threads,
+                    Frontier *frontier);
+
 // If called from the main thread, updates the main thread's TID in the thread
 // registry. We need this to handle processes that fork() without a subsequent
 // exec(), which invalidates the recorded TID. To update it, we must call
 // gettid() from the main thread. Our solution is to call this function before
 // leak checking and also before every call to pthread_create() (to handle cases
 // where leak checking is initiated from a non-main thread).
 void EnsureMainThreadIDIsCorrect();
 // If p points into a chunk that has been allocated to the user, returns its

compiler-rt/lib/lsan/lsan_common.cpp

 #include "sanitizer_common/sanitizer_procmaps.h"
 #include "sanitizer_common/sanitizer_report_decorator.h"
 #include "sanitizer_common/sanitizer_stackdepot.h"
 #include "sanitizer_common/sanitizer_stacktrace.h"
 #include "sanitizer_common/sanitizer_suppressions.h"
 #include "sanitizer_common/sanitizer_thread_registry.h"
 #include "sanitizer_common/sanitizer_tls_get_addr.h"
 
+#if SANITIZER_EMSCRIPTEN
+#include "lsan/lsan_allocator.h"
+#endif
+
 #if CAN_SANITIZE_LEAKS
 namespace __lsan {
 
 // This mutex is used to prevent races between DoLeakCheck and IgnoreObject, and
 // also to protect the global list of root regions.
 BlockingMutex global_mutex(LINKER_INITIALIZED);
 
 Flags lsan_flags;
void ScanRangeForPointers(uptr begin, uptr end,
                           Frontier *frontier,
                           const char *region_type, ChunkTag tag) {
   CHECK(tag == kReachable || tag == kIndirectlyLeaked);
   const uptr alignment = flags()->pointer_alignment();
   LOG_POINTERS("Scanning %s range %p-%p.\n", region_type, begin, end);
   uptr pp = begin;
   if (pp % alignment)
     pp = pp + alignment - pp % alignment;
+
+    // Emscripten in non-threaded mode stores thread_local variables in the
+    // same place as normal globals. This means allocator_cache must be skipped
+    // when scanning globals instead of when scanning thread-locals.
+#if SANITIZER_EMSCRIPTEN && !defined(USE_THREADS)
+  uptr cache_begin, cache_end;
+  GetAllocatorCacheRange(&cache_begin, &cache_end);
+#endif
+
   for (; pp + sizeof(void *) <= end; pp += alignment) {  // NOLINT
     void *p = *reinterpret_cast<void **>(pp);
     if (!CanBeAHeapPointer(reinterpret_cast<uptr>(p))) continue;
     uptr chunk = PointsIntoChunk(p);
     if (!chunk) continue;
     // Pointers to self don't count. This matters when tag == kIndirectlyLeaked.
     if (chunk == begin) continue;
     LsanMetadata m(chunk);
     if (m.tag() == kReachable || m.tag() == kIgnored) continue;
 
     // Do this check relatively late so we can log only the interesting cases.
     if (!flags()->use_poisoned && WordIsPoisoned(pp)) {
       LOG_POINTERS(
           "%p is poisoned: ignoring %p pointing into chunk %p-%p of size "
           "%zu.\n",
           pp, p, chunk, chunk + m.requested_size(), m.requested_size());
       continue;
     }
 
+#if SANITIZER_EMSCRIPTEN && !defined(USE_THREADS)
+    if (cache_begin <= pp && pp < cache_end) {
+      LOG_POINTERS("%p: skipping because it overlaps the cache %p-%p.\n", pp,
+                   cache_begin, cache_end);
+      continue;
+    }
+#endif
+
     m.set_tag(tag);
     LOG_POINTERS("%p: found %p pointing into chunk %p-%p of size %zu.\n", pp, p,
                  chunk, chunk + m.requested_size(), m.requested_size());
     if (frontier)
       frontier->push_back(chunk);
   }
 }
 
void ScanGlobalRange(uptr begin, uptr end, Frontier *frontier) {
   }
 }
 
 void ForEachExtraStackRangeCb(uptr begin, uptr end, void* arg) {
   Frontier *frontier = reinterpret_cast<Frontier *>(arg);
   ScanRangeForPointers(begin, end, frontier, "FAKE STACK", kReachable);
 }
 
+#if !SANITIZER_EMSCRIPTEN
 // Scans thread data (stacks and TLS) for heap pointers.
-static void ProcessThreads(SuspendedThreadsList const &suspended_threads,
-                           Frontier *frontier) {
+void ProcessThreads(SuspendedThreadsList const &suspended_threads,
   InternalMmapVector<uptr> registers(suspended_threads.RegisterCount());
   uptr registers_begin = reinterpret_cast<uptr>(registers.data());
   uptr registers_end =
       reinterpret_cast<uptr>(registers.data() + registers.size());
   for (uptr i = 0; i < suspended_threads.ThreadCount(); i++) {
     tid_t os_id = static_cast<tid_t>(suspended_threads.GetThreadID(i));
     LOG_THREADS("Processing thread %d.\n", os_id);
     uptr stack_begin, stack_end, tls_begin, tls_end, cache_begin, cache_end;
if (flags()->use_tls) {
       } else {
         // We are handling a thread with DTLS under destruction. Log about
         // this and continue.
         LOG_THREADS("Thread %d has DTLS under destruction.\n", os_id);
       }
     }
   }
 }
+#endif  // !SANITIZER_EMSCRIPTEN
 
 void ScanRootRegion(Frontier *frontier, const RootRegion &root_region,
                     uptr region_begin, uptr region_end, bool is_readable) {
   uptr intersection_begin = Max(root_region.begin, region_begin);
   uptr intersection_end = Min(region_end, root_region.begin + root_region.size);
   if (intersection_begin >= intersection_end) return;
   LOG_POINTERS("Root region %p-%p intersects with mapped region %p-%p (%s)\n",
                root_region.begin, root_region.begin + root_region.size,
                region_begin, region_end,
                is_readable ? "readable" : "unreadable");
   if (is_readable)
     ScanRangeForPointers(intersection_begin, intersection_end, frontier, "ROOT",
                          kReachable);
 }
 
+#if SANITIZER_EMSCRIPTEN
+extern "C" uptr emscripten_get_heap_size();
+#endif
+
 static void ProcessRootRegion(Frontier *frontier,
                               const RootRegion &root_region) {
+#if SANITIZER_EMSCRIPTEN
+  ScanRootRegion(frontier, root_region, 0, emscripten_get_heap_size(), true);
+#else
   MemoryMappingLayout proc_maps(/*cache_enabled*/ true);
   MemoryMappedSegment segment;
   while (proc_maps.Next(&segment)) {
     ScanRootRegion(frontier, root_region, segment.start, segment.end,
                    segment.IsReadable());
   }
+#endif  // SANITIZER_EMSCRIPTEN
 }
 
 // Scans root regions for heap pointers.
 static void ProcessRootRegions(Frontier *frontier) {
   if (!flags()->use_root_regions) return;
   CHECK(root_regions);
   for (uptr i = 0; i < root_regions->size(); i++) {
     ProcessRootRegion(frontier, (*root_regions)[i]);

 // can't special-case it either, since we don't know its size.
 // Our solution is to include in the root set all allocations made from
 // ld-linux.so (which is where allocate_and_init() is implemented). This is
 // guaranteed to include all dynamic TLS blocks (and possibly other allocations
 // which we don't care about).
 // On all other platforms, this simply checks to ensure that the caller pc is
 // valid before reporting chunks as leaked.
 void ProcessPC(Frontier *frontier) {
+#if !SANITIZER_EMSCRIPTEN
   StackDepotReverseMap stack_depot_reverse_map;
   InvalidPCParam arg;
   arg.frontier = frontier;
   arg.stack_depot_reverse_map = &stack_depot_reverse_map;
   arg.skip_linker_allocations =
       flags()->use_tls && flags()->use_ld_allocations && GetLinker() != nullptr;
   ForEachChunk(MarkInvalidPCCb, &arg);
+#endif
 }
 
 // Sets the appropriate tag on each chunk.
 static void ClassifyAllChunks(SuspendedThreadsList const &suspended_threads) {
   // Holds the flood fill frontier.
   Frontier frontier;
 
   ForEachChunk(CollectIgnoredCb, &frontier);
GetThreadRegistryLocked()->RunCallbackForEachThreadLocked(
       &ReportIfNotSuspended, &threads);
 }
 
 static void CheckForLeaksCallback(const SuspendedThreadsList &suspended_threads,
                                   void *arg) {
   CheckForLeaksParam *param = reinterpret_cast<CheckForLeaksParam *>(arg);
   CHECK(param);
   CHECK(!param->success);
+#if !SANITIZER_EMSCRIPTEN
   ReportUnsuspendedThreads(suspended_threads);
+#endif
   ClassifyAllChunks(suspended_threads);
   ForEachChunk(CollectLeaksCb, &param->leak_report);
   // Clean up for subsequent leak checks. This assumes we did not overwrite any
   // kIgnored tags.
   ForEachChunk(ResetTagsCb, nullptr);
   param->success = true;
 }
 
Report(
         "HINT: For debugging, try setting environment variable "
         "LSAN_OPTIONS=verbosity=1:log_threads=1\n");
     Report(
         "HINT: LeakSanitizer does not work under ptrace (strace, gdb, etc)\n");
     Die();
   }
   param.leak_report.ApplySuppressions();
   uptr unsuppressed_count = param.leak_report.UnsuppressedLeakCount();
+
   if (unsuppressed_count > 0) {
     Decorator d;
     Printf("\n"
            "================================================================="
            "\n");
     Printf("%s", d.Error());
     Report("ERROR: LeakSanitizer: detected memory leaks\n");
     Printf("%s", d.Default());
static Suppression *GetSuppressionForAddr(uptr addr) {
   }
   frames->ClearAll();
   return s;
 }
 
 static Suppression *GetSuppressionForStack(u32 stack_trace_id) {
   StackTrace stack = StackDepotGet(stack_trace_id);
   for (uptr i = 0; i < stack.size; i++) {
+#if SANITIZER_EMSCRIPTEN
+    // On Emscripten, the stack trace is the actual call site, not
+    // the code that would be executed after the return.
+    // Therefore, StackTrace::GetPreviousInstructionPc is not needed.
+    Suppression *s = GetSuppressionForAddr(stack.trace[i]);
+#else
     Suppression *s = GetSuppressionForAddr(
         StackTrace::GetPreviousInstructionPc(stack.trace[i]));
+#endif
     if (s) return s;
   }
   return nullptr;
 }
 
 ///// LeakReport implementation. /////
 
 // A hard limit on the number of distinct leaks, to avoid quadratic complexity

compiler-rt/lib/lsan/lsan_common_emscripten.cpp

+//=--
+//lsan_common_emscripten.cpp--------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of LeakSanitizer.
+// Implementation of common leak checking functionality.
+// Emscripten-specific code.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lsan_common.h"
+#include "sanitizer_common/sanitizer_platform.h"
+
+#if CAN_SANITIZE_LEAKS && SANITIZER_EMSCRIPTEN
+#include <emscripten.h>
+
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_getauxval.h"
+#include "sanitizer_common/sanitizer_linux.h"
+#include "sanitizer_common/sanitizer_stackdepot.h"
+#include "sanitizer_common/sanitizer_thread_registry.h"
+
+#define LOG_THREADS(...)      \
+  do {                        \
+    if (flags()->log_threads) \
+      Report(__VA_ARGS__);    \
+  } while (0)
+
+namespace __lsan {
+
+extern "C" uptr emscripten_get_heap_size();
+
+static const char kLinkerName[] = "ld";
+
+static char linker_placeholder[sizeof(LoadedModule)] ALIGNED(64);
+static LoadedModule *linker = nullptr;
+
+static bool IsLinker(const LoadedModule &module) { return false; }
+
+thread_local int disable_counter;
+bool DisabledInThisThread() { return disable_counter > 0; }
+void DisableInThisThread() { disable_counter++; }
+void EnableInThisThread() {
+  if (disable_counter == 0) {
+    DisableCounterUnderflow();
+  }
+  disable_counter--;
+}
+
+void InitializePlatformSpecificModules() {
+  ListOfModules modules;
+  modules.init();
+  for (LoadedModule &module : modules) {
+    if (!IsLinker(module))
+      continue;
+    if (linker == nullptr) {
+      linker = reinterpret_cast<LoadedModule *>(linker_placeholder);
+      *linker = module;
+      module = LoadedModule();
+    } else {
+      VReport(1,
+              "LeakSanitizer: Multiple modules match \"%s\". "
+              "TLS and other allocations originating from linker might be "
+              "falsely reported as leaks.\n",
+              kLinkerName);
+      linker->clear();
+      linker = nullptr;
+      return;
+    }
+  }
+  if (linker == nullptr) {
+    VReport(1,
+            "LeakSanitizer: Dynamic linker not found. TLS and other "
+            "allocations originating from linker might be falsely reported "
+            "as leaks.\n");
+  }
+}
+
+extern "C" {
+extern char __global_base;
+extern char __data_end;
+}
+
+// Scans global variables for heap pointers.
+void ProcessGlobalRegions(Frontier *frontier) {
+  if (!flags()->use_globals)
+    return;
+  ScanGlobalRange((uptr)&__global_base, (uptr)&__data_end, frontier);
+}
+
+LoadedModule *GetLinker() { return linker; }
+
+void ProcessPlatformSpecificAllocations(Frontier *frontier) {}
+
+// While calling Die() here is undefined behavior and can potentially
+// cause race conditions, it isn't possible to intercept exit on Emscripten,
+// so we have no choice but to call Die() from the atexit handler.
+void HandleLeaks() {
+  if (common_flags()->exitcode)
+    Die();
+}
+
+void DoStopTheWorld(StopTheWorldCallback callback, void *argument) {
+  // Currently, on Emscripten this does nothing and just calls the callback.
+  // This works fine on a single-threaded environment.
+  StopTheWorld(callback, argument);
+}
+
+u32 GetCurrentThread();
+
+// This is based on ProcessThreads in lsan_common.cpp.
+// We changed this to be a callback that gets called per thread by
+// ThreadRegistry::RunCallbackForEachThreadLocked.
+// We do not scan registers or DTLS since we do not have those.
+// Finally, we can only obtain the stack pointer for the current thread,
+// so we scan the full stack for other threads.
+static void ProcessThreadsCallback(ThreadContextBase *tctx, void *arg) {
+  if (tctx->status != ThreadStatusRunning)
+    return;
+
+  Frontier *frontier = reinterpret_cast<Frontier *>(arg);
+  tid_t os_id = tctx->os_id;
+
+  uptr stack_begin, stack_end, tls_begin, tls_end, cache_begin, cache_end;
+  DTLS *dtls;
+  bool thread_found =
+      GetThreadRangesLocked(os_id, &stack_begin, &stack_end, &tls_begin,
+                            &tls_end, &cache_begin, &cache_end, &dtls);
+  if (!thread_found) {
+    LOG_THREADS("Thread %d not found in registry.\n", os_id);
+    return;
+  }
+
+  if (flags()->use_stacks) {
+    LOG_THREADS("Stack at %p-%p.\n", stack_begin, stack_end);
+
+    // We can't get the SP for other threads to narrow down the range, but we
+    // we can for the current thread.
+    if (tctx->tid == GetCurrentThread()) {
+      uptr sp = (uptr)__builtin_frame_address(0);
+      CHECK(stack_begin <= sp && sp < stack_end);
+      stack_begin = sp;
+    }
+
+    ScanRangeForPointers(stack_begin, stack_end, frontier, "STACK", kReachable);
+  }
+
+  if (flags()->use_tls && tls_begin) {
+    LOG_THREADS("TLS at %p-%p.\n", tls_begin, tls_end);
+    // If the tls and cache ranges don't overlap, scan full tls range,
+    // otherwise, only scan the non-overlapping portions
+    if (cache_begin == cache_end || tls_end < cache_begin ||
+        tls_begin > cache_end) {
+      ScanRangeForPointers(tls_begin, tls_end, frontier, "TLS", kReachable);
+    } else {
+      if (tls_begin < cache_begin)
+        ScanRangeForPointers(tls_begin, cache_begin, frontier, "TLS",
+                             kReachable);
+      if (tls_end > cache_end)
+        ScanRangeForPointers(cache_end, tls_end, frontier, "TLS", kReachable);
+    }
+  }
+}
+
+void ProcessThreads(SuspendedThreadsList const &suspended_threads,
+                    Frontier *frontier) {
+  GetThreadRegistryLocked()->RunCallbackForEachThreadLocked(
+      ProcessThreadsCallback, frontier);
+}
+
+}  // namespace __lsan
+
+extern "C" void __lsan_disable_in_this_thread() {
+  __lsan::DisableInThisThread();
+}
+
+extern "C" void __lsan_enable_in_this_thread() { __lsan::EnableInThisThread(); }
+#endif  // CAN_SANITIZE_LEAKS && SANITIZER_EMSCRIPTEN

compiler-rt/lib/lsan/lsan_interceptors.cpp

 #endif
 
 struct ThreadParam {
   void *(*callback)(void *arg);
   void *param;
   atomic_uintptr_t tid;
 };
 
+#if SANITIZER_EMSCRIPTEN
+extern "C" {
+int emscripten_builtin_pthread_create(void *thread, void *attr,
+                                      void *(*callback)(void *), void *arg);
+int emscripten_builtin_pthread_join(void *th, void **ret);
+void *emscripten_builtin_malloc(size_t size);
+void emscripten_builtin_free(void *);
+}
+#endif
+
 extern "C" void *__lsan_thread_start_func(void *arg) {
   ThreadParam *p = (ThreadParam*)arg;
   void* (*callback)(void *arg) = p->callback;
   void *param = p->param;
   // Wait until the last iteration to maximize the chance that we are the last
   // destructor to run.
 #if !SANITIZER_NETBSD && !SANITIZER_FREEBSD
   if (pthread_setspecific(g_thread_finalize_key,
                           (void*)GetPthreadDestructorIterations())) {
     Report("LeakSanitizer: failed to set thread key.\n");
     Die();
   }
 #endif
   int tid = 0;
   while ((tid = atomic_load(&p->tid, memory_order_acquire)) == 0)
     internal_sched_yield();
   SetCurrentThread(tid);
   ThreadStart(tid, GetTid());
+#if SANITIZER_EMSCRIPTEN
+  emscripten_builtin_free(p);
+#else
   atomic_store(&p->tid, 0, memory_order_release);
+#endif
   return callback(param);
 }
 
 INTERCEPTOR(int, pthread_create, void *th, void *attr,
             void *(*callback)(void *), void *param) {
   ENSURE_LSAN_INITED;
   EnsureMainThreadIDIsCorrect();
   __sanitizer_pthread_attr_t myattr;
   if (!attr) {
     pthread_attr_init(&myattr);
     attr = &myattr;
   }
   AdjustStackSize(attr);
   int detached = 0;
   pthread_attr_getdetachstate(attr, &detached);
+#if SANITIZER_EMSCRIPTEN
+  ThreadParam *p =
+      (ThreadParam *)emscripten_builtin_malloc(sizeof(ThreadParam));
+  p->callback = callback;
+  p->param = param;
+  atomic_store(&p->tid, 0, memory_order_relaxed);
+#else
   ThreadParam p;
   p.callback = callback;
   p.param = param;
   atomic_store(&p.tid, 0, memory_order_relaxed);
+#endif
   int res;
   {
     // Ignore all allocations made by pthread_create: thread stack/TLS may be
     // stored by pthread for future reuse even after thread destruction, and
     // the linked list it's stored in doesn't even hold valid pointers to the
     // objects, the latter are calculated by obscure pointer arithmetic.
     ScopedInterceptorDisabler disabler;
+#if SANITIZER_EMSCRIPTEN
+    res = REAL(pthread_create)(th, attr, __lsan_thread_start_func, p);
+#else
     res = REAL(pthread_create)(th, attr, __lsan_thread_start_func, &p);
+#endif
   }
   if (res == 0) {
     int tid = ThreadCreate(GetCurrentThread(), *(uptr *)th,
                            IsStateDetached(detached));
     CHECK_NE(tid, 0);
+#if SANITIZER_EMSCRIPTEN
+    atomic_store(&p->tid, tid, memory_order_release);
+#else
     atomic_store(&p.tid, tid, memory_order_release);
     while (atomic_load(&p.tid, memory_order_acquire) != 0)
       internal_sched_yield();
+#endif
   }
   if (attr == &myattr)
     pthread_attr_destroy(&myattr);
   return res;
 }
 
 INTERCEPTOR(int, pthread_join, void *th, void **ret) {
   ENSURE_LSAN_INITED;
   int tid = ThreadTid((uptr)th);
   int res = REAL(pthread_join)(th, ret);
   if (res == 0)
     ThreadJoin(tid);
   return res;
 }
 
+#if !SANITIZER_EMSCRIPTEN
 INTERCEPTOR(void, _exit, int status) {
   if (status == 0 && HasReportedLeaks()) status = common_flags()->exitcode;
   REAL(_exit)(status);
 }
+#endif
+
+#if SANITIZER_EMSCRIPTEN
+namespace __lsan {
 
+void InitializeInterceptors() {}
+
+}  // namespace __lsan
+
+#else
 #define COMMON_INTERCEPT_FUNCTION(name) INTERCEPT_FUNCTION(name)
 #include "sanitizer_common/sanitizer_signal_interceptors.inc"
 
 namespace __lsan {
 
 void InitializeInterceptors() {
   InitializeSignalInterceptors();
 
#if !SANITIZER_NETBSD && !SANITIZER_FREEBSD
   if (pthread_key_create(&g_thread_finalize_key, &thread_finalize)) {
     Report("LeakSanitizer: failed to create thread key.\n");
     Die();
   }
 #endif
 }
 
 } // namespace __lsan
+#endif  // SANITIZER_EMSCRIPTEN

compiler-rt/lib/lsan/lsan_linux.cpp

 //=-- lsan_linux.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 LeakSanitizer. Linux/NetBSD-specific code.
 //
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common/sanitizer_platform.h"
 
-#if SANITIZER_LINUX || SANITIZER_NETBSD
+#if SANITIZER_LINUX || SANITIZER_NETBSD || SANITIZER_EMSCRIPTEN
 
 #include "lsan_allocator.h"
 
 namespace __lsan {
 
 static THREADLOCAL u32 current_thread_tid = kInvalidTid;
 u32 GetCurrentThread() { return current_thread_tid; }
 void SetCurrentThread(u32 tid) { current_thread_tid = tid; }
 
 static THREADLOCAL AllocatorCache allocator_cache;
 AllocatorCache *GetAllocatorCache() { return &allocator_cache; }
 
 void ReplaceSystemMalloc() {}
 
 } // namespace __lsan
 
-#endif  // SANITIZER_LINUX || SANITIZER_NETBSD
+#endif  // SANITIZER_LINUX || SANITIZER_NETBSD || SANITIZER_EMSCRIPTEN

compiler-rt/lib/sanitizer_common/sanitizer_emscripten.cpp

+//===-- sanitizer_emscripten.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 provides implementations of some functions in sanitizer_linux_libcdep.c
+// on emscripten. We are not using sanitizer_linux_libcdep.c because it contains
+// a lot of threading and other code that does not work with emscripten yet,
+// so instead, some minimal implementations are provided here so that UBSan can
+// work.
+//===----------------------------------------------------------------------===//
+
+#include <signal.h>
+
+#include "sanitizer_common.h"
+#include "sanitizer_platform.h"
+#include "sanitizer_stoptheworld.h"
+
+#if SANITIZER_EMSCRIPTEN
+
+#include <emscripten.h>
+
+namespace __sanitizer {
+
+extern "C" {
+int emscripten_get_module_name(char *buf, uptr length);
+}
+
+void ListOfModules::init() {
+  modules_.Initialize(2);
+
+  char name[256];
+  emscripten_get_module_name(name, 256);
+
+  LoadedModule main_module;
+  main_module.set(name, 0);
+
+  // Emscripten represents program counters as offsets into WebAssembly
+  // modules. For JavaScript code, the "program counter" is the line number
+  // of the JavaScript code with the high bit set.
+  // Therefore, PC values 0x80000000 and beyond represents JavaScript code.
+  // As a result, 0x00000000 to 0x7FFFFFFF represents PC values for WASM code.
+  // We consider WASM code as main_module.
+  main_module.addAddressRange(0, 0x7FFFFFFF, /*executable*/ true,
+                              /*writable*/ false);
+  modules_.push_back(main_module);
+
+  // The remaining PC values, 0x80000000 to 0xFFFFFFFF, are JavaScript,
+  // and we consider it a separate module, js_module.
+  LoadedModule js_module;
+  js_module.set("JavaScript", 0x80000000);
+  js_module.addAddressRange(0x80000000, 0xFFFFFFFF, /*executable*/ true,
+                            /*writable*/ false);
+  modules_.push_back(js_module);
+}
+
+void ListOfModules::fallbackInit() { clear(); }
+
+SANITIZER_WEAK_ATTRIBUTE int real_sigaction(int signum, const void *act,
+                                            void *oldact);
+
+int internal_sigaction(int signum, const void *act, void *oldact) {
+#if !SANITIZER_GO
+  if (&real_sigaction)
+    return real_sigaction(signum, act, oldact);
+#endif
+  return sigaction(signum, (const struct sigaction *)act,
+                   (struct sigaction *)oldact);
+}
+
+extern "C" {
+uptr emscripten_builtin_mmap2(void *addr, uptr length, int prot, int flags,
+                              int fd, unsigned offset);
+uptr emscripten_builtin_munmap(void *addr, uptr length);
+}
+
+uptr internal_mmap(void *addr, uptr length, int prot, int flags, int fd,
+                   OFF_T offset) {
+  CHECK(IsAligned(offset, 4096));
+  return emscripten_builtin_mmap2(addr, length, prot, flags, fd, offset / 4096);
+}
+
+uptr internal_munmap(void *addr, uptr length) {
+  return emscripten_builtin_munmap(addr, length);
+}
+
+void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
+                                uptr *stack_bottom) {
+  *stack_top = EM_ASM_INT({ return STACK_BASE; });
+  *stack_bottom = EM_ASM_INT({ return STACK_MAX; });
+}
+
+char *fake_argv[] = {0};
+char *fake_envp[] = {0};
+
+char **GetArgv() { return fake_argv; }
+
+char **GetEnviron() { return fake_envp; }
+
+uptr GetTlsSize() { return 0; }
+
+void InitTlsSize() {}
+
+void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size,
+                          uptr *tls_addr, uptr *tls_size) {
+  uptr stk_top;
+  GetThreadStackTopAndBottom(true, &stk_top, stk_addr);
+  *stk_size = stk_top - *stk_addr;
+#ifdef USE_THREADS
+  *tls_addr = (uptr)__builtin_wasm_tls_base();
+  *tls_size = __builtin_wasm_tls_size();
+#else
+  *tls_addr = *tls_size = 0;
+#endif
+}
+
+void StopTheWorld(StopTheWorldCallback callback, void *argument) {
+  // TODO: have some workable alternative, since we can't just fork and suspend
+  // the parent process. This does not matter when single thread.
+  callback(SuspendedThreadsList(), argument);
+}
+
+}  // namespace __sanitizer
+
+#endif

compiler-rt/lib/sanitizer_common/sanitizer_flag_parser.cpp

 
 #include "sanitizer_flag_parser.h"
 
 #include "sanitizer_common.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_flag_parser.h"
 
+#if SANITIZER_EMSCRIPTEN
+extern "C" void emscripten_builtin_free(void *);
+#include <emscripten/em_asm.h>
+#endif
+
 namespace __sanitizer {
 
 LowLevelAllocator FlagParser::Alloc;
 
 class UnknownFlags {
   static const int kMaxUnknownFlags = 20;
   const char *unknown_flags_[kMaxUnknownFlags];
   int n_unknown_flags_;
void FlagParser::parse_flags(const char *env_option_name) {
   }
 
   // Do a sanity check for certain flags.
   if (common_flags_dont_use.malloc_context_size < 1)
     common_flags_dont_use.malloc_context_size = 1;
 }
 
 void FlagParser::ParseStringFromEnv(const char *env_name) {
+#if SANITIZER_EMSCRIPTEN
+  const char *env = (char *)EM_ASM_INT({
+    return _emscripten_with_builtin_malloc(function() {
+      return allocateUTF8(Module['UBSAN_OPTIONS'] || 0);
+    });
+  });
+#else
   const char *env = GetEnv(env_name);
+#endif  // SANITIZER_EMSCRIPTEN
   VPrintf(1, "%s: %s\n", env_name, env ? env : "<empty>");
   ParseString(env, env_name);
+#if SANITIZER_EMSCRIPTEN
+  emscripten_builtin_free(env)
+#endif
 }
 
 void FlagParser::ParseString(const char *s, const char *env_option_name) {
   if (!s) return;
   // Backup current parser state to allow nested ParseString() calls.
   const char *old_buf_ = buf_;
   uptr old_pos_ = pos_;
   buf_ = s;

compiler-rt/lib/sanitizer_common/sanitizer_internal_defs.h

 #else
 typedef uptr OFF_T;
 #endif
 typedef u64  OFF64_T;
 
 #if (SANITIZER_WORDSIZE == 64) || SANITIZER_MAC
 typedef uptr operator_new_size_type;
 #else
-# if SANITIZER_OPENBSD || defined(__s390__) && !defined(__s390x__)
+#if SANITIZER_OPENBSD || defined(__s390__) && !defined(__s390x__) || \
+    SANITIZER_EMSCRIPTEN
 // Special case: 31-bit s390 has unsigned long as size_t.
 typedef unsigned long operator_new_size_type;
 # else
 typedef u32 operator_new_size_type;
 # endif
 #endif
 
 typedef u64 tid_t;

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

 //===-- sanitizer_linux.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 and implements linux-specific functions from
 // sanitizer_libc.h.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
 
 #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
-    SANITIZER_OPENBSD || SANITIZER_SOLARIS
+    SANITIZER_OPENBSD || SANITIZER_SOLARIS || SANITIZER_EMSCRIPTEN
 
 #include "sanitizer_common.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_getauxval.h"
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_libc.h"
 #include "sanitizer_linux.h"
 #include "sanitizer_mutex.h"
 #include "sanitizer_placement_new.h"
+#include "sanitizer_posix.h"
 #include "sanitizer_procmaps.h"
 
 #if SANITIZER_LINUX
 #include <asm/param.h>
 #endif
 
 // For mips64, syscall(__NR_stat) fills the buffer in the 'struct kernel_stat'
 // format. Struct kernel_stat is defined as 'struct stat' in asm/stat.h. To

 #endif  // SANITIZER_NETBSD
 
 #if SANITIZER_SOLARIS
 #include <stdlib.h>
 #include <thread.h>
 #define environ _environ
 #endif
 
+#if SANITIZER_EMSCRIPTEN
+#include <emscripten/threading.h>
+#include <math.h>
+#endif
+
 extern char **environ;
 
-#if SANITIZER_LINUX
+#if SANITIZER_LINUX || SANITIZER_EMSCRIPTEN
 // <linux/time.h>
 struct kernel_timeval {
   long tv_sec;
   long tv_usec;
 };
 
 // <linux/futex.h> is broken on some linux distributions.
 const int FUTEX_WAIT = 0;

 namespace __sanitizer {
 
 #if SANITIZER_LINUX && defined(__x86_64__)
 #include "sanitizer_syscall_linux_x86_64.inc"
 #elif SANITIZER_LINUX && defined(__aarch64__)
 #include "sanitizer_syscall_linux_aarch64.inc"
 #elif SANITIZER_LINUX && defined(__arm__)
 #include "sanitizer_syscall_linux_arm.inc"
+#elif SANITIZER_EMSCRIPTEN
+#include "sanitizer_syscall_emscripten.inc"
 #else
 #include "sanitizer_syscall_generic.inc"
 #endif
 
 // --------------- sanitizer_libc.h
 #if !SANITIZER_SOLARIS && !SANITIZER_NETBSD
-#if !SANITIZER_S390 && !SANITIZER_OPENBSD
+#if !SANITIZER_S390 && !SANITIZER_OPENBSD && !SANITIZER_EMSCRIPTEN
 uptr internal_mmap(void *addr, uptr length, int prot, int flags, int fd,
                    OFF_T offset) {
 #if SANITIZER_FREEBSD || SANITIZER_LINUX_USES_64BIT_SYSCALLS
   return internal_syscall(SYSCALL(mmap), (uptr)addr, length, prot, flags, fd,
                           offset);
 #else
   // mmap2 specifies file offset in 4096-byte units.
   CHECK(IsAligned(offset, 4096));
   return internal_syscall(SYSCALL(mmap2), addr, length, prot, flags, fd,
                           offset / 4096);
 #endif
 }
-#endif // !SANITIZER_S390 && !SANITIZER_OPENBSD
+#endif  // !SANITIZER_S390 && !SANITIZER_OPENBSD && !SANITIZER_NETBSD
 
-#if !SANITIZER_OPENBSD
+#if !SANITIZER_OPENBSD && !SANITIZER_EMSCRIPTEN
 uptr internal_munmap(void *addr, uptr length) {
   return internal_syscall(SYSCALL(munmap), (uptr)addr, length);
 }
+#endif
 
+#if !SANITIZER_OPENBSD
 int internal_mprotect(void *addr, uptr length, int prot) {
   return internal_syscall(SYSCALL(mprotect), (uptr)addr, length, prot);
 }
 #endif
 
 uptr internal_close(fd_t fd) {
   return internal_syscall(SYSCALL(close), fd);
 }

 
 uptr internal_ftruncate(fd_t fd, uptr size) {
   sptr res;
   HANDLE_EINTR(res, (sptr)internal_syscall(SYSCALL(ftruncate), fd,
                (OFF_T)size));
   return res;
 }
 
-#if !SANITIZER_LINUX_USES_64BIT_SYSCALLS && SANITIZER_LINUX
+#if !SANITIZER_LINUX_USES_64BIT_SYSCALLS && SANITIZER_LINUX || \
+    SANITIZER_EMSCRIPTEN
 static void stat64_to_stat(struct stat64 *in, struct stat *out) {
   internal_memset(out, 0, sizeof(*out));
   out->st_dev = in->st_dev;
   out->st_ino = in->st_ino;
   out->st_mode = in->st_mode;
   out->st_nlink = in->st_nlink;
   out->st_uid = in->st_uid;
   out->st_gid = in->st_gid;
#if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS || SANITIZER_OPENBSD
   return internal_syscall(SYSCALL(renameat), AT_FDCWD, (uptr)oldpath, AT_FDCWD,
                           (uptr)newpath);
 #else
   return internal_syscall(SYSCALL(rename), (uptr)oldpath, (uptr)newpath);
 #endif
 }
 
 uptr internal_sched_yield() {
+#if SANITIZER_EMSCRIPTEN
+  return 0;
+#else
   return internal_syscall(SYSCALL(sched_yield));
+#endif
 }
 
 void internal__exit(int exitcode) {
 #if SANITIZER_FREEBSD || SANITIZER_OPENBSD
   internal_syscall(SYSCALL(exit), exitcode);
 #else
   internal_syscall(SYSCALL(exit_group), exitcode);
 #endif

 #if SANITIZER_FREEBSD
   long Tid;
   thr_self(&Tid);
   return Tid;
 #elif SANITIZER_OPENBSD
   return internal_syscall(SYSCALL(getthrid));
 #elif SANITIZER_SOLARIS
   return thr_self();
+#elif SANITIZER_EMSCRIPTEN
+  return (tid_t)pthread_self();
 #else
   return internal_syscall(SYSCALL(gettid));
 #endif
 }
 
 int TgKill(pid_t pid, tid_t tid, int sig) {
-#if SANITIZER_LINUX
+#if SANITIZER_LINUX || SANITIZER_EMSCRIPTEN
   return internal_syscall(SYSCALL(tgkill), pid, tid, sig);
 #elif SANITIZER_FREEBSD
   return internal_syscall(SYSCALL(thr_kill2), pid, tid, sig);
 #elif SANITIZER_OPENBSD
   (void)pid;
   return internal_syscall(SYSCALL(thrkill), tid, sig, nullptr);
 #elif SANITIZER_SOLARIS
   (void)pid;

 #else
   kernel_timeval tv;
 #endif
   internal_memset(&tv, 0, sizeof(tv));
   internal_syscall(SYSCALL(gettimeofday), &tv, 0);
   return (u64)tv.tv_sec * 1000*1000*1000 + tv.tv_usec * 1000;
 }
 
+#if SANITIZER_EMSCRIPTEN
+int __clock_gettime(__sanitizer_clockid_t clk_id, void *tp);
+
+uptr internal_clock_gettime(__sanitizer_clockid_t clk_id, void *tp) {
+  return __clock_gettime(clk_id, tp);
+}
+#else
 uptr internal_clock_gettime(__sanitizer_clockid_t clk_id, void *tp) {
   return internal_syscall(SYSCALL(clock_gettime), clk_id, tp);
 }
+#endif  // SANITIZER_EMSCRIPTEN
 #endif  // !SANITIZER_SOLARIS && !SANITIZER_NETBSD
 
+#if SANITIZER_EMSCRIPTEN
+extern "C" const char *emscripten_get_env(const char *name);
+#endif
+
 // Like getenv, but reads env directly from /proc (on Linux) or parses the
 // '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_OPENBSD || \
     SANITIZER_SOLARIS
   if (::environ != 0) {
     uptr NameLen = internal_strlen(name);
const char* endp =
         (char*)internal_memchr(p, '\0', len - (p - environ));
     if (!endp)  // this entry isn't NUL terminated
       return nullptr;
     else if (!internal_memcmp(p, name, namelen) && p[namelen] == '=')  // Match.
       return p + namelen + 1;  // point after =
     p = endp + 1;
   }
   return nullptr;  // Not found.
+#elif SANITIZER_EMSCRIPTEN
+  return emscripten_get_env(name);
 #else
 #error "Unsupported platform"
 #endif
 }
 
 #if !SANITIZER_FREEBSD && !SANITIZER_NETBSD && !SANITIZER_OPENBSD
 extern "C" {
 SANITIZER_WEAK_ATTRIBUTE extern void *__libc_stack_end;
if (buff[i] == 0) {
       CHECK_LE(count, arr_size - 1);  // FIXME: make this more flexible.
       count++;
     }
   }
   (*arr)[count] = nullptr;
 }
 #endif
 
-#if !SANITIZER_OPENBSD
+#if !SANITIZER_OPENBSD && !SANITIZER_EMSCRIPTEN
 static void GetArgsAndEnv(char ***argv, char ***envp) {
 #if SANITIZER_FREEBSD
   // On FreeBSD, retrieving the argument and environment arrays is done via the
   // kern.ps_strings sysctl, which returns a pointer to a structure containing
   // this information. See also <sys/exec.h>.
   ps_strings *pss;
   uptr sz = sizeof(pss);
   if (internal_sysctlbyname("kern.ps_strings", &pss, &sz, NULL, 0) == -1) {

 }
 
 char **GetEnviron() {
   char **argv, **envp;
   GetArgsAndEnv(&argv, &envp);
   return envp;
 }
 
-#endif  // !SANITIZER_OPENBSD
+#endif  // !SANITIZER_OPENBSD && !SANITIZER_EMSCRIPTEN
 
 #if !SANITIZER_SOLARIS
 enum MutexState {
   MtxUnlocked = 0,
   MtxLocked = 1,
   MtxSleeping = 2
 };
 
 BlockingMutex::BlockingMutex() {
   internal_memset(this, 0, sizeof(*this));
 }
 
 void BlockingMutex::Lock() {
   CHECK_EQ(owner_, 0);
   atomic_uint32_t *m = reinterpret_cast<atomic_uint32_t *>(&opaque_storage_);
   if (atomic_exchange(m, MtxLocked, memory_order_acquire) == MtxUnlocked)
     return;
   while (atomic_exchange(m, MtxSleeping, memory_order_acquire) != MtxUnlocked) {
 #if SANITIZER_FREEBSD
     _umtx_op(m, UMTX_OP_WAIT_UINT, MtxSleeping, 0, 0);
 #elif SANITIZER_NETBSD
     sched_yield(); /* No userspace futex-like synchronization */
+#elif SANITIZER_EMSCRIPTEN
+    emscripten_futex_wait(m, MtxSleeping, INFINITY);
 #else
     internal_syscall(SYSCALL(futex), (uptr)m, FUTEX_WAIT_PRIVATE, MtxSleeping,
                      0, 0, 0);
 #endif
   }
 }
 
 void BlockingMutex::Unlock() {
   atomic_uint32_t *m = reinterpret_cast<atomic_uint32_t *>(&opaque_storage_);
   u32 v = atomic_exchange(m, MtxUnlocked, memory_order_release);
   CHECK_NE(v, MtxUnlocked);
   if (v == MtxSleeping) {
 #if SANITIZER_FREEBSD
     _umtx_op(m, UMTX_OP_WAKE, 1, 0, 0);
 #elif SANITIZER_NETBSD
                    /* No userspace futex-like synchronization */
+#elif SANITIZER_EMSCRIPTEN
+    emscripten_futex_wake(m, 1);
 #else
     internal_syscall(SYSCALL(futex), (uptr)m, FUTEX_WAKE_PRIVATE, 1, 0, 0, 0);
 #endif
   }
 }
 
 void BlockingMutex::CheckLocked() {
   atomic_uint32_t *m = reinterpret_cast<atomic_uint32_t *>(&opaque_storage_);

 }
 #endif
 
 uptr internal_sigaltstack(const void *ss, void *oss) {
   return internal_syscall(SYSCALL(sigaltstack), (uptr)ss, (uptr)oss);
 }
 
 int internal_fork() {
-#if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
+#if SANITIZER_EMSCRIPTEN
+  Report("fork not supported on emscripten\n");
+  return -1;
+#elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
   return internal_syscall(SYSCALL(clone), SIGCHLD, 0);
 #else
   return internal_syscall(SYSCALL(fork));
 #endif
 }
 
 #if SANITIZER_FREEBSD || SANITIZER_OPENBSD
 int internal_sysctl(const int *name, unsigned int namelen, void *oldp,

 
 bool internal_sigismember(__sanitizer_sigset_t *set, int signum) {
   sigset_t *rset = reinterpret_cast<sigset_t *>(set);
   return sigismember(rset, signum);
 }
 #endif
 #endif // !SANITIZER_SOLARIS
 
-#if !SANITIZER_NETBSD
+#if !SANITIZER_NETBSD && !SANITIZER_EMSCRIPTEN
 // ThreadLister implementation.
 ThreadLister::ThreadLister(pid_t pid) : pid_(pid), buffer_(4096) {
   char task_directory_path[80];
   internal_snprintf(task_directory_path, sizeof(task_directory_path),
                     "/proc/%d/task/", pid);
   descriptor_ = internal_open(task_directory_path, O_RDONLY | O_DIRECTORY);
   if (internal_iserror(descriptor_)) {
     Report("Can't open /proc/%d/task for reading.\n", pid);
// Use sysctl as sysconf can trigger interceptors internally.
   CHECK_EQ(rv, 0);
   return (uptr)pz;
 #else
   return sysconf(_SC_PAGESIZE);  // EXEC_PAGESIZE may not be trustworthy.
 #endif
 }
 #endif // !SANITIZER_ANDROID
 
+#if SANITIZER_EMSCRIPTEN
+extern "C" uptr emscripten_get_module_name(char *buf, uptr buf_len);
+#endif
+
 #if !SANITIZER_OPENBSD
 uptr ReadBinaryName(/*out*/char *buf, uptr buf_len) {
 #if SANITIZER_SOLARIS
   const char *default_module_name = getexecname();
   CHECK_NE(default_module_name, NULL);
   return internal_snprintf(buf, buf_len, "%s", default_module_name);
+#elif SANITIZER_EMSCRIPTEN
+  return emscripten_get_module_name(buf, buf_len);
 #else
 #if SANITIZER_FREEBSD || SANITIZER_NETBSD
 #if SANITIZER_FREEBSD
   const int Mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
 #else
   const int Mib[4] = {CTL_KERN, KERN_PROC_ARGS, -1, KERN_PROC_PATHNAME};
 #endif
   const char *default_module_name = "kern.proc.pathname";
#elif defined(__s390__)
   ucontext_t *ucontext = (ucontext_t*)context;
 # if defined(__s390x__)
   *pc = ucontext->uc_mcontext.psw.addr;
 # else
   *pc = ucontext->uc_mcontext.psw.addr & 0x7fffffff;
 # endif
   *bp = ucontext->uc_mcontext.gregs[11];
   *sp = ucontext->uc_mcontext.gregs[15];
+#elif SANITIZER_EMSCRIPTEN
+  Report("GetPcSpBp not implemented on emscripten");
+  Abort();
 #else
 # error "Unsupported arch"
 #endif
 }
 
 void SignalContext::InitPcSpBp() { GetPcSpBp(context, &pc, &sp, &bp); }
 
 void InitializePlatformEarly() {

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(__OpenBSD__) && !defined(__APPLE__) && !defined(_WIN32) && \
-  !defined(__Fuchsia__) && !defined(__rtems__) && \
-  !(defined(__sun__) && defined(__svr4__))
+    !defined(__OpenBSD__) && !defined(__APPLE__) && !defined(_WIN32) &&     \
+    !defined(__Fuchsia__) && !defined(__rtems__) &&                         \
+    !(defined(__sun__) && defined(__svr4__)) && !defined(__EMSCRIPTEN__)
 # error "This operating system is not supported"
 #endif
 
 #if defined(__linux__)
 # define SANITIZER_LINUX   1
 #else
 # define SANITIZER_LINUX   0
 #endif

 #endif
 
 #if defined(__rtems__)
 # define SANITIZER_RTEMS 1
 #else
 # define SANITIZER_RTEMS 0
 #endif
 
-#define SANITIZER_POSIX \
-  (SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_MAC || \
-    SANITIZER_NETBSD || SANITIZER_OPENBSD || SANITIZER_SOLARIS)
+#if defined(__EMSCRIPTEN__)
+#define SANITIZER_EMSCRIPTEN 1
+#else
+#define SANITIZER_EMSCRIPTEN 0
+#endif
+
+#define SANITIZER_POSIX                                          \
+  (SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_MAC ||      \
+   SANITIZER_NETBSD || SANITIZER_OPENBSD || SANITIZER_SOLARIS || \
+   SANITIZER_EMSCRIPTEN)
 
 #if __LP64__ || defined(_WIN64)
 #  define SANITIZER_WORDSIZE 64
 #else
 #  define SANITIZER_WORDSIZE 32
 #endif
 
 #if SANITIZER_WORDSIZE == 64

compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h

 #endif
 
 #if SANITIZER_LINUX && !SANITIZER_FREEBSD
 # define SI_LINUX_NOT_FREEBSD 1
 # else
 # define SI_LINUX_NOT_FREEBSD 0
 #endif
 
+#if SANITIZER_EMSCRIPTEN
+#define SI_EMSCRIPTEN 1
+#else
+#define SI_EMSCRIPTEN 0
+#endif
+
 #define SANITIZER_INTERCEPT_STRLEN SI_NOT_FUCHSIA
 #define SANITIZER_INTERCEPT_STRNLEN (SI_NOT_MAC && SI_NOT_FUCHSIA)
 #define SANITIZER_INTERCEPT_STRCMP SI_NOT_FUCHSIA
 #define SANITIZER_INTERCEPT_STRSTR SI_NOT_FUCHSIA
 #define SANITIZER_INTERCEPT_STRCASESTR SI_POSIX
 #define SANITIZER_INTERCEPT_STRTOK SI_NOT_FUCHSIA
 #define SANITIZER_INTERCEPT_STRCHR SI_NOT_FUCHSIA
 #define SANITIZER_INTERCEPT_STRCHRNUL SI_POSIX_NOT_MAC
#define SANITIZER_INTERCEPT_ACCEPT4 \
   (SI_LINUX_NOT_ANDROID || SI_NETBSD || SI_OPENBSD)
 #define SANITIZER_INTERCEPT_PACCEPT SI_NETBSD
 #define SANITIZER_INTERCEPT_MODF SI_POSIX
 #define SANITIZER_INTERCEPT_RECVMSG SI_POSIX
 #define SANITIZER_INTERCEPT_SENDMSG SI_POSIX
 #define SANITIZER_INTERCEPT_RECVMMSG SI_LINUX
 #define SANITIZER_INTERCEPT_SENDMMSG SI_LINUX
 #define SANITIZER_INTERCEPT_GETPEERNAME SI_POSIX
-#define SANITIZER_INTERCEPT_IOCTL SI_POSIX
+#define SANITIZER_INTERCEPT_IOCTL SI_POSIX && !SI_EMSCRIPTEN
 #define SANITIZER_INTERCEPT_INET_ATON SI_POSIX
 #define SANITIZER_INTERCEPT_SYSINFO SI_LINUX
 #define SANITIZER_INTERCEPT_READDIR SI_POSIX
 #define SANITIZER_INTERCEPT_READDIR64 SI_LINUX_NOT_ANDROID || SI_SOLARIS32
 #if SI_LINUX_NOT_ANDROID && \
   (defined(__i386) || defined(__x86_64) || defined(__mips64) || \
     defined(__powerpc64__) || defined(__aarch64__) || defined(__arm__) || \
     defined(__s390__))

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_EMSCRIPTEN
 
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_platform.h"
 
 # define GET_LINK_MAP_BY_DLOPEN_HANDLE(handle) ((link_map*)(handle))
 
 #ifndef __GLIBC_PREREQ
 #define __GLIBC_PREREQ(x, y) 0

 #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_EMSCRIPTEN
   typedef int __sanitizer_clockid_t;
 #endif
 
 #if SANITIZER_LINUX
 #if defined(_LP64) || defined(__x86_64__) || defined(__powerpc__)\
                    || defined(__mips__)
   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)];
   };
+#elif SANITIZER_EMSCRIPTEN
+  typedef unsigned 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);

 #endif
 
   // ioctl request identifiers
 
   // A special value to mark ioctls that are not present on the target platform,
   // when it can not be determined without including any system headers.
   extern const unsigned IOCTL_NOT_PRESENT;
 
+#if !SANITIZER_EMSCRIPTEN
   extern unsigned IOCTL_FIOASYNC;
   extern unsigned IOCTL_FIOCLEX;
   extern unsigned IOCTL_FIOGETOWN;
   extern unsigned IOCTL_FIONBIO;
   extern unsigned IOCTL_FIONCLEX;
   extern unsigned IOCTL_FIOSETOWN;
   extern unsigned IOCTL_SIOCADDMULTI;
   extern unsigned IOCTL_SIOCATMARK;
#if !SANITIZER_EMSCRIPTEN
   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;
   extern unsigned IOCTL_SIOCGETVIFCNT;
 #endif
+#endif
+
 #if SANITIZER_LINUX
   extern unsigned IOCTL_EVIOCGABS;
   extern unsigned IOCTL_EVIOCGBIT;
   extern unsigned IOCTL_EVIOCGEFFECTS;
   extern unsigned IOCTL_EVIOCGID;
   extern unsigned IOCTL_EVIOCGKEY;
   extern unsigned IOCTL_EVIOCGKEYCODE;
   extern unsigned IOCTL_EVIOCGLED;

compiler-rt/lib/sanitizer_common/sanitizer_platform_limits_posix.cpp

 //===-- sanitizer_platform_limits_posix.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 Sanitizer common code.
 //
 // Sizes and layouts of platform-specific POSIX data structures.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
 
-#if SANITIZER_LINUX || SANITIZER_MAC
+#if SANITIZER_LINUX || SANITIZER_MAC || SANITIZER_EMSCRIPTEN
 // Tests in this file assume that off_t-dependent data structures match the
 // libc ABI. For example, struct dirent here is what readdir() function (as
 // exported from libc) returns, and not the user-facing "dirent", which
 // depends on _FILE_OFFSET_BITS setting.
 // To get this "true" dirent definition, we undefine _FILE_OFFSET_BITS below.
 #ifdef _FILE_OFFSET_BITS
 #undef _FILE_OFFSET_BITS
 #endif

 #if !SANITIZER_MAC
 #include <utmp.h>
 #endif
 
 #if !SANITIZER_IOS
 #include <net/route.h>
 #endif
 
-#if !SANITIZER_ANDROID
+#if !SANITIZER_ANDROID && !SANITIZER_EMSCRIPTEN
 #include <fstab.h>
 #include <sys/mount.h>
 #include <sys/timeb.h>
 #include <utmpx.h>
 #endif
 
 #if SANITIZER_LINUX
 #include <malloc.h>
#endif // !SANITIZER_IOS
   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 && !SANITIZER_IOS
   unsigned struct_statfs64_sz = sizeof(struct statfs64);
 #endif // SANITIZER_MAC && !SANITIZER_IOS
 
-#if !SANITIZER_ANDROID
+#if !SANITIZER_ANDROID && !SANITIZER_EMSCRIPTEN
   unsigned struct_fstab_sz = sizeof(struct fstab);
   unsigned struct_statfs_sz = sizeof(struct statfs);
   unsigned struct_sockaddr_sz = sizeof(struct sockaddr);
   unsigned ucontext_t_sz = sizeof(ucontext_t);
 #endif // !SANITIZER_ANDROID
 
 #if SANITIZER_LINUX
   unsigned struct_epoll_event_sz = sizeof(struct epoll_event);

 #endif // PTRACE_GETREGSET/PTRACE_SETREGSET
 #endif
 
   unsigned path_max = PATH_MAX;
 
   // ioctl arguments
   unsigned struct_ifreq_sz = sizeof(struct ifreq);
   unsigned struct_termios_sz = sizeof(struct termios);
+
+#if !SANITIZER_EMSCRIPTEN
   unsigned struct_winsize_sz = sizeof(struct winsize);
+#endif
 
 #if SANITIZER_LINUX
   unsigned struct_arpreq_sz = sizeof(struct arpreq);
   unsigned struct_cdrom_msf_sz = sizeof(struct cdrom_msf);
   unsigned struct_cdrom_multisession_sz = sizeof(struct cdrom_multisession);
   unsigned struct_cdrom_read_audio_sz = sizeof(struct cdrom_read_audio);
   unsigned struct_cdrom_subchnl_sz = sizeof(struct cdrom_subchnl);
   unsigned struct_cdrom_ti_sz = sizeof(struct cdrom_ti);
#endif
   unsigned struct_unimapinit_sz = sizeof(struct unimapinit);
 #endif // SANITIZER_LINUX && !SANITIZER_ANDROID
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
   unsigned struct_audio_buf_info_sz = sizeof(struct audio_buf_info);
   unsigned struct_ppp_stats_sz = sizeof(struct ppp_stats);
 #endif // (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
 
-#if !SANITIZER_ANDROID && !SANITIZER_MAC
+#if !SANITIZER_ANDROID && !SANITIZER_MAC && !SANITIZER_EMSCRIPTEN
   unsigned struct_sioc_sg_req_sz = sizeof(struct sioc_sg_req);
   unsigned struct_sioc_vif_req_sz = sizeof(struct sioc_vif_req);
 #endif
 
+#if !SANITIZER_EMSCRIPTEN
   const unsigned long __sanitizer_bufsiz = BUFSIZ;
+#endif
 
   const unsigned IOCTL_NOT_PRESENT = 0;
 
+#if !SANITIZER_EMSCRIPTEN
   unsigned IOCTL_FIOASYNC = FIOASYNC;
   unsigned IOCTL_FIOCLEX = FIOCLEX;
   unsigned IOCTL_FIOGETOWN = FIOGETOWN;
   unsigned IOCTL_FIONBIO = FIONBIO;
   unsigned IOCTL_FIONCLEX = FIONCLEX;
   unsigned IOCTL_FIOSETOWN = FIOSETOWN;
   unsigned IOCTL_SIOCADDMULTI = SIOCADDMULTI;
   unsigned IOCTL_SIOCATMARK = SIOCATMARK;
#if !SANITIZER_EMSCRIPTEN
   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;
   unsigned IOCTL_SIOCGETVIFCNT = SIOCGETVIFCNT;
 #endif
+#endif
 
 #if SANITIZER_LINUX
   unsigned IOCTL_EVIOCGABS = EVIOCGABS(0);
   unsigned IOCTL_EVIOCGBIT = EVIOCGBIT(0, 0);
   unsigned IOCTL_EVIOCGEFFECTS = EVIOCGEFFECTS;
   unsigned IOCTL_EVIOCGID = EVIOCGID;
   unsigned IOCTL_EVIOCGKEY = EVIOCGKEY(0);
   unsigned IOCTL_EVIOCGKEYCODE = EVIOCGKEYCODE;

 
 #if SANITIZER_LINUX && (__ANDROID_API__ >= 21 || __GLIBC_PREREQ (2, 14))
 CHECK_TYPE_SIZE(mmsghdr);
 CHECK_SIZE_AND_OFFSET(mmsghdr, msg_hdr);
 CHECK_SIZE_AND_OFFSET(mmsghdr, msg_len);
 #endif
 
 COMPILER_CHECK(sizeof(__sanitizer_dirent) <= sizeof(dirent));
+#if !SANITIZER_EMSCRIPTEN
 CHECK_SIZE_AND_OFFSET(dirent, d_ino);
 #if SANITIZER_MAC
 CHECK_SIZE_AND_OFFSET(dirent, d_seekoff);
 #elif SANITIZER_FREEBSD
 // There is no 'd_off' field on FreeBSD.
 #else
 CHECK_SIZE_AND_OFFSET(dirent, d_off);
 #endif
 CHECK_SIZE_AND_OFFSET(dirent, d_reclen);
+#endif  // !SANITIZER_EMSCRIPTEN
 
 #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_SIZE_AND_OFFSET(ifconf, ifc_ifcu);
 
 CHECK_TYPE_SIZE(pollfd);
 CHECK_SIZE_AND_OFFSET(pollfd, fd);
 CHECK_SIZE_AND_OFFSET(pollfd, events);
 CHECK_SIZE_AND_OFFSET(pollfd, revents);
 
 CHECK_TYPE_SIZE(nfds_t);
 
+#if !SANITIZER_EMSCRIPTEN
 CHECK_TYPE_SIZE(sigset_t);
 
 COMPILER_CHECK(sizeof(__sanitizer_sigaction) == sizeof(struct sigaction));
 // Can't write checks for sa_handler and sa_sigaction due to them being
 // preprocessor macros.
 CHECK_STRUCT_SIZE_AND_OFFSET(sigaction, sa_mask);
 #if !defined(__s390x__) || __GLIBC_PREREQ (2, 20)
 // On s390x glibc 2.19 and earlier sa_flags was unsigned long, and sa_resv
 // didn't exist.
 CHECK_STRUCT_SIZE_AND_OFFSET(sigaction, sa_flags);
 #endif
 #if SANITIZER_LINUX && (!SANITIZER_ANDROID || !SANITIZER_MIPS32)
 CHECK_STRUCT_SIZE_AND_OFFSET(sigaction, sa_restorer);
 #endif
+#endif  // !SANITIZER_EMSCRIPTEN
 
 #if SANITIZER_LINUX
 CHECK_TYPE_SIZE(__sysctl_args);
 CHECK_SIZE_AND_OFFSET(__sysctl_args, name);
 CHECK_SIZE_AND_OFFSET(__sysctl_args, nlen);
 CHECK_SIZE_AND_OFFSET(__sysctl_args, oldval);
 CHECK_SIZE_AND_OFFSET(__sysctl_args, oldlenp);
 CHECK_SIZE_AND_OFFSET(__sysctl_args, newval);

 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
 
+#if !SANITIZER_EMSCRIPTEN
 CHECK_TYPE_SIZE(ether_addr);
+#endif
 
 #if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
 CHECK_TYPE_SIZE(ipc_perm);
 # if SANITIZER_FREEBSD
 CHECK_SIZE_AND_OFFSET(ipc_perm, key);
 CHECK_SIZE_AND_OFFSET(ipc_perm, seq);
 # else
 CHECK_SIZE_AND_OFFSET(ipc_perm, __key);

 #endif
 
 CHECK_TYPE_SIZE(clock_t);
 
 #if SANITIZER_LINUX
 CHECK_TYPE_SIZE(clockid_t);
 #endif
 
-#if !SANITIZER_ANDROID
+#if !SANITIZER_ANDROID && !SANITIZER_EMSCRIPTEN
 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_LINUX
 COMPILER_CHECK(sizeof(__sanitizer_struct_mallinfo) == sizeof(struct mallinfo));
 #endif
 
-#if !SANITIZER_ANDROID
+#if !SANITIZER_ANDROID && !SANITIZER_EMSCRIPTEN
 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
 
 CHECK_TYPE_SIZE(passwd);

compiler-rt/lib/sanitizer_common/sanitizer_posix.cpp

 
 static inline bool IntervalsAreSeparate(uptr start1, uptr end1,
                                         uptr start2, uptr end2) {
   CHECK(start1 <= end1);
   CHECK(start2 <= end2);
   return (end1 < start2) || (end2 < start1);
 }
 
+#if SANITIZER_EMSCRIPTEN
+bool MemoryRangeIsAvailable(uptr /*range_start*/, uptr /*range_end*/) {
+  // TODO: actually implement this.
+  return true;
+}
+
+void DumpProcessMap() { Report("Cannot dump memory map on emscripten"); }
+#else
 // FIXME: this is thread-unsafe, but should not cause problems most of the time.
 // When the shadow is mapped only a single thread usually exists (plus maybe
 // several worker threads on Mac, which aren't expected to map big chunks of
 // memory).
 bool MemoryRangeIsAvailable(uptr range_start, uptr range_end) {
   MemoryMappingLayout proc_maps(/*cache_enabled*/true);
   if (proc_maps.Error())
     return true; // and hope for the best
void DumpProcessMap() {
   Report("Process memory map follows:\n");
   while (proc_maps.Next(&segment)) {
     Printf("\t%p-%p\t%s\n", (void *)segment.start, (void *)segment.end,
            segment.filename);
   }
   Report("End of process memory map.\n");
   UnmapOrDie(filename, kBufSize);
 }
+#endif
 
 const char *GetPwd() {
   return GetEnv("PWD");
 }
 
 bool IsPathSeparator(const char c) {
   return c == '/';
 }
 
 bool IsAbsolutePath(const char *path) {
   return path != nullptr && IsPathSeparator(path[0]);
 }
 
 void ReportFile::Write(const char *buffer, uptr length) {
   SpinMutexLock l(mu);
   ReopenIfNecessary();
   internal_write(fd, buffer, length);
 }
 
 bool GetCodeRangeForFile(const char *module, uptr *start, uptr *end) {
+#if SANITIZER_EMSCRIPTEN
+  // Code is not mapped in memory in Emscripten, so this operation is
+  // meaningless and thus always fails.
+#else
   MemoryMappingLayout proc_maps(/*cache_enabled*/false);
   InternalScopedString buff(kMaxPathLength);
   MemoryMappedSegment segment(buff.data(), kMaxPathLength);
   while (proc_maps.Next(&segment)) {
     if (segment.IsExecutable() &&
         internal_strcmp(module, segment.filename) == 0) {
       *start = segment.start;
       *end = segment.end;
       return true;
     }
   }
+#endif
   return false;
 }
 
 uptr SignalContext::GetAddress() const {
   auto si = static_cast<const siginfo_t *>(siginfo);
   return (uptr)si->si_addr;
 }
 

compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cpp

static void MaybeInstallSigaction(int signum,
   CHECK_EQ(0, internal_sigaction(signum, &sigact, nullptr));
   VReport(1, "Installed the sigaction for signal %d\n", signum);
 }
 
 void InstallDeadlySignalHandlers(SignalHandlerType handler) {
   // Set the alternate signal stack for the main thread.
   // This will cause SetAlternateSignalStack to be called twice, but the stack
   // will be actually set only once.
+#if !SANITIZER_EMSCRIPTEN
   if (common_flags()->use_sigaltstack) SetAlternateSignalStack();
+#endif
   MaybeInstallSigaction(SIGSEGV, handler);
   MaybeInstallSigaction(SIGBUS, handler);
   MaybeInstallSigaction(SIGABRT, handler);
   MaybeInstallSigaction(SIGFPE, handler);
   MaybeInstallSigaction(SIGILL, handler);
   MaybeInstallSigaction(SIGTRAP, handler);
 }
 
bool IsAccessibleMemoryRange(uptr beg, uptr size) {
   return result;
 }
 
 void PlatformPrepareForSandboxing(__sanitizer_sandbox_arguments *args) {
   // Some kinds of sandboxes may forbid filesystem access, so we won't be able
   // to read the file mappings from /proc/self/maps. Luckily, neither the
   // process will be able to load additional libraries, so it's fine to use the
   // cached mappings.
+#if !SANITIZER_EMSCRIPTEN
   MemoryMappingLayout::CacheMemoryMappings();
+#endif
 }
 
 bool MmapFixedNoReserve(uptr fixed_addr, uptr size, const char *name) {
   size = RoundUpTo(size, GetPageSizeCached());
   fixed_addr = RoundDownTo(fixed_addr, GetPageSizeCached());
   uptr p = MmapNamed((void *)fixed_addr, size, PROT_READ | PROT_WRITE,
                      MAP_PRIVATE | MAP_FIXED | MAP_NORESERVE | MAP_ANON, name);
   int reserrno;

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 || SANITIZER_OPENBSD || SANITIZER_RTEMS
+#if SANITIZER_MAC || SANITIZER_OPENBSD || SANITIZER_RTEMS || \
+    SANITIZER_EMSCRIPTEN
 # 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_stacktrace.cpp

#if defined(__sparc__) || defined(__mips__)
   return pc + 8;
 #elif defined(__powerpc__) || defined(__arm__) || defined(__aarch64__)
   return pc + 4;
 #else
   return pc + 1;
 #endif
 }
 
+#if !defined(__EMSCRIPTEN__)
 uptr StackTrace::GetCurrentPc() {
   return GET_CALLER_PC();
 }
+#endif
 
 void BufferedStackTrace::Init(const uptr *pcs, uptr cnt, uptr extra_top_pc) {
   size = cnt + !!extra_top_pc;
   CHECK_LE(size, kStackTraceMax);
   internal_memcpy(trace_buffer, pcs, cnt * sizeof(trace_buffer[0]));
   if (extra_top_pc)
     trace_buffer[cnt] = extra_top_pc;
   top_frame_bp = 0;
 }
 
-// Sparc implemention is in its own file.
-#if !defined(__sparc__)
+// Sparc and Emscripten implementions are in their own files.
+#if !defined(__sparc__) && !defined(__EMSCRIPTEN__)
 
 // In GCC on ARM bp points to saved lr, not fp, so we should check the next
 // cell in stack to be a saved frame pointer. GetCanonicFrame returns the
 // pointer to saved frame pointer in any case.
 static inline uhwptr *GetCanonicFrame(uptr bp,
                                       uptr stack_top,
                                       uptr stack_bottom) {
   CHECK_GT(stack_top, stack_bottom);

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_emscripten.cpp

+//===-- sanitizer_stacktrace_emscripten.cpp
+//--------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries.
+//
+// Implementation of fast stack unwinding for Emscripten.
+//===----------------------------------------------------------------------===//
+
+#ifdef __EMSCRIPTEN__
+
+#include "sanitizer_common.h"
+#include "sanitizer_stacktrace.h"
+
+namespace __sanitizer {
+
+extern "C" {
+uptr emscripten_stack_snapshot();
+uptr emscripten_return_address(int level);
+u32 emscripten_stack_unwind_buffer(uptr pc, uptr *buffer, u32 depth);
+}
+
+uptr StackTrace::GetCurrentPc() { return emscripten_stack_snapshot(); }
+
+void BufferedStackTrace::FastUnwindStack(uptr pc, uptr bp, uptr stack_top,
+                                         uptr stack_bottom, u32 max_depth) {
+  bool saw_pc = false;
+  max_depth = Min(max_depth, kStackTraceMax);
+  size = emscripten_stack_unwind_buffer(pc, trace_buffer, max_depth);
+  trace_buffer[0] = pc;
+  size = Max(size, 1U);
+}
+
+}  // namespace __sanitizer
+
+#endif  // __EMSCRIPTEN__

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_libcdep.cpp

if (trace == nullptr || size == 0) {
     Printf("    <empty stack>\n\n");
     return;
   }
   InternalScopedString frame_desc(GetPageSizeCached() * 2);
   InternalScopedString dedup_token(GetPageSizeCached());
   int dedup_frames = common_flags()->dedup_token_length;
   uptr frame_num = 0;
   for (uptr i = 0; i < size && trace[i]; i++) {
+#if !SANITIZER_EMSCRIPTEN
     // PCs in stack traces are actually the return addresses, that is,
     // addresses of the next instructions after the call.
     uptr pc = GetPreviousInstructionPc(trace[i]);
+#else
+    // On Emscripten, the stack traces are obtained from JavaScript, and the
+    // addresses are not return addresses.
+    uptr pc = trace[i];
+#endif
     SymbolizedStack *frames = Symbolizer::GetOrInit()->SymbolizePC(pc);
     CHECK(frames);
     for (SymbolizedStack *cur = frames; cur; cur = cur->next) {
       frame_desc.clear();
       RenderFrame(&frame_desc, common_flags()->stack_trace_format, frame_num++,
                   cur->info, common_flags()->symbolize_vs_style,
                   common_flags()->strip_path_prefix);
       Printf("%s\n", frame_desc.data());

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_emscripten.cpp

+//===-- sanitizer_symbolizer_emscripten.cpp
+//--------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is shared between AddressSanitizer and ThreadSanitizer
+// run-time libraries.
+// Emscripten-specific implementation of symbolizer parts.
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+
+#if SANITIZER_EMSCRIPTEN
+
+#include "sanitizer_symbolizer_internal.h"
+
+namespace __sanitizer {
+
+extern "C" {
+const char *emscripten_pc_get_function(uptr pc);
+const char *emscripten_pc_get_file(uptr pc);
+int emscripten_pc_get_line(uptr pc);
+int emscripten_pc_get_column(uptr pc);
+}
+
+class EmscriptenSymbolizerTool : public SymbolizerTool {
+ public:
+  bool SymbolizePC(uptr addr, SymbolizedStack *stack) override;
+  bool SymbolizeData(uptr addr, DataInfo *info) override { return false; }
+  const char *Demangle(const char *name) override { return name; }
+};
+
+bool EmscriptenSymbolizerTool::SymbolizePC(uptr addr, SymbolizedStack *frame) {
+  const char *func_name = emscripten_pc_get_function(addr);
+  if (func_name) {
+    frame->info.function = internal_strdup(func_name);
+    frame->info.function_offset = addr;
+  }
+
+  const char *file_name = emscripten_pc_get_file(addr);
+  if (file_name) {
+    frame->info.file = internal_strdup(file_name);
+    frame->info.line = emscripten_pc_get_line(addr);
+    frame->info.column = emscripten_pc_get_column(addr);
+  }
+
+  return !!func_name;
+}
+
+static void ChooseSymbolizerTools(IntrusiveList<SymbolizerTool> *list,
+                                  LowLevelAllocator *allocator) {
+  if (!common_flags()->symbolize) {
+    VReport(2, "Symbolizer is disabled.\n");
+    return;
+  }
+
+  list->push_back(new (*allocator) EmscriptenSymbolizerTool());
+}
+
+const char *Symbolizer::PlatformDemangle(const char *name) { return name; }
+
+Symbolizer *Symbolizer::PlatformInit() {
+  IntrusiveList<SymbolizerTool> list;
+  list.clear();
+  ChooseSymbolizerTools(&list, &symbolizer_allocator_);
+
+  return new (symbolizer_allocator_) Symbolizer(list);
+}
+
+void Symbolizer::LateInitialize() { Symbolizer::GetOrInit(); }
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_EMSCRIPTEN

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
+#if SANITIZER_POSIX && !SANITIZER_EMSCRIPTEN
 #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"

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_report.cpp

void ReportErrorSummary(const char *error_type, const AddressInfo &info,
   InternalScopedString buff(kMaxSummaryLength);
   buff.append("%s ", error_type);
   RenderFrame(&buff, "%L %F", 0, info, common_flags()->symbolize_vs_style,
               common_flags()->strip_path_prefix);
   ReportErrorSummary(buff.data(), alt_tool_name);
 }
 #endif
 
-#if !SANITIZER_FUCHSIA
+#if SANITIZER_EMSCRIPTEN
+#include <emscripten/em_asm.h>
+
+static INLINE bool ReportSupportsColors() {
+  return !!EM_ASM_INT({
+    var setting = Module['printWithColors'];
+    if (setting != null) {
+      return setting;
+    } else {
+      return ENVIRONMENT_IS_NODE && process.stderr.isTTY;
+    }
+  });
+}
+
+#elif !SANITIZER_FUCHSIA
 
 bool ReportFile::SupportsColors() {
   SpinMutexLock l(mu);
   ReopenIfNecessary();
   return SupportsColoredOutput(fd);
 }
 
 static INLINE bool ReportSupportsColors() {
   return report_file.SupportsColors();
 }
 
 #else  // SANITIZER_FUCHSIA
 
 // Fuchsia's logs always go through post-processing that handles colorization.
 static INLINE bool ReportSupportsColors() { return true; }
 
-#endif  // !SANITIZER_FUCHSIA
+#endif  // SANITIZER_EMSCRIPTEN, !SANITIZER_FUCHSIA
 
 bool ColorizeReports() {
   // FIXME: Add proper Windows support to AnsiColorDecorator and re-enable color
   // printing on Windows.
   if (SANITIZER_WINDOWS)
     return false;
 
   const char *flag = common_flags()->color;

compiler-rt/lib/sanitizer_common/sanitizer_syscall_emscripten.inc

+#define __scc(X) ((long) (X))
+
+#define __syscall_emscripten(n, ...) __syscall##n(n, ##__VA_ARGS__)
+#define __syscall_emscripten0(n) __syscall_emscripten(n)
+#define __syscall_emscripten1(n,a) __syscall_emscripten(n,__scc(a))
+#define __syscall_emscripten2(n,a,b) __syscall_emscripten(n,__scc(a),__scc(b))
+#define __syscall_emscripten3(n,a,b,c) __syscall_emscripten(n,__scc(a),__scc(b),__scc(c))
+#define __syscall_emscripten4(n,a,b,c,d) __syscall_emscripten(n,__scc(a),__scc(b),__scc(c),__scc(d))
+#define __syscall_emscripten5(n,a,b,c,d,e) __syscall_emscripten(n,__scc(a),__scc(b),__scc(c),__scc(d),__scc(e))
+#define __syscall_emscripten6(n,a,b,c,d,e,f) __syscall_emscripten(n,__scc(a),__scc(b),__scc(c),__scc(d),__scc(e),__scc(f))
+#define __syscall_emscripten7(n,a,b,c,d,e,f,g) __syscall_emscripten(n,__scc(a),__scc(b),__scc(c),__scc(d),__scc(e),__scc(f),__scc(g))
+
+#define __SYSCALL_NARGS_X(a,b,c,d,e,f,g,h,n,...) n
+#define __SYSCALL_NARGS(...) __SYSCALL_NARGS_X(__VA_ARGS__,7,6,5,4,3,2,1,0,)
+#define __SYSCALL_CONCAT_X(a,b) a##b
+#define __SYSCALL_CONCAT(a,b) __SYSCALL_CONCAT_X(a,b)
+#define __SYSCALL_DISP(b,...) __SYSCALL_CONCAT(b,__SYSCALL_NARGS(__VA_ARGS__))(__VA_ARGS__)
+#define internal_syscall(...) __SYSCALL_DISP(__syscall_emscripten,__VA_ARGS__)
+
+#define DECLARE_SYSCALL2(x) extern "C" long __syscall##x(int which, ...)
+#define DECLARE_SYSCALL1(x) DECLARE_SYSCALL2(x)
+#define DECLARE_SYSCALL(x) DECLARE_SYSCALL1(SYS_##x)
+
+DECLARE_SYSCALL(dup);
+DECLARE_SYSCALL(mmap2);
+DECLARE_SYSCALL(munmap);
+DECLARE_SYSCALL(mprotect);
+DECLARE_SYSCALL(close);
+DECLARE_SYSCALL(open);
+DECLARE_SYSCALL(read);
+DECLARE_SYSCALL(write);
+DECLARE_SYSCALL(ftruncate);
+DECLARE_SYSCALL(stat64);
+DECLARE_SYSCALL(lstat64);
+DECLARE_SYSCALL(fstat64);
+DECLARE_SYSCALL(dup2);
+DECLARE_SYSCALL(readlink);
+DECLARE_SYSCALL(unlink);
+DECLARE_SYSCALL(rename);
+DECLARE_SYSCALL(exit_group);
+DECLARE_SYSCALL(nanosleep);
+DECLARE_SYSCALL(execve);
+DECLARE_SYSCALL(gettid);
+DECLARE_SYSCALL(getpid);
+DECLARE_SYSCALL(getppid);
+DECLARE_SYSCALL(getdents);
+DECLARE_SYSCALL(wait4);
+DECLARE_SYSCALL(lseek);
+DECLARE_SYSCALL(sigaltstack);
+DECLARE_SYSCALL(ptrace);
+DECLARE_SYSCALL(tgkill);
+DECLARE_SYSCALL(gettimeofday);
+DECLARE_SYSCALL(rt_sigprocmask);
+
+#define SYSCALL(x) SYS_##x
+
+bool internal_iserror(uptr retval, int *rverrno) {
+  if (retval >= (uptr)-4095) {
+    if (rverrno)
+      *rverrno = -retval;
+    return true;
+  }
+  return false;
+}

compiler-rt/lib/ubsan/ubsan_flags.cpp

 }
 
 void InitializeFlags() {
   SetCommonFlagsDefaults();
   {
     CommonFlags cf;
     cf.CopyFrom(*common_flags());
     cf.print_summary = false;
+#if !SANITIZER_EMSCRIPTEN
+    // getenv on emscripten uses malloc, which we can't when using some
+    // sanitizers. You can't run external symbolizers anyway.
     cf.external_symbolizer_path = GetFlag("UBSAN_SYMBOLIZER_PATH");
+#endif
     OverrideCommonFlags(cf);
   }
 
   Flags *f = flags();
   f->SetDefaults();
 
   FlagParser parser;
   RegisterCommonFlags(&parser);

compiler-rt/lib/ubsan/ubsan_platform.h

 //===-- ubsan_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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the platforms which UBSan is supported at.
 //
 //===----------------------------------------------------------------------===//
 #ifndef UBSAN_PLATFORM_H
 #define UBSAN_PLATFORM_H
 
 // Other platforms should be easy to add, and probably work as-is.
 #if defined(__linux__) || defined(__FreeBSD__) || defined(__APPLE__) ||        \
-    defined(__NetBSD__) || defined(__OpenBSD__) || \
-    (defined(__sun__) && defined(__svr4__)) || \
-    defined(_WIN32) || defined(__Fuchsia__) || defined(__rtems__)
+    defined(__NetBSD__) || defined(__OpenBSD__) ||                             \
+    (defined(__sun__) && defined(__svr4__)) || defined(_WIN32) ||              \
+    defined(__Fuchsia__) || defined(__rtems__) || defined(__EMSCRIPTEN__)
 # define CAN_SANITIZE_UB 1
 #else
 # define CAN_SANITIZE_UB 0
 #endif
 
 #endif

compiler-rt/lib/ubsan/ubsan_signals_standalone.cpp

 //=-- ubsan_signals_standalone.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
 //
 //===----------------------------------------------------------------------===//
 //
 // Installs signal handlers and related interceptors for UBSan standalone.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ubsan_platform.h"
 #include "sanitizer_common/sanitizer_platform.h"
-#if CAN_SANITIZE_UB
-#include "interception/interception.h"
-#include "sanitizer_common/sanitizer_stacktrace.h"
-#include "ubsan_diag.h"
-#include "ubsan_init.h"
 
 // Interception of signals breaks too many things on Android.
 // * It requires that ubsan is the first dependency of the main executable for
 // the interceptors to work correctly. This complicates deployment, as it
 // prevents us from enabling ubsan on random platform modules independently.
 // * For this to work with ART VM, ubsan signal handler has to be set after the
 // debuggerd handler, but before the ART handler.
 // * Interceptors don't work at all when ubsan runtime is loaded late, ex. when
 // it is part of an APK that does not use wrap.sh method.
-#if SANITIZER_FUCHSIA || SANITIZER_ANDROID
+#if SANITIZER_FUCHSIA || SANITIZER_ANDROID || SANITIZER_EMSCRIPTEN
 
 namespace __ubsan {
 void InitializeDeadlySignals() {}
 }
 
-#else
+#elif CAN_SANITIZE_UB
+
+#include "interception/interception.h"
+#include "sanitizer_common/sanitizer_stacktrace.h"
+#include "ubsan_diag.h"
+#include "ubsan_init.h"
 
 #define COMMON_INTERCEPT_FUNCTION(name) INTERCEPT_FUNCTION(name)
 #include "sanitizer_common/sanitizer_signal_interceptors.inc"
 
 // TODO(yln): Temporary workaround. Will be removed.
 void ubsan_GetStackTrace(BufferedStackTrace *stack, uptr max_depth,
                          uptr pc, uptr bp, void *context, bool fast);
 
if (is_initialized)
     return;
   is_initialized = true;
   InitializeSignalInterceptors();
   InstallDeadlySignalHandlers(&UBsanOnDeadlySignal);
 }
 
 } // namespace __ubsan
 
-#endif
-
 #endif // CAN_SANITIZE_UB