From 2c5cee46a242e67b093c706be2e308d0a58bf72c Mon Sep 17 00:00:00 2001 From: chenli Date: Thu, 17 Aug 2023 17:01:25 +0800 Subject: [PATCH] [LoongArch] Backport patches --- 0001-backport-LoongArch-patches.patch | 270 ++++++++++++++++++++++++++ compiler-rt.spec | 10 +- 2 files changed, 279 insertions(+), 1 deletion(-) create mode 100644 0001-backport-LoongArch-patches.patch diff --git a/0001-backport-LoongArch-patches.patch b/0001-backport-LoongArch-patches.patch new file mode 100644 index 0000000..03ccdbb --- /dev/null +++ b/0001-backport-LoongArch-patches.patch @@ -0,0 +1,270 @@ +diff --git a/compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake b/compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake +index cc929c521..dcbce8331 100644 +--- a/compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake ++++ b/compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake +@@ -54,7 +54,8 @@ else() + set(ALL_LSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${MIPS64} ${ARM64} ${ARM32} + ${PPC64} ${S390X} ${RISCV64} ${HEXAGON} ${LOONGARCH64}) + endif() +-set(ALL_MSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64} ${S390X}) ++set(ALL_MSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64} ${S390X} ++ ${LOONGARCH64}) + set(ALL_HWASAN_SUPPORTED_ARCH ${X86_64} ${ARM64} ${RISCV64}) + set(ALL_MEMPROF_SUPPORTED_ARCH ${X86_64}) + set(ALL_PROFILE_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${PPC32} ${PPC64} +diff --git a/compiler-rt/lib/msan/msan.h b/compiler-rt/lib/msan/msan.h +index 5d8ea5266..8e5120019 100644 +--- a/compiler-rt/lib/msan/msan.h ++++ b/compiler-rt/lib/msan/msan.h +@@ -89,6 +89,27 @@ const MappingDesc kMemoryLayout[] = { + # define MEM_TO_SHADOW(mem) ((uptr)mem ^ 0xB00000000000ULL) + # define SHADOW_TO_ORIGIN(shadow) (((uptr)(shadow)) + 0x200000000000ULL) + ++#elif SANITIZER_LINUX && SANITIZER_LOONGARCH64 ++// LoongArch64 maps: ++// - 0x000000000000-0x010000000000: Program own segments ++// - 0x555500000000-0x555600000000: PIE program segments ++// - 0x7fff00000000-0x7fffffffffff: libraries segments. ++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(shadow) (((uptr)(shadow)) + 0x100000000000ULL) ++ + #elif SANITIZER_LINUX && SANITIZER_PPC64 + const MappingDesc kMemoryLayout[] = { + {0x000000000000ULL, 0x000200000000ULL, MappingDesc::APP, "low memory"}, +diff --git a/compiler-rt/lib/msan/msan_allocator.cpp b/compiler-rt/lib/msan/msan_allocator.cpp +index 3308ee705..3922b8973 100644 +--- a/compiler-rt/lib/msan/msan_allocator.cpp ++++ b/compiler-rt/lib/msan/msan_allocator.cpp +@@ -78,6 +78,22 @@ struct AP64 { // Allocator64 parameters. Deliberately using a short name. + + typedef SizeClassAllocator64 PrimaryAllocator; + ++#elif defined(__loongarch_lp64) ++const uptr kAllocatorSpace = 0x700000000000ULL; ++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 MsanMapUnmapCallback MapUnmapCallback; ++ static const uptr kFlags = 0; ++ using AddressSpaceView = LocalAddressSpaceView; ++}; ++ ++typedef SizeClassAllocator64 PrimaryAllocator; ++ + #elif defined(__powerpc64__) + static const uptr kMaxAllowedMallocSize = 2UL << 30; // 2G + +diff --git a/compiler-rt/lib/msan/tests/msan_test.cpp b/compiler-rt/lib/msan/tests/msan_test.cpp +index e3ad9bf63..9c8ff9d9b 100644 +--- a/compiler-rt/lib/msan/tests/msan_test.cpp ++++ b/compiler-rt/lib/msan/tests/msan_test.cpp +@@ -3170,19 +3170,21 @@ static void GetPathToLoadable(char *buf, size_t sz) { + const char *last_slash = strrchr(program_path, '/'); + ASSERT_NE(nullptr, last_slash); + size_t dir_len = (size_t)(last_slash - program_path); +-#if defined(__x86_64__) ++# if defined(__x86_64__) + static const char basename[] = "libmsan_loadable.x86_64.so"; +-#elif defined(__MIPSEB__) || defined(MIPSEB) ++# elif defined(__MIPSEB__) || defined(MIPSEB) + static const char basename[] = "libmsan_loadable.mips64.so"; +-#elif defined(__mips64) ++# elif defined(__mips64) + static const char basename[] = "libmsan_loadable.mips64el.so"; +-#elif defined(__aarch64__) ++# elif defined(__aarch64__) + static const char basename[] = "libmsan_loadable.aarch64.so"; +-#elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ ++# elif defined(__loongarch_lp64) ++ static const char basename[] = "libmsan_loadable.loongarch64.so"; ++# elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + static const char basename[] = "libmsan_loadable.powerpc64.so"; +-#elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ ++# elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ + static const char basename[] = "libmsan_loadable.powerpc64le.so"; +-#endif ++# endif + int res = snprintf(buf, sz, "%.*s/%s", + (int)dir_len, program_path, basename); + ASSERT_GE(res, 0); +diff --git a/compiler-rt/lib/tsan/rtl/tsan_platform_linux.cpp b/compiler-rt/lib/tsan/rtl/tsan_platform_linux.cpp +index 9094469ba..384a443c1 100644 +--- a/compiler-rt/lib/tsan/rtl/tsan_platform_linux.cpp ++++ b/compiler-rt/lib/tsan/rtl/tsan_platform_linux.cpp +@@ -66,7 +66,8 @@ extern "C" void *__libc_stack_end; + void *__libc_stack_end = 0; + #endif + +-#if SANITIZER_LINUX && defined(__aarch64__) && !SANITIZER_GO ++#if SANITIZER_LINUX && (defined(__aarch64__) || defined(__loongarch_lp64)) && \ ++ !SANITIZER_GO + # define INIT_LONGJMP_XOR_KEY 1 + #else + # define INIT_LONGJMP_XOR_KEY 0 +@@ -314,7 +315,7 @@ void InitializePlatform() { + } + + #endif +-#if SANITIZER_LINUX && defined(__aarch64__) ++#if SANITIZER_LINUX && (defined(__aarch64__) || defined(__loongarch_lp64)) + // Initialize the xor key used in {sig}{set,long}jump. + InitializeLongjmpXorKey(); + #endif +@@ -387,8 +388,8 @@ static uptr UnmangleLongJmpSp(uptr mangled_sp) { + # else + return mangled_sp; + # endif +-#elif defined(__loongarch__) +- return mangled_sp; ++#elif defined(__loongarch_lp64) ++ return mangled_sp ^ longjmp_xor_key; + #elif defined(__powerpc64__) + // Reverse of: + // ld r4, -28696(r13) +@@ -452,7 +453,11 @@ static void InitializeLongjmpXorKey() { + + // 2. Retrieve vanilla/mangled SP. + uptr sp; ++#ifdef __loongarch__ ++ asm("move %0, $sp" : "=r" (sp)); ++#else + asm("mov %0, sp" : "=r" (sp)); ++#endif + uptr mangled_sp = ((uptr *)&env)[LONG_JMP_SP_ENV_SLOT]; + + // 3. xor SPs to obtain key. +diff --git a/compiler-rt/test/lsan/TestCases/Linux/leak_check_segv.cpp b/compiler-rt/test/lsan/TestCases/Linux/leak_check_segv.cpp +index 88fb21788..faa154456 100644 +--- a/compiler-rt/test/lsan/TestCases/Linux/leak_check_segv.cpp ++++ b/compiler-rt/test/lsan/TestCases/Linux/leak_check_segv.cpp +@@ -1,18 +1,22 @@ + // Test that SIGSEGV during leak checking does not crash the process. + // RUN: %clangxx_lsan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s + // UNSUPPORTED: ppc +-#include ++#include + #include ++#include + #include +-#include ++#include + + char data[10 * 1024 * 1024]; + + int main() { ++ long pagesize_mask = sysconf(_SC_PAGESIZE) - 1; + void *p = malloc(10 * 1024 * 1024); + // surprise-surprise! +- mprotect((void*)(((unsigned long)p + 4095) & ~4095), 16 * 1024, PROT_NONE); +- mprotect((void*)(((unsigned long)data + 4095) & ~4095), 16 * 1024, PROT_NONE); ++ mprotect((void *)(((unsigned long)p + pagesize_mask) & ~pagesize_mask), ++ 16 * 1024, PROT_NONE); ++ mprotect((void *)(((unsigned long)data + pagesize_mask) & ~pagesize_mask), ++ 16 * 1024, PROT_NONE); + __lsan_do_leak_check(); + fprintf(stderr, "DONE\n"); + } +diff --git a/compiler-rt/test/msan/mmap.cpp b/compiler-rt/test/msan/mmap.cpp +index 0a085b207..16c482628 100644 +--- a/compiler-rt/test/msan/mmap.cpp ++++ b/compiler-rt/test/msan/mmap.cpp +@@ -18,6 +18,10 @@ bool AddrIsApp(void *p) { + return (addr >= 0x000000000000ULL && addr < 0x010000000000ULL) || + (addr >= 0x510000000000ULL && addr < 0x600000000000ULL) || + (addr >= 0x700000000000ULL && addr < 0x800000000000ULL); ++#elif defined(__loongarch_lp64) ++ return (addr >= 0x000000000000ULL && addr < 0x010000000000ULL) || ++ (addr >= 0x510000000000ULL && addr < 0x600000000000ULL) || ++ (addr >= 0x700000000000ULL && addr < 0x800000000000ULL); + #elif defined(__mips64) + return (addr >= 0x0000000000ULL && addr <= 0x0200000000ULL) || + (addr >= 0xa200000000ULL && addr <= 0xc000000000ULL) || +diff --git a/compiler-rt/test/msan/mmap_below_shadow.cpp b/compiler-rt/test/msan/mmap_below_shadow.cpp +index 13d362517..97b561e50 100644 +--- a/compiler-rt/test/msan/mmap_below_shadow.cpp ++++ b/compiler-rt/test/msan/mmap_below_shadow.cpp +@@ -21,6 +21,9 @@ int main(void) { + #elif defined(__x86_64__) + uintptr_t hint = 0x4f0000000000ULL; + const uintptr_t app_start = 0x600000000000ULL; ++#elif defined(__loongarch_lp64) ++ uintptr_t hint = 0x4f0000000000ULL; ++ const uintptr_t app_start = 0x600000000000ULL; + #elif defined (__mips64) + uintptr_t hint = 0x4f00000000ULL; + const uintptr_t app_start = 0x6000000000ULL; +diff --git a/compiler-rt/test/msan/param_tls_limit.cpp b/compiler-rt/test/msan/param_tls_limit.cpp +index d28ce7404..35032f9ed 100644 +--- a/compiler-rt/test/msan/param_tls_limit.cpp ++++ b/compiler-rt/test/msan/param_tls_limit.cpp +@@ -5,9 +5,9 @@ + // RUN: %clangxx_msan -fno-sanitize-memory-param-retval -fsanitize-memory-track-origins -O0 %s -o %t && %run %t + // RUN: %clangxx_msan -fno-sanitize-memory-param-retval -fsanitize-memory-track-origins=2 -O0 %s -o %t && %run %t + // +-// AArch64 fails with: ++// AArch64 and LoongArch64 fail with: + // void f801(S<801>): Assertion `__msan_test_shadow(&s, sizeof(s)) == -1' failed +-// XFAIL: target=aarch64{{.*}} ++// XFAIL: target={{(aarch64|loongarch64).*}} + // When passing huge structs by value, SystemZ uses pointers, therefore this + // test in its present form is unfortunately not applicable. + // ABI says: "A struct or union of any other size . Replace such an +diff --git a/compiler-rt/test/msan/signal_stress_test.cpp b/compiler-rt/test/msan/signal_stress_test.cpp +index 043393fce..aade0f1f4 100644 +--- a/compiler-rt/test/msan/signal_stress_test.cpp ++++ b/compiler-rt/test/msan/signal_stress_test.cpp +@@ -5,6 +5,9 @@ + // Reported deadly signal due to stack-overflow + // XFAIL: target={{.*netbsd.*}} + ++// VarArg implementation on LoongArch isn't supported yet. ++// UNSUPPORTED: target=loongarch{{.*}} ++ + #include + #include + #include +diff --git a/compiler-rt/test/msan/strlen_of_shadow.cpp b/compiler-rt/test/msan/strlen_of_shadow.cpp +index bafff3aa8..39962481d 100644 +--- a/compiler-rt/test/msan/strlen_of_shadow.cpp ++++ b/compiler-rt/test/msan/strlen_of_shadow.cpp +@@ -15,6 +15,8 @@ + const char *mem_to_shadow(const char *p) { + #if defined(__x86_64__) + return (char *)((uintptr_t)p ^ 0x500000000000ULL); ++#elif defined(__loongarch_lp64) ++ return (char *)((uintptr_t)p ^ 0x500000000000ULL); + #elif defined (__mips64) + return (char *)((uintptr_t)p ^ 0x8000000000ULL); + #elif defined(__powerpc64__) +diff --git a/compiler-rt/test/msan/vararg.cpp b/compiler-rt/test/msan/vararg.cpp +index e72d99023..32f4c5db4 100644 +--- a/compiler-rt/test/msan/vararg.cpp ++++ b/compiler-rt/test/msan/vararg.cpp +@@ -16,8 +16,8 @@ + + // Check that shadow and origin are passed through va_args. + +-// Copying origins on AArch64, MIPS and PowerPC isn't supported yet. +-// XFAIL: target={{(aarch64|mips|powerpc64).*}} ++// Copying origins on AArch64, LoongArch64, MIPS and PowerPC isn't supported yet. ++// XFAIL: target={{(aarch64|loongarch64|mips|powerpc64).*}} + + #include + #include diff --git a/compiler-rt.spec b/compiler-rt.spec index 76f5ac0..17ea3fa 100644 --- a/compiler-rt.spec +++ b/compiler-rt.spec @@ -1,4 +1,4 @@ -%define anolis_release 1 +%define anolis_release 2 %global toolchain clang %undefine _include_frame_pointers @@ -27,6 +27,8 @@ URL: http://llvm.org Source0: https://github.com/llvm/llvm-project/releases/download/llvmorg-%{compiler_rt_version}/%{crt_srcdir}.tar.xz Source3: https://github.com/llvm/llvm-project/releases/download/llvmorg-%{compiler_rt_version}/%{cmake_srcdir}.tar.xz +Patch0: 0001-backport-LoongArch-patches.patch + BuildRequires: clang BuildRequires: cmake BuildRequires: ninja-build @@ -97,12 +99,18 @@ popd %{_includedir}/* %{_libdir}/clang/%{maj_ver}/lib/* %{_libdir}/clang/%{maj_ver}/share/* +%ifnarch loongarch64 %{_bindir}/hwasan_symbolize +%endif %files doc %doc README.txt CODE_OWNERS.TXT docs/TestingGuide.rst %changelog +* Thu Aug 17 2023 Chen Li - 16.0.6-2 +- Backport LoongArch patches from llvmorg-17.0.0-rc2 +- Exclude hwasan_symbolize on loongarch64 because of nonsupport + * Tue Aug 8 2023 Funda Wang - 16.0.6-1 - New version 16.0.6 -- Gitee