[sanitizer] Compare against the alignment of the latter range trying to find consecutive TLS blocks in GetStaticTlsBoundary

[xry111]

Summary

On a mips64el-linux-gnu system, the dynamic linker arranges TLS blocks
like:

[0] 0xfff7fe9680..0xfff7fe9684, align = 0x4
[1] 0xfff7fe9688..0xfff7fe96a8, align = 0x8
[2] 0xfff7fe96c0..0xfff7fe9e60, align = 0x40
[3] 0xfff7fe9e60..0xfff7fe9ef8, align = 0x8

Note that the dynamic linker can only put [1] at 0xfff7fe9688, not
0xfff7fe9684 or it will be misaligned. But we were comparing the
distance between two blocks with the alignment of the previous range,
causing GetStaticTlsBoundary fail to merge the consecutive blocks.

Compare against the alignment of the latter range to fix the issue.

[djtodoro]

@xry111 Thanks for this! Since the implementation of TLS in glibc may differ in various versions (but should be very constant after ~2.19), is there anything here that depends on the glibc version?

[xry111]

In D129112#3629811, @djtodoro wrote:

@xry111 Thanks for this! Since the implementation of TLS in glibc may differ in various versions (but should be very constant after ~2.19), is there anything here that depends on the glibc version?

I'm not sure. I'm using Glibc-2.35 and the arrangement I've mentioned in the commit message caused 4 test failures running GCC thread sanitizer testsuite, but @dmilosevic141 cannot reproduce the failure. So I guess it's related to glibc version. Or maybe it's related to kernel page size (mine is 16KB) or something.

[MaskRay]

For https://sourceware.org/bugzilla/show_bug.cgi?id=16291 (feature request: provide simpler ways to compute stack and tls boundaries), I created an implementation https://sourceware.org/pipermail/libc-alpha/2021-September/131388.html but the patch is stuck. Someone may leave a comment on https://sourceware.org/bugzilla/show_bug.cgi?id=16291 to hopefully make the patch forward.

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

__attribute__((unused)) static void GetStaticTlsBoundary(uptr *addr, uptr *size,
   if (one == len) {
     // This may happen with musl if no module uses PT_TLS.
     *addr = 0;
     *size = 0;
     *align = 1;
     return;
   }
   // Find the maximum consecutive ranges. We consider two modules consecutive if
-  // the gap is smaller than the alignment. The dynamic loader places static TLS
-  // blocks this way not to waste space.
+  // the gap is smaller than the alignment of the latter range. The dynamic
+  // loader places static TLS blocks this way not to waste space.
   uptr l = one;
   *align = ranges[l].align;
-  while (l != 0 && ranges[l].begin < ranges[l - 1].end + ranges[l - 1].align)
+  while (l != 0 && ranges[l].begin < ranges[l - 1].end + ranges[l].align)
     *align = Max(*align, ranges[--l].align);
   uptr r = one + 1;
-  while (r != len && ranges[r].begin < ranges[r - 1].end + ranges[r - 1].align)
+  while (r != len && ranges[r].begin < ranges[r - 1].end + ranges[r].align)
     *align = Max(*align, ranges[r++].align);
   *addr = ranges[l].begin;
   *size = ranges[r - 1].end - ranges[l].begin;
 }
 #endif  // (x86_64 || i386 || mips || ...) && (SANITIZER_FREEBSD ||
         // SANITIZER_LINUX) && !SANITIZER_ANDROID && !SANITIZER_GO
 
 #if SANITIZER_NETBSD