sanitizer: fix GCC warnings

[marxin]

Summary

Fixes the following GCC warnings:

sanitizer_common/sanitizer_posix.cpp:165:27: warning: ‘flags’ may be used uninitialized [-Wmaybe-uninitialized]
sanitizer_common/sanitizer_stack_store.cpp:192:17: warning: ‘diff’ may be used uninitialized [-Wmaybe-uninitialized]
asan/asan_interceptors_memintrinsics.h:57:10: warning: ‘local_iovec.__sanitizer::__sanitizer_iovec::iov_base’ may be used uninitialized [-Wmaybe-uninitialized]
tsan/tsan_dense_alloc.h:165:46: warning: suggest parentheses around arithmetic in operand of ‘|’ [-Wparentheses]
ubsan/ubsan_diag.h:193:21: warning: ‘CheckKindStr’ may be used uninitialized [-Wmaybe-uninitialized]
tsan/tsan_rtl.h:739:3: warning: ‘evp’ may be used uninitialized [-Wmaybe-uninitialized]
tsan/tsan_rtl.h:728:52: warning: ‘evp’ may be used uninitialized [-Wmaybe-uninitialized]
sanitizer_common/sanitizer_common_interceptors.inc:3509:21: warning: ‘local_iovec.__sanitizer::__sanitizer_iovec::iov_len’ may be used uninitialized [-Wmaybe-uninitialized]

[MaskRay]

Sorry, llvm-project considers that GCC -Wmaybe-uninitialized introduces too much false positive and doesn't use it. (See USE_NO_MAYBE_UNINITIALIZED.)
I have checked most call sites and think the changes will add unnecessary runtime overhead / harm readability (as the user cannot know that a function call has a write-only parameter and will guarantee to initialize the variable).

compiler-rt/lib/tsan/rtl/tsan_dense_alloc.h

165

The new code changes semantics and likely introduces a bug...

[marxin]

Fair enough, then let's discard this.

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

 #else
 #define INIT_READDIR64
 #endif
 
 #if SANITIZER_INTERCEPT_PTRACE
 INTERCEPTOR(uptr, ptrace, int request, int pid, void *addr, void *data) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, ptrace, request, pid, addr, data);
-  __sanitizer_iovec local_iovec;
+  __sanitizer_iovec local_iovec = {};
 
   if (data) {
     if (request == ptrace_setregs) {
       COMMON_INTERCEPTOR_READ_RANGE(ctx, data, struct_user_regs_struct_sz);
     } else if (request == ptrace_setfpregs) {
       COMMON_INTERCEPTOR_READ_RANGE(ctx, data, struct_user_fpregs_struct_sz);
     } else if (request == ptrace_setfpxregs) {
       COMMON_INTERCEPTOR_READ_RANGE(ctx, data, struct_user_fpxregs_struct_sz);

compiler-rt/lib/sanitizer_common/sanitizer_posix.cpp

 
 #if !SANITIZER_APPLE
 void MprotectMallocZones(void *addr, int prot) {}
 #endif
 
 fd_t OpenFile(const char *filename, FileAccessMode mode, error_t *errno_p) {
   if (ShouldMockFailureToOpen(filename))
     return kInvalidFd;
-  int flags;
+  int flags = 0;
   switch (mode) {
     case RdOnly: flags = O_RDONLY; break;
     case WrOnly: flags = O_WRONLY | O_CREAT | O_TRUNC; break;
     case RdWr: flags = O_RDWR | O_CREAT; break;
   }
   fd_t res = internal_open(filename, flags, 0660);
   if (internal_iserror(res, errno_p))
     return kInvalidFd;

compiler-rt/lib/sanitizer_common/sanitizer_stack_store.cpp

bool operator==(const SLeb128Decoder &other) const {
     return begin == other.begin;
   }
 
   bool operator!=(const SLeb128Decoder &other) const {
     return begin != other.begin;
   }
 
   uptr operator*() {
-    sptr diff;
+    sptr diff = 0;
     begin = DecodeSLEB128(begin, end, &diff);
     previous += diff;
     return previous;
   }
   SLeb128Decoder &operator++() { return *this; }
 
   SLeb128Decoder operator++(int) { return *this; }
 

compiler-rt/lib/tsan/rtl/tsan_dense_alloc.h

for (uptr i = 0; i < Cache::kSize / 2 && c->pos; i++) {
       head_idx = idx;
     }
     // Push it onto the freelist stack.
     Block *head = MapBlock(head_idx);
     u64 xchg;
     u64 cmp = atomic_load(&freelist_, memory_order_acquire);
     do {
       head->next = static_cast<IndexT>(cmp);
-      xchg = head_idx | (cmp & kCounterMask) + kCounterInc;
+      xchg = (head_idx | (cmp & kCounterMask)) + kCounterInc;
     } while (!atomic_compare_exchange_weak(&freelist_, &cmp, xchg,
                                            memory_order_acq_rel));
   }
 
   NOINLINE void AllocSuperBlock(Cache *c) {
     Lock lock(&mtx_);
     uptr fillpos = atomic_load_relaxed(&fillpos_);
     if (fillpos == kL1Size) {

compiler-rt/lib/tsan/rtl/tsan_rtl.h

 template <typename EventT>
 ALWAYS_INLINE void TraceRelease(ThreadState *thr, EventT *evp) {
   DCHECK_LE(evp + 1, &thr->tctx->trace.parts.Back()->events[TracePart::kSize]);
   atomic_store_relaxed(&thr->trace_pos, (uptr)(evp + 1));
 }
 
 template <typename EventT>
 void TraceEvent(ThreadState *thr, EventT ev) {
-  EventT *evp;
+  EventT *evp = nullptr;
   if (!TraceAcquire(thr, &evp)) {
     TraceSwitchPart(thr);
     UNUSED bool res = TraceAcquire(thr, &evp);
     DCHECK(res);
   }
   *evp = ev;
   TraceRelease(thr, evp);
 }

compiler-rt/lib/ubsan/ubsan_handlers_cxx.cpp

void __ubsan_handle_cfi_bad_type(CFICheckFailData *Data, ValueHandle Vtable,
   case CFITCK_UnrelatedCast:
     CheckKindStr = "cast to unrelated type";
     break;
   case CFITCK_VMFCall:
     CheckKindStr = "virtual pointer to member function call";
     break;
   case CFITCK_ICall:
   case CFITCK_NVMFCall:
+  default:
     Die();
   }
 
   Diag(Loc, DL_Error, ET,
        "control flow integrity check for type %0 failed during "
        "%1 (vtable address %2)")
       << Data->Type << CheckKindStr << (void *)Vtable;