[sanitizer][msan] The LLVM part of the LoongArch memory sanitizer implementation

[Ami-zhang]

Summary

This patch enabled msan in LLVM and fixed all failing tests in
check-msan.

It does not add VarArgHelper implementation on LoongArch, which
will be done separately later. And it adds a test for VarArgNoOpHelper,
which is based on the X86 one.

[Ami-zhang]

Tests on LoongArch in check-msan are as follows:
(1) Without this patch

$ ninja check-msan
Testing Time: 58.13s
  Unsupported      :   9
  Passed           :   1
  Expectedly Failed:   3
  Failed           : 153

(2) With this patch

$ ninja check-msan
Testing Time: 75.51s
  Unsupported      :   9
  Passed           : 154
  Expectedly Failed:   3

Test for vararg.ll on LoongArch:

$ _build_rt/bin/llvm-lit llvm/test/Instrumentation/MemorySanitizer/LoongArch/vararg.ll 
-- Testing: 1 tests, 1 workers --
PASS: LLVM :: Instrumentation/MemorySanitizer/LoongArch/vararg.ll (1 of 1)

Testing Time: 0.14s
  Passed: 1

[Ami-zhang]

Ping

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

 // aarch64 Linux
 static const MemoryMapParams Linux_AArch64_MemoryMapParams = {
     0,               // AndMask (not used)
     0x0B00000000000, // XorMask
     0,               // ShadowBase (not used)
     0x0200000000000, // OriginBase
 };
 
+// loongarch64 Linux
+static const MemoryMapParams Linux_LoongArch64_MemoryMapParams = {
+    0,              // AndMask (not used)
+    0x500000000000, // XorMask
+    0,              // ShadowBase (not used)
+    0x100000000000, // OriginBase
+};
+
 // aarch64 FreeBSD
 static const MemoryMapParams FreeBSD_AArch64_MemoryMapParams = {
     0x1800000000000, // AndMask
     0x0400000000000, // XorMask
     0x0200000000000, // ShadowBase
     0x0700000000000, // OriginBase
 };
 
static const PlatformMemoryMapParams Linux_S390_MemoryMapParams = {
     &Linux_S390X_MemoryMapParams,
 };
 
 static const PlatformMemoryMapParams Linux_ARM_MemoryMapParams = {
     nullptr,
     &Linux_AArch64_MemoryMapParams,
 };
 
+static const PlatformMemoryMapParams Linux_LoongArch_MemoryMapParams = {
+    nullptr,
+    &Linux_LoongArch64_MemoryMapParams,
+};
+
 static const PlatformMemoryMapParams FreeBSD_ARM_MemoryMapParams = {
     nullptr,
     &FreeBSD_AArch64_MemoryMapParams,
 };
 
 static const PlatformMemoryMapParams FreeBSD_X86_MemoryMapParams = {
     &FreeBSD_I386_MemoryMapParams,
     &FreeBSD_X86_64_MemoryMapParams,
case Triple::Linux:
         break;
       case Triple::systemz:
         MapParams = Linux_S390_MemoryMapParams.bits64;
         break;
       case Triple::aarch64:
       case Triple::aarch64_be:
         MapParams = Linux_ARM_MemoryMapParams.bits64;
         break;
+      case Triple::loongarch64:
+        MapParams = Linux_LoongArch_MemoryMapParams.bits64;
+        break;
       default:
         report_fatal_error("unsupported architecture");
       }
       break;
     default:
       report_fatal_error("unsupported operating system");
     }
   }

llvm/test/Instrumentation/MemorySanitizer/LoongArch/vararg.ll

+; RUN: opt < %s -msan-check-access-address=0 -S -passes=msan 2>&1
+; Test that code using va_start can be compiled on LoongArch.
+
+target datalayout = "e-m:e-p:64:64-i64:64-i128:128-n64-S128"
+target triple = "loongarch64-unknown-linux-gnu"
+
+define void @VaStart(ptr %s, ...) {
+entry:
+  %vl = alloca ptr, align 4
+  call void @llvm.va_start(ptr %vl)
+  ret void
+}
+
+declare void @llvm.va_start(ptr)