[dfsan] Support Linux AArch64

[MaskRay]

Summary

compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake:ALL_DFSAN_SUPPORTED_ARCH
allows AArch64 but currently the instrumentation will crash.

Port Linux AArch64 memory mappings from msan but use
SizeClassAllocator64 for a slightly more efficient allocator (used by
asan/lsan). Change dfsan/lit.cfg.py to allow Linux aarch64. All tests
should pass.

• dfsan/origin_invalid.c uses x86_64 assembly. Just make it x86_64 specific.
• dfsan/interceptors.c our mallinfo interceptor takes an argument instead of returning a struct. This does not work on AArch64 which uses different registers for the two function types. Disable AArch64 as msan/Linux/mallinfo.cpp does.

[browneee]

Copying maps from MSan LGTM.

Should this change also update test/dfsan/lit.cfg.py ?

Have you tested on aarch64? or submitting to have buildbot do it?

[MaskRay]

Fix interceptors.c (mallinfo somehow crashes.
unfortunately running the test in a debugger gives me

==939877==ERROR: DataflowSanitizer failed to allocate 0x1600000800000 (387028101365760) bytes at address 6fffff800000 (errno: 12))

[MaskRay]

In D140770#4020029, @browneee wrote:

Copying maps from MSan LGTM.

Should this change also update test/dfsan/lit.cfg.py ?

Have you tested on aarch64? or submitting to have buildbot do it?

Yes, I have tested ninja check-dfsan on a Ubuntu 22.04.1 aarch64 machine. All tests pass now.

If there is an aarch64 build bot testing compiler-rt, by default it shall test dfsan.

[MaskRay]

Try using SizeClassAllocator64 (see D140792 for msan).
Change interceptors.c mallinfo to exclude aarch64 instead of only allowing x86_64.

compiler-rt/lib/dfsan/dfsan_allocator.cpp

struct Metadata {
   uptr requested_size;
 };
 
 struct DFsanMapUnmapCallback {
   void OnMap(uptr p, uptr size) const { dfsan_set_label(0, (void *)p, size); }
   void OnUnmap(uptr p, uptr size) const { dfsan_set_label(0, (void *)p, size); }
 };
 
