[sanitizer][sancov] Use pc-1 for s390x

[MaskRay]

Summary

The stack trace addresses may be odd (normally addresses should be even), but
seems a good compromise when the instruction length (2,4,6) cannot be detected
easily.

[uweigand]

See inline comment. Otherwise LGTM. Thanks for the quick fix.

compiler-rt/test/tsan/test.h

73

Comment doesn't match the code any more.

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.h

 #elif SANITIZER_RISCV64
   // RV-64 has variable instruciton length...
   // C extentions gives us 2-byte instructoins
   // RV-64 has 4-byte instructions
   // + RISCV architecture allows instructions up to 8 bytes
   // It seems difficult to figure out the exact instruction length -
   // pc - 2 seems like a safe option for the purposes of stack tracing
   return pc - 2;
-#elif SANITIZER_I386 || SANITIZER_X32 || SANITIZER_X64
+#elif SANITIZER_S390 || SANITIZER_I386 || SANITIZER_X32 || SANITIZER_X64
   return pc - 1;
 #else
   return pc - 4;
 #endif
 }
 
 // StackTrace that owns the buffer used to store the addresses.
 struct BufferedStackTrace : public StackTrace {

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.cpp

if ((InsnByte & 0x3f) == 0x1f) {
     return pc + 6;
   }
   if ((InsnByte & 0x7f) == 0x3f) {
     // xxxxxxxxx0111111 | 64 bit |
     return pc + 8;
   }
   // bail-out if could not figure out the instruction size
   return 0;
-#elif SANITIZER_I386 || SANITIZER_X32 || SANITIZER_X64
+#elif SANITIZER_S390 || SANITIZER_I386 || SANITIZER_X32 || SANITIZER_X64
   return pc + 1;
 #else
   return pc + 4;
 #endif
 }
 
 uptr StackTrace::GetCurrentPc() {
   return GET_CALLER_PC();

compiler-rt/test/tsan/test.h

 unsigned long long monotonic_clock_ns() {
   struct timespec t;
   clock_gettime(CLOCK_MONOTONIC, &t);
   return (unsigned long long)t.tv_sec * 1000000000ull + t.tv_nsec;
 }
 #endif
 
 //The const kPCInc must be in sync with StackTrace::GetPreviousInstructionPc
-#if defined(__powerpc64__) || defined(__arm__) || defined(__aarch64__)
+#if defined(__s390__) || defined(__i386__) || defined(__x86_64__)
 // PCs are always 4 byte aligned.
-const int kPCInc = 4;
+const int kPCInc = 1;
 #elif defined(__sparc__) || defined(__mips__)
 const int kPCInc = 8;
 #else
-const int kPCInc = 1;
+const int kPCInc = 4;
 #endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 void AnnotateThreadName(const char *f, int l, const char *name);
 

llvm/tools/sancov/sancov.cpp

 static uint64_t getPreviousInstructionPc(uint64_t PC,
                                          Triple TheTriple) {
   if (TheTriple.isARM())
     return (PC - 3) & (~1);
   if (TheTriple.isMIPS())
     return PC - 8;
   if (TheTriple.isRISCV())
     return PC - 2;
-  if (TheTriple.isX86())
+  if (TheTriple.isX86() || TheTriple.isSystemZ())
     return PC - 1;
   return PC - 4;
 }
 
 // Locate addresses of all coverage points in a file. Coverage point
 // is defined as the 'address of instruction following __sanitizer_cov
 // call - 1'.
 static void getObjectCoveragePoints(const object::ObjectFile &O,