[asan] Add support for Myriad RTEMS memory map

[waltl]

Summary

The Myriad RTEMS memory system has a few unique aspects that
require support in the ASan run-time.

• A limited amount of memory (currently 512M).

• No virtual memory, no memory protection.

• DRAM starts at address 0x80000000. Other parts of memory may be used for MMIO, etc.

• The second highest address bit is the "cache" bit, and 0x80000000 and 0x84000000 alias to the same memory.

To support the above, we make the following changes:

• Use a ShadowScale of 5, to reduce shadow memory overhead.

• Adjust some existing macros to remove assumption that the lowest memory address is 0.

• add a RAW_ADDR macro that on Myriad strips the cache bit from the input address, before using the address for shadow memory (for other archs this does nothing).

• We must check that an address is in DRAM range before using it to index into shadow memory.

[kcc]

compiler-rt/lib/asan/asan_mapping.h

244

this section is very hard to read (and, hence, maintain) due to extra ?:
I'd prefer if you create a separate asan_mapping_myriad.h or some such and hide the specific logic there.

[waltl]

Move Myriad memory mapping definitions to its own file.

[waltl]

Rebase.

[krytarowski]

compiler-rt/lib/asan/asan_mapping.h

141

Is this RTEMS/Myriad2 CPU?

[waltl]

compiler-rt/lib/asan/asan_mapping.h

141

The memory map is for Myriad2, which is a chip comprising multiple CPUs (2 Sparcs and one Shave). RTEMS is the OS used but it is not tied to the memory map.

[vitalybuka]

compiler-rt/lib/asan/asan_mapping.h

201

please define SHADOW_SCALE here

294

you can use ASAN_FIXED_MAPPING and platform specific FindDynamicShadowStart()

311

what is this for?

329

Instead of checking kHighMemBeg here, can you just set kHighMemEnd = kHighMemBeg - 1

compiler-rt/lib/asan/asan_poisoning.cc

187

Why do you need to check AddrIsInShadow here? Could you make sure that ranges set so that not DRAM is not AddrIsInMem

[waltl]

compiler-rt/lib/asan/asan_mapping.h

311

Myriad addresses have a bit that tells the processor whether its data should be cached. For example, addresses 0x80abcdef and 0x84abcdef correspond to the same addresses. So to get the raw address we need to strip the cache bit.

[waltl]

compiler-rt/lib/asan/asan_mapping.h

294

Can you clarify? If I use ASAN_FIXED_MAPPING I have to clone the definitions in this header, and initialize them in the header and not FindDynamicShadowStart().

[vitalybuka]

compiler-rt/lib/asan/asan_mapping.h

294

Sorry, I meant to write "NOT ASAN_FIXED_MAPPING" and reset pointers in runtime from platform specific FindDynamicShadowStart

[waltl]

Address CR comments

[waltl]

compiler-rt/lib/asan/asan_mapping.h

294

Myriad port doesn't use FindDynamicShadowStart, but I've put the initialization in InitializeShadowMemory() defined in asan_rtems.cc (see https://reviews.llvm.org/D46468).

[alekseyshl]

compiler-rt/lib/asan/asan_mapping.h

316

It would be more in the spirit of this file to define a macro here:
#define RAW_ADDR(mem) (mem)
and in asan_mapping_myriad.h:
#define RAW_ADDR(mem) (mem & ~kMyriadCacheBitMask32)

357

Why the address is shadow is also considered in mem?

AddrIsInShadowGap(a) is covered by the next check, protect_shadow_gap is always 0 in your config, right?

368–369

return kHighShadowBeg && a >= kHighShadowBeg && a <= kHighShadowEnd;

otherwise nullptr will pass as a high shadow.

compiler-rt/lib/asan/asan_mapping_myriad.h

27

If you do not have a concept of high mem, why not set kHighMemBeg and kHighMemEnd to 0? It'll make other conditions more explicit.

compiler-rt/lib/asan/asan_rtl.cc

59–60

Instead of this condition, add CHECK(!f->unmap_shadow_on_exit) to InitializeFlags(), the same way you do for SANITIZER_RTEMS. By the way, isn't that existing check enough already?

144

Why __asan_region_is_poisoned special cases SANITIZER_MYRIAD2 and here you check for SANITIZER_RTEMS? Shouldn't it be the same?

322–327

"if (kHighShadowBeg) {" or, if you set kHighMemBeg to 0, "if (kHighMemBeg) {"

349

if (kHighShadowBeg) {

[waltl]

compiler-rt/lib/asan/asan_mapping.h

357

Why the address is shadow is also considered in mem?

I had a few places where I had to check AddrIsInMem(addr) && AddrIsInShadow(addr). Vitaly suggested that I define AddIsInMem accordingly so I don't have to do both checks. This makes sense to me conceptually and I checked that it shouldn't break existing uses of the function.

AddrIsInShadowGap(a) is covered by the next check, protect_shadow_gap is always 0 in
your config, right?

True. I'll simplify.

compiler-rt/lib/asan/asan_mapping_myriad.h

27

That's what I did originally. Vitally suggested that I define things this way. I'm fine with either. The tradeoffs I see are:

• define as 0: cleaner conceptually, consistent with handling of mid memory.

• define as range [begin, begin - 1]: fewer changes required.

compiler-rt/lib/asan/asan_rtl.cc

59–60

Yes this code never executes. But without the guard I get a compiler error even at -O2:

error: implicit conversion from 'unsigned long long' to '__sanitizer::uptr' (aka 'unsigned long') changes value from 18446744071041974272 to 1627389952

[waltl]

Address CR comments

[waltl]

compiler-rt/lib/asan/asan_mapping_myriad.h

27

I went back to setting kHighMemBeg to 0.

[waltl]

Fixes to support changing the shadow scale.

[alekseyshl]

Looks good, thanks!

compiler-rt/lib/asan/asan_mapping.h

357

I see. What are these places? I'd rather have those checks explicit, because, on top of being pretty confusing to read, for one example, GetShadowAddressInformation() won't work on Myriad2.

368–369

kHighMemBeg -> kHighShadowBeg

compiler-rt/lib/asan/asan_rtl.cc

59–60

Right. Then let's change it to "if (kHighShadowEnd)" to make the code more generic:

if (kMidMemBeg) {
  UnmapOrDie((void*)kLowShadowBeg, kMidMemBeg - kLowShadowBeg);
  if (kHighShadowEnd)
    UnmapOrDie((void*)kMidMemEnd, kHighShadowEnd - kMidMemEnd);
} else {
  if (kHighShadowEnd)
    UnmapOrDie((void*)kLowShadowBeg, kHighShadowEnd - kLowShadowBeg);
}

318

I think it should be

#if !SANITIZER_MYRIAD2
#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

[vitalybuka]

compiler-rt/lib/asan/asan_mapping.h

316

The rest of the function is trivial, so not much value in code reuse.
Maybe just move what ever is using RAW_ADDR into myriad file?

compiler-rt/lib/asan/asan_mapping_myriad.h

27

It's not just fewer changes, with [begin, begin - 1] you don't need sentinel value like 0. This also confusing because kLowMemBeg is 0 and it's not sentinel in that case.
Still we already use 0 as sentinel for kMidMemBeg.

So I'd prefer to convert all code into [begin, begin - 1] for unavailable regions, but feel free to keep as 0, as it's already a mix of approaches.

[alekseyshl]

compiler-rt/lib/asan/asan_mapping_myriad.h

27

Yep, that was my point, let's keep the code consistent, it is pretty non-trivial as it is.

[waltl]

compiler-rt/lib/asan/asan_mapping.h

357

They are in __asan_region_is_poisoned (2 places) and
ASAN_MEMORY_ACCESS_CALLBACK_BODY, where there are now checks for just !AddrIsInMem(addr).

368–369

This should be ok, if we keep kHighMemBeg = 0? I was keeping consistent with AddrIsInMidShadow().

[alekseyshl]

compiler-rt/lib/asan/asan_mapping.h

357

Yep, move them there and do not change AddrIsInMem. As I mentioned, it breaks other stuff using AddrIsInMem.

368–369

Makes sense, keep kHighMemBeg.

[waltl]

Address CR comments

[waltl]

compiler-rt/lib/asan/asan_mapping_myriad.h

27

Using 0 for now.

[alekseyshl]

compiler-rt/lib/asan/asan_mapping.h

151

How about dropping kMyriadShadowScale:

#if defined(ASAN_SHADOW_SCALE)
static const u64 kDefaultShadowScale = ASAN_SHADOW_SCALE;
#elif defined(SANITIZER_MYRIAD2)
static const u64 kDefaultShadowScale = 5;
#else
static const u64 kDefaultShadowScale = 3;
#endif

then you won't need to fiddle with SHADOW_SCALE defines

[waltl]

Address CR comments

compiler-rt/lib/asan/asan_mapping.h

 // Default Windows/i386 mapping:
 // (the exact location of HighShadow/HighMem may vary depending
 //  on WoW64, /LARGEADDRESSAWARE, etc).
 // || `[0x50000000, 0xffffffff]` || HighMem    ||
 // || `[0x3a000000, 0x4fffffff]` || HighShadow ||
 // || `[0x36000000, 0x39ffffff]` || ShadowGap  ||
 // || `[0x30000000, 0x35ffffff]` || LowShadow  ||
 // || `[0x00000000, 0x2fffffff]` || LowMem     ||
+//
+// Shadow mapping on Myriad2:
+// || `[0x9ff80000, 0x9fffffff]` || ShadowGap  ||
+// || `[0x9f000000, 0x9ff7ffff]` || LowShadow  ||
+// || `[0x80000000, 0x9effffff]` || LowMem     ||
+// || `[0x00000000, 0x7fffffff]` || Ignored    ||
 
 #if defined(ASAN_SHADOW_SCALE)
 static const u64 kDefaultShadowScale = ASAN_SHADOW_SCALE;
 #else
 static const u64 kDefaultShadowScale = 3;
 #endif
 static const u64 kDefaultShadowSentinel = ~(uptr)0;
 static const u64 kDefaultShadowOffset32 = 1ULL << 29;  // 0x20000000
 static const u64 kDefaultShadowOffset64 = 1ULL << 44;
 static const u64 kDefaultShort64bitShadowOffset =
     0x7FFFFFFF & (~0xFFFULL << kDefaultShadowScale);  // < 2G.
 static const u64 kIosShadowOffset32 = 1ULL << 30;  // 0x40000000
 static const u64 kIosShadowOffset64 = 0x120200000;
 static const u64 kIosSimShadowOffset32 = 1ULL << 30;
 static const u64 kIosSimShadowOffset64 = kDefaultShadowOffset64;
 static const u64 kAArch64_ShadowOffset64 = 1ULL << 36;
 static const u64 kMIPS32_ShadowOffset32 = 0x0aaa0000;
 static const u64 kMIPS64_ShadowOffset64 = 1ULL << 37;
 static const u64 kPPC64_ShadowOffset64 = 1ULL << 44;
 static const u64 kSystemZ_ShadowOffset64 = 1ULL << 52;
 static const u64 kFreeBSD_ShadowOffset32 = 1ULL << 30;  // 0x40000000
 static const u64 kFreeBSD_ShadowOffset64 = 1ULL << 46;  // 0x400000000000
 static const u64 kNetBSD_ShadowOffset32 = 1ULL << 30;  // 0x40000000
 static const u64 kNetBSD_ShadowOffset64 = 1ULL << 46;  // 0x400000000000
 static const u64 kWindowsShadowOffset32 = 3ULL << 28;  // 0x30000000
 
-#define SHADOW_SCALE kDefaultShadowScale
+static const u64 kMyriadShadowScale = 5;
+static const u64 kMyriadMemoryOffset32 = 0x80000000ULL;
+static const u64 kMyriadMemoryEnd32 = 0x9fffffffULL;
+static const u64 kMyriadShadowOffset32 = 0x9f000000ULL;
+static const u64 kMyriadCacheBitMask32 = 0x40000000ULL;
+
+#define SHADOW_SCALE \
+  (SANITIZER_MYRIAD2 ? kMyriadShadowScale : kDefaultShadowScale)
 
 #if SANITIZER_FUCHSIA
 #  define SHADOW_OFFSET (0)
 #elif SANITIZER_WORDSIZE == 32
 #  if SANITIZER_ANDROID
 #    define SHADOW_OFFSET __asan_shadow_memory_dynamic_address
 #  elif defined(__mips__)
 #    define SHADOW_OFFSET kMIPS32_ShadowOffset32
 #  elif SANITIZER_FREEBSD
 #    define SHADOW_OFFSET kFreeBSD_ShadowOffset32
 #  elif SANITIZER_NETBSD
 #    define SHADOW_OFFSET kNetBSD_ShadowOffset32
 #  elif SANITIZER_WINDOWS
 #    define SHADOW_OFFSET kWindowsShadowOffset32
 #  elif SANITIZER_IOS
 #    if SANITIZER_IOSSIM
 #      define SHADOW_OFFSET kIosSimShadowOffset32
 #    else
 #      define SHADOW_OFFSET kIosShadowOffset32
 #    endif
+#  elif SANITIZER_MYRIAD2
+#    define SHADOW_OFFSET kMyriadShadowOffset32
 #  else
 #    define SHADOW_OFFSET kDefaultShadowOffset32
 #  endif
 #else
 #  if SANITIZER_IOS
 #    if SANITIZER_IOSSIM
 #      define SHADOW_OFFSET kIosSimShadowOffset64
 #    else

 
 #if SANITIZER_ANDROID && defined(__arm__)
 # define ASAN_PREMAP_SHADOW 1
 #else
 # define ASAN_PREMAP_SHADOW 0
 #endif
 
 #define SHADOW_GRANULARITY (1ULL << SHADOW_SCALE)
+
+#if SANITIZER_MYRIAD2
+#include "asan_mapping_myriad.h"
+#else
 #define MEM_TO_SHADOW(mem) (((mem) >> SHADOW_SCALE) + (SHADOW_OFFSET))
 
 #define kLowMemBeg      0
 #define kLowMemEnd      (SHADOW_OFFSET ? SHADOW_OFFSET - 1 : 0)
 
 #define kLowShadowBeg   SHADOW_OFFSET
 #define kLowShadowEnd   MEM_TO_SHADOW(kLowMemEnd)
 
 #define kHighMemBeg     (MEM_TO_SHADOW(kHighMemEnd) + 1)
#define kShadowGapBeg   (kLowShadowEnd ? kLowShadowEnd + 1 \
                                        : kZeroBaseShadowStart)
 #define kShadowGapEnd   ((kMidMemBeg ? kMidShadowBeg : kHighShadowBeg) - 1)
 
 #define kShadowGap2Beg (kMidMemBeg ? kMidShadowEnd + 1 : 0)
 #define kShadowGap2End (kMidMemBeg ? kMidMemBeg - 1 : 0)
 
 #define kShadowGap3Beg (kMidMemBeg ? kMidMemEnd + 1 : 0)
 #define kShadowGap3End (kMidMemBeg ? kHighShadowBeg - 1 : 0)
+#endif  // SANITIZER_MYRIAD2
 
 #define DO_ASAN_MAPPING_PROFILE 0  // Set to 1 to profile the functions below.
 
 #if DO_ASAN_MAPPING_PROFILE
 # define PROFILE_ASAN_MAPPING() AsanMappingProfile[__LINE__]++;
 #else
 # define PROFILE_ASAN_MAPPING()
 #endif
 
 // If 1, all shadow boundaries are constants.
-// Don't set to 1 other than for testing.
-#define ASAN_FIXED_MAPPING 0
+// Myriad is fixed-mapping only; for others, don't set to 1 other than
+// for testing.
+#define ASAN_FIXED_MAPPING SANITIZER_MYRIAD2
 
 namespace __asan {
 
 extern uptr AsanMappingProfile[];
 
 #if ASAN_FIXED_MAPPING
+#if SANITIZER_MYRIAD2
+static uptr kHighMemEnd = 0;
+static uptr kMidMemBeg =  0;
+static uptr kMidMemEnd =  0;
+#else  // SANITIZER_MYRIAD2
 // Fixed mapping for 64-bit Linux. Mostly used for performance comparison
 // with non-fixed mapping. As of r175253 (Feb 2013) the performance
 // difference between fixed and non-fixed mapping is below the noise level.
 static uptr kHighMemEnd = 0x7fffffffffffULL;
 static uptr kMidMemBeg =    0x3000000000ULL;
 static uptr kMidMemEnd =    0x4fffffffffULL;
-#else
+#endif  // SANITIZER_MYRIAD2
+#else  // ASAN_FIXED_MAPPING
 extern uptr kHighMemEnd, kMidMemBeg, kMidMemEnd;  // Initialized in __asan_init.
-#endif
+#endif  // ASAN_FIXED_MAPPING
+
+static inline uptr RawAddr(uptr a) {
+  return SANITIZER_MYRIAD2 ? (a & ~kMyriadCacheBitMask32) : a;
+}
 
 static inline bool AddrIsInLowMem(uptr a) {
   PROFILE_ASAN_MAPPING();
-  return a < kLowMemEnd;
+  a = RawAddr(a);
+  return a >= kLowMemBeg && a <= kLowMemEnd;
 }
 
 static inline bool AddrIsInLowShadow(uptr a) {
   PROFILE_ASAN_MAPPING();
+  a = RawAddr(a);
   return a >= kLowShadowBeg && a <= kLowShadowEnd;
 }
 
 static inline bool AddrIsInHighMem(uptr a) {
   PROFILE_ASAN_MAPPING();
-  return a >= kHighMemBeg && a <= kHighMemEnd;
+  a = RawAddr(a);
+  return kHighMemBeg && a >= kHighMemBeg && a <= kHighMemEnd;
 }
 
 static inline bool AddrIsInMidMem(uptr a) {
   PROFILE_ASAN_MAPPING();
+  a = RawAddr(a);
   return kMidMemBeg && a >= kMidMemBeg && a <= kMidMemEnd;
 }
 
 static inline bool AddrIsInShadowGap(uptr a) {
   PROFILE_ASAN_MAPPING();
+  a = RawAddr(a);
   if (kMidMemBeg) {
     if (a <= kShadowGapEnd)
       return SHADOW_OFFSET == 0 || a >= kShadowGapBeg;
     return (a >= kShadowGap2Beg && a <= kShadowGap2End) ||
            (a >= kShadowGap3Beg && a <= kShadowGap3End);
   }
   // In zero-based shadow mode we treat addresses near zero as addresses
   // in shadow gap as well.
   if (SHADOW_OFFSET == 0)
     return a <= kShadowGapEnd;
   return a >= kShadowGapBeg && a <= kShadowGapEnd;
 }
 
 static inline bool AddrIsInMem(uptr a) {
   PROFILE_ASAN_MAPPING();
   return AddrIsInLowMem(a) || AddrIsInMidMem(a) || AddrIsInHighMem(a) ||
       (flags()->protect_shadow_gap == 0 && AddrIsInShadowGap(a));
 }
 
 static inline uptr MemToShadow(uptr p) {
   PROFILE_ASAN_MAPPING();
   CHECK(AddrIsInMem(p));
   return MEM_TO_SHADOW(p);
 }
 
 static inline bool AddrIsInHighShadow(uptr a) {
   PROFILE_ASAN_MAPPING();
-  return a >= kHighShadowBeg && a <= kHighShadowEnd;
+  a = RawAddr(a);
+  return kHighMemBeg && a >= kHighShadowBeg && a <= kHighShadowEnd;
 }
 
 static inline bool AddrIsInMidShadow(uptr a) {
   PROFILE_ASAN_MAPPING();
+  a = RawAddr(a);
   return kMidMemBeg && a >= kMidShadowBeg && a <= kMidShadowEnd;
 }
 
 static inline bool AddrIsInShadow(uptr a) {
   PROFILE_ASAN_MAPPING();
   return AddrIsInLowShadow(a) || AddrIsInMidShadow(a) || AddrIsInHighShadow(a);
 }
 
 static inline bool AddrIsAlignedByGranularity(uptr a) {
   PROFILE_ASAN_MAPPING();
   return (a & (SHADOW_GRANULARITY - 1)) == 0;
 }
 
 static inline bool AddressIsPoisoned(uptr a) {
   PROFILE_ASAN_MAPPING();
+  if (SANITIZER_MYRIAD2 && !AddrIsInMem(a) && !AddrIsInShadow(a))
+    return false;
   const uptr kAccessSize = 1;
   u8 *shadow_address = (u8*)MEM_TO_SHADOW(a);
   s8 shadow_value = *shadow_address;
   if (shadow_value) {
     u8 last_accessed_byte = (a & (SHADOW_GRANULARITY - 1))
                                  + kAccessSize - 1;
     return (last_accessed_byte >= shadow_value);
   }

compiler-rt/lib/asan/asan_mapping_myriad.h

+//===-- asan_mapping_myriad.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.
+//
+// Myriad-specific definitions for ASan memory mapping.
+//===----------------------------------------------------------------------===//
+#ifndef ASAN_MAPPING_MYRIAD_H
+#define ASAN_MAPPING_MYRIAD_H
+
+#define MEM_TO_SHADOW(mem)                                              \
+  (((__asan::RawAddr(mem) - kLowMemBeg) >> SHADOW_SCALE) + (SHADOW_OFFSET))
+
+#define kLowMemBeg     kMyriadMemoryOffset32
+#define kLowMemEnd     (SHADOW_OFFSET - 1)
+
+#define kLowShadowBeg  SHADOW_OFFSET
+#define kLowShadowEnd  MEM_TO_SHADOW(kLowMemEnd)
+
+#define kHighMemBeg    0
+
+#define kHighShadowBeg 0
+#define kHighShadowEnd 0
+
+#define kMidShadowBeg  0
+#define kMidShadowEnd  0
+
+#define kShadowGapBeg  (kLowShadowEnd + 1)
+#define kShadowGapEnd  kMyriadMemoryEnd32
+
+#define kShadowGap2Beg 0
+#define kShadowGap2End 0
+
+#define kShadowGap3Beg 0
+#define kShadowGap3End 0
+
+#endif  // ASAN_MAPPING_MYRIAD_H

compiler-rt/lib/asan/asan_poisoning.cc

 
 int __asan_address_is_poisoned(void const volatile *addr) {
   return __asan::AddressIsPoisoned((uptr)addr);
 }
 
 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 (!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);
   // First check the first and the last application bytes,
   // then check the SHADOW_GRANULARITY-aligned region by calling
   // mem_is_zero on the corresponding shadow.

 }
 
 // --- Implementation of LSan-specific functions --- {{{1
 namespace __lsan {
 bool WordIsPoisoned(uptr addr) {
   return (__asan_region_is_poisoned(addr, sizeof(uptr)) != 0);
 }
 }
-

compiler-rt/lib/asan/asan_rtl.cc

if (flags()->sleep_before_dying) {
     Report("Sleeping for %d second(s)\n", flags()->sleep_before_dying);
     SleepForSeconds(flags()->sleep_before_dying);
   }
   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);
     }
   }
 }
 
 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);
void __asan_report_ ## type ## _n_noabort(uptr addr, uptr size) {           \
   GET_CALLER_PC_BP_SP;                                                      \
   ReportGenericError(pc, bp, sp, addr, is_write, size, 0, false);           \
 }                                                                           \
 
 ASAN_REPORT_ERROR_N(load, false)
 ASAN_REPORT_ERROR_N(store, true)
 
 #define ASAN_MEMORY_ACCESS_CALLBACK_BODY(type, is_write, size, exp_arg, fatal) \
+    if (SANITIZER_RTEMS && !AddrIsInMem(addr) && !AddrIsInShadow(addr))        \
+      return;                                                                  \
     uptr sp = MEM_TO_SHADOW(addr);                                             \
     uptr s = size <= SHADOW_GRANULARITY ? *reinterpret_cast<u8 *>(sp)          \
                                         : *reinterpret_cast<u16 *>(sp);        \
     if (UNLIKELY(s)) {                                                         \
       if (UNLIKELY(size >= SHADOW_GRANULARITY ||                               \
                    ((s8)((addr & (SHADOW_GRANULARITY - 1)) + size - 1)) >=     \
                        (s8)s)) {                                               \
         if (__asan_test_only_reported_buggy_pointer) {                         \

 
 static void InitializeHighMemEnd() {
 #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);
 }
 
 void PrintAddressSpaceLayout() {
+  if (kHighMemBeg) {
     Printf("|| `[%p, %p]` || HighMem    ||\n",
            (void*)kHighMemBeg, (void*)kHighMemEnd);
     Printf("|| `[%p, %p]` || HighShadow ||\n",
            (void*)kHighShadowBeg, (void*)kHighShadowEnd);
+  }
   if (kMidMemBeg) {
     Printf("|| `[%p, %p]` || ShadowGap3 ||\n",
            (void*)kShadowGap3Beg, (void*)kShadowGap3End);
     Printf("|| `[%p, %p]` || MidMem     ||\n",
            (void*)kMidMemBeg, (void*)kMidMemEnd);
     Printf("|| `[%p, %p]` || ShadowGap2 ||\n",
            (void*)kShadowGap2Beg, (void*)kShadowGap2End);
     Printf("|| `[%p, %p]` || MidShadow  ||\n",
            (void*)kMidShadowBeg, (void*)kMidShadowEnd);
   }
   Printf("|| `[%p, %p]` || ShadowGap  ||\n",
          (void*)kShadowGapBeg, (void*)kShadowGapEnd);
   if (kLowShadowBeg) {
     Printf("|| `[%p, %p]` || LowShadow  ||\n",
            (void*)kLowShadowBeg, (void*)kLowShadowEnd);
     Printf("|| `[%p, %p]` || LowMem     ||\n",
            (void*)kLowMemBeg, (void*)kLowMemEnd);
   }
-  Printf("MemToShadow(shadow): %p %p %p %p",
+  Printf("MemToShadow(shadow): %p %p",
          (void*)MEM_TO_SHADOW(kLowShadowBeg),
-         (void*)MEM_TO_SHADOW(kLowShadowEnd),
+         (void*)MEM_TO_SHADOW(kLowShadowEnd));
+  if (kHighMemBeg) {
+    Printf(" %p %p",
            (void*)MEM_TO_SHADOW(kHighShadowBeg),
            (void*)MEM_TO_SHADOW(kHighShadowEnd));
+  }
   if (kMidMemBeg) {
     Printf(" %p %p",
            (void*)MEM_TO_SHADOW(kMidShadowBeg),
            (void*)MEM_TO_SHADOW(kMidShadowEnd));
   }
   Printf("\n");
   Printf("redzone=%zu\n", (uptr)flags()->redzone);
   Printf("max_redzone=%zu\n", (uptr)flags()->max_redzone);
   Printf("quarantine_size_mb=%zuM\n", (uptr)flags()->quarantine_size_mb);
   Printf("thread_local_quarantine_size_kb=%zuK\n",
          (uptr)flags()->thread_local_quarantine_size_kb);
   Printf("malloc_context_size=%zu\n",
          (uptr)common_flags()->malloc_context_size);
 
   Printf("SHADOW_SCALE: %d\n", (int)SHADOW_SCALE);
   Printf("SHADOW_GRANULARITY: %d\n", (int)SHADOW_GRANULARITY);
   Printf("SHADOW_OFFSET: 0x%zx\n", (uptr)SHADOW_OFFSET);
   CHECK(SHADOW_SCALE >= 3 && SHADOW_SCALE <= 7);
   if (kMidMemBeg)
     CHECK(kMidShadowBeg > kLowShadowEnd &&
           kMidMemBeg > kMidShadowEnd &&
-          kHighShadowBeg > kMidMemEnd);
+          (!kHighMemBeg || kHighShadowBeg > kMidMemEnd));
 }
 
 static void AsanInitInternal() {
   if (LIKELY(asan_inited)) return;
   SanitizerToolName = "AddressSanitizer";
   CHECK(!asan_init_is_running && "ASan init calls itself!");
   asan_init_is_running = true;