-static const uptr kAllocatorSpace = 0x700000000000ULL;
-static const uptr kMaxAllowedMallocSize = 8UL << 30;
+#if defined(__aarch64__)
+const uptr kAllocatorSpace = 0xE00000000000ULL;
+#else
+const uptr kAllocatorSpace = 0x700000000000ULL;
+#endif
+const uptr kMaxAllowedMallocSize = 8UL << 30;
 
 struct AP64 {  // Allocator64 parameters. Deliberately using a short name.
   static const uptr kSpaceBeg = kAllocatorSpace;
   static const uptr kSpaceSize = 0x40000000000;  // 4T.
   static const uptr kMetadataSize = sizeof(Metadata);
   typedef DefaultSizeClassMap SizeClassMap;
   typedef DFsanMapUnmapCallback MapUnmapCallback;
   static const uptr kFlags = 0;

compiler-rt/lib/dfsan/dfsan_platform.h

struct MappingDesc {
   uptr start;
   uptr end;
   enum Type { INVALID, APP, SHADOW, ORIGIN } type;
   const char *name;
 };
 
 #if SANITIZER_LINUX && SANITIZER_WORDSIZE == 64
 
+#  if defined(__aarch64__)
+// The mapping assumes 48-bit VMA. AArch64 maps:
+// - 0x0000000000000-0x0100000000000: 39/42/48-bits program own segments
+// - 0x0a00000000000-0x0b00000000000: 48-bits PIE program segments
+//   Ideally, this would extend to 0x0c00000000000 (2^45 bytes - the
+//   maximum ASLR region for 48-bit VMA) but it is too hard to fit in
+//   the larger app/shadow/origin regions.
+// - 0x0e00000000000-0x1000000000000: 48-bits libraries segments
+const MappingDesc kMemoryLayout[] = {
+    {0X0000000000000, 0X0100000000000, MappingDesc::APP, "app-10-13"},
+    {0X0100000000000, 0X0200000000000, MappingDesc::SHADOW, "shadow-14"},
+    {0X0200000000000, 0X0300000000000, MappingDesc::INVALID, "invalid"},
+    {0X0300000000000, 0X0400000000000, MappingDesc::ORIGIN, "origin-14"},
+    {0X0400000000000, 0X0600000000000, MappingDesc::SHADOW, "shadow-15"},
+    {0X0600000000000, 0X0800000000000, MappingDesc::ORIGIN, "origin-15"},
+    {0X0800000000000, 0X0A00000000000, MappingDesc::INVALID, "invalid"},
+    {0X0A00000000000, 0X0B00000000000, MappingDesc::APP, "app-14"},
+    {0X0B00000000000, 0X0C00000000000, MappingDesc::SHADOW, "shadow-10-13"},
+    {0X0C00000000000, 0X0D00000000000, MappingDesc::INVALID, "invalid"},
+    {0X0D00000000000, 0X0E00000000000, MappingDesc::ORIGIN, "origin-10-13"},
+    {0X0E00000000000, 0X1000000000000, MappingDesc::APP, "app-15"},
+};
+#    define MEM_TO_SHADOW(mem) ((uptr)mem ^ 0xB00000000000ULL)
+#    define SHADOW_TO_ORIGIN(shadow) (((uptr)(shadow)) + 0x200000000000ULL)
+
+#  else
 // All of the following configurations are supported.
 // ASLR disabled: main executable and DSOs at 0x555550000000
 // PIE and ASLR: main executable and DSOs at 0x7f0000000000
 // non-PIE: main executable below 0x100000000, DSOs at 0x7f0000000000
 // Heap at 0x700000000000.
 const MappingDesc kMemoryLayout[] = {
     {0x000000000000ULL, 0x010000000000ULL, MappingDesc::APP, "app-1"},
     {0x010000000000ULL, 0x100000000000ULL, MappingDesc::SHADOW, "shadow-2"},
     {0x100000000000ULL, 0x110000000000ULL, MappingDesc::INVALID, "invalid"},
     {0x110000000000ULL, 0x200000000000ULL, MappingDesc::ORIGIN, "origin-2"},
     {0x200000000000ULL, 0x300000000000ULL, MappingDesc::SHADOW, "shadow-3"},
     {0x300000000000ULL, 0x400000000000ULL, MappingDesc::ORIGIN, "origin-3"},
     {0x400000000000ULL, 0x500000000000ULL, MappingDesc::INVALID, "invalid"},
     {0x500000000000ULL, 0x510000000000ULL, MappingDesc::SHADOW, "shadow-1"},
     {0x510000000000ULL, 0x600000000000ULL, MappingDesc::APP, "app-2"},
     {0x600000000000ULL, 0x610000000000ULL, MappingDesc::ORIGIN, "origin-1"},
     {0x610000000000ULL, 0x700000000000ULL, MappingDesc::INVALID, "invalid"},
     {0x700000000000ULL, 0x800000000000ULL, MappingDesc::APP, "app-3"}};
-#  define MEM_TO_SHADOW(mem) (((uptr)(mem)) ^ 0x500000000000ULL)
-#  define SHADOW_TO_ORIGIN(mem) (((uptr)(mem)) + 0x100000000000ULL)
+#    define MEM_TO_SHADOW(mem) (((uptr)(mem)) ^ 0x500000000000ULL)
+#    define SHADOW_TO_ORIGIN(mem) (((uptr)(mem)) + 0x100000000000ULL)
+#  endif
 
 #else
 #  error "Unsupported platform"
 #endif
 
 const uptr kMemoryLayoutSize = sizeof(kMemoryLayout) / sizeof(kMemoryLayout[0]);
 
 #define MEM_TO_ORIGIN(mem) (SHADOW_TO_ORIGIN(MEM_TO_SHADOW((mem))))

compiler-rt/test/dfsan/interceptors.c

 void test_free() {
   char *p = (char *) malloc(kSize);
   dfsan_set_label(1, p, kSize);
   free(p);
   ASSERT_READ_ZERO_LABEL(p, kSize);
 }
 
 void test_mallinfo() {
+  // The mallinfo interceptor takes an argument instead of returning a struct.
+  // This doesn't work on AArch64 which uses different registers for the two
+  // function types.
+#ifdef defined(__GLIBC__) && !defined(__aarch64__)
   struct mallinfo mi = mallinfo();
   for (int i = 0; i < sizeof(struct mallinfo); ++i) {
     char c = ((char *)(&mi))[i];
     assert(!c);
     ASSERT_ZERO_LABEL(c);
   }
+#endif
 }
 
 void test_malloc() {
   char *p = (char *) malloc(kSize);
   ASSERT_ZERO_LABEL(p);
   ASSERT_READ_ZERO_LABEL(p, kSize);
   free(p);
 }

compiler-rt/test/dfsan/lit.cfg.py

 
 config.substitutions.append( ("%clang_dfsan ", build_invocation(clang_dfsan_cflags)) )
 config.substitutions.append( ("%clangxx_dfsan ", build_invocation(clang_dfsan_cxxflags)) )
 
 # Default test suffixes.
 config.suffixes = ['.c', '.cpp']
 
 # DataFlowSanitizer tests are currently supported on Linux only.
-if not (config.host_os in ['Linux'] and config.target_arch in ['x86_64']):
+if not (config.host_os in ['Linux'] and config.target_arch in ['aarch64', 'x86_64']):
   config.unsupported = True

compiler-rt/test/dfsan/origin_invalid.c

+// REQUIRES: target={{x86_64-.*}}
 // RUN: %clang_dfsan -gmlt -mllvm -dfsan-track-origins=1 %s -o %t && \
 // RUN:     %run %t >%t.out 2>&1
 // RUN: FileCheck %s < %t.out
 
 #include <sanitizer/dfsan_interface.h>
 
 int main(int argc, char *argv[]) {
   uint64_t a = 10;

llvm/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

struct MemoryMapParams {
   uint64_t AndMask;
   uint64_t XorMask;
   uint64_t ShadowBase;
   uint64_t OriginBase;
 };
 
 } // end anonymous namespace
 
+// NOLINTBEGIN(readability-identifier-naming)
+// aarch64 Linux
+const MemoryMapParams Linux_AArch64_MemoryMapParams = {
+    0,               // AndMask (not used)
+    0x0B00000000000, // XorMask
+    0,               // ShadowBase (not used)
+    0x0200000000000, // OriginBase
+};
+
 // x86_64 Linux
-// NOLINTNEXTLINE(readability-identifier-naming)
-static const MemoryMapParams Linux_X86_64_MemoryMapParams = {
+const MemoryMapParams Linux_X86_64_MemoryMapParams = {
     0,              // AndMask (not used)
     0x500000000000, // XorMask
     0,              // ShadowBase (not used)
     0x100000000000, // OriginBase
 };
+// NOLINTEND(readability-identifier-naming)
 
 namespace {
 
 class DFSanABIList {
   std::unique_ptr<SpecialCaseList> SCL;
 
 public:
   DFSanABIList() = default;

 }
 
 bool DataFlowSanitizer::initializeModule(Module &M) {
   Triple TargetTriple(M.getTargetTriple());
   const DataLayout &DL = M.getDataLayout();
 
   if (TargetTriple.getOS() != Triple::Linux)
     report_fatal_error("unsupported operating system");
-  if (TargetTriple.getArch() != Triple::x86_64)
-    report_fatal_error("unsupported architecture");
+  switch (TargetTriple.getArch()) {
+  case Triple::aarch64:
+    MapParams = &Linux_AArch64_MemoryMapParams;
+    break;
+  case Triple::x86_64:
     MapParams = &Linux_X86_64_MemoryMapParams;
+    break;
+  default:
+    report_fatal_error("unsupported architecture");
+  }
 
   Mod = &M;
   Ctx = &M.getContext();
   Int8Ptr = Type::getInt8PtrTy(*Ctx);
   OriginTy = IntegerType::get(*Ctx, OriginWidthBits);
   OriginPtrTy = PointerType::getUnqual(OriginTy);
   PrimitiveShadowTy = IntegerType::get(*Ctx, ShadowWidthBits);
   PrimitiveShadowPtrTy = PointerType::getUnqual(PrimitiveShadowTy);