Revert "[tsan] Fix GCC 8.3 build after D107911"

[melver]

Summary

This reverts commit 797fe59e6b9512652c0ae5a6b69a3c6f5a573fcd.

The use of "EventType type : 3" is replicated for all Event structs and
therefore was still present. As a result this still caused failures on
older GCCs (9.2 or 8.3 or earlier).

The particular bot that was failing due to buggy GCC was fixed by
fef39cc472a773fae4761deaab1c701024ad13ec.

Therefore, no reason to keep the workaround around; revert it.

[vitalybuka]

I just realized it's GO only. Any idea why this did not report on regular tsan builds? We have 8.3 on our bots.

[melver]

In D108192#2949748, @vitalybuka wrote:

I just realized it's GO only. Any idea why this did not report on regular tsan builds? We have 8.3 on our bots.

It seems GCC has tons of warnings by default (even when I use latest GCC), and so enabling Werror on GCC just seems impossible. Checking the bot's script, it looks like Werror is only enabled when using self-hosted Clang:

I see this comment:

# Use both gcc and just-built Clang/LLD as a host compiler/linker for sanitizer                                                                                                                                                                                
# tests. Assume that self-hosted build tree should compile with -Werror.

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

for (;;) {
     // Since an event can take up to 2 elements,
     // we ensure we have at least 2 before adding an event.
     Event *end = &part->events[TracePart::kSize - 1];
     if (part == last)
       end = last_pos;
     for (Event *evp = &part->events[0]; evp < end; evp++) {
       Event *evp0 = evp;
       if (!evp->is_access && !evp->is_func) {
-        switch (evp->GetType()) {
+        switch (evp->type) {
           case EventType::kTime: {
             auto *ev = reinterpret_cast<EventTime *>(evp);
             ev_sid = static_cast<Sid>(ev->sid);
             ev_epoch = static_cast<Epoch>(ev->epoch);
             if (ev_sid == sid && ev_epoch > epoch)
               return;
             break;
           }
bool RestoreStack(Tid tid, EventType type, Sid sid, Epoch epoch, uptr addr,
   bool is_read = typ & kAccessRead;
   bool is_atomic = typ & kAccessAtomic;
   bool is_free = typ & kAccessFree;
   TraceReplay(
       trace, last_part, last_pos, sid, epoch,
       [&](Sid ev_sid, Epoch ev_epoch, Event *evp) {
         bool match = ev_sid == sid && ev_epoch == epoch;
         if (evp->is_access) {
-          if (evp->is_func == 0 && evp->GetType() == EventType::kAccessExt &&
+          if (evp->is_func == 0 && evp->type == EventType::kAccessExt &&
               evp->_ == 0)  // NopEvent
             return;
           auto *ev = reinterpret_cast<EventAccess *>(evp);
           uptr ev_addr = RestoreAddr(ev->addr);
           uptr ev_size = 1 << ev->size_log;
           uptr ev_pc =
               prev_pc + ev->pc_delta - (1 << (EventAccess::kPCBits - 1));
           prev_pc = ev_pc;
TraceReplay(
             stack.PushBack(ev->pc);
           } else {
             DPrintf2("  FuncExit\n");
             CHECK(stack.Size());
             stack.PopBack();
           }
           return;
         }
-        switch (evp->GetType()) {
+        switch (evp->type) {
           case EventType::kAccessExt: {
             auto *ev = reinterpret_cast<EventAccessExt *>(evp);
             uptr ev_addr = RestoreAddr(ev->addr);
             uptr ev_size = 1 << ev->size_log;
             prev_pc = ev->pc;
             DPrintf2("  AccessExt: pc=0x%zx addr=0x%llx/%llu type=%llu/%llu\n",
                      ev->pc, ev_addr, ev_size, ev->is_read, ev->is_atomic);
             if (match && type == EventType::kAccessExt &&

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

 // "Base" type for all events for type dispatch.
 struct Event {
   // We use variable-length type encoding to give more bits to some event
   // types that need them. If is_access is set, this is EventAccess.
   // Otherwise, if is_func is set, this is EventFunc.
   // Otherwise type denotes the type.
   u64 is_access : 1;
   u64 is_func : 1;
-  u64 type : 3;
+  EventType type : 3;
   u64 _ : 59;
-
-  EventType GetType() const {
-    return static_cast<EventType>(type);
-  }
 };
 static_assert(sizeof(Event) == 8, "bad Event size");
 
 // Nop event used as padding and does not affect state during replay.
-static constexpr Event NopEvent = {1, 0, static_cast<u64>(EventType::kAccessExt), 0};
+static constexpr Event NopEvent = {1, 0, EventType::kAccessExt, 0};
 
 // Compressed memory access can represent only some events with PCs
 // close enough to each other. Otherwise we fall back to EventAccessExt.
 struct EventAccess {
   static constexpr uptr kPCBits = 15;
 
   u64 is_access : 1;  // = 1
   u64 is_read : 1;