Add some initializations code for sanitizers

[yingcong-wu]

Summary

This patch aims to do some missing initializations to some class members. This would make the code more conforming to the CppCoreGuildlines Pro.safety: Type-safety profile, which says to have member variables initialized.

[MaskRay]

Can you please state the motivation of this patch and what are the behavior changes (ideally testable)? Some information can go to the summary/commit message.

[yingcong-wu]

merge

[yingcong-wu]

Yes, I would do that. Thank you.

[vitalybuka]

If it inserts memset, it will break things. We have workaround to prevent memsets, but it's not 100% reliably.
So I would recommend avoid change without need.

[yingcong-wu]

We don't want this patch to break things. I will abandon this patch then.

compiler-rt/lib/asan/asan_errors.cpp

: ErrorBase(tid),
       addr_description(addr, access_size_, /*shouldLockThreadRegistry=*/false),
       pc(pc_),
       bp(bp_),
       sp(sp_),
       access_size(access_size_),
       is_write(is_write_),
       shadow_val(0) {
   scariness.Clear();
+  bug_descr = "unknown-crash";
   if (access_size) {
     if (access_size <= 9) {
       char desr[] = "?-byte";
       desr[0] = '0' + access_size;
       scariness.Scare(access_size + access_size / 2, desr);
     } else if (access_size >= 10) {
       scariness.Scare(15, "multi-byte");
     }
     is_write ? scariness.Scare(20, "write") : scariness.Scare(1, "read");
 
     // Determine the error type.
-    bug_descr = "unknown-crash";
     if (AddrIsInMem(addr)) {
       u8 *shadow_addr = (u8 *)MemToShadow(addr);
       // If we are accessing 16 bytes, look at the second shadow byte.
       if (*shadow_addr == 0 && access_size > ASAN_SHADOW_GRANULARITY)
         shadow_addr++;
       // If we are in the partial right redzone, look at the next shadow byte.
       if (*shadow_addr > 0 && *shadow_addr < 128) shadow_addr++;
       bool far_from_bounds = false;

compiler-rt/lib/sanitizer_common/sanitizer_procmaps.h

 static const uptr kProtectionExecute = 4;
 static const uptr kProtectionShared = 8;
 
 struct MemoryMappedSegmentData;
 
 class MemoryMappedSegment {
  public:
   explicit MemoryMappedSegment(char *buff = nullptr, uptr size = 0)
-      : filename(buff), filename_size(size), data_(nullptr) {}
+      : filename(buff),
+        filename_size(size),
+        data_(nullptr),
+        start(0),
+        end(0),
+        offset(0),
+        protection(0),
+        arch(kModuleArchUnknown) {}
   ~MemoryMappedSegment() {}
 
   bool IsReadable() const { return protection & kProtectionRead; }
   bool IsWritable() const { return protection & kProtectionWrite; }
   bool IsExecutable() const { return protection & kProtectionExecute; }
   bool IsShared() const { return protection & kProtectionShared; }
 
   void AddAddressRanges(LoadedModule *module);

compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp

 // InterceptorContext holds all global data required for interceptors.
 // It's explicitly constructed in InitializeInterceptors with placement new
 // and is never destroyed. This allows usage of members with non-trivial
 // constructors and destructors.
 struct InterceptorContext {
   // The object is 64-byte aligned, because we want hot data to be located
   // in a single cache line if possible (it's accessed in every interceptor).
   ALIGNED(64) LibIgnore libignore;
-  __sanitizer_sigaction sigactions[kSigCount];
+  __sanitizer_sigaction sigactions[kSigCount] = {};
 #if !SANITIZER_APPLE && !SANITIZER_NETBSD
   unsigned finalize_key;
 #endif
 
   Mutex atexit_mu;
   Vector<struct AtExitCtx *> AtExitStack;
 
   InterceptorContext() : libignore(LINKER_INITIALIZED), atexit_mu(MutexTypeAtExit), AtExitStack() {}

compiler-rt/lib/tsan/rtl/tsan_interface_ann.cpp

struct ExpectRace {
   uptr size;
   char *file;
   int line;
   char desc[kMaxDescLen];
 };
 
 struct DynamicAnnContext {
   Mutex mtx;
-  ExpectRace benign;
+  ExpectRace benign = {};
 
   DynamicAnnContext() : mtx(MutexTypeAnnotations) {}
 };
 
 static DynamicAnnContext *dyn_ann_ctx;
 static char dyn_ann_ctx_placeholder[sizeof(DynamicAnnContext)] ALIGNED(64);
 
 static void AddExpectRace(ExpectRace *list,

compiler-rt/lib/tsan/rtl/tsan_report.cpp

ReportDesc::ReportDesc()
     , mutexes()
     , threads()
     , unique_tids()
     , sleep()
     , count() {
 }
 
 ReportMop::ReportMop()
-    : mset() {
+    : mset()
+    , tid()
+    , addr()
+    , size()
+    , write()
+    , atomic()
+    , external_tag()
+    , stack() {
 }
 
 ReportDesc::~ReportDesc() {
   // FIXME(dvyukov): it must be leaking a lot of memory.
 }
 
 #if !SANITIZER_GO
 

compiler-rt/lib/ubsan/ubsan_diag.h

 private:
   LocationKind Kind;
   // FIXME: In C++11, wrap these in an anonymous union.
   SourceLocation SourceLoc;
   MemoryLocation MemoryLoc;
   const SymbolizedStack *SymbolizedLoc;  // Not owned.
 
 public:
-  Location() : Kind(LK_Null) {}
-  Location(SourceLocation Loc) :
-    Kind(LK_Source), SourceLoc(Loc) {}
-  Location(MemoryLocation Loc) :
-    Kind(LK_Memory), MemoryLoc(Loc) {}
+  Location()
+      : Kind(LK_Null), SourceLoc(), MemoryLoc(), SymbolizedLoc(nullptr) {}
+  Location(SourceLocation Loc)
+      : Kind(LK_Source), SourceLoc(Loc), MemoryLoc(), SymbolizedLoc(nullptr) {}
+  Location(MemoryLocation Loc)
+      : Kind(LK_Memory), MemoryLoc(Loc), SourceLoc(), SymbolizedLoc(nullptr) {}
   // SymbolizedStackHolder must outlive Location object.
-  Location(const SymbolizedStackHolder &Stack) :
-    Kind(LK_Symbolized), SymbolizedLoc(Stack.get()) {}
+  Location(const SymbolizedStackHolder &Stack)
+      : Kind(LK_Symbolized), SymbolizedLoc(Stack.get()), SourceLoc(),
+        MemoryLoc() {}
 
   LocationKind getKind() const { return Kind; }
 
   bool isSourceLocation() const { return Kind == LK_Source; }
   bool isMemoryLocation() const { return Kind == LK_Memory; }
   bool isSymbolizedStack() const { return Kind == LK_Symbolized; }
 
   SourceLocation getSourceLocation() const {