[sanitizers] [NFC] Add defines for the various PowerPC

[• koriakin]

Summary

To be used by two upcoming patches.

[aizatsky]

As long as you are sure that BYTE_ORDER and _CALL_ELF means the same.

[• koriakin]

In D19542#412410, @aizatsky wrote:

As long as you are sure that BYTE_ORDER and _CALL_ELF means the same.

It doesn't really, but _CALL_ELF is the correct one.

The story is: there are two ABIs for ppc64 (determined by _CALL_ELF) and two endians. Originally, only BE was used. One day, they decided to transition to LE for whatever reason, and made a new ABI while they were at it. So if you configure for powerpc64, you get BE and v1, while configuring for powerpc64le results in v2. It is possible to convince gcc (but not llvm) to compile for other combinations via some -m options, but you won't find such cases in the wild (someone would have to compile a full system like that, and it's quite painful).

[eugenis]

Thanks for the explanation. Maybe add a short comment with this info near the macro definitions. Is it true that in V2 ABI function pointers are simple code pointers?

[• koriakin]

In D19542#412442, @eugenis wrote:

Thanks for the explanation. Maybe add a short comment with this info near the macro definitions. Is it true that in V2 ABI function pointers are simple code pointers?

I'll add a comment. Yeah, in v2 (or 32-bit ppc, for that matter) function pointers are plain old code pointers, like on most architectures.

compiler-rt/trunk/lib/asan/asan_report.cc

bool DescribeAddressIfStack(uptr addr, uptr access_size) {
 
   // Now we print the frame where the alloca has happened.
   // We print this frame as a stack trace with one element.
   // The symbolizer may print more than one frame if inlining was involved.
   // The frame numbers may be different than those in the stack trace printed
   // previously. That's unfortunate, but I have no better solution,
   // especially given that the alloca may be from entirely different place
   // (e.g. use-after-scope, or different thread's stack).
-#if defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#if SANITIZER_PPC64V1
   // On PowerPC64 ELFv1, the address of a function actually points to a
   // three-doubleword data structure with the first field containing
   // the address of the function's code.
   access.frame_pc = *reinterpret_cast<uptr *>(access.frame_pc);
 #endif
   access.frame_pc += 16;
   Printf("%s", d.EndLocation());
   StackTrace alloca_stack(&access.frame_pc, 1);

compiler-rt/trunk/lib/msan/msan.h

const MappingDesc kMemoryLayout[] = {
     {0x3C000000000ULL, 0x3D000000000ULL, MappingDesc::INVALID, "invalid"},
     {0x3D000000000ULL, 0x3E000000000ULL, MappingDesc::SHADOW, "shadow-8"},
     {0x3E000000000ULL, 0x3F000000000ULL, MappingDesc::ORIGIN, "origin-8"},
     {0x3F000000000ULL, 0x40000000000ULL, MappingDesc::APP, "app-9"},
 };
 # define MEM_TO_SHADOW(mem) ((uptr)mem ^ 0x6000000000ULL)
 # define SHADOW_TO_ORIGIN(shadow) (((uptr)(shadow)) + 0x1000000000ULL)
 
-#elif SANITIZER_LINUX && defined(__powerpc64__)
+#elif SANITIZER_LINUX && SANITIZER_PPC64
 
 const MappingDesc kMemoryLayout[] = {
     {0x000000000000ULL, 0x000100000000ULL, MappingDesc::APP, "low memory"},
     {0x000100000000ULL, 0x080000000000ULL, MappingDesc::INVALID, "invalid"},
     {0x080000000000ULL, 0x180100000000ULL, MappingDesc::SHADOW, "shadow"},
     {0x180100000000ULL, 0x1C0000000000ULL, MappingDesc::INVALID, "invalid"},
     {0x1C0000000000ULL, 0x2C0100000000ULL, MappingDesc::ORIGIN, "origin"},
     {0x2C0100000000ULL, 0x300000000000ULL, MappingDesc::INVALID, "invalid"},

compiler-rt/trunk/lib/sanitizer_common/sanitizer_platform.h

 #  define SANITIZER_S390_64 0
 # endif
 #else
 # define SANITIZER_S390 0
 # define SANITIZER_S390_31 0
 # define SANITIZER_S390_64 0
 #endif
 
+#if defined(__powerpc__)
+# define SANITIZER_PPC 1
+# if defined(__powerpc64__)
+#  define SANITIZER_PPC32 0
+#  define SANITIZER_PPC64 1
+// 64-bit PPC has two ABIs (v1 and v2).  The old powerpc64 target is
+// big-endian, and uses v1 ABI (known for its function descriptors),
+// while the new powerpc64le target is little-endian and uses v2.
+// In theory, you could convince gcc to compile for their evil twins
+// (eg. big-endian v2), but you won't find such combinations in the wild
+// (it'd require bootstrapping a whole system, which would be quite painful
+// - there's no target triple for that).  LLVM doesn't support them either.
+#  if _CALL_ELF == 2
+#   define SANITIZER_PPC64V1 0
+#   define SANITIZER_PPC64V2 1
+#  else
+#   define SANITIZER_PPC64V1 1
+#   define SANITIZER_PPC64V2 0
+#  endif
+# else
+#  define SANITIZER_PPC32 1
+#  define SANITIZER_PPC64 0
+#  define SANITIZER_PPC64V1 0
+#  define SANITIZER_PPC64V2 0
+# endif
+#else
+# define SANITIZER_PPC 0
+# define SANITIZER_PPC32 0
+# define SANITIZER_PPC64 0
+# define SANITIZER_PPC64V1 0
+# define SANITIZER_PPC64V2 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 defined(__mips64) || defined(__aarch64__)
 #  define SANITIZER_CAN_USE_ALLOCATOR64 0

compiler-rt/trunk/lib/tsan/rtl/tsan_interceptors.cc

 };
 #else
 struct ucontext_t {
   // The size is determined by looking at sizeof of real ucontext_t on linux.
   u64 opaque[936 / sizeof(u64) + 1];
 };
 #endif
 
-#if defined(__x86_64__) || defined(__mips__) \
-  || (defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#if defined(__x86_64__) || defined(__mips__) || SANITIZER_PPC64V1
 #define PTHREAD_ABI_BASE  "GLIBC_2.3.2"
-#elif defined(__aarch64__) || (defined(__powerpc64__) \
-  && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#elif defined(__aarch64__) || SANITIZER_PPC64V2
 #define PTHREAD_ABI_BASE  "GLIBC_2.17"
 #endif
 
 extern "C" int pthread_attr_init(void *attr);
 extern "C" int pthread_attr_destroy(void *attr);
 DECLARE_REAL(int, pthread_attr_getdetachstate, void *, void *)
 extern "C" int pthread_attr_setstacksize(void *attr, uptr stacksize);
 extern "C" int pthread_key_create(unsigned *key, void (*destructor)(void* v));