[Sanitizer] Update GetMaxVirtualAddress for PowerPC64 Linux

[foad]

Summary

On PowerPC64 the sanitizers currently have no reliable way of detecting whether we're using 44- or 46-bit virtual addressing.

Linux switched from 44- to 46-bit in release 3.7, so this patch calls uname(2) and checks the Linux release string to decide what to return. This gets some basic sanitizer functionality working for me on big-endian Fedora 19 (Linux 3.14).

I've left the non-Linux defaults alone, even though they seem pretty arbitrary: 44-bit for big-endian and 46-bit for little-endian.

See also the discussion here: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=55975

[kcc]

Do we need to support 44-bit AS at all?
Why not just support the new ans shiny 46 bit?

If we absolutely need this, maybe try mapping something in a few different places and see if 46 bits work?

[willschm]

Hi Jay,

Can you see if the updated patch from ( http://reviews.llvm.org/D6044 ) works for you.   It should work for both old and new kernels, etc.

[foad]

In D6082#4, @kcc wrote:

Do we need to support 44-bit AS at all?
Why not just support the new ans shiny 46 bit?

I can't answer that. It's a question for the sanitizer maintainers. Do you want to support PowerPC64 on Linux older than 3.7 (released about two years ago)? Do you support PowerPC64 on any other OSes?

Personally, I'd be very happy with only supporting 46-bit. But I was trying to be conservative, by fixing the modern Linux case but not breaking any other setups that might already have been working.

If we absolutely need this, maybe try mapping something in a few different places and see if 46 bits work?

Sure, if you'd prefer that approach, I'll try to come up with a patch.

[kcc]

I am always reluctant to support any old OS (and > 2+ years is old) unless there is a specific request and someone is willing to do the support work.
My team currently does't test on PowerPC at all. So, the simplest solution (i.e. only support 46-bit and assert at run-time if the OS is old) seems best for me.

[foad]

OK, so we could go with Will's patch from D6044, or simplify even further to just:

return (1ULL << 46) - 1;

What do you think, Will?

[willschm]

In D6082#7, @kcc wrote:

I am always reluctant to support any old OS (and > 2+ years is old) unless there is a specific request and someone is willing to do the support work.
My team currently does't test on PowerPC at all. So, the simplest solution (i.e. only support 46-bit and assert at run-time if the OS is old) seems best for me.

In D6082#8, @foad wrote:

OK, so we could go with Will's patch from D6044, or simplify even further to just:

return (1ULL << 46) - 1;

What do you think, Will?

Roughly half of the systems I'm running on are old enough that they use the 44-bit address space, so I would prefer to allow those to continue working. :-) At least until they fail for some other difficult reason, at least.
When the address space is wrongly calculated, the tests tend to hang or spin rather than crash and terminate,.. so if we decide that 44-bit address space will not be supported, we'll want to have an explicit abort of some sort.

[foad]

In D6082#9, @willschm wrote:

Roughly half of the systems I'm running on are old enough that they use the 44-bit address space, so I would prefer to allow those to continue working. :-) At least until they fail for some other difficult reason, at least.

Fair enough. In that case I humbly withdraw this patch; let's go with D6044 instead. It sounds like you're best placed to test this stuff anyway, Will.

lib/sanitizer_common/sanitizer_posix.cc

#endif  // SANITIZER_ANDROID
   // Top gigabyte is reserved for kernel.
   return gbyte;
 #else
   return 0;
 #endif  // SANITIZER_LINUX
 }
 #endif  // SANITIZER_WORDSIZE == 32
 
+#if defined(__powerpc64__) && SANITIZER_LINUX
+
+// Compare two decimal digit strings by their numeric value.
+// The strings are terminated by any non-digit character.
+// Empty strings are allowed and are treated as zero.
+// Return -1, 0 or 1 when a is less than, equal to or greater than b
+// respectively.
+// Update a and b to point just past the end of the digit strings.
+static int cmp_decimal(const char *&a, const char *&b) {
+  // Skip leading zeros.
+  while (*a == '0')
+    ++a;
+  while (*b == '0')
+    ++b;
+  // Compare string lengths.
+  size_t la = 0, lb = 0;
+  while (a[la] >= '0' && a[la] <= '9')
+    ++la;
+  while (b[lb] >= '0' && b[lb] <= '9')
+    ++lb;
+  if (la != lb)
+    return la > lb ? 1 : -1;
+  // Compare strings lexicographically.
+  for (; la--; ++a, ++b)
+    if (*a != *b)
+      return *a > *b ? 1 : -1;
+  return 0;
+}
+
+// Compare two version strings of the form "x", "x.y", "x.y.z" etc.
+// The strings are terminated by any non-digit, non-dot character.
+// Any missing trailing components are treated as zero.
+// Return -1, 0 or 1 when a is less than, equal to or greater than b
+// respectively.
+static int cmp_version(const char *a, const char *b) {
+  while (true) {
+    int ret = cmp_decimal(a, b);
+    if (ret)
+      return ret;
+    if (*a != '.' && *b != '.')
+      return 0;
+    if (*a == '.')
+      ++a;
+    if (*b == '.')
+      ++b;
+  }
+}
+
+#endif // defined(__powerpc64__) && SANITIZER_LINUX
+
 uptr GetMaxVirtualAddress() {
 #if SANITIZER_WORDSIZE == 64
-# if defined(__powerpc64__) && defined(__BIG_ENDIAN__)
+# if defined(__powerpc64__)
   // On PowerPC64 we have two different address space layouts: 44- and 46-bit.
   // We somehow need to figure out which one we are using now and choose
   // one of 0x00000fffffffffffUL and 0x00003fffffffffffUL.
   // Note that with 'ulimit -s unlimited' the stack is moved away from the top
   // of the address space, so simply checking the stack address is not enough.
+#  if SANITIZER_LINUX
+  // Linux switched to 46-bit addressing in version 3.7.
+  struct utsname uname_info;
+  if (uname(&uname_info) == 0) {
+    if (cmp_version(uname_info.release, "3.7") >= 0)
+      return (1ULL << 46) - 1;  // 0x00003fffffffffffUL
+    else
       return (1ULL << 44) - 1;  // 0x00000fffffffffffUL
-# elif defined(__powerpc64__) && defined(__LITTLE_ENDIAN__)
+  }
+#  endif
+#  if defined(__BIG_ENDIAN__)
+  return (1ULL << 44) - 1;  // 0x00000fffffffffffUL
+#  else
   return (1ULL << 46) - 1;  // 0x00003fffffffffffUL
+#  endif
 # elif defined(__aarch64__)
   return (1ULL << 39) - 1;
 # else
   return (1ULL << 47) - 1;  // 0x00007fffffffffffUL;
 # endif
 #else  // SANITIZER_WORDSIZE == 32
   uptr res = (1ULL << 32) - 1;  // 0xffffffff;
   if (!common_flags()->full_address_space)