[PATCH] libsanitizer: Support non-POSIX extension REG_STARTEND.

[marxin]

Summary

A recent (15 years old) glibc is needed in order to support
REG_STARTEND.

The patch addresses problem reported here:
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=98920

[vitalybuka]

There is D96348

[marxin]

In D95864#2573793, @vitalybuka wrote:

There is D96348

Ahh, good. That's addressing the very same issue.

[arichardson]

compiler-rt/lib/sanitizer_common/sanitizer_platform.h

353

Is this missing SANITIZER_I386?

Having to hardcode all the architectures is rather awkward, maybe we should just fall back to an unversioned lookup if the versioned one fails?

[marxin]

compiler-rt/lib/sanitizer_common/sanitizer_platform.h

353

Yes, doing an unversioned fallback would be the best approach! Can you please do it in your patch submission?
I tend to close this review request.

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

 }
 INTERCEPTOR(void, regfree, const void *preg) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, regfree, preg);
   if (preg)
     COMMON_INTERCEPTOR_READ_RANGE(ctx, preg, struct_regex_sz);
   REAL(regfree)(preg);
 }
+
+#ifdef SANITIZER_REGEXEC_VERSION
+#define COMMON_INTERCEPT_FUNCTION_REGEXEC(fn)                          \
+    COMMON_INTERCEPT_FUNCTION_VER(fn, SANITIZER_REGEXEC_VERSION)
+#else
+#define COMMON_INTERCEPT_FUNCTION_REGEXEC(fn)                          \
+    COMMON_INTERCEPT_FUNCTION(fn)
+#endif
+
 #define INIT_REGEX                                                             \
   COMMON_INTERCEPT_FUNCTION(regcomp);                                          \
-  COMMON_INTERCEPT_FUNCTION(regexec);                                          \
+  COMMON_INTERCEPT_FUNCTION_REGEXEC(regexec);                                  \
   COMMON_INTERCEPT_FUNCTION(regerror);                                         \
   COMMON_INTERCEPT_FUNCTION(regfree);
 #else
 #define INIT_REGEX
 #endif
 
 #if SANITIZER_INTERCEPT_REGEXSUB
 INTERCEPTOR(SSIZE_T, regnsub, char *buf, SIZE_T bufsiz, const char *sub,

compiler-rt/lib/sanitizer_common/sanitizer_platform.h

 #endif
 
 #if defined(__x86_64__) && !defined(_LP64)
 # define SANITIZER_X32 1
 #else
 # define SANITIZER_X32 0
 #endif
 
+#if defined(__x86_64__) && defined(_LP64)
+# define SANITIZER_X86_64 1
+#else
+# define SANITIZER_X86_64 0
+#endif
+
 #if defined(__i386__) || defined(_M_IX86)
 # define SANITIZER_I386 1
 #else
 # define SANITIZER_I386 0
 #endif
 
 #if defined(__mips__)
 # define SANITIZER_MIPS 1

 #endif
 
 #if defined(__riscv) && (__riscv_xlen == 64)
 #define SANITIZER_RISCV64 1
 #else
 #define SANITIZER_RISCV64 0
 #endif
 
+#if defined(__sparc__)
+#define SANITIZER_SPARC 1
+#else
+#define SANITIZER_SPARC 0
+#endif
+
 // By default we allow to use SizeClassAllocator64 on 64-bit platform.
 // But in some cases (e.g. AArch64's 39-bit address space) SizeClassAllocator64
 // does not work well and we need to fallback to SizeClassAllocator32.
 // For such platforms build this code with -DSANITIZER_CAN_USE_ALLOCATOR64=0 or
 // change the definition of SANITIZER_CAN_USE_ALLOCATOR64 here.
 #ifndef SANITIZER_CAN_USE_ALLOCATOR64
 # if (SANITIZER_ANDROID && defined(__aarch64__)) || SANITIZER_FUCHSIA
 #  define SANITIZER_CAN_USE_ALLOCATOR64 1

 #define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 38)
 #elif defined(__aarch64__)
 # if SANITIZER_MAC
 // Darwin iOS/ARM64 has a 36-bit VMA, 64GiB VM
 #  define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 36)
 # else
 #  define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 48)
 # endif
-#elif defined(__sparc__)
+#elif defined(SANITIZER_SPARC)
 #define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 52)
 #else
 # define SANITIZER_MMAP_RANGE_SIZE FIRST_32_SECOND_64(1ULL << 32, 1ULL << 47)
 #endif
 
 // Whether the addresses are sign-extended from the VMA range to the word.
 // The SPARC64 Linux port implements this to split the VMA space into two
 // non-contiguous halves with a huge hole in the middle.
-#if defined(__sparc__) && SANITIZER_WORDSIZE == 64
+#if defined(SANITIZER_SPARC) && SANITIZER_WORDSIZE == 64
 #define SANITIZER_SIGN_EXTENDED_ADDRESSES 1
 #else
 #define SANITIZER_SIGN_EXTENDED_ADDRESSES 0
 #endif
 
 // The AArch64 and RISC-V linux ports use the canonical syscall set as
 // mandated by the upstream linux community for all new ports. Other ports
 // may still use legacy syscalls.
 #ifndef SANITIZER_USES_CANONICAL_LINUX_SYSCALLS
 # if (defined(__aarch64__) || defined(__riscv)) && SANITIZER_LINUX
 # define SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 1
 # else
 # define SANITIZER_USES_CANONICAL_LINUX_SYSCALLS 0
 # endif
 #endif
 
 // udi16 syscalls can only be used when the following conditions are
 // met:
 // * target is one of arm32, x86-32, sparc32, sh or m68k
 // * libc version is libc5, glibc-2.0, glibc-2.1 or glibc-2.2 to 2.15
 //   built against > linux-2.2 kernel headers
 // Since we don't want to include libc headers here, we check the
 // target only.
-#if defined(__arm__) || SANITIZER_X32 || defined(__sparc__)
+#if defined(__arm__) || SANITIZER_X32 || defined(SANITIZER_SPARC)
 #define SANITIZER_USES_UID16_SYSCALLS 1
 #else
 #define SANITIZER_USES_UID16_SYSCALLS 0
 #endif
 
 #if defined(__mips__)
 # define SANITIZER_POINTER_FORMAT_LENGTH FIRST_32_SECOND_64(8, 10)
 #else

 // On linux, some architectures had an ABI transition from 64-bit long double
 // (ie. same as double) to 128-bit long double.  On those, glibc symbols
 // involving long doubles come in two versions, and we need to pass the
 // correct one to dlvsym when intercepting them.
 #if SANITIZER_LINUX && (SANITIZER_S390 || SANITIZER_PPC32 || SANITIZER_PPC64V1)
 #define SANITIZER_NLDBL_VERSION "GLIBC_2.4"
 #endif
 
+// On linux, we need a recent regexec implementation that supports
+// a non-POSIX flag REG_STARTEND.  Target that are younger than GLIBC_2.3.4
+// can use a default (non-versioned) symbol.
+#if SANITIZER_LINUX && (SANITIZER_MIPS || SANITIZER_S390 || SANITIZER_SPARC \
+    || SANITIZER_PPC32 || SANITIZER_PPC64V1 || SANITIZER_X86_64)
+#define SANITIZER_REGEXEC_VERSION "GLIBC_2.3.4"
+#endif
+
 #if SANITIZER_GO == 0
 # define SANITIZER_GO 0
 #endif
 
 // On PowerPC and ARM Thumb, calling pthread_exit() causes LSan to detect leaks.
 // pthread_exit() performs unwinding that leads to dlopen'ing libgcc_s.so.
 // dlopen mallocs "libgcc_s.so" string which confuses LSan, it fails to realize
 // that this allocation happens in dynamic linker and should be ignored